1088 files changed, 287815 insertions, 0 deletions

diff --git a/Source/.gitattributes b/Source/.gitattributes
new file mode 100644
index 0000000..0f829a3
--- /dev/null
+++ b/Source/.gitattributes
@@ -0,0 +1,2 @@
+# Do not format third-party sources.
+/kwsys/**                                  -format.clang-format
diff --git a/Source/CMakeInstallDestinations.cmake b/Source/CMakeInstallDestinations.cmake
new file mode 100644
index 0000000..28f4e87
--- /dev/null
+++ b/Source/CMakeInstallDestinations.cmake
@@ -0,0 +1,54 @@
+# Keep formatting here consistent with bootstrap script expectations.
+if(BEOS)
+  set(CMAKE_BIN_DIR_DEFAULT "bin") # HAIKU
+  set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # HAIKU
+  set(CMAKE_MAN_DIR_DEFAULT "documentation/man") # HAIKU
+  set(CMAKE_DOC_DIR_DEFAULT "documentation/doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # HAIKU
+  set(CMAKE_XDGDATA_DIR_DEFAULT "share") # HAIKU
+elseif(CYGWIN)
+  set(CMAKE_BIN_DIR_DEFAULT "bin") # CYGWIN
+  set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION}") # CYGWIN
+  set(CMAKE_DOC_DIR_DEFAULT "share/doc/cmake-${CMake_VERSION}") # CYGWIN
+  set(CMAKE_MAN_DIR_DEFAULT "share/man") # CYGWIN
+  set(CMAKE_XDGDATA_DIR_DEFAULT "share") # CYGWIN
+else()
+  set(CMAKE_BIN_DIR_DEFAULT "bin") # OTHER
+  set(CMAKE_DATA_DIR_DEFAULT "share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # OTHER
+  set(CMAKE_DOC_DIR_DEFAULT "doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") # OTHER
+  set(CMAKE_MAN_DIR_DEFAULT "man") # OTHER
+  set(CMAKE_XDGDATA_DIR_DEFAULT "share") # OTHER
+endif()
+
+set(CMAKE_BIN_DIR_DESC "bin")
+set(CMAKE_DATA_DIR_DESC "data")
+set(CMAKE_DOC_DIR_DESC "docs")
+set(CMAKE_MAN_DIR_DESC "man pages")
+set(CMAKE_XDGDATA_DIR_DESC "XDG specific files")
+
+set(CMake_INSTALL_INFIX "" CACHE STRING "")
+set_property(CACHE CMake_INSTALL_INFIX PROPERTY HELPSTRING
+  "Intermediate installation path (empty by default)"
+  )
+mark_as_advanced(CMake_INSTALL_INFIX)
+
+foreach(v
+    CMAKE_BIN_DIR
+    CMAKE_DATA_DIR
+    CMAKE_DOC_DIR
+    CMAKE_MAN_DIR
+    CMAKE_XDGDATA_DIR
+    )
+  # Populate the cache with empty values so we know when the user sets them.
+  set(${v} "" CACHE STRING "")
+  set_property(CACHE ${v} PROPERTY HELPSTRING
+    "Location under install prefix for ${${v}_DESC} (default \"${${v}_DEFAULT}\")"
+    )
+  set_property(CACHE ${v} PROPERTY ADVANCED 1)
+
+  # Use the default when the user did not set this variable.
+  if(NOT ${v})
+    set(${v} "${CMake_INSTALL_INFIX}${${v}_DEFAULT}")
+  endif()
+  # Remove leading slash to treat as relative to install prefix.
+  string(REGEX REPLACE "^/" "" ${v} "${${v}}")
+endforeach()
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
new file mode 100644
index 0000000..cd1287c
--- /dev/null
+++ b/Source/CMakeLists.txt
@@ -0,0 +1,1091 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(CheckIncludeFile)
+# Check if we can build support for ELF parsing.
+if(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
+  CHECK_INCLUDE_FILES("stdint.h;elf_abi.h" HAVE_ELF_H)
+else()
+  CHECK_INCLUDE_FILE("elf.h" HAVE_ELF_H)
+endif()
+if(HAVE_ELF_H)
+  set(CMAKE_USE_ELF_PARSER 1)
+elseif(HAIKU)
+  # On Haiku, we need to include elf32.h from the private headers
+  set(CMake_HAIKU_INCLUDE_DIRS
+    /boot/system/develop/headers/private/system
+    /boot/system/develop/headers/private/system/arch/x86
+    )
+
+  set(CMAKE_REQUIRED_INCLUDES ${CMake_HAIKU_INCLUDE_DIRS})
+  CHECK_INCLUDE_FILE("elf32.h" HAVE_ELF32_H)
+  unset(CMAKE_REQUIRED_INCLUDES)
+
+  if(HAVE_ELF32_H)
+    set(CMAKE_USE_ELF_PARSER 1)
+  else()
+    unset(CMake_HAIKU_INCLUDE_DIRS)
+    set(CMAKE_USE_ELF_PARSER)
+  endif()
+else()
+  set(CMAKE_USE_ELF_PARSER)
+endif()
+
+if(APPLE)
+  set(CMAKE_USE_MACH_PARSER 1)
+endif()
+
+set(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})
+
+if(WIN32)
+  # ensure Unicode friendly APIs are used on Windows
+  add_definitions(-DUNICODE -D_UNICODE)
+
+  # minimize windows.h content
+  add_definitions(-DWIN32_LEAN_AND_MEAN)
+endif()
+
+# configure the .dox.in file
+if(CMake_BUILD_DEVELOPER_REFERENCE)
+  configure_file(
+    "${CMake_SOURCE_DIR}/Source/dir.dox.in"
+    "${CMake_BINARY_DIR}/Source/dir.dox"
+    @ONLY
+    )
+endif()
+
+# configure the .h file
+configure_file(
+  "${CMake_SOURCE_DIR}/Source/cmConfigure.cmake.h.in"
+  "${CMake_BINARY_DIR}/Source/cmConfigure.h"
+  )
+configure_file(
+  "${CMake_SOURCE_DIR}/Source/cmVersionConfig.h.in"
+  "${CMake_BINARY_DIR}/Source/cmVersionConfig.h"
+  )
+configure_file(
+  "${CMake_SOURCE_DIR}/Source/CPack/cmCPackConfigure.h.in"
+  "${CMake_BINARY_DIR}/Source/CPack/cmCPackConfigure.h"
+  )
+
+# Tell CMake executable in the build tree where to find the source tree.
+configure_file(
+  "${CMake_SOURCE_DIR}/Source/CMakeSourceDir.txt.in"
+  "${CMake_BINARY_DIR}/CMakeFiles/CMakeSourceDir.txt" @ONLY
+  )
+
+# add the include path to find the .h
+include_directories(
+  "${CMake_BINARY_DIR}/Source"
+  "${CMake_SOURCE_DIR}/Source"
+  "${CMake_SOURCE_DIR}/Source/LexerParser"
+  ${CMAKE_ZLIB_INCLUDES}
+  ${CMAKE_EXPAT_INCLUDES}
+  ${CMAKE_TAR_INCLUDES}
+  ${CMAKE_COMPRESS_INCLUDES}
+  ${CMake_HAIKU_INCLUDE_DIRS}
+  )
+
+# let cmake know it is supposed to use it
+add_definitions(-DCMAKE_BUILD_WITH_CMAKE)
+
+# Check if we can build the ELF parser.
+if(CMAKE_USE_ELF_PARSER)
+  set(ELF_SRCS cmELF.h cmELF.cxx)
+endif()
+
+# Check if we can build the Mach-O parser.
+if(CMAKE_USE_MACH_PARSER)
+  set(MACH_SRCS cmMachO.h cmMachO.cxx)
+endif()
+
+#
+# Sources for CMakeLib
+#
+set(SRCS
+  # Lexers/Parsers
+  LexerParser/cmCommandArgumentLexer.cxx
+  LexerParser/cmCommandArgumentLexer.h
+  LexerParser/cmCommandArgumentLexer.in.l
+  LexerParser/cmCommandArgumentParser.cxx
+  LexerParser/cmCommandArgumentParserTokens.h
+  LexerParser/cmCommandArgumentParser.y
+  LexerParser/cmDependsJavaLexer.cxx
+  LexerParser/cmDependsJavaLexer.h
+  LexerParser/cmDependsJavaLexer.in.l
+  LexerParser/cmDependsJavaParser.cxx
+  LexerParser/cmDependsJavaParserTokens.h
+  LexerParser/cmDependsJavaParser.y
+  LexerParser/cmExprLexer.cxx
+  LexerParser/cmExprLexer.h
+  LexerParser/cmExprLexer.in.l
+  LexerParser/cmExprParser.cxx
+  LexerParser/cmExprParserTokens.h
+  LexerParser/cmExprParser.y
+  LexerParser/cmFortranLexer.cxx
+  LexerParser/cmFortranLexer.h
+  LexerParser/cmFortranLexer.in.l
+  LexerParser/cmFortranParser.cxx
+  LexerParser/cmFortranParserTokens.h
+  LexerParser/cmFortranParser.y
+  LexerParser/cmListFileLexer.c
+  LexerParser/cmListFileLexer.in.l
+
+  cmArchiveWrite.cxx
+  cmBase32.cxx
+  cmCacheManager.cxx
+  cmCacheManager.h
+  cmCLocaleEnvironmentScope.h
+  cmCLocaleEnvironmentScope.cxx
+  cmCommandArgumentParserHelper.cxx
+  cmCommonTargetGenerator.cxx
+  cmCommonTargetGenerator.h
+  cmComputeComponentGraph.cxx
+  cmComputeComponentGraph.h
+  cmComputeLinkDepends.cxx
+  cmComputeLinkDepends.h
+  cmComputeLinkInformation.cxx
+  cmComputeLinkInformation.h
+  cmComputeTargetDepends.h
+  cmComputeTargetDepends.cxx
+  cmCPackPropertiesGenerator.h
+  cmCPackPropertiesGenerator.cxx
+  cmCryptoHash.cxx
+  cmCryptoHash.h
+  cmCurl.cxx
+  cmCurl.h
+  cmCustomCommand.cxx
+  cmCustomCommand.h
+  cmCustomCommandGenerator.cxx
+  cmCustomCommandGenerator.h
+  cmDefinitions.cxx
+  cmDefinitions.h
+  cmDepends.cxx
+  cmDepends.h
+  cmDependsC.cxx
+  cmDependsC.h
+  cmDependsFortran.cxx
+  cmDependsFortran.h
+  cmDependsJava.cxx
+  cmDependsJava.h
+  cmDependsJavaParserHelper.cxx
+  cmDependsJavaParserHelper.h
+  cmDocumentation.cxx
+  cmDocumentationFormatter.cxx
+  cmDocumentationSection.cxx
+  cmDynamicLoader.cxx
+  cmDynamicLoader.h
+  ${ELF_SRCS}
+  cmExprParserHelper.cxx
+  cmExportBuildAndroidMKGenerator.h
+  cmExportBuildAndroidMKGenerator.cxx
+  cmExportBuildFileGenerator.h
+  cmExportBuildFileGenerator.cxx
+  cmExportFileGenerator.h
+  cmExportFileGenerator.cxx
+  cmExportInstallAndroidMKGenerator.h
+  cmExportInstallAndroidMKGenerator.cxx
+  cmExportInstallFileGenerator.h
+  cmExportInstallFileGenerator.cxx
+  cmExportTryCompileFileGenerator.h
+  cmExportTryCompileFileGenerator.cxx
+  cmExportSet.h
+  cmExportSet.cxx
+  cmExportSetMap.h
+  cmExportSetMap.cxx
+  cmExternalMakefileProjectGenerator.cxx
+  cmExternalMakefileProjectGenerator.h
+  cmExtraCodeBlocksGenerator.cxx
+  cmExtraCodeBlocksGenerator.h
+  cmExtraCodeLiteGenerator.cxx
+  cmExtraCodeLiteGenerator.h
+  cmExtraEclipseCDT4Generator.cxx
+  cmExtraEclipseCDT4Generator.h
+  cmExtraKateGenerator.cxx
+  cmExtraKateGenerator.h
+  cmExtraSublimeTextGenerator.cxx
+  cmExtraSublimeTextGenerator.h
+  cmFileLock.cxx
+  cmFileLock.h
+  cmFileLockPool.cxx
+  cmFileLockPool.h
+  cmFileLockResult.cxx
+  cmFileLockResult.h
+  cmFilePathChecksum.cxx
+  cmFilePathChecksum.h
+  cmFileTimeComparison.cxx
+  cmFileTimeComparison.h
+  cmFortranParserImpl.cxx
+  cmFSPermissions.cxx
+  cmFSPermissions.h
+  cmGeneratedFileStream.cxx
+  cmGeneratorExpressionContext.cxx
+  cmGeneratorExpressionContext.h
+  cmGeneratorExpressionDAGChecker.cxx
+  cmGeneratorExpressionDAGChecker.h
+  cmGeneratorExpressionEvaluationFile.cxx
+  cmGeneratorExpressionEvaluationFile.h
+  cmGeneratorExpressionEvaluator.cxx
+  cmGeneratorExpressionEvaluator.h
+  cmGeneratorExpressionLexer.cxx
+  cmGeneratorExpressionLexer.h
+  cmGeneratorExpressionNode.cxx
+  cmGeneratorExpressionNode.h
+  cmGeneratorExpressionParser.cxx
+  cmGeneratorExpressionParser.h
+  cmGeneratorExpression.cxx
+  cmGeneratorExpression.h
+  cmGeneratorTarget.cxx
+  cmGeneratorTarget.h
+  cmGlobalCommonGenerator.cxx
+  cmGlobalCommonGenerator.h
+  cmGlobalGenerator.cxx
+  cmGlobalGenerator.h
+  cmGlobalGeneratorFactory.h
+  cmGlobalUnixMakefileGenerator3.cxx
+  cmGlobalUnixMakefileGenerator3.h
+  cmGraphAdjacencyList.h
+  cmGraphVizWriter.cxx
+  cmGraphVizWriter.h
+  cmInstallGenerator.h
+  cmInstallGenerator.cxx
+  cmInstallExportGenerator.cxx
+  cmInstalledFile.h
+  cmInstalledFile.cxx
+  cmInstallFilesGenerator.h
+  cmInstallFilesGenerator.cxx
+  cmInstallScriptGenerator.h
+  cmInstallScriptGenerator.cxx
+  cmInstallTargetGenerator.h
+  cmInstallTargetGenerator.cxx
+  cmInstallDirectoryGenerator.h
+  cmInstallDirectoryGenerator.cxx
+  cmLinkedTree.h
+  cmLinkItem.h
+  cmLinkLineComputer.cxx
+  cmLinkLineComputer.h
+  cmLinkLineDeviceComputer.cxx
+  cmLinkLineDeviceComputer.h
+  cmListFileCache.cxx
+  cmListFileCache.h
+  cmLocalCommonGenerator.cxx
+  cmLocalCommonGenerator.h
+  cmLocalGenerator.cxx
+  cmLocalGenerator.h
+  cmRulePlaceholderExpander.cxx
+  cmRulePlaceholderExpander.h
+  cmLocalUnixMakefileGenerator3.cxx
+  cmLocale.h
+  ${MACH_SRCS}
+  cmMakefile.cxx
+  cmMakefile.h
+  cmMakefileTargetGenerator.cxx
+  cmMakefileExecutableTargetGenerator.cxx
+  cmMakefileLibraryTargetGenerator.cxx
+  cmMakefileUtilityTargetGenerator.cxx
+  cmMessenger.cxx
+  cmMessenger.h
+  cmMSVC60LinkLineComputer.cxx
+  cmMSVC60LinkLineComputer.h
+  cmOSXBundleGenerator.cxx
+  cmOSXBundleGenerator.h
+  cmOutputConverter.cxx
+  cmOutputConverter.h
+  cmNewLineStyle.h
+  cmNewLineStyle.cxx
+  cmOrderDirectories.cxx
+  cmOrderDirectories.h
+  cmPolicies.h
+  cmPolicies.cxx
+  cmProcessOutput.cxx
+  cmProcessOutput.h
+  cmProcessTools.cxx
+  cmProcessTools.h
+  cmProperty.cxx
+  cmProperty.h
+  cmPropertyDefinition.cxx
+  cmPropertyDefinition.h
+  cmPropertyDefinitionMap.cxx
+  cmPropertyDefinitionMap.h
+  cmPropertyMap.cxx
+  cmPropertyMap.h
+  cmQtAutoGen.cxx
+  cmQtAutoGen.h
+  cmQtAutoGenerator.cxx
+  cmQtAutoGenerator.h
+  cmQtAutoGenInitializer.cxx
+  cmQtAutoGenInitializer.h
+  cmQtAutoGeneratorMocUic.cxx
+  cmQtAutoGeneratorMocUic.h
+  cmQtAutoGeneratorRcc.cxx
+  cmQtAutoGeneratorRcc.h
+  cmRST.cxx
+  cmRST.h
+  cmScriptGenerator.h
+  cmScriptGenerator.cxx
+  cmSourceFile.cxx
+  cmSourceFile.h
+  cmSourceFileLocation.cxx
+  cmSourceFileLocation.h
+  cmSourceFileLocationKind.h
+  cmSourceGroup.cxx
+  cmSourceGroup.h
+  cmState.cxx
+  cmState.h
+  cmStateDirectory.cxx
+  cmStateDirectory.h
+  cmStateSnapshot.cxx
+  cmStateSnapshot.h
+  cmStateTypes.h
+  cmSystemTools.cxx
+  cmSystemTools.h
+  cmTarget.cxx
+  cmTarget.h
+  cmTargetPropertyComputer.cxx
+  cmTargetPropertyComputer.h
+  cmTargetExport.h
+  cmTest.cxx
+  cmTest.h
+  cmTestGenerator.cxx
+  cmTestGenerator.h
+  cmUuid.cxx
+  cmUVHandlePtr.cxx
+  cmUVHandlePtr.h
+  cmVariableWatch.cxx
+  cmVariableWatch.h
+  cmVersion.cxx
+  cmVersion.h
+  cmWorkingDirectory.cxx
+  cmWorkingDirectory.h
+  cmXMLParser.cxx
+  cmXMLParser.h
+  cmXMLSafe.cxx
+  cmXMLSafe.h
+  cmXMLWriter.cxx
+  cmXMLWriter.h
+  cmake.cxx
+  cmake.h
+
+  cmCommand.cxx
+  cmCommand.h
+  cmCommands.cxx
+  cmCommands.h
+  cmAddCompileOptionsCommand.cxx
+  cmAddCompileOptionsCommand.h
+  cmAddCustomCommandCommand.cxx
+  cmAddCustomCommandCommand.h
+  cmAddCustomTargetCommand.cxx
+  cmAddCustomTargetCommand.h
+  cmAddDefinitionsCommand.cxx
+  cmAddDefinitionsCommand.h
+  cmAddDependenciesCommand.cxx
+  cmAddDependenciesCommand.h
+  cmAddExecutableCommand.cxx
+  cmAddExecutableCommand.h
+  cmAddLibraryCommand.cxx
+  cmAddLibraryCommand.h
+  cmAddSubDirectoryCommand.cxx
+  cmAddSubDirectoryCommand.h
+  cmAddTestCommand.cxx
+  cmAddTestCommand.h
+  cmAuxSourceDirectoryCommand.cxx
+  cmAuxSourceDirectoryCommand.h
+  cmBreakCommand.cxx
+  cmBreakCommand.h
+  cmBuildCommand.cxx
+  cmBuildCommand.h
+  cmBuildNameCommand.cxx
+  cmBuildNameCommand.h
+  cmCMakeHostSystemInformationCommand.cxx
+  cmCMakeHostSystemInformationCommand.h
+  cmCMakeMinimumRequired.cxx
+  cmCMakeMinimumRequired.h
+  cmCMakePolicyCommand.cxx
+  cmCMakePolicyCommand.h
+  cmCommandArgumentsHelper.cxx
+  cmCommandArgumentsHelper.h
+  cmConditionEvaluator.cxx
+  cmConditionEvaluator.h
+  cmConfigureFileCommand.cxx
+  cmConfigureFileCommand.h
+  cmContinueCommand.cxx
+  cmContinueCommand.h
+  cmCoreTryCompile.cxx
+  cmCoreTryCompile.h
+  cmCreateTestSourceList.cxx
+  cmCreateTestSourceList.h
+  cmDefinePropertyCommand.cxx
+  cmDefinePropertyCommand.h
+  cmDisallowedCommand.cxx
+  cmDisallowedCommand.h
+  cmEnableLanguageCommand.cxx
+  cmEnableLanguageCommand.h
+  cmEnableTestingCommand.cxx
+  cmEnableTestingCommand.h
+  cmExecProgramCommand.cxx
+  cmExecProgramCommand.h
+  cmExecuteProcessCommand.cxx
+  cmExecuteProcessCommand.h
+  cmExpandedCommandArgument.cxx
+  cmExpandedCommandArgument.h
+  cmExportCommand.cxx
+  cmExportCommand.h
+  cmExportLibraryDependenciesCommand.cxx
+  cmExportLibraryDependenciesCommand.h
+  cmFLTKWrapUICommand.cxx
+  cmFLTKWrapUICommand.h
+  cmFileCommand.cxx
+  cmFileCommand.h
+  cmFindBase.cxx
+  cmFindBase.h
+  cmFindCommon.cxx
+  cmFindCommon.h
+  cmFindFileCommand.cxx
+  cmFindFileCommand.h
+  cmFindLibraryCommand.cxx
+  cmFindLibraryCommand.h
+  cmFindPackageCommand.cxx
+  cmFindPackageCommand.h
+  cmFindPathCommand.cxx
+  cmFindPathCommand.h
+  cmFindProgramCommand.cxx
+  cmFindProgramCommand.h
+  cmForEachCommand.cxx
+  cmForEachCommand.h
+  cmFunctionCommand.cxx
+  cmFunctionCommand.h
+  cmGetCMakePropertyCommand.cxx
+  cmGetCMakePropertyCommand.h
+  cmGetDirectoryPropertyCommand.cxx
+  cmGetDirectoryPropertyCommand.h
+  cmGetFilenameComponentCommand.cxx
+  cmGetFilenameComponentCommand.h
+  cmGetPropertyCommand.cxx
+  cmGetPropertyCommand.h
+  cmGetSourceFilePropertyCommand.cxx
+  cmGetSourceFilePropertyCommand.h
+  cmGetTargetPropertyCommand.cxx
+  cmGetTargetPropertyCommand.h
+  cmGetTestPropertyCommand.cxx
+  cmGetTestPropertyCommand.h
+  cmHexFileConverter.cxx
+  cmHexFileConverter.h
+  cmIfCommand.cxx
+  cmIfCommand.h
+  cmIncludeCommand.cxx
+  cmIncludeCommand.h
+  cmIncludeDirectoryCommand.cxx
+  cmIncludeDirectoryCommand.h
+  cmIncludeExternalMSProjectCommand.cxx
+  cmIncludeExternalMSProjectCommand.h
+  cmIncludeGuardCommand.cxx
+  cmIncludeGuardCommand.h
+  cmIncludeRegularExpressionCommand.cxx
+  cmIncludeRegularExpressionCommand.h
+  cmInstallCommand.cxx
+  cmInstallCommand.h
+  cmInstallCommandArguments.cxx
+  cmInstallCommandArguments.h
+  cmInstallFilesCommand.cxx
+  cmInstallFilesCommand.h
+  cmInstallProgramsCommand.cxx
+  cmInstallProgramsCommand.h
+  cmInstallTargetsCommand.cxx
+  cmInstallTargetsCommand.h
+  cmLinkDirectoriesCommand.cxx
+  cmLinkDirectoriesCommand.h
+  cmLinkLibrariesCommand.cxx
+  cmLinkLibrariesCommand.h
+  cmListCommand.cxx
+  cmListCommand.h
+  cmLoadCacheCommand.cxx
+  cmLoadCacheCommand.h
+  cmLoadCommandCommand.cxx
+  cmLoadCommandCommand.h
+  cmMacroCommand.cxx
+  cmMacroCommand.h
+  cmMakeDirectoryCommand.cxx
+  cmMakeDirectoryCommand.h
+  cmMarkAsAdvancedCommand.cxx
+  cmMarkAsAdvancedCommand.h
+  cmMathCommand.cxx
+  cmMathCommand.h
+  cmMessageCommand.cxx
+  cmMessageCommand.h
+  cmOptionCommand.cxx
+  cmOptionCommand.h
+  cmOutputRequiredFilesCommand.cxx
+  cmOutputRequiredFilesCommand.h
+  cmParseArgumentsCommand.cxx
+  cmParseArgumentsCommand.h
+  cmPathLabel.cxx
+  cmPathLabel.h
+  cmProjectCommand.cxx
+  cmProjectCommand.h
+  cmQTWrapCPPCommand.cxx
+  cmQTWrapCPPCommand.h
+  cmQTWrapUICommand.cxx
+  cmQTWrapUICommand.h
+  cmRemoveCommand.cxx
+  cmRemoveCommand.h
+  cmRemoveDefinitionsCommand.cxx
+  cmRemoveDefinitionsCommand.h
+  cmReturnCommand.cxx
+  cmReturnCommand.h
+  cmSearchPath.cxx
+  cmSearchPath.h
+  cmSeparateArgumentsCommand.cxx
+  cmSeparateArgumentsCommand.h
+  cmSetCommand.cxx
+  cmSetCommand.h
+  cmSetDirectoryPropertiesCommand.cxx
+  cmSetDirectoryPropertiesCommand.h
+  cmSetPropertyCommand.cxx
+  cmSetPropertyCommand.h
+  cmSetSourceFilesPropertiesCommand.cxx
+  cmSetSourceFilesPropertiesCommand.h
+  cmSetTargetPropertiesCommand.cxx
+  cmSetTargetPropertiesCommand.h
+  cmSetTestsPropertiesCommand.cxx
+  cmSetTestsPropertiesCommand.h
+  cmSiteNameCommand.cxx
+  cmSiteNameCommand.h
+  cmSourceGroupCommand.cxx
+  cmSourceGroupCommand.h
+  cmStringCommand.cxx
+  cmStringCommand.h
+  cmSubdirCommand.cxx
+  cmSubdirCommand.h
+  cmSubdirDependsCommand.cxx
+  cmSubdirDependsCommand.h
+  cmTargetCompileDefinitionsCommand.cxx
+  cmTargetCompileDefinitionsCommand.h
+  cmTargetCompileFeaturesCommand.cxx
+  cmTargetCompileFeaturesCommand.h
+  cmTargetCompileOptionsCommand.cxx
+  cmTargetCompileOptionsCommand.h
+  cmTargetIncludeDirectoriesCommand.cxx
+  cmTargetIncludeDirectoriesCommand.h
+  cmTargetLinkLibrariesCommand.cxx
+  cmTargetLinkLibrariesCommand.h
+  cmTargetPropCommandBase.cxx
+  cmTargetPropCommandBase.h
+  cmTargetSourcesCommand.cxx
+  cmTargetSourcesCommand.h
+  cmTimestamp.cxx
+  cmTimestamp.h
+  cmTryCompileCommand.cxx
+  cmTryCompileCommand.h
+  cmTryRunCommand.cxx
+  cmTryRunCommand.h
+  cmUnexpectedCommand.cxx
+  cmUnexpectedCommand.h
+  cmUnsetCommand.cxx
+  cmUnsetCommand.h
+  cmUseMangledMesaCommand.cxx
+  cmUseMangledMesaCommand.h
+  cmUtilitySourceCommand.cxx
+  cmUtilitySourceCommand.h
+  cmVariableRequiresCommand.cxx
+  cmVariableRequiresCommand.h
+  cmVariableWatchCommand.cxx
+  cmVariableWatchCommand.h
+  cmWhileCommand.cxx
+  cmWhileCommand.h
+  cmWriteFileCommand.cxx
+  cmWriteFileCommand.h
+
+  cm_get_date.h
+  cm_get_date.c
+  cm_utf8.h
+  cm_utf8.c
+  cm_codecvt.hxx
+  cm_codecvt.cxx
+  cm_thread.hxx
+  )
+
+SET_PROPERTY(SOURCE cmProcessOutput.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+  KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
+
+# Kdevelop only works on UNIX and not windows
+if(UNIX)
+  set(SRCS ${SRCS} cmGlobalKdevelopGenerator.cxx)
+endif()
+
+# Xcode only works on Apple
+if(APPLE)
+  set(SRCS ${SRCS}
+    cmXCodeObject.cxx
+    cmXCode21Object.cxx
+    cmXCodeScheme.cxx
+    cmGlobalXCodeGenerator.cxx
+    cmGlobalXCodeGenerator.h
+    cmLocalXCodeGenerator.cxx
+    cmLocalXCodeGenerator.h)
+endif()
+
+
+if (WIN32)
+  set(SRCS ${SRCS}
+    cmCallVisualStudioMacro.cxx
+    cmCallVisualStudioMacro.h
+    bindexplib.cxx
+    )
+
+  if(NOT UNIX)
+    set(SRCS ${SRCS}
+      cmGlobalBorlandMakefileGenerator.cxx
+      cmGlobalBorlandMakefileGenerator.h
+      cmGlobalMSYSMakefileGenerator.cxx
+      cmGlobalMinGWMakefileGenerator.cxx
+      cmGlobalNMakeMakefileGenerator.cxx
+      cmGlobalNMakeMakefileGenerator.h
+      cmGlobalJOMMakefileGenerator.cxx
+      cmGlobalJOMMakefileGenerator.h
+      cmGlobalVisualStudio71Generator.cxx
+      cmGlobalVisualStudio71Generator.h
+      cmGlobalVisualStudio7Generator.cxx
+      cmGlobalVisualStudio7Generator.h
+      cmGlobalVisualStudio8Generator.cxx
+      cmGlobalVisualStudio8Generator.h
+      cmGlobalVisualStudio9Generator.cxx
+      cmGlobalVisualStudio9Generator.h
+      cmVisualStudioGeneratorOptions.h
+      cmVisualStudioGeneratorOptions.cxx
+      cmVisualStudio10TargetGenerator.h
+      cmVisualStudio10TargetGenerator.cxx
+      cmVisualStudio10ToolsetOptions.h
+      cmVisualStudio10ToolsetOptions.cxx
+      cmLocalVisualStudio10Generator.cxx
+      cmLocalVisualStudio10Generator.h
+      cmGlobalVisualStudio10Generator.h
+      cmGlobalVisualStudio10Generator.cxx
+      cmGlobalVisualStudio11Generator.h
+      cmGlobalVisualStudio11Generator.cxx
+      cmGlobalVisualStudio12Generator.h
+      cmGlobalVisualStudio12Generator.cxx
+      cmGlobalVisualStudio14Generator.h
+      cmGlobalVisualStudio14Generator.cxx
+      cmGlobalVisualStudio15Generator.h
+      cmGlobalVisualStudio15Generator.cxx
+      cmGlobalVisualStudioGenerator.cxx
+      cmGlobalVisualStudioGenerator.h
+      cmIDEFlagTable.h
+      cmIDEOptions.cxx
+      cmIDEOptions.h
+      cmLocalVisualStudio7Generator.cxx
+      cmLocalVisualStudio7Generator.h
+      cmLocalVisualStudioGenerator.cxx
+      cmLocalVisualStudioGenerator.h
+      cmVisualStudioSlnData.h
+      cmVisualStudioSlnData.cxx
+      cmVisualStudioSlnParser.h
+      cmVisualStudioSlnParser.cxx
+      cmVisualStudioWCEPlatformParser.h
+      cmVisualStudioWCEPlatformParser.cxx
+      cmGlobalGhsMultiGenerator.cxx
+      cmGlobalGhsMultiGenerator.h
+      cmLocalGhsMultiGenerator.cxx
+      cmLocalGhsMultiGenerator.h
+      cmGhsMultiTargetGenerator.cxx
+      cmGhsMultiTargetGenerator.h
+      cmGhsMultiGpj.cxx
+      cmGhsMultiGpj.h
+      cmVSSetupHelper.cxx
+      cmVSSetupHelper.h
+      )
+
+    # Add a manifest file to executables on Windows to allow for
+    # GetVersion to work properly on Windows 8 and above.
+    set(MANIFEST_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake.version.manifest)
+  endif()
+endif ()
+
+# Watcom support
+if(WIN32 OR CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  set_property(SOURCE cmake.cxx APPEND PROPERTY COMPILE_DEFINITIONS CMAKE_USE_WMAKE)
+  list(APPEND SRCS
+    cmGlobalWatcomWMakeGenerator.cxx
+    cmGlobalWatcomWMakeGenerator.h
+    )
+endif()
+
+# Ninja support
+set(SRCS ${SRCS}
+  cmGlobalNinjaGenerator.cxx
+  cmGlobalNinjaGenerator.h
+  cmNinjaTypes.h
+  cmLocalNinjaGenerator.cxx
+  cmLocalNinjaGenerator.h
+  cmNinjaTargetGenerator.cxx
+  cmNinjaTargetGenerator.h
+  cmNinjaNormalTargetGenerator.cxx
+  cmNinjaNormalTargetGenerator.h
+  cmNinjaUtilityTargetGenerator.cxx
+  cmNinjaUtilityTargetGenerator.h
+  cmNinjaLinkLineComputer.cxx
+  cmNinjaLinkLineComputer.h
+  )
+
+# Temporary variable for tools targets
+set(_tools)
+
+if(WIN32 AND NOT CYGWIN)
+  set_source_files_properties(cmcldeps.cxx PROPERTIES COMPILE_DEFINITIONS _WIN32_WINNT=0x0501)
+  add_executable(cmcldeps cmcldeps.cxx ${MANIFEST_FILE})
+  list(APPEND _tools cmcldeps)
+  target_link_libraries(cmcldeps CMakeLib)
+endif()
+
+foreach(v CURL_CA_BUNDLE CURL_CA_PATH)
+  if(${v})
+    set_property(SOURCE cmCurl.cxx APPEND PROPERTY COMPILE_DEFINITIONS ${v}="${${v}}")
+  endif()
+endforeach()
+
+foreach(check
+    STAT_HAS_ST_MTIM
+    STAT_HAS_ST_MTIMESPEC
+    )
+  if(KWSYS_CXX_${check}_COMPILED) # abuse KWSys check cache entry
+    set(CMake_${check} 1)
+  else()
+    set(CMake_${check} 0)
+  endif()
+  set_property(SOURCE cmFileTimeComparison.cxx APPEND PROPERTY
+    COMPILE_DEFINITIONS CMake_${check}=${CMake_${check}})
+endforeach()
+
+# create a library used by the command line and the GUI
+add_library(CMakeLib ${SRCS})
+target_link_libraries(CMakeLib cmsys
+  ${CMAKE_EXPAT_LIBRARIES} ${CMAKE_ZLIB_LIBRARIES}
+  ${CMAKE_TAR_LIBRARIES} ${CMAKE_COMPRESS_LIBRARIES}
+  ${CMAKE_CURL_LIBRARIES}
+  ${CMAKE_JSONCPP_LIBRARIES}
+  ${CMAKE_LIBUV_LIBRARIES}
+  ${CMAKE_LIBRHASH_LIBRARIES}
+  ${CMake_KWIML_LIBRARIES}
+  )
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "sparc")
+  # the atomic instructions are implemented using libatomic on some platforms,
+  # so linking to that may be required
+  check_library_exists(atomic __atomic_fetch_add_4 "" LIBATOMIC_NEEDED)
+  if(LIBATOMIC_NEEDED)
+    target_link_libraries(CMakeLib atomic)
+  endif()
+endif()
+
+# On Apple we need CoreFoundation
+if(APPLE)
+  target_link_libraries(CMakeLib "-framework CoreFoundation")
+endif()
+
+if(WIN32 AND NOT UNIX)
+  # We need the rpcrt4 library on Windows.
+  # We need the crypt32 library on Windows for crypto/cert APIs.
+  target_link_libraries(CMakeLib rpcrt4 crypt32)
+endif()
+
+target_compile_definitions(CMakeLib PUBLIC ${CLANG_TIDY_DEFINITIONS})
+
+#
+# CTestLib
+#
+include_directories(
+  "${CMake_SOURCE_DIR}/Source/CTest"
+  ${CMAKE_XMLRPC_INCLUDES}
+  ${CMAKE_CURL_INCLUDES}
+  )
+#
+# Sources for CTestLib
+#
+set(CTEST_SRCS cmCTest.cxx
+  CTest/cmProcess.cxx
+  CTest/cmCTestBuildAndTestHandler.cxx
+  CTest/cmCTestBuildCommand.cxx
+  CTest/cmCTestBuildHandler.cxx
+  CTest/cmCTestConfigureCommand.cxx
+  CTest/cmCTestConfigureHandler.cxx
+  CTest/cmCTestCoverageCommand.cxx
+  CTest/cmCTestCoverageHandler.cxx
+  CTest/cmCTestCurl.cxx
+  CTest/cmParseMumpsCoverage.cxx
+  CTest/cmParseCacheCoverage.cxx
+  CTest/cmParseGTMCoverage.cxx
+  CTest/cmParseJacocoCoverage.cxx
+  CTest/cmParseBlanketJSCoverage.cxx
+  CTest/cmParsePHPCoverage.cxx
+  CTest/cmParseCoberturaCoverage.cxx
+  CTest/cmParseDelphiCoverage.cxx
+  CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
+  CTest/cmCTestGenericHandler.cxx
+  CTest/cmCTestHandlerCommand.cxx
+  CTest/cmCTestLaunch.cxx
+  CTest/cmCTestMemCheckCommand.cxx
+  CTest/cmCTestMemCheckHandler.cxx
+  CTest/cmCTestMultiProcessHandler.cxx
+  CTest/cmCTestReadCustomFilesCommand.cxx
+  CTest/cmCTestRunScriptCommand.cxx
+  CTest/cmCTestRunTest.cxx
+  CTest/cmCTestScriptHandler.cxx
+  CTest/cmCTestSleepCommand.cxx
+  CTest/cmCTestStartCommand.cxx
+  CTest/cmCTestSubmitCommand.cxx
+  CTest/cmCTestSubmitHandler.cxx
+  CTest/cmCTestTestCommand.cxx
+  CTest/cmCTestTestHandler.cxx
+  CTest/cmCTestUpdateCommand.cxx
+  CTest/cmCTestUpdateHandler.cxx
+  CTest/cmCTestUploadCommand.cxx
+  CTest/cmCTestUploadHandler.cxx
+
+  CTest/cmCTestVC.cxx
+  CTest/cmCTestVC.h
+  CTest/cmCTestGlobalVC.cxx
+  CTest/cmCTestGlobalVC.h
+  CTest/cmCTestCVS.cxx
+  CTest/cmCTestCVS.h
+  CTest/cmCTestSVN.cxx
+  CTest/cmCTestSVN.h
+  CTest/cmCTestBZR.cxx
+  CTest/cmCTestBZR.h
+  CTest/cmCTestGIT.cxx
+  CTest/cmCTestGIT.h
+  CTest/cmCTestHG.cxx
+  CTest/cmCTestHG.h
+  CTest/cmCTestP4.cxx
+  CTest/cmCTestP4.h
+  )
+
+# Build CTestLib
+add_library(CTestLib ${CTEST_SRCS})
+target_link_libraries(CTestLib CMakeLib ${CMAKE_CURL_LIBRARIES} ${CMAKE_XMLRPC_LIBRARIES})
+
+#
+# CPack
+#
+include_directories(
+  "${CMake_SOURCE_DIR}/Source/CPack"
+  )
+#
+# Sources for CPack
+#
+set(CPACK_SRCS
+  CPack/cmCPackArchiveGenerator.cxx
+  CPack/cmCPackComponentGroup.cxx
+  CPack/cmCPackGeneratorFactory.cxx
+  CPack/cmCPackGenerator.cxx
+  CPack/cmCPackLog.cxx
+  CPack/cmCPackNSISGenerator.cxx
+  CPack/cmCPackSTGZGenerator.cxx
+  CPack/cmCPackTGZGenerator.cxx
+  CPack/cmCPackTXZGenerator.cxx
+  CPack/cmCPackTarBZip2Generator.cxx
+  CPack/cmCPackTarCompressGenerator.cxx
+  CPack/cmCPackZIPGenerator.cxx
+  CPack/cmCPack7zGenerator.cxx
+  CPack/cmCPackDebGenerator.cxx
+  )
+# CPack IFW generator
+set(CPACK_SRCS ${CPACK_SRCS}
+  CPack/IFW/cmCPackIFWCommon.cxx
+  CPack/IFW/cmCPackIFWCommon.h
+  CPack/IFW/cmCPackIFWGenerator.cxx
+  CPack/IFW/cmCPackIFWGenerator.h
+  CPack/IFW/cmCPackIFWInstaller.cxx
+  CPack/IFW/cmCPackIFWInstaller.h
+  CPack/IFW/cmCPackIFWPackage.cxx
+  CPack/IFW/cmCPackIFWPackage.h
+  CPack/IFW/cmCPackIFWRepository.cxx
+  CPack/IFW/cmCPackIFWRepository.h
+  )
+
+if(CYGWIN)
+  set(CPACK_SRCS ${CPACK_SRCS}
+    CPack/cmCPackCygwinBinaryGenerator.cxx
+    CPack/cmCPackCygwinSourceGenerator.cxx
+    )
+endif()
+
+option(CPACK_ENABLE_FREEBSD_PKG "Add FreeBSD pkg(8) generator to CPack." OFF)
+
+if(UNIX)
+  set(CPACK_SRCS ${CPACK_SRCS}
+    CPack/cmCPackRPMGenerator.cxx
+    )
+
+  # Optionally, try to use pkg(8)
+  if(CPACK_ENABLE_FREEBSD_PKG)
+    # On UNIX, you may find FreeBSD's pkg(8) and attendant
+    # library -- it can be used on FreeBSD, Dragonfly, NetBSD,
+    # OpenBSD and also Linux and OSX. Look for the header and
+    # the library; it's a warning on FreeBSD if they're not
+    # found, and informational on other platforms.
+    find_path(FREEBSD_PKG_INCLUDE_DIRS "pkg.h")
+    if(FREEBSD_PKG_INCLUDE_DIRS)
+      find_library(FREEBSD_PKG_LIBRARIES
+        pkg
+        DOC "FreeBSD pkg(8) library")
+      if(FREEBSD_PKG_LIBRARIES)
+        set(CPACK_SRCS ${CPACK_SRCS}
+          CPack/cmCPackFreeBSDGenerator.cxx
+          )
+      endif()
+    endif()
+
+    if (NOT FREEBSD_PKG_INCLUDE_DIRS OR NOT FREEBSD_PKG_LIBRARIES)
+      message(FATAL_ERROR "CPack needs libpkg(3) to produce FreeBSD packages natively.")
+    endif()
+  else()
+    set(FREEBSD_PKG_INCLUDE_DIRS NOTFOUND)
+    set(FREEBSD_PKG_LIBRARIES NOTFOUND)
+  endif()
+endif()
+
+if(CYGWIN)
+  find_package(LibUUID)
+endif()
+if(WIN32 OR (CYGWIN AND LibUUID_FOUND))
+  set(CPACK_SRCS ${CPACK_SRCS}
+    CPack/Wix/cmCMakeToWixPath.cxx
+    CPack/Wix/cmCMakeToWixPath.h
+    CPack/WiX/cmCPackWIXGenerator.cxx
+    CPack/WiX/cmCPackWIXGenerator.h
+    CPack/WiX/cmWIXAccessControlList.cxx
+    CPack/WiX/cmWIXAccessControlList.h
+    CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
+    CPack/WiX/cmWIXDirectoriesSourceWriter.h
+    CPack/WiX/cmWIXFeaturesSourceWriter.cxx
+    CPack/WiX/cmWIXFeaturesSourceWriter.h
+    CPack/WiX/cmWIXFilesSourceWriter.cxx
+    CPack/WiX/cmWIXFilesSourceWriter.h
+    CPack/WiX/cmWIXPatch.cxx
+    CPack/WiX/cmWIXPatch.h
+    CPack/WiX/cmWIXPatchParser.cxx
+    CPack/WiX/cmWIXPatchParser.h
+    CPack/WiX/cmWIXRichTextFormatWriter.cxx
+    CPack/WiX/cmWIXRichTextFormatWriter.h
+    CPack/WiX/cmWIXShortcut.cxx
+    CPack/WiX/cmWIXShortcut.h
+    CPack/WiX/cmWIXSourceWriter.cxx
+    CPack/WiX/cmWIXSourceWriter.h
+    )
+endif()
+
+if(APPLE)
+  set(CPACK_SRCS ${CPACK_SRCS}
+    CPack/cmCPackBundleGenerator.cxx
+    CPack/cmCPackDragNDropGenerator.cxx
+    CPack/cmCPackOSXX11Generator.cxx
+    CPack/cmCPackPKGGenerator.cxx
+    CPack/cmCPackPackageMakerGenerator.cxx
+    CPack/cmCPackProductBuildGenerator.cxx
+    )
+endif()
+
+# Build CPackLib
+add_library(CPackLib ${CPACK_SRCS})
+target_link_libraries(CPackLib CMakeLib)
+if(APPLE)
+  # Some compilers produce errors in the CoreServices framework headers.
+  # Ideally such errors should be fixed by either the compiler vendor
+  # or the framework source, but we try to workaround it and build anyway.
+  # If it does not work, build with reduced functionality and warn.
+  check_include_file("CoreServices/CoreServices.h" HAVE_CoreServices)
+  if(HAVE_CoreServices)
+    set_property(SOURCE CPack/cmCPackDragNDropGenerator.cxx PROPERTY COMPILE_DEFINITIONS HAVE_CoreServices)
+    target_link_libraries(CPackLib "-framework CoreServices")
+  else()
+    message(WARNING "This compiler does not appear to support\n"
+      "  #include <CoreServices/CoreServices.h>\n"
+      "Some CPack functionality may be limited.\n"
+      "See CMakeFiles/CMakeError.log for details of the failure.")
+  endif()
+endif()
+if(CYGWIN AND LibUUID_FOUND)
+  target_link_libraries(CPackLib ${LibUUID_LIBRARIES})
+  include_directories(CPackLib ${LibUUID_INCLUDE_DIRS})
+  set_property(SOURCE CPack/cmCPackGeneratorFactory.cxx PROPERTY COMPILE_DEFINITIONS HAVE_LIBUUID)
+endif()
+if(CPACK_ENABLE_FREEBSD_PKG AND FREEBSD_PKG_INCLUDE_DIRS AND FREEBSD_PKG_LIBRARIES)
+  target_link_libraries(CPackLib ${FREEBSD_PKG_LIBRARIES})
+  include_directories(${FREEBSD_PKG_INCLUDE_DIRS})
+  add_definitions(-DHAVE_FREEBSD_PKG)
+endif()
+
+if(APPLE)
+  add_executable(cmakexbuild cmakexbuild.cxx)
+  list(APPEND _tools cmakexbuild)
+  target_link_libraries(cmakexbuild CMakeLib)
+  add_executable(OSXScriptLauncher
+    CPack/OSXScriptLauncher.cxx)
+  target_link_libraries(OSXScriptLauncher cmsys)
+  target_link_libraries(OSXScriptLauncher "-framework CoreFoundation")
+endif()
+
+# Build CMake executable
+add_executable(cmake cmakemain.cxx cmcmd.cxx cmcmd.h ${MANIFEST_FILE})
+list(APPEND _tools cmake)
+target_link_libraries(cmake CMakeLib)
+
+add_library(CMakeServerLib
+  cmConnection.h cmConnection.cxx
+  cmFileMonitor.cxx cmFileMonitor.h
+  cmPipeConnection.cxx cmPipeConnection.h
+  cmServer.cxx cmServer.h
+  cmServerConnection.cxx cmServerConnection.h
+  cmServerProtocol.cxx cmServerProtocol.h
+  )
+target_link_libraries(CMakeServerLib CMakeLib)
+target_link_libraries(cmake CMakeServerLib)
+
+# Build CTest executable
+add_executable(ctest ctest.cxx ${MANIFEST_FILE})
+list(APPEND _tools ctest)
+target_link_libraries(ctest CTestLib)
+
+# Build CPack executable
+add_executable(cpack CPack/cpack.cxx ${MANIFEST_FILE})
+list(APPEND _tools cpack)
+target_link_libraries(cpack CPackLib)
+
+# Curses GUI
+if(BUILD_CursesDialog)
+  include(${CMake_SOURCE_DIR}/Source/CursesDialog/CMakeLists.txt)
+endif()
+
+# Qt GUI
+option(BUILD_QtDialog "Build Qt dialog for CMake" FALSE)
+if(BUILD_QtDialog)
+  add_subdirectory(QtDialog)
+endif()
+
+include (${CMake_BINARY_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
+include (${CMake_SOURCE_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
+
+if(WIN32)
+  # Add Windows executable version information.
+  configure_file("CMakeVersion.rc.in" "CMakeVersion.rc" @ONLY)
+
+  # We use a separate object library for this to work around a limitation of
+  # MinGW's windres tool with spaces in the path to the include directories.
+  add_library(CMakeVersion OBJECT "${CMAKE_CURRENT_BINARY_DIR}/CMakeVersion.rc")
+  set_property(TARGET CMakeVersion PROPERTY INCLUDE_DIRECTORIES "")
+  foreach(_tool ${_tools})
+    target_sources(${_tool} PRIVATE $<TARGET_OBJECTS:CMakeVersion>)
+  endforeach()
+endif()
+
+# Install tools
+
+foreach(_tool ${_tools})
+  CMake_OPTIONAL_COMPONENT(${_tool})
+  install(TARGETS ${_tool} DESTINATION ${CMAKE_BIN_DIR} ${COMPONENT})
+endforeach()
+
+install(FILES cmCPluginAPI.h DESTINATION ${CMAKE_DATA_DIR}/include)
+
+# Unset temporary variables
+unset(_tools)
diff --git a/Source/CMakeSourceDir.txt.in b/Source/CMakeSourceDir.txt.in
new file mode 100644
index 0000000..5e6a988
--- /dev/null
+++ b/Source/CMakeSourceDir.txt.in
@@ -0,0 +1 @@
+@CMake_SOURCE_DIR@
diff --git a/Source/CMakeVersion.bash b/Source/CMakeVersion.bash
new file mode 100755
index 0000000..853b0ca
--- /dev/null
+++ b/Source/CMakeVersion.bash
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Update the version component if it looks like a date or -f is given.
+if test "x$1" = "x-f"; then shift ; n='*' ; else n='\{8\}' ; fi
+if test "$#" -gt 0; then echo 1>&2 "usage: CMakeVersion.bash [-f]"; exit 1; fi
+sed -i -e '
+s/\(^set(CMake_VERSION_PATCH\) [0-9]'"$n"'\(.*\)/\1 '"$(date +%Y%m%d)"'\2/
+' "${BASH_SOURCE%/*}/CMakeVersion.cmake"
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
new file mode 100644
index 0000000..bab642b
--- /dev/null
+++ b/Source/CMakeVersion.cmake
@@ -0,0 +1,5 @@
+# CMake version number components.
+set(CMake_VERSION_MAJOR 3)
+set(CMake_VERSION_MINOR 10)
+set(CMake_VERSION_PATCH 20180124)
+#set(CMake_VERSION_RC 1)
diff --git a/Source/CMakeVersion.rc.in b/Source/CMakeVersion.rc.in
new file mode 100644
index 0000000..22b4a36
--- /dev/null
+++ b/Source/CMakeVersion.rc.in
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#define VER_FILEVERSION             @CMake_RCVERSION@
+#define VER_FILEVERSION_STR         "@CMake_RCVERSION_STR@\0"
+
+#define VER_PRODUCTVERSION          @CMake_RCVERSION@
+#define VER_PRODUCTVERSION_STR      "@CMake_RCVERSION_STR@\0"
+
+/* Version-information resource identifier.  */
+#define VS_VERSION_INFO 1
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION    	VER_FILEVERSION
+PRODUCTVERSION 	VER_PRODUCTVERSION
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        BEGIN
+            VALUE "FileVersion",      VER_FILEVERSION_STR
+            VALUE "ProductVersion",   VER_PRODUCTVERSION_STR
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        /* The following line should only be modified for localized versions.     */
+        /* It consists of any number of WORD,WORD pairs, with each pair           */
+        /* describing a language,codepage combination supported by the file.      */
+        /*                                                                        */
+        /* For example, a file might have values "0x409,1252" indicating that it  */
+        /* supports English language (0x409) in the Windows ANSI codepage (1252). */
+
+        VALUE "Translation", 0x409, 1252
+    END
+END
diff --git a/Source/CMakeVersionCompute.cmake b/Source/CMakeVersionCompute.cmake
new file mode 100644
index 0000000..79264ed
--- /dev/null
+++ b/Source/CMakeVersionCompute.cmake
@@ -0,0 +1,39 @@
+# Load version number components.
+include(${CMake_SOURCE_DIR}/Source/CMakeVersion.cmake)
+
+# Releases define a small patch level.
+if("${CMake_VERSION_PATCH}" VERSION_LESS 20000000)
+  set(CMake_VERSION_IS_DIRTY 0)
+  set(CMake_VERSION_IS_RELEASE 1)
+  set(CMake_VERSION_SOURCE "")
+else()
+  set(CMake_VERSION_IS_DIRTY 0) # may be set to 1 by CMakeVersionSource
+  set(CMake_VERSION_IS_RELEASE 0)
+  include(${CMake_SOURCE_DIR}/Source/CMakeVersionSource.cmake)
+endif()
+
+# Compute the full version string.
+set(CMake_VERSION ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH})
+if(CMake_VERSION_SOURCE)
+  set(CMake_VERSION_SUFFIX "${CMake_VERSION_SOURCE}")
+elseif(CMake_VERSION_RC)
+  set(CMake_VERSION_SUFFIX "rc${CMake_VERSION_RC}")
+else()
+  set(CMake_VERSION_SUFFIX "")
+endif()
+if(CMake_VERSION_SUFFIX)
+  set(CMake_VERSION ${CMake_VERSION}-${CMake_VERSION_SUFFIX})
+endif()
+if(CMake_VERSION_IS_DIRTY)
+  set(CMake_VERSION ${CMake_VERSION}-dirty)
+endif()
+
+# Compute the binary version that appears in the RC file. Version
+# components in the RC file are 16-bit integers so we may have to
+# split the patch component.
+if(CMake_VERSION_PATCH MATCHES "^([0-9]+)([0-9][0-9][0-9][0-9])$")
+  set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMAKE_MATCH_1},${CMAKE_MATCH_2})
+else()
+  set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH})
+endif()
+set(CMake_RCVERSION_STR ${CMake_VERSION})
diff --git a/Source/CMakeVersionSource.cmake b/Source/CMakeVersionSource.cmake
new file mode 100644
index 0000000..5ea1de3
--- /dev/null
+++ b/Source/CMakeVersionSource.cmake
@@ -0,0 +1,30 @@
+# Try to identify the current development source version.
+set(CMake_VERSION_SOURCE "")
+if(EXISTS ${CMake_SOURCE_DIR}/.git/HEAD)
+  find_program(GIT_EXECUTABLE NAMES git git.cmd)
+  mark_as_advanced(GIT_EXECUTABLE)
+  if(GIT_EXECUTABLE)
+    execute_process(
+      COMMAND ${GIT_EXECUTABLE} rev-parse --verify -q --short=4 HEAD
+      OUTPUT_VARIABLE head
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMake_SOURCE_DIR}
+      )
+    if(head)
+      set(CMake_VERSION_SOURCE "g${head}")
+      execute_process(
+        COMMAND ${GIT_EXECUTABLE} update-index -q --refresh
+        WORKING_DIRECTORY ${CMake_SOURCE_DIR}
+        )
+      execute_process(
+        COMMAND ${GIT_EXECUTABLE} diff-index --name-only HEAD --
+        OUTPUT_VARIABLE dirty
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        WORKING_DIRECTORY ${CMake_SOURCE_DIR}
+        )
+      if(dirty)
+        set(CMake_VERSION_IS_DIRTY 1)
+      endif()
+    endif()
+  endif()
+endif()
diff --git a/Source/CPack/IFW/cmCPackIFWCommon.cxx b/Source/CPack/IFW/cmCPackIFWCommon.cxx
new file mode 100644
index 0000000..1e72641
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWCommon.cxx
@@ -0,0 +1,137 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackIFWCommon.h"
+
+#include "cmCPackGenerator.h"
+#include "cmCPackIFWGenerator.h"
+#include "cmCPackLog.h" // IWYU pragma: keep
+#include "cmSystemTools.h"
+#include "cmTimestamp.h"
+#include "cmVersionConfig.h"
+#include "cmXMLWriter.h"
+
+#include <sstream>
+#include <utility>
+#include <vector>
+
+cmCPackIFWCommon::cmCPackIFWCommon()
+  : Generator(nullptr)
+{
+}
+
+const char* cmCPackIFWCommon::GetOption(const std::string& op) const
+{
+  return this->Generator ? this->Generator->cmCPackGenerator::GetOption(op)
+                         : nullptr;
+}
+
+bool cmCPackIFWCommon::IsOn(const std::string& op) const
+{
+  return this->Generator ? this->Generator->cmCPackGenerator::IsOn(op) : false;
+}
+
+bool cmCPackIFWCommon::IsSetToOff(const std::string& op) const
+{
+  return this->Generator ? this->Generator->cmCPackGenerator::IsSetToOff(op)
+                         : false;
+}
+
+bool cmCPackIFWCommon::IsSetToEmpty(const std::string& op) const
+{
+  return this->Generator ? this->Generator->cmCPackGenerator::IsSetToEmpty(op)
+                         : false;
+}
+
+bool cmCPackIFWCommon::IsVersionLess(const char* version)
+{
+  if (!this->Generator) {
+    return false;
+  }
+
+  return cmSystemTools::VersionCompare(
+    cmSystemTools::OP_LESS, this->Generator->FrameworkVersion.data(), version);
+}
+
+bool cmCPackIFWCommon::IsVersionGreater(const char* version)
+{
+  if (!this->Generator) {
+    return false;
+  }
+
+  return cmSystemTools::VersionCompare(
+    cmSystemTools::OP_GREATER, this->Generator->FrameworkVersion.data(),
+    version);
+}
+
+bool cmCPackIFWCommon::IsVersionEqual(const char* version)
+{
+  if (!this->Generator) {
+    return false;
+  }
+
+  return cmSystemTools::VersionCompare(
+    cmSystemTools::OP_EQUAL, this->Generator->FrameworkVersion.data(),
+    version);
+}
+
+void cmCPackIFWCommon::ExpandListArgument(
+  const std::string& arg, std::map<std::string, std::string>& argsOut)
+{
+  std::vector<std::string> args;
+  cmSystemTools::ExpandListArgument(arg, args, false);
+  if (args.empty()) {
+    return;
+  }
+
+  std::size_t i = 0;
+  std::size_t c = args.size();
+  if (c % 2) {
+    argsOut[""] = args[i];
+    ++i;
+  }
+
+  --c;
+  for (; i < c; i += 2) {
+    argsOut[args[i]] = args[i + 1];
+  }
+}
+
+void cmCPackIFWCommon::ExpandListArgument(
+  const std::string& arg, std::multimap<std::string, std::string>& argsOut)
+{
+  std::vector<std::string> args;
+  cmSystemTools::ExpandListArgument(arg, args, false);
+  if (args.empty()) {
+    return;
+  }
+
+  std::size_t i = 0;
+  std::size_t c = args.size();
+  if (c % 2) {
+    argsOut.insert(std::pair<std::string, std::string>("", args[i]));
+    ++i;
+  }
+
+  --c;
+  for (; i < c; i += 2) {
+    argsOut.insert(std::pair<std::string, std::string>(args[i], args[i + 1]));
+  }
+}
+
+void cmCPackIFWCommon::WriteGeneratedByToStrim(cmXMLWriter& xout)
+{
+  if (!this->Generator) {
+    return;
+  }
+
+  std::ostringstream comment;
+  comment << "Generated by CPack " << CMake_VERSION << " IFW generator "
+          << "for QtIFW ";
+  if (this->IsVersionEqual("1.9.9")) {
+    comment << "less 2.0";
+  } else {
+    comment << this->Generator->FrameworkVersion;
+  }
+  comment << " tools at " << cmTimestamp().CurrentTime("", true);
+  xout.Comment(comment.str().c_str());
+}
diff --git a/Source/CPack/IFW/cmCPackIFWCommon.h b/Source/CPack/IFW/cmCPackIFWCommon.h
new file mode 100644
index 0000000..354d849
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWCommon.h
@@ -0,0 +1,81 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackIFWCommon_h
+#define cmCPackIFWCommon_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+
+class cmCPackIFWGenerator;
+class cmXMLWriter;
+
+/** \class cmCPackIFWCommon
+ * \brief A base class for CPack IFW generator implementation subclasses
+ */
+class cmCPackIFWCommon
+{
+public:
+  // Constructor
+
+  /**
+   * Construct Part
+   */
+  cmCPackIFWCommon();
+
+public:
+  // Internal implementation
+
+  const char* GetOption(const std::string& op) const;
+  bool IsOn(const std::string& op) const;
+  bool IsSetToOff(const std::string& op) const;
+  bool IsSetToEmpty(const std::string& op) const;
+
+  /**
+   * Compare \a version with QtIFW framework version
+   */
+  bool IsVersionLess(const char* version);
+
+  /**
+   * Compare \a version with QtIFW framework version
+   */
+  bool IsVersionGreater(const char* version);
+
+  /**
+   * Compare \a version with QtIFW framework version
+   */
+  bool IsVersionEqual(const char* version);
+
+  /** Expand the list argument containing the map of the key-value pairs.
+   *  If the number of elements is odd, then the first value is used as the
+   *  default value with an empty key.
+   *  Any values with the same keys will be permanently overwritten.
+   */
+  static void ExpandListArgument(const std::string& arg,
+                                 std::map<std::string, std::string>& argsOut);
+
+  /** Expand the list argument containing the multimap of the key-value pairs.
+   *  If the number of elements is odd, then the first value is used as the
+   *  default value with an empty key.
+   */
+  static void ExpandListArgument(
+    const std::string& arg, std::multimap<std::string, std::string>& argsOut);
+
+  cmCPackIFWGenerator* Generator;
+
+protected:
+  void WriteGeneratedByToStrim(cmXMLWriter& xout);
+};
+
+#define cmCPackIFWLogger(logType, msg)                                        \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    if (Generator) {                                                          \
+      Generator->Logger->Log(cmCPackLog::LOG_##logType, __FILE__, __LINE__,   \
+                             cmCPackLog_msg.str().c_str());                   \
+    }                                                                         \
+  } while (false)
+
+#endif // cmCPackIFWCommon_h
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
new file mode 100644
index 0000000..86c6981
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
@@ -0,0 +1,604 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackIFWGenerator.h"
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackIFWCommon.h"
+#include "cmCPackIFWInstaller.h"
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWRepository.h"
+#include "cmCPackLog.h" // IWYU pragma: keep
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+#include <sstream>
+#include <utility>
+
+cmCPackIFWGenerator::cmCPackIFWGenerator()
+{
+  this->Generator = this;
+}
+
+cmCPackIFWGenerator::~cmCPackIFWGenerator()
+{
+}
+
+int cmCPackIFWGenerator::PackageFiles()
+{
+  cmCPackIFWLogger(OUTPUT, "- Configuration" << std::endl);
+
+  // Installer configuragion
+  this->Installer.GenerateInstallerFile();
+
+  // Packages configuration
+  this->Installer.GeneratePackageFiles();
+
+  std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  std::string ifwTmpFile = ifwTLD;
+  ifwTmpFile += "/IFWOutput.log";
+
+  // Run repogen
+  if (!this->Installer.RemoteRepositories.empty()) {
+    std::string ifwCmd = this->RepoGen;
+
+    if (this->IsVersionLess("2.0.0")) {
+      ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+    }
+
+    ifwCmd += " -p " + this->toplevel + "/packages";
+
+    if (!this->PkgsDirsVector.empty()) {
+      for (std::string const& it : this->PkgsDirsVector) {
+        ifwCmd += " -p " + it;
+      }
+    }
+
+    if (!this->RepoDirsVector.empty()) {
+      if (!this->IsVersionLess("3.1")) {
+        for (std::string const& rd : this->RepoDirsVector) {
+          ifwCmd += " --repository " + rd;
+        }
+      } else {
+        cmCPackIFWLogger(WARNING, "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
+                           << "variable is set, but content will be skipped, "
+                           << "because this feature available only since "
+                           << "QtIFW 3.1. Please update your QtIFW instance."
+                           << std::endl);
+      }
+    }
+
+    if (!this->OnlineOnly && !this->DownloadedPackages.empty()) {
+      ifwCmd += " -i ";
+      std::set<cmCPackIFWPackage*>::iterator it =
+        this->DownloadedPackages.begin();
+      ifwCmd += (*it)->Name;
+      ++it;
+      while (it != this->DownloadedPackages.end()) {
+        ifwCmd += "," + (*it)->Name;
+        ++it;
+      }
+    }
+    ifwCmd += " " + this->toplevel + "/repository";
+    cmCPackIFWLogger(VERBOSE, "Execute: " << ifwCmd << std::endl);
+    std::string output;
+    int retVal = 1;
+    cmCPackIFWLogger(OUTPUT, "- Generate repository" << std::endl);
+    bool res = cmSystemTools::RunSingleCommand(ifwCmd.c_str(), &output,
+                                               &output, &retVal, nullptr,
+                                               this->GeneratorVerbose, 0);
+    if (!res || retVal) {
+      cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+      ofs << "# Run command: " << ifwCmd << std::endl
+          << "# Output:" << std::endl
+          << output << std::endl;
+      cmCPackIFWLogger(ERROR, "Problem running IFW command: "
+                         << ifwCmd << std::endl
+                         << "Please check " << ifwTmpFile << " for errors"
+                         << std::endl);
+      return 0;
+    }
+
+    if (!this->Repository.RepositoryUpdate.empty() &&
+        !this->Repository.PatchUpdatesXml()) {
+      cmCPackIFWLogger(WARNING, "Problem patch IFW \"Updates\" "
+                         << "file: "
+                         << this->toplevel + "/repository/Updates.xml"
+                         << std::endl);
+    }
+
+    cmCPackIFWLogger(OUTPUT, "- repository: " << this->toplevel
+                                              << "/repository generated"
+                                              << std::endl);
+  }
+
+  // Run binary creator
+  {
+    std::string ifwCmd = this->BinCreator;
+    ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+
+    if (!this->Installer.Resources.empty()) {
+      ifwCmd += " -r ";
+      std::vector<std::string>::iterator it =
+        this->Installer.Resources.begin();
+      std::string path = this->toplevel + "/resources/";
+      ifwCmd += path + *it;
+      ++it;
+      while (it != this->Installer.Resources.end()) {
+        ifwCmd += "," + path + *it;
+        ++it;
+      }
+    }
+
+    ifwCmd += " -p " + this->toplevel + "/packages";
+
+    if (!this->PkgsDirsVector.empty()) {
+      for (std::string const& it : this->PkgsDirsVector) {
+        ifwCmd += " -p " + it;
+      }
+    }
+
+    if (!this->RepoDirsVector.empty()) {
+      if (!this->IsVersionLess("3.1")) {
+        for (std::string const& rd : this->RepoDirsVector) {
+          ifwCmd += " --repository " + rd;
+        }
+      } else {
+        cmCPackIFWLogger(WARNING, "The \"CPACK_IFW_REPOSITORIES_DIRECTORIES\" "
+                           << "variable is set, but content will be skipped, "
+                           << "because this feature available only since "
+                           << "QtIFW 3.1. Please update your QtIFW instance."
+                           << std::endl);
+      }
+    }
+
+    if (this->OnlineOnly) {
+      ifwCmd += " --online-only";
+    } else if (!this->DownloadedPackages.empty() &&
+               !this->Installer.RemoteRepositories.empty()) {
+      ifwCmd += " -e ";
+      std::set<cmCPackIFWPackage*>::iterator it =
+        this->DownloadedPackages.begin();
+      ifwCmd += (*it)->Name;
+      ++it;
+      while (it != this->DownloadedPackages.end()) {
+        ifwCmd += "," + (*it)->Name;
+        ++it;
+      }
+    } else if (!this->DependentPackages.empty()) {
+      ifwCmd += " -i ";
+      // Binary
+      std::set<cmCPackIFWPackage*>::iterator bit =
+        this->BinaryPackages.begin();
+      while (bit != this->BinaryPackages.end()) {
+        ifwCmd += (*bit)->Name + ",";
+        ++bit;
+      }
+      // Depend
+      DependenceMap::iterator it = this->DependentPackages.begin();
+      ifwCmd += it->second.Name;
+      ++it;
+      while (it != this->DependentPackages.end()) {
+        ifwCmd += "," + it->second.Name;
+        ++it;
+      }
+    }
+    // TODO: set correct name for multipackages
+    if (!this->packageFileNames.empty()) {
+      ifwCmd += " " + this->packageFileNames[0];
+    } else {
+      ifwCmd += " installer";
+      ifwCmd += this->OutputExtension;
+    }
+    cmCPackIFWLogger(VERBOSE, "Execute: " << ifwCmd << std::endl);
+    std::string output;
+    int retVal = 1;
+    cmCPackIFWLogger(OUTPUT, "- Generate package" << std::endl);
+    bool res = cmSystemTools::RunSingleCommand(ifwCmd.c_str(), &output,
+                                               &output, &retVal, nullptr,
+                                               this->GeneratorVerbose, 0);
+    if (!res || retVal) {
+      cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+      ofs << "# Run command: " << ifwCmd << std::endl
+          << "# Output:" << std::endl
+          << output << std::endl;
+      cmCPackIFWLogger(ERROR, "Problem running IFW command: "
+                         << ifwCmd << std::endl
+                         << "Please check " << ifwTmpFile << " for errors"
+                         << std::endl);
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+const char* cmCPackIFWGenerator::GetPackagingInstallPrefix()
+{
+  const char* defPrefix = this->cmCPackGenerator::GetPackagingInstallPrefix();
+
+  std::string tmpPref = defPrefix ? defPrefix : "";
+
+  if (this->Components.empty()) {
+    tmpPref += "packages/" + this->GetRootPackageName() + "/data";
+  }
+
+  this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
+
+  return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
+}
+
+const char* cmCPackIFWGenerator::GetOutputExtension()
+{
+  return this->OutputExtension.c_str();
+}
+
+int cmCPackIFWGenerator::InitializeInternal()
+{
+  // Search Qt Installer Framework tools
+
+  const std::string BinCreatorOpt = "CPACK_IFW_BINARYCREATOR_EXECUTABLE";
+  const std::string RepoGenOpt = "CPACK_IFW_REPOGEN_EXECUTABLE";
+  const std::string FrameworkVersionOpt = "CPACK_IFW_FRAMEWORK_VERSION";
+
+  if (!this->IsSet(BinCreatorOpt) || !this->IsSet(RepoGenOpt) ||
+      !this->IsSet(FrameworkVersionOpt)) {
+    this->ReadListFile("CPackIFW.cmake");
+  }
+
+  // Look 'binarycreator' executable (needs)
+
+  const char* BinCreatorStr = this->GetOption(BinCreatorOpt);
+  if (!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr)) {
+    this->BinCreator.clear();
+  } else {
+    this->BinCreator = BinCreatorStr;
+  }
+
+  if (this->BinCreator.empty()) {
+    cmCPackIFWLogger(ERROR, "Cannot find QtIFW compiler \"binarycreator\": "
+                            "likely it is not installed, or not in your PATH"
+                       << std::endl);
+    return 0;
+  }
+
+  // Look 'repogen' executable (optional)
+
+  const char* RepoGenStr = this->GetOption(RepoGenOpt);
+  if (!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr)) {
+    this->RepoGen.clear();
+  } else {
+    this->RepoGen = RepoGenStr;
+  }
+
+  // Framework version
+  if (const char* FrameworkVersionSrt = this->GetOption(FrameworkVersionOpt)) {
+    this->FrameworkVersion = FrameworkVersionSrt;
+  } else {
+    this->FrameworkVersion = "1.9.9";
+  }
+
+  // Variables that Change Behavior
+
+  // Resolve duplicate names
+  this->ResolveDuplicateNames =
+    this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
+
+  // Additional packages dirs
+  this->PkgsDirsVector.clear();
+  if (const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) {
+    cmSystemTools::ExpandListArgument(dirs, this->PkgsDirsVector);
+  }
+
+  // Additional repositories dirs
+  this->RepoDirsVector.clear();
+  if (const char* dirs =
+        this->GetOption("CPACK_IFW_REPOSITORIES_DIRECTORIES")) {
+    cmSystemTools::ExpandListArgument(dirs, this->RepoDirsVector);
+  }
+
+  // Installer
+  this->Installer.Generator = this;
+  this->Installer.ConfigureFromOptions();
+
+  // Repository
+  this->Repository.Generator = this;
+  this->Repository.Name = "Unspecified";
+  if (const char* site = this->GetOption("CPACK_DOWNLOAD_SITE")) {
+    this->Repository.Url = site;
+    this->Installer.RemoteRepositories.push_back(&this->Repository);
+  }
+
+  // Repositories
+  if (const char* RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL")) {
+    std::vector<std::string> RepoAllVector;
+    cmSystemTools::ExpandListArgument(RepoAllStr, RepoAllVector);
+    for (std::string const& r : RepoAllVector) {
+      this->GetRepository(r);
+    }
+  }
+
+  if (const char* ifwDownloadAll = this->GetOption("CPACK_IFW_DOWNLOAD_ALL")) {
+    this->OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
+  } else if (const char* cpackDownloadAll =
+               this->GetOption("CPACK_DOWNLOAD_ALL")) {
+    this->OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
+  } else {
+    this->OnlineOnly = false;
+  }
+
+  if (!this->Installer.RemoteRepositories.empty() && this->RepoGen.empty()) {
+    cmCPackIFWLogger(ERROR,
+                     "Cannot find QtIFW repository generator \"repogen\": "
+                     "likely it is not installed, or not in your PATH"
+                       << std::endl);
+    return 0;
+  }
+
+  // Executable suffix
+  std::string exeSuffix(this->GetOption("CMAKE_EXECUTABLE_SUFFIX"));
+  std::string sysName(this->GetOption("CMAKE_SYSTEM_NAME"));
+  if (sysName == "Linux") {
+    this->ExecutableSuffix = ".run";
+  } else if (sysName == "Windows") {
+    this->ExecutableSuffix = ".exe";
+  } else if (sysName == "Darwin") {
+    this->ExecutableSuffix = ".app";
+  } else {
+    this->ExecutableSuffix = exeSuffix;
+  }
+
+  // Output extension
+  if (const char* optOutExt =
+        this->GetOption("CPACK_IFW_PACKAGE_FILE_EXTENSION")) {
+    this->OutputExtension = optOutExt;
+  } else if (sysName == "Darwin") {
+    this->OutputExtension = ".dmg";
+  } else {
+    this->OutputExtension = this->ExecutableSuffix;
+  }
+  if (this->OutputExtension.empty()) {
+    this->OutputExtension = this->cmCPackGenerator::GetOutputExtension();
+  }
+
+  return this->Superclass::InitializeInternal();
+}
+
+std::string cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  const std::string prefix = "packages/";
+  const std::string suffix = "/data";
+
+  if (this->componentPackageMethod == this->ONE_PACKAGE) {
+    return std::string(prefix + this->GetRootPackageName() + suffix);
+  }
+
+  return prefix +
+    this->GetComponentPackageName(&this->Components[componentName]) + suffix;
+}
+
+cmCPackComponent* cmCPackIFWGenerator::GetComponent(
+  const std::string& projectName, const std::string& componentName)
+{
+  ComponentsMap::iterator cit = this->Components.find(componentName);
+  if (cit != this->Components.end()) {
+    return &(cit->second);
+  }
+
+  cmCPackComponent* component =
+    this->cmCPackGenerator::GetComponent(projectName, componentName);
+  if (!component) {
+    return component;
+  }
+
+  std::string name = this->GetComponentPackageName(component);
+  PackagesMap::iterator pit = this->Packages.find(name);
+  if (pit != this->Packages.end()) {
+    return component;
+  }
+
+  cmCPackIFWPackage* package = &this->Packages[name];
+  package->Name = name;
+  package->Generator = this;
+  if (package->ConfigureFromComponent(component)) {
+    package->Installer = &this->Installer;
+    this->Installer.Packages.insert(
+      std::pair<std::string, cmCPackIFWPackage*>(name, package));
+    this->ComponentPackages.insert(
+      std::pair<cmCPackComponent*, cmCPackIFWPackage*>(component, package));
+    if (component->IsDownloaded) {
+      this->DownloadedPackages.insert(package);
+    } else {
+      this->BinaryPackages.insert(package);
+    }
+  } else {
+    this->Packages.erase(name);
+    cmCPackIFWLogger(ERROR, "Cannot configure package \""
+                       << name << "\" for component \"" << component->Name
+                       << "\"" << std::endl);
+  }
+
+  return component;
+}
+
+cmCPackComponentGroup* cmCPackIFWGenerator::GetComponentGroup(
+  const std::string& projectName, const std::string& groupName)
+{
+  cmCPackComponentGroup* group =
+    this->cmCPackGenerator::GetComponentGroup(projectName, groupName);
+  if (!group) {
+    return group;
+  }
+
+  std::string name = this->GetGroupPackageName(group);
+  PackagesMap::iterator pit = this->Packages.find(name);
+  if (pit != this->Packages.end()) {
+    return group;
+  }
+
+  cmCPackIFWPackage* package = &this->Packages[name];
+  package->Name = name;
+  package->Generator = this;
+  if (package->ConfigureFromGroup(group)) {
+    package->Installer = &this->Installer;
+    this->Installer.Packages.insert(
+      std::pair<std::string, cmCPackIFWPackage*>(name, package));
+    this->GroupPackages.insert(
+      std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(group, package));
+    this->BinaryPackages.insert(package);
+  } else {
+    this->Packages.erase(name);
+    cmCPackIFWLogger(ERROR, "Cannot configure package \""
+                       << name << "\" for component group \"" << group->Name
+                       << "\"" << std::endl);
+  }
+  return group;
+}
+
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackIFWGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
+}
+
+bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const
+{
+  return false;
+}
+
+bool cmCPackIFWGenerator::SupportsComponentInstallation() const
+{
+  return true;
+}
+
+bool cmCPackIFWGenerator::IsOnePackage() const
+{
+  return this->componentPackageMethod == cmCPackGenerator::ONE_PACKAGE;
+}
+
+std::string cmCPackIFWGenerator::GetRootPackageName()
+{
+  // Default value
+  std::string name = "root";
+  if (const char* optIFW_PACKAGE_GROUP =
+        this->GetOption("CPACK_IFW_PACKAGE_GROUP")) {
+    // Configure from root group
+    cmCPackIFWPackage package;
+    package.Generator = this;
+    package.ConfigureFromGroup(optIFW_PACKAGE_GROUP);
+    name = package.Name;
+  } else if (const char* optIFW_PACKAGE_NAME =
+               this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
+    // Configure from root package name
+    name = optIFW_PACKAGE_NAME;
+  } else if (const char* optPACKAGE_NAME =
+               this->GetOption("CPACK_PACKAGE_NAME")) {
+    // Configure from package name
+    name = optPACKAGE_NAME;
+  }
+  return name;
+}
+
+std::string cmCPackIFWGenerator::GetGroupPackageName(
+  cmCPackComponentGroup* group) const
+{
+  std::string name;
+  if (!group) {
+    return name;
+  }
+  if (cmCPackIFWPackage* package = this->GetGroupPackage(group)) {
+    return package->Name;
+  }
+  const char* option =
+    this->GetOption("CPACK_IFW_COMPONENT_GROUP_" +
+                    cmsys::SystemTools::UpperCase(group->Name) + "_NAME");
+  name = option ? option : group->Name;
+  if (group->ParentGroup) {
+    cmCPackIFWPackage* package = this->GetGroupPackage(group->ParentGroup);
+    bool dot = !this->ResolveDuplicateNames;
+    if (dot && name.substr(0, package->Name.size()) == package->Name) {
+      dot = false;
+    }
+    if (dot) {
+      name = package->Name + "." + name;
+    }
+  }
+  return name;
+}
+
+std::string cmCPackIFWGenerator::GetComponentPackageName(
+  cmCPackComponent* component) const
+{
+  std::string name;
+  if (!component) {
+    return name;
+  }
+  if (cmCPackIFWPackage* package = this->GetComponentPackage(component)) {
+    return package->Name;
+  }
+  std::string prefix = "CPACK_IFW_COMPONENT_" +
+    cmsys::SystemTools::UpperCase(component->Name) + "_";
+  const char* option = this->GetOption(prefix + "NAME");
+  name = option ? option : component->Name;
+  if (component->Group) {
+    cmCPackIFWPackage* package = this->GetGroupPackage(component->Group);
+    if ((this->componentPackageMethod ==
+         cmCPackGenerator::ONE_PACKAGE_PER_GROUP) ||
+        this->IsOn(prefix + "COMMON")) {
+      return package->Name;
+    }
+    bool dot = !this->ResolveDuplicateNames;
+    if (dot && name.substr(0, package->Name.size()) == package->Name) {
+      dot = false;
+    }
+    if (dot) {
+      name = package->Name + "." + name;
+    }
+  }
+  return name;
+}
+
+cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
+  cmCPackComponentGroup* group) const
+{
+  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit =
+    this->GroupPackages.find(group);
+  return pit != this->GroupPackages.end() ? pit->second : nullptr;
+}
+
+cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
+  cmCPackComponent* component) const
+{
+  std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit =
+    this->ComponentPackages.find(component);
+  return pit != this->ComponentPackages.end() ? pit->second : nullptr;
+}
+
+cmCPackIFWRepository* cmCPackIFWGenerator::GetRepository(
+  const std::string& repositoryName)
+{
+  RepositoriesMap::iterator rit = this->Repositories.find(repositoryName);
+  if (rit != this->Repositories.end()) {
+    return &(rit->second);
+  }
+
+  cmCPackIFWRepository* repository = &this->Repositories[repositoryName];
+  repository->Name = repositoryName;
+  repository->Generator = this;
+  if (repository->ConfigureFromOptions()) {
+    if (repository->Update == cmCPackIFWRepository::None) {
+      this->Installer.RemoteRepositories.push_back(repository);
+    } else {
+      this->Repository.RepositoryUpdate.push_back(repository);
+    }
+  } else {
+    this->Repositories.erase(repositoryName);
+    repository = nullptr;
+    cmCPackIFWLogger(WARNING, "Invalid repository \""
+                       << repositoryName << "\""
+                       << " configuration. Repository will be skipped."
+                       << std::endl);
+  }
+  return repository;
+}
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
new file mode 100644
index 0000000..919dd46
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -0,0 +1,154 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackIFWGenerator_h
+#define cmCPackIFWGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackIFWCommon.h"
+#include "cmCPackIFWInstaller.h"
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWRepository.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+/** \class cmCPackIFWGenerator
+ * \brief A generator for Qt Installer Framework tools
+ *
+ * http://qt-project.org/doc/qtinstallerframework/index.html
+ */
+class cmCPackIFWGenerator : public cmCPackGenerator, public cmCPackIFWCommon
+{
+public:
+  cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator);
+
+  typedef std::map<std::string, cmCPackIFWPackage> PackagesMap;
+  typedef std::map<std::string, cmCPackIFWRepository> RepositoriesMap;
+  typedef std::map<std::string, cmCPackComponent> ComponentsMap;
+  typedef std::map<std::string, cmCPackComponentGroup> ComponentGoupsMap;
+  typedef std::map<std::string, cmCPackIFWPackage::DependenceStruct>
+    DependenceMap;
+
+  using cmCPackIFWCommon::GetOption;
+  using cmCPackIFWCommon::IsOn;
+  using cmCPackIFWCommon::IsSetToOff;
+  using cmCPackIFWCommon::IsSetToEmpty;
+
+  /**
+   * Construct IFW generator
+   */
+  cmCPackIFWGenerator();
+
+  /**
+   * Destruct IFW generator
+   */
+  ~cmCPackIFWGenerator() override;
+
+protected:
+  // cmCPackGenerator reimplementation
+
+  /**
+   * @brief Initialize generator
+   * @return 0 on failure
+   */
+  int InitializeInternal() override;
+  int PackageFiles() override;
+  const char* GetPackagingInstallPrefix() override;
+
+  /**
+   * @brief Target binary extension
+   * @return Executable suffix or disk image format
+   */
+  const char* GetOutputExtension() override;
+
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) override;
+
+  /**
+   * @brief Get Component
+   * @param projectName Project name
+   * @param componentName Component name
+   *
+   * This method calls the base implementation.
+   *
+   * @return Pointer to component
+   */
+  cmCPackComponent* GetComponent(const std::string& projectName,
+                                 const std::string& componentName) override;
+
+  /**
+   * @brief Get group of component
+   * @param projectName Project name
+   * @param groupName Component group name
+   *
+   * This method calls the base implementation.
+   *
+   * @return Pointer to component group
+   */
+  cmCPackComponentGroup* GetComponentGroup(
+    const std::string& projectName, const std::string& groupName) override;
+
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir()
+    const override;
+  bool SupportsAbsoluteDestination() const override;
+  bool SupportsComponentInstallation() const override;
+
+protected:
+  // Methods
+
+  bool IsOnePackage() const;
+
+  std::string GetRootPackageName();
+
+  std::string GetGroupPackageName(cmCPackComponentGroup* group) const;
+  std::string GetComponentPackageName(cmCPackComponent* component) const;
+
+  cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup* group) const;
+  cmCPackIFWPackage* GetComponentPackage(cmCPackComponent* component) const;
+
+  cmCPackIFWRepository* GetRepository(const std::string& repositoryName);
+
+protected:
+  // Data
+
+  friend class cmCPackIFWPackage;
+  friend class cmCPackIFWCommon;
+  friend class cmCPackIFWInstaller;
+  friend class cmCPackIFWRepository;
+
+  // Installer
+  cmCPackIFWInstaller Installer;
+  // Repository
+  cmCPackIFWRepository Repository;
+  // Collection of packages
+  PackagesMap Packages;
+  // Collection of repositories
+  RepositoriesMap Repositories;
+  // Collection of binary packages
+  std::set<cmCPackIFWPackage*> BinaryPackages;
+  // Collection of downloaded packages
+  std::set<cmCPackIFWPackage*> DownloadedPackages;
+  // Dependent packages
+  DependenceMap DependentPackages;
+  std::map<cmCPackComponent*, cmCPackIFWPackage*> ComponentPackages;
+  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*> GroupPackages;
+
+private:
+  std::string RepoGen;
+  std::string BinCreator;
+  std::string FrameworkVersion;
+  std::string ExecutableSuffix;
+  std::string OutputExtension;
+
+  bool OnlineOnly;
+  bool ResolveDuplicateNames;
+  std::vector<std::string> PkgsDirsVector;
+  std::vector<std::string> RepoDirsVector;
+};
+
+#endif
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
new file mode 100644
index 0000000..bcbe84d
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -0,0 +1,511 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackIFWInstaller.h"
+
+#include "cmCPackIFWCommon.h"
+#include "cmCPackIFWGenerator.h"
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWRepository.h"
+#include "cmCPackLog.h" // IWYU pragma: keep
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+#include "cmXMLWriter.h"
+
+#include <sstream>
+#include <stddef.h>
+#include <utility>
+
+cmCPackIFWInstaller::cmCPackIFWInstaller()
+{
+}
+
+void cmCPackIFWInstaller::printSkippedOptionWarning(
+  const std::string& optionName, const std::string& optionValue)
+{
+  cmCPackIFWLogger(
+    WARNING, "Option "
+      << optionName << " is set to \"" << optionValue
+      << "\" but will be skipped because the specified file does not exist."
+      << std::endl);
+}
+
+void cmCPackIFWInstaller::ConfigureFromOptions()
+{
+  // Name;
+  if (const char* optIFW_PACKAGE_NAME =
+        this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
+    this->Name = optIFW_PACKAGE_NAME;
+  } else if (const char* optPACKAGE_NAME =
+               this->GetOption("CPACK_PACKAGE_NAME")) {
+    this->Name = optPACKAGE_NAME;
+  } else {
+    this->Name = "Your package";
+  }
+
+  // Title;
+  if (const char* optIFW_PACKAGE_TITLE =
+        this->GetOption("CPACK_IFW_PACKAGE_TITLE")) {
+    this->Title = optIFW_PACKAGE_TITLE;
+  } else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
+               this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
+    this->Title = optPACKAGE_DESCRIPTION_SUMMARY;
+  } else {
+    this->Title = "Your package description";
+  }
+
+  // Version;
+  if (const char* option = this->GetOption("CPACK_PACKAGE_VERSION")) {
+    this->Version = option;
+  } else {
+    this->Version = "1.0.0";
+  }
+
+  // Publisher
+  if (const char* optIFW_PACKAGE_PUBLISHER =
+        this->GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
+    this->Publisher = optIFW_PACKAGE_PUBLISHER;
+  } else if (const char* optPACKAGE_VENDOR =
+               GetOption("CPACK_PACKAGE_VENDOR")) {
+    this->Publisher = optPACKAGE_VENDOR;
+  }
+
+  // ProductUrl
+  if (const char* option = this->GetOption("CPACK_IFW_PRODUCT_URL")) {
+    this->ProductUrl = option;
+  }
+
+  // ApplicationIcon
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_ICON")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->InstallerApplicationIcon = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_ICON", option);
+    }
+  }
+
+  // WindowIcon
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->InstallerWindowIcon = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_WINDOW_ICON", option);
+    }
+  }
+
+  // RemoveTargetDir
+  if (this->IsSetToOff("CPACK_IFW_PACKAGE_REMOVE_TARGET_DIR")) {
+    this->RemoveTargetDir = "false";
+  } else if (this->IsOn("CPACK_IFW_PACKAGE_REMOVE_TARGET_DIR")) {
+    this->RemoveTargetDir = "true";
+  } else {
+    this->RemoveTargetDir.clear();
+  }
+
+  // Logo
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_LOGO")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->Logo = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_LOGO", option);
+    }
+  }
+
+  // Watermark
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WATERMARK")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->Watermark = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_WATERMARK", option);
+    }
+  }
+
+  // Banner
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_BANNER")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->Banner = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_BANNER", option);
+    }
+  }
+
+  // Background
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_BACKGROUND")) {
+    if (cmSystemTools::FileExists(option)) {
+      this->Background = option;
+    } else {
+      this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_BACKGROUND", option);
+    }
+  }
+
+  // WizardStyle
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WIZARD_STYLE")) {
+    // Setting the user value in any case
+    this->WizardStyle = option;
+    // Check known values
+    if (this->WizardStyle != "Modern" && this->WizardStyle != "Aero" &&
+        this->WizardStyle != "Mac" && this->WizardStyle != "Classic") {
+      cmCPackIFWLogger(
+        WARNING, "Option CPACK_IFW_PACKAGE_WIZARD_STYLE has unknown value \""
+          << option << "\". Expected values are: Modern, Aero, Mac, Classic."
+          << std::endl);
+    }
+  }
+
+  // WizardDefaultWidth
+  if (const char* option =
+        this->GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_WIDTH")) {
+    this->WizardDefaultWidth = option;
+  }
+
+  // WizardDefaultHeight
+  if (const char* option =
+        this->GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_HEIGHT")) {
+    this->WizardDefaultHeight = option;
+  }
+
+  // TitleColor
+  if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_TITLE_COLOR")) {
+    this->TitleColor = option;
+  }
+
+  // Start menu
+  if (const char* optIFW_START_MENU_DIR =
+        this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY")) {
+    this->StartMenuDir = optIFW_START_MENU_DIR;
+  } else {
+    this->StartMenuDir = Name;
+  }
+
+  // Default target directory for installation
+  if (const char* optIFW_TARGET_DIRECTORY =
+        this->GetOption("CPACK_IFW_TARGET_DIRECTORY")) {
+    this->TargetDir = optIFW_TARGET_DIRECTORY;
+  } else if (const char* optPACKAGE_INSTALL_DIRECTORY =
+               this->GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) {
+    this->TargetDir = "@ApplicationsDir@/";
+    this->TargetDir += optPACKAGE_INSTALL_DIRECTORY;
+  } else {
+    this->TargetDir = "@RootDir@/usr/local";
+  }
+
+  // Default target directory for installation with administrator rights
+  if (const char* option =
+        this->GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) {
+    this->AdminTargetDir = option;
+  }
+
+  // Maintenance tool
+  if (const char* optIFW_MAINTENANCE_TOOL =
+        this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME")) {
+    this->MaintenanceToolName = optIFW_MAINTENANCE_TOOL;
+  }
+
+  // Maintenance tool ini file
+  if (const char* optIFW_MAINTENANCE_TOOL_INI =
+        this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE")) {
+    this->MaintenanceToolIniFile = optIFW_MAINTENANCE_TOOL_INI;
+  }
+
+  // Allow non-ASCII characters
+  if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
+    if (this->IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
+      this->AllowNonAsciiCharacters = "true";
+    } else {
+      this->AllowNonAsciiCharacters = "false";
+    }
+  }
+
+  // Space in path
+  if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
+    if (this->IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
+      this->AllowSpaceInPath = "true";
+    } else {
+      this->AllowSpaceInPath = "false";
+    }
+  }
+
+  // Control script
+  if (const char* optIFW_CONTROL_SCRIPT =
+        this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT")) {
+    this->ControlScript = optIFW_CONTROL_SCRIPT;
+  }
+
+  // Resources
+  if (const char* optIFW_PACKAGE_RESOURCES =
+        this->GetOption("CPACK_IFW_PACKAGE_RESOURCES")) {
+    this->Resources.clear();
+    cmSystemTools::ExpandListArgument(optIFW_PACKAGE_RESOURCES,
+                                      this->Resources);
+  }
+}
+
+/** \class cmCPackIFWResourcesParser
+ * \brief Helper class that parse resources form .qrc (Qt)
+ */
+class cmCPackIFWResourcesParser : public cmXMLParser
+{
+public:
+  cmCPackIFWResourcesParser(cmCPackIFWInstaller* i)
+    : installer(i)
+    , file(false)
+  {
+    this->path = i->Directory + "/resources";
+  }
+
+  bool ParseResource(size_t r)
+  {
+    this->hasFiles = false;
+    this->hasErrors = false;
+
+    this->basePath =
+      cmSystemTools::GetFilenamePath(this->installer->Resources[r]);
+
+    this->ParseFile(this->installer->Resources[r].data());
+
+    return this->hasFiles && !this->hasErrors;
+  }
+
+  cmCPackIFWInstaller* installer;
+  bool file, hasFiles, hasErrors;
+  std::string path, basePath;
+
+protected:
+  void StartElement(const std::string& name, const char** /*atts*/) override
+  {
+    this->file = name == "file";
+    if (file) {
+      this->hasFiles = true;
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    if (this->file) {
+      std::string content(data, data + length);
+      content = cmSystemTools::TrimWhitespace(content);
+      std::string source = this->basePath + "/" + content;
+      std::string destination = this->path + "/" + content;
+      if (!cmSystemTools::CopyFileIfDifferent(source.data(),
+                                              destination.data())) {
+        this->hasErrors = true;
+      }
+    }
+  }
+
+  void EndElement(const std::string& /*name*/) override {}
+};
+
+void cmCPackIFWInstaller::GenerateInstallerFile()
+{
+  // Lazy directory initialization
+  if (this->Directory.empty() && this->Generator) {
+    this->Directory = this->Generator->toplevel;
+  }
+
+  // Output stream
+  cmGeneratedFileStream fout((this->Directory + "/config/config.xml").data());
+  cmXMLWriter xout(fout);
+
+  xout.StartDocument();
+
+  WriteGeneratedByToStrim(xout);
+
+  xout.StartElement("Installer");
+
+  xout.Element("Name", this->Name);
+  xout.Element("Version", this->Version);
+  xout.Element("Title", this->Title);
+
+  if (!this->Publisher.empty()) {
+    xout.Element("Publisher", this->Publisher);
+  }
+
+  if (!this->ProductUrl.empty()) {
+    xout.Element("ProductUrl", this->ProductUrl);
+  }
+
+  // ApplicationIcon
+  if (!this->InstallerApplicationIcon.empty()) {
+    std::string name =
+      cmSystemTools::GetFilenameName(this->InstallerApplicationIcon);
+    std::string path = this->Directory + "/config/" + name;
+    name = cmSystemTools::GetFilenameWithoutExtension(name);
+    cmsys::SystemTools::CopyFileIfDifferent(this->InstallerApplicationIcon,
+                                            path);
+    xout.Element("InstallerApplicationIcon", name);
+  }
+
+  // WindowIcon
+  if (!this->InstallerWindowIcon.empty()) {
+    std::string name =
+      cmSystemTools::GetFilenameName(this->InstallerWindowIcon);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->InstallerWindowIcon, path);
+    xout.Element("InstallerWindowIcon", name);
+  }
+
+  // Logo
+  if (!this->Logo.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->Logo);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->Logo, path);
+    xout.Element("Logo", name);
+  }
+
+  // Banner
+  if (!this->Banner.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->Banner);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->Banner, path);
+    xout.Element("Banner", name);
+  }
+
+  // Watermark
+  if (!this->Watermark.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->Watermark);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->Watermark, path);
+    xout.Element("Watermark", name);
+  }
+
+  // Background
+  if (!this->Background.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->Background);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->Background, path);
+    xout.Element("Background", name);
+  }
+
+  // WizardStyle
+  if (!this->WizardStyle.empty()) {
+    xout.Element("WizardStyle", this->WizardStyle);
+  }
+
+  // WizardDefaultWidth
+  if (!this->WizardDefaultWidth.empty()) {
+    xout.Element("WizardDefaultWidth", this->WizardDefaultWidth);
+  }
+
+  // WizardDefaultHeight
+  if (!this->WizardDefaultHeight.empty()) {
+    xout.Element("WizardDefaultHeight", this->WizardDefaultHeight);
+  }
+
+  // TitleColor
+  if (!this->TitleColor.empty()) {
+    xout.Element("TitleColor", this->TitleColor);
+  }
+
+  // Start menu
+  if (!this->IsVersionLess("2.0")) {
+    xout.Element("StartMenuDir", this->StartMenuDir);
+  }
+
+  // Target dir
+  if (!this->TargetDir.empty()) {
+    xout.Element("TargetDir", this->TargetDir);
+  }
+
+  // Admin target dir
+  if (!this->AdminTargetDir.empty()) {
+    xout.Element("AdminTargetDir", this->AdminTargetDir);
+  }
+
+  // Remote repositories
+  if (!this->RemoteRepositories.empty()) {
+    xout.StartElement("RemoteRepositories");
+    for (cmCPackIFWRepository* r : this->RemoteRepositories) {
+      r->WriteRepositoryConfig(xout);
+    }
+    xout.EndElement();
+  }
+
+  // Maintenance tool
+  if (!this->IsVersionLess("2.0") && !this->MaintenanceToolName.empty()) {
+    xout.Element("MaintenanceToolName", this->MaintenanceToolName);
+  }
+
+  // Maintenance tool ini file
+  if (!this->IsVersionLess("2.0") && !this->MaintenanceToolIniFile.empty()) {
+    xout.Element("MaintenanceToolIniFile", this->MaintenanceToolIniFile);
+  }
+
+  if (!this->RemoveTargetDir.empty()) {
+    xout.Element("RemoveTargetDir", this->RemoveTargetDir);
+  }
+
+  // Different allows
+  if (this->IsVersionLess("2.0")) {
+    // CPack IFW default policy
+    xout.Comment("CPack IFW default policy for QtIFW less 2.0");
+    xout.Element("AllowNonAsciiCharacters", "true");
+    xout.Element("AllowSpaceInPath", "true");
+  } else {
+    if (!this->AllowNonAsciiCharacters.empty()) {
+      xout.Element("AllowNonAsciiCharacters", this->AllowNonAsciiCharacters);
+    }
+    if (!this->AllowSpaceInPath.empty()) {
+      xout.Element("AllowSpaceInPath", this->AllowSpaceInPath);
+    }
+  }
+
+  // Control script (copy to config dir)
+  if (!this->IsVersionLess("2.0") && !this->ControlScript.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->ControlScript);
+    std::string path = this->Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->ControlScript, path);
+    xout.Element("ControlScript", name);
+  }
+
+  // Resources (copy to resources dir)
+  if (!this->Resources.empty()) {
+    std::vector<std::string> resources;
+    cmCPackIFWResourcesParser parser(this);
+    for (size_t i = 0; i < this->Resources.size(); i++) {
+      if (parser.ParseResource(i)) {
+        std::string name = cmSystemTools::GetFilenameName(this->Resources[i]);
+        std::string path = this->Directory + "/resources/" + name;
+        cmsys::SystemTools::CopyFileIfDifferent(this->Resources[i], path);
+        resources.push_back(name);
+      } else {
+        cmCPackIFWLogger(WARNING, "Can't copy resources from \""
+                           << this->Resources[i]
+                           << "\". Resource will be skipped." << std::endl);
+      }
+    }
+    this->Resources = resources;
+  }
+
+  xout.EndElement();
+  xout.EndDocument();
+}
+
+void cmCPackIFWInstaller::GeneratePackageFiles()
+{
+  if (this->Packages.empty() || this->Generator->IsOnePackage()) {
+    // Generate default package
+    cmCPackIFWPackage package;
+    package.Generator = this->Generator;
+    package.Installer = this;
+    // Check package group
+    if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_GROUP")) {
+      package.ConfigureFromGroup(option);
+      std::string forcedOption = "CPACK_IFW_COMPONENT_GROUP_" +
+        cmsys::SystemTools::UpperCase(option) + "_FORCED_INSTALLATION";
+      if (!GetOption(forcedOption)) {
+        package.ForcedInstallation = "true";
+      }
+    } else {
+      package.ConfigureFromOptions();
+    }
+    package.GeneratePackageFile();
+    return;
+  }
+
+  // Generate packages meta information
+  for (auto& p : this->Packages) {
+    cmCPackIFWPackage* package = p.second;
+    package->GeneratePackageFile();
+  }
+}
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.h b/Source/CPack/IFW/cmCPackIFWInstaller.h
new file mode 100644
index 0000000..37ad339
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.h
@@ -0,0 +1,133 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackIFWInstaller_h
+#define cmCPackIFWInstaller_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackIFWCommon.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCPackIFWPackage;
+class cmCPackIFWRepository;
+
+/** \class cmCPackIFWInstaller
+ * \brief A binary installer to be created CPack IFW generator
+ */
+class cmCPackIFWInstaller : public cmCPackIFWCommon
+{
+public:
+  // Types
+
+  typedef std::map<std::string, cmCPackIFWPackage*> PackagesMap;
+  typedef std::vector<cmCPackIFWRepository*> RepositoriesVector;
+
+public:
+  // Constructor
+
+  /**
+   * Construct installer
+   */
+  cmCPackIFWInstaller();
+
+public:
+  // Configuration
+
+  /// Name of the product being installed
+  std::string Name;
+
+  /// Version number of the product being installed
+  std::string Version;
+
+  /// Name of the installer as displayed on the title bar
+  std::string Title;
+
+  /// Publisher of the software (as shown in the Windows Control Panel)
+  std::string Publisher;
+
+  /// URL to a page that contains product information on your web site
+  std::string ProductUrl;
+
+  /// Filename for a custom installer icon
+  std::string InstallerApplicationIcon;
+
+  /// Filename for a custom window icon
+  std::string InstallerWindowIcon;
+
+  /// Filename for a logo
+  std::string Logo;
+
+  /// Filename for a watermark
+  std::string Watermark;
+
+  /// Filename for a banner
+  std::string Banner;
+
+  /// Filename for a background
+  std::string Background;
+
+  /// Wizard style name
+  std::string WizardStyle;
+
+  /// Wizard width
+  std::string WizardDefaultWidth;
+
+  /// Wizard height
+  std::string WizardDefaultHeight;
+
+  /// Title color
+  std::string TitleColor;
+
+  /// Name of the default program group in the Windows Start menu
+  std::string StartMenuDir;
+
+  /// Default target directory for installation
+  std::string TargetDir;
+
+  /// Default target directory for installation with administrator rights
+  std::string AdminTargetDir;
+
+  /// Filename of the generated maintenance tool
+  std::string MaintenanceToolName;
+
+  /// Filename for the configuration of the generated maintenance tool
+  std::string MaintenanceToolIniFile;
+
+  /// Set to true if the installation path can contain non-ASCII characters
+  std::string AllowNonAsciiCharacters;
+
+  /// Set to false if the target directory should not be deleted when
+  /// uninstalling
+  std::string RemoveTargetDir;
+
+  /// Set to false if the installation path cannot contain space characters
+  std::string AllowSpaceInPath;
+
+  /// Filename for a custom installer control script
+  std::string ControlScript;
+
+  /// List of resources to include in the installer binary
+  std::vector<std::string> Resources;
+
+public:
+  // Internal implementation
+
+  void ConfigureFromOptions();
+
+  void GenerateInstallerFile();
+
+  void GeneratePackageFiles();
+
+  PackagesMap Packages;
+  RepositoriesVector RemoteRepositories;
+  std::string Directory;
+
+protected:
+  void printSkippedOptionWarning(const std::string& optionName,
+                                 const std::string& optionValue);
+};
+
+#endif // cmCPackIFWInstaller_h
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
new file mode 100644
index 0000000..d3ce15c
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -0,0 +1,714 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackIFWPackage.h"
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackIFWCommon.h"
+#include "cmCPackIFWGenerator.h"
+#include "cmCPackIFWInstaller.h"
+#include "cmCPackLog.h" // IWYU pragma: keep
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmTimestamp.h"
+#include "cmXMLWriter.h"
+
+#include <map>
+#include <sstream>
+#include <stddef.h>
+#include <utility>
+
+//---------------------------------------------------------- CompareStruct ---
+cmCPackIFWPackage::CompareStruct::CompareStruct()
+  : Type(cmCPackIFWPackage::CompareNone)
+{
+}
+
+//------------------------------------------------------- DependenceStruct ---
+cmCPackIFWPackage::DependenceStruct::DependenceStruct()
+{
+}
+
+cmCPackIFWPackage::DependenceStruct::DependenceStruct(
+  const std::string& dependence)
+{
+  // Search compare section
+  size_t pos = std::string::npos;
+  if ((pos = dependence.find("<=")) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareLessOrEqual;
+    this->Compare.Value = dependence.substr(pos + 2);
+  } else if ((pos = dependence.find(">=")) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareGreaterOrEqual;
+    this->Compare.Value = dependence.substr(pos + 2);
+  } else if ((pos = dependence.find('<')) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareLess;
+    this->Compare.Value = dependence.substr(pos + 1);
+  } else if ((pos = dependence.find('=')) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareEqual;
+    this->Compare.Value = dependence.substr(pos + 1);
+  } else if ((pos = dependence.find('>')) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareGreater;
+    this->Compare.Value = dependence.substr(pos + 1);
+  } else if ((pos = dependence.find('-')) != std::string::npos) {
+    this->Compare.Type = cmCPackIFWPackage::CompareNone;
+    this->Compare.Value = dependence.substr(pos + 1);
+  }
+  size_t dashPos = dependence.find('-');
+  if (dashPos != std::string::npos) {
+    pos = dashPos;
+  }
+  this->Name =
+    pos == std::string::npos ? dependence : dependence.substr(0, pos);
+}
+
+std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
+{
+  if (this->Compare.Type == cmCPackIFWPackage::CompareNone) {
+    return this->Name;
+  }
+
+  std::string result = this->Name;
+
+  if (this->Compare.Type != cmCPackIFWPackage::CompareNone ||
+      !this->Compare.Value.empty()) {
+    result += "-";
+  }
+
+  if (this->Compare.Type == cmCPackIFWPackage::CompareLessOrEqual) {
+    result += "<=";
+  } else if (this->Compare.Type == cmCPackIFWPackage::CompareGreaterOrEqual) {
+    result += ">=";
+  } else if (this->Compare.Type == cmCPackIFWPackage::CompareLess) {
+    result += "<";
+  } else if (this->Compare.Type == cmCPackIFWPackage::CompareEqual) {
+    result += "=";
+  } else if (this->Compare.Type == cmCPackIFWPackage::CompareGreater) {
+    result += ">";
+  }
+
+  result += this->Compare.Value;
+
+  return result;
+}
+
+//------------------------------------------------------ cmCPackIFWPackage ---
+cmCPackIFWPackage::cmCPackIFWPackage()
+  : Installer(nullptr)
+{
+}
+
+std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent* component)
+{
+  if (!component) {
+    return "";
+  }
+  const char* option =
+    this->GetOption("CPACK_IFW_COMPONENT_" +
+                    cmsys::SystemTools::UpperCase(component->Name) + "_NAME");
+  return option ? option : component->Name;
+}
+
+void cmCPackIFWPackage::DefaultConfiguration()
+{
+  this->DisplayName.clear();
+  this->Description.clear();
+  this->Version.clear();
+  this->ReleaseDate.clear();
+  this->Script.clear();
+  this->Licenses.clear();
+  this->UserInterfaces.clear();
+  this->Translations.clear();
+  this->SortingPriority.clear();
+  this->UpdateText.clear();
+  this->Default.clear();
+  this->Essential.clear();
+  this->Virtual.clear();
+  this->ForcedInstallation.clear();
+  this->RequiresAdminRights.clear();
+}
+
+// Defaul configuration (all in one package)
+int cmCPackIFWPackage::ConfigureFromOptions()
+{
+  // Restore defaul configuration
+  this->DefaultConfiguration();
+
+  // Name
+  this->Name = this->Generator->GetRootPackageName();
+
+  // Display name
+  if (const char* option = this->GetOption("CPACK_PACKAGE_NAME")) {
+    this->DisplayName[""] = option;
+  } else {
+    this->DisplayName[""] = "Your package";
+  }
+
+  // Description
+  if (const char* option =
+        this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
+    this->Description[""] = option;
+  } else {
+    this->Description[""] = "Your package description";
+  }
+
+  // Version
+  if (const char* option = this->GetOption("CPACK_PACKAGE_VERSION")) {
+    this->Version = option;
+  } else {
+    this->Version = "1.0.0";
+  }
+
+  this->ForcedInstallation = "true";
+
+  return 1;
+}
+
+int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
+{
+  if (!component) {
+    return 0;
+  }
+
+  // Restore defaul configuration
+  this->DefaultConfiguration();
+
+  std::string prefix = "CPACK_IFW_COMPONENT_" +
+    cmsys::SystemTools::UpperCase(component->Name) + "_";
+
+  // Display name
+  this->DisplayName[""] = component->DisplayName;
+
+  // Description
+  this->Description[""] = component->Description;
+
+  // Version
+  if (const char* optVERSION = this->GetOption(prefix + "VERSION")) {
+    this->Version = optVERSION;
+  } else if (const char* optPACKAGE_VERSION =
+               this->GetOption("CPACK_PACKAGE_VERSION")) {
+    this->Version = optPACKAGE_VERSION;
+  } else {
+    this->Version = "1.0.0";
+  }
+
+  // Script
+  if (const char* option = this->GetOption(prefix + "SCRIPT")) {
+    this->Script = option;
+  }
+
+  // User interfaces
+  if (const char* option = this->GetOption(prefix + "USER_INTERFACES")) {
+    this->UserInterfaces.clear();
+    cmSystemTools::ExpandListArgument(option, this->UserInterfaces);
+  }
+
+  // CMake dependencies
+  if (!component->Dependencies.empty()) {
+    for (cmCPackComponent* dep : component->Dependencies) {
+      this->Dependencies.insert(this->Generator->ComponentPackages[dep]);
+    }
+  }
+
+  // Licenses
+  if (const char* option = this->GetOption(prefix + "LICENSES")) {
+    this->Licenses.clear();
+    cmSystemTools::ExpandListArgument(option, this->Licenses);
+    if (this->Licenses.size() % 2 != 0) {
+      cmCPackIFWLogger(
+        WARNING,
+        prefix << "LICENSES"
+               << " should contain pairs of <display_name> and <file_path>."
+               << std::endl);
+      this->Licenses.clear();
+    }
+  }
+
+  // Priority
+  if (const char* option = this->GetOption(prefix + "PRIORITY")) {
+    this->SortingPriority = option;
+    cmCPackIFWLogger(
+      WARNING, "The \"PRIORITY\" option is set "
+        << "for component \"" << component->Name << "\", but there option is "
+        << "deprecated. Please use \"SORTING_PRIORITY\" option instead."
+        << std::endl);
+  }
+
+  // Default
+  this->Default = component->IsDisabledByDefault ? "false" : "true";
+
+  // Essential
+  if (this->IsOn(prefix + "ESSENTIAL")) {
+    this->Essential = "true";
+  }
+
+  // Virtual
+  this->Virtual = component->IsHidden ? "true" : "";
+
+  // ForcedInstallation
+  this->ForcedInstallation = component->IsRequired ? "true" : "false";
+
+  return this->ConfigureFromPrefix(prefix);
+}
+
+int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
+{
+  if (!group) {
+    return 0;
+  }
+
+  // Restore defaul configuration
+  this->DefaultConfiguration();
+
+  std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" +
+    cmsys::SystemTools::UpperCase(group->Name) + "_";
+
+  this->DisplayName[""] = group->DisplayName;
+  this->Description[""] = group->Description;
+
+  // Version
+  if (const char* optVERSION = this->GetOption(prefix + "VERSION")) {
+    this->Version = optVERSION;
+  } else if (const char* optPACKAGE_VERSION =
+               this->GetOption("CPACK_PACKAGE_VERSION")) {
+    this->Version = optPACKAGE_VERSION;
+  } else {
+    this->Version = "1.0.0";
+  }
+
+  // Script
+  if (const char* option = this->GetOption(prefix + "SCRIPT")) {
+    this->Script = option;
+  }
+
+  // User interfaces
+  if (const char* option = this->GetOption(prefix + "USER_INTERFACES")) {
+    this->UserInterfaces.clear();
+    cmSystemTools::ExpandListArgument(option, this->UserInterfaces);
+  }
+
+  // Licenses
+  if (const char* option = this->GetOption(prefix + "LICENSES")) {
+    this->Licenses.clear();
+    cmSystemTools::ExpandListArgument(option, this->Licenses);
+    if (this->Licenses.size() % 2 != 0) {
+      cmCPackIFWLogger(
+        WARNING,
+        prefix << "LICENSES"
+               << " should contain pairs of <display_name> and <file_path>."
+               << std::endl);
+      this->Licenses.clear();
+    }
+  }
+
+  // Priority
+  if (const char* option = this->GetOption(prefix + "PRIORITY")) {
+    this->SortingPriority = option;
+    cmCPackIFWLogger(
+      WARNING, "The \"PRIORITY\" option is set "
+        << "for component group \"" << group->Name
+        << "\", but there option is "
+        << "deprecated. Please use \"SORTING_PRIORITY\" option instead."
+        << std::endl);
+  }
+
+  return this->ConfigureFromPrefix(prefix);
+}
+
+int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
+{
+  // Group configuration
+
+  cmCPackComponentGroup group;
+  std::string prefix =
+    "CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(groupName) + "_";
+
+  if (const char* option = this->GetOption(prefix + "DISPLAY_NAME")) {
+    group.DisplayName = option;
+  } else {
+    group.DisplayName = group.Name;
+  }
+
+  if (const char* option = this->GetOption(prefix + "DESCRIPTION")) {
+    group.Description = option;
+  }
+  group.IsBold = this->IsOn(prefix + "BOLD_TITLE");
+  group.IsExpandedByDefault = this->IsOn(prefix + "EXPANDED");
+
+  // Package configuration
+
+  group.Name = groupName;
+
+  if (Generator) {
+    this->Name = this->Generator->GetGroupPackageName(&group);
+  } else {
+    this->Name = group.Name;
+  }
+
+  return this->ConfigureFromGroup(&group);
+}
+
+// Common options for components and groups
+int cmCPackIFWPackage::ConfigureFromPrefix(const std::string& prefix)
+{
+  // Temporary variable for full option name
+  std::string option;
+
+  // Display name
+  option = prefix + "DISPLAY_NAME";
+  if (this->IsSetToEmpty(option)) {
+    this->DisplayName.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->ExpandListArgument(value, this->DisplayName);
+  }
+
+  // Description
+  option = prefix + "DESCRIPTION";
+  if (this->IsSetToEmpty(option)) {
+    this->Description.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->ExpandListArgument(value, this->Description);
+  }
+
+  // Release date
+  option = prefix + "RELEASE_DATE";
+  if (this->IsSetToEmpty(option)) {
+    this->ReleaseDate.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->ReleaseDate = value;
+  }
+
+  // Sorting priority
+  option = prefix + "SORTING_PRIORITY";
+  if (this->IsSetToEmpty(option)) {
+    this->SortingPriority.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->SortingPriority = value;
+  }
+
+  // Update text
+  option = prefix + "UPDATE_TEXT";
+  if (this->IsSetToEmpty(option)) {
+    this->UpdateText.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->UpdateText = value;
+  }
+
+  // Translations
+  option = prefix + "TRANSLATIONS";
+  if (this->IsSetToEmpty(option)) {
+    this->Translations.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->Translations.clear();
+    cmSystemTools::ExpandListArgument(value, this->Translations);
+  }
+
+  // QtIFW dependencies
+  std::vector<std::string> deps;
+  option = prefix + "DEPENDS";
+  if (const char* value = this->GetOption(option)) {
+    cmSystemTools::ExpandListArgument(value, deps);
+  }
+  option = prefix + "DEPENDENCIES";
+  if (const char* value = this->GetOption(option)) {
+    cmSystemTools::ExpandListArgument(value, deps);
+  }
+  for (std::string const& d : deps) {
+    DependenceStruct dep(d);
+    if (this->Generator->Packages.count(dep.Name)) {
+      cmCPackIFWPackage& depPkg = this->Generator->Packages[dep.Name];
+      dep.Name = depPkg.Name;
+    }
+    bool hasDep = this->Generator->DependentPackages.count(dep.Name) > 0;
+    DependenceStruct& depRef = this->Generator->DependentPackages[dep.Name];
+    if (!hasDep) {
+      depRef = dep;
+    }
+    this->AlienDependencies.insert(&depRef);
+  }
+
+  // Automatic dependency on
+  option = prefix + "AUTO_DEPEND_ON";
+  if (this->IsSetToEmpty(option)) {
+    this->AlienAutoDependOn.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    std::vector<std::string> depsOn;
+    cmSystemTools::ExpandListArgument(value, depsOn);
+    for (std::string const& d : depsOn) {
+      DependenceStruct dep(d);
+      if (this->Generator->Packages.count(dep.Name)) {
+        cmCPackIFWPackage& depPkg = this->Generator->Packages[dep.Name];
+        dep.Name = depPkg.Name;
+      }
+      bool hasDep = this->Generator->DependentPackages.count(dep.Name) > 0;
+      DependenceStruct& depRef = this->Generator->DependentPackages[dep.Name];
+      if (!hasDep) {
+        depRef = dep;
+      }
+      this->AlienAutoDependOn.insert(&depRef);
+    }
+  }
+
+  // Visibility
+  option = prefix + "VIRTUAL";
+  if (this->IsSetToEmpty(option)) {
+    this->Virtual.clear();
+  } else if (this->IsOn(option)) {
+    this->Virtual = "true";
+  }
+
+  // Default selection
+  option = prefix + "DEFAULT";
+  if (this->IsSetToEmpty(option)) {
+    this->Default.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    std::string lowerValue = cmsys::SystemTools::LowerCase(value);
+    if (lowerValue == "true") {
+      this->Default = "true";
+    } else if (lowerValue == "false") {
+      this->Default = "false";
+    } else if (lowerValue == "script") {
+      this->Default = "script";
+    } else {
+      this->Default = value;
+    }
+  }
+
+  // Forsed installation
+  option = prefix + "FORCED_INSTALLATION";
+  if (this->IsSetToEmpty(option)) {
+    this->ForcedInstallation.clear();
+  } else if (this->IsOn(option)) {
+    this->ForcedInstallation = "true";
+  } else if (this->IsSetToOff(option)) {
+    this->ForcedInstallation = "false";
+  }
+
+  // Replaces
+  option = prefix + "REPLACES";
+  if (this->IsSetToEmpty(option)) {
+    this->Replaces.clear();
+  } else if (const char* value = this->GetOption(option)) {
+    this->Replaces.clear();
+    cmSystemTools::ExpandListArgument(value, this->Replaces);
+  }
+
+  // Requires admin rights
+  option = prefix + "REQUIRES_ADMIN_RIGHTS";
+  if (this->IsSetToEmpty(option)) {
+    this->RequiresAdminRights.clear();
+  } else if (this->IsOn(option)) {
+    this->RequiresAdminRights = "true";
+  } else if (this->IsSetToOff(option)) {
+    this->RequiresAdminRights = "false";
+  }
+
+  // Checkable
+  option = prefix + "CHECKABLE";
+  if (this->IsSetToEmpty(option)) {
+    this->Checkable.clear();
+  } else if (this->IsOn(option)) {
+    this->Checkable = "true";
+  } else if (this->IsSetToOff(option)) {
+    this->Checkable = "false";
+  }
+
+  return 1;
+}
+
+void cmCPackIFWPackage::GeneratePackageFile()
+{
+  // Lazy directory initialization
+  if (this->Directory.empty()) {
+    if (this->Installer) {
+      this->Directory = this->Installer->Directory + "/packages/" + this->Name;
+    } else if (this->Generator) {
+      this->Directory = this->Generator->toplevel + "/packages/" + this->Name;
+    }
+  }
+
+  // Output stream
+  cmGeneratedFileStream fout((this->Directory + "/meta/package.xml").data());
+  cmXMLWriter xout(fout);
+
+  xout.StartDocument();
+
+  WriteGeneratedByToStrim(xout);
+
+  xout.StartElement("Package");
+
+  // DisplayName (with translations)
+  for (auto const& dn : this->DisplayName) {
+    xout.StartElement("DisplayName");
+    if (!dn.first.empty()) {
+      xout.Attribute("xml:lang", dn.first);
+    }
+    xout.Content(dn.second);
+    xout.EndElement();
+  }
+
+  // Description (with translations)
+  for (auto const& d : this->Description) {
+    xout.StartElement("Description");
+    if (!d.first.empty()) {
+      xout.Attribute("xml:lang", d.first);
+    }
+    xout.Content(d.second);
+    xout.EndElement();
+  }
+
+  // Update text
+  if (!this->UpdateText.empty()) {
+    xout.Element("UpdateText", this->UpdateText);
+  }
+
+  xout.Element("Name", this->Name);
+  xout.Element("Version", this->Version);
+
+  if (!this->ReleaseDate.empty()) {
+    xout.Element("ReleaseDate", this->ReleaseDate);
+  } else {
+    xout.Element("ReleaseDate", cmTimestamp().CurrentTime("%Y-%m-%d", true));
+  }
+
+  // Script (copy to meta dir)
+  if (!this->Script.empty()) {
+    std::string name = cmSystemTools::GetFilenameName(this->Script);
+    std::string path = this->Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(this->Script, path);
+    xout.Element("Script", name);
+  }
+
+  // User Interfaces (copy to meta dir)
+  std::vector<std::string> userInterfaces = UserInterfaces;
+  for (std::string& userInterface : userInterfaces) {
+    std::string name = cmSystemTools::GetFilenameName(userInterface);
+    std::string path = this->Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(userInterface, path);
+    userInterface = name;
+  }
+  if (!userInterfaces.empty()) {
+    xout.StartElement("UserInterfaces");
+    for (std::string const& userInterface : userInterfaces) {
+      xout.Element("UserInterface", userInterface);
+    }
+    xout.EndElement();
+  }
+
+  // Translations (copy to meta dir)
+  std::vector<std::string> translations = Translations;
+  for (std::string& translation : translations) {
+    std::string name = cmSystemTools::GetFilenameName(translation);
+    std::string path = this->Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(translation, path);
+    translation = name;
+  }
+  if (!translations.empty()) {
+    xout.StartElement("Translations");
+    for (std::string const& translation : translations) {
+      xout.Element("Translation", translation);
+    }
+    xout.EndElement();
+  }
+
+  // Dependencies
+  std::set<DependenceStruct> compDepSet;
+  for (DependenceStruct* ad : this->AlienDependencies) {
+    compDepSet.insert(*ad);
+  }
+  for (cmCPackIFWPackage* d : this->Dependencies) {
+    compDepSet.insert(DependenceStruct(d->Name));
+  }
+  // Write dependencies
+  if (!compDepSet.empty()) {
+    std::ostringstream dependencies;
+    std::set<DependenceStruct>::iterator it = compDepSet.begin();
+    dependencies << it->NameWithCompare();
+    ++it;
+    while (it != compDepSet.end()) {
+      dependencies << "," << it->NameWithCompare();
+      ++it;
+    }
+    xout.Element("Dependencies", dependencies.str());
+  }
+
+  // Automatic dependency on
+  std::set<DependenceStruct> compAutoDepSet;
+  for (DependenceStruct* aad : this->AlienAutoDependOn) {
+    compAutoDepSet.insert(*aad);
+  }
+  // Write automatic dependency on
+  if (!compAutoDepSet.empty()) {
+    std::ostringstream dependencies;
+    std::set<DependenceStruct>::iterator it = compAutoDepSet.begin();
+    dependencies << it->NameWithCompare();
+    ++it;
+    while (it != compAutoDepSet.end()) {
+      dependencies << "," << it->NameWithCompare();
+      ++it;
+    }
+    xout.Element("AutoDependOn", dependencies.str());
+  }
+
+  // Licenses (copy to meta dir)
+  std::vector<std::string> licenses = this->Licenses;
+  for (size_t i = 1; i < licenses.size(); i += 2) {
+    std::string name = cmSystemTools::GetFilenameName(licenses[i]);
+    std::string path = this->Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(licenses[i], path);
+    licenses[i] = name;
+  }
+  if (!licenses.empty()) {
+    xout.StartElement("Licenses");
+    for (size_t i = 0; i < licenses.size(); i += 2) {
+      xout.StartElement("License");
+      xout.Attribute("name", licenses[i]);
+      xout.Attribute("file", licenses[i + 1]);
+      xout.EndElement();
+    }
+    xout.EndElement();
+  }
+
+  if (!this->ForcedInstallation.empty()) {
+    xout.Element("ForcedInstallation", this->ForcedInstallation);
+  }
+
+  // Replaces
+  if (!this->Replaces.empty()) {
+    std::ostringstream replaces;
+    std::vector<std::string>::iterator it = this->Replaces.begin();
+    replaces << *it;
+    ++it;
+    while (it != this->Replaces.end()) {
+      replaces << "," << *it;
+      ++it;
+    }
+    xout.Element("Replaces", replaces.str());
+  }
+
+  if (!this->RequiresAdminRights.empty()) {
+    xout.Element("RequiresAdminRights", this->RequiresAdminRights);
+  }
+
+  if (!this->Virtual.empty()) {
+    xout.Element("Virtual", this->Virtual);
+  } else if (!this->Default.empty()) {
+    xout.Element("Default", this->Default);
+  }
+
+  // Essential
+  if (!this->Essential.empty()) {
+    xout.Element("Essential", this->Essential);
+  }
+
+  // Priority
+  if (!this->SortingPriority.empty()) {
+    xout.Element("SortingPriority", this->SortingPriority);
+  }
+
+  // Checkable
+  if (!this->Checkable.empty()) {
+    xout.Element("Checkable", this->Checkable);
+  }
+
+  xout.EndElement();
+  xout.EndDocument();
+}
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h
new file mode 100644
index 0000000..ae41146
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -0,0 +1,153 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackIFWPackage_h
+#define cmCPackIFWPackage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackIFWCommon.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmCPackComponent;
+class cmCPackComponentGroup;
+class cmCPackIFWInstaller;
+
+/** \class cmCPackIFWPackage
+ * \brief A single component to be installed by CPack IFW generator
+ */
+class cmCPackIFWPackage : public cmCPackIFWCommon
+{
+public:
+  // Types
+
+  enum CompareTypes
+  {
+    CompareNone = 0x0,
+    CompareEqual = 0x1,
+    CompareLess = 0x2,
+    CompareLessOrEqual = 0x3,
+    CompareGreater = 0x4,
+    CompareGreaterOrEqual = 0x5
+  };
+
+  struct CompareStruct
+  {
+    CompareStruct();
+
+    unsigned int Type;
+    std::string Value;
+  };
+
+  struct DependenceStruct
+  {
+    DependenceStruct();
+    DependenceStruct(const std::string& dependence);
+
+    std::string Name;
+    CompareStruct Compare;
+
+    std::string NameWithCompare() const;
+
+    bool operator<(const DependenceStruct& other) const
+    {
+      return Name < other.Name;
+    }
+  };
+
+public:
+  // [Con|De]structor
+
+  /**
+   * Construct package
+   */
+  cmCPackIFWPackage();
+
+public:
+  // Configuration
+
+  /// Human-readable name of the component
+  std::map<std::string, std::string> DisplayName;
+
+  /// Human-readable description of the component
+  std::map<std::string, std::string> Description;
+
+  /// Version number of the component
+  std::string Version;
+
+  /// Date when this component version was released
+  std::string ReleaseDate;
+
+  /// Domain-like identification for this component
+  std::string Name;
+
+  /// File name of a script being loaded
+  std::string Script;
+
+  /// List of license agreements to be accepted by the installing user
+  std::vector<std::string> Licenses;
+
+  /// List of pages to load
+  std::vector<std::string> UserInterfaces;
+
+  /// List of translation files to load
+  std::vector<std::string> Translations;
+
+  /// Priority of the component in the tree
+  std::string SortingPriority;
+
+  /// Description added to the component description
+  std::string UpdateText;
+
+  /// Set to true to preselect the component in the installer
+  std::string Default;
+
+  /// Marks the package as essential to force a restart of the MaintenanceTool
+  std::string Essential;
+
+  /// Set to true to hide the component from the installer
+  std::string Virtual;
+
+  /// Determines that the package must always be installed
+  std::string ForcedInstallation;
+
+  /// List of components to replace
+  std::vector<std::string> Replaces;
+
+  /// Package needs to be installed with elevated permissions
+  std::string RequiresAdminRights;
+
+  /// Set to false if you want to hide the checkbox for an item
+  std::string Checkable;
+
+public:
+  // Internal implementation
+
+  std::string GetComponentName(cmCPackComponent* component);
+
+  void DefaultConfiguration();
+
+  int ConfigureFromOptions();
+  int ConfigureFromComponent(cmCPackComponent* component);
+  int ConfigureFromGroup(cmCPackComponentGroup* group);
+  int ConfigureFromGroup(const std::string& groupName);
+  int ConfigureFromPrefix(const std::string& prefix);
+
+  void GeneratePackageFile();
+
+  // Pointer to installer
+  cmCPackIFWInstaller* Installer;
+  // Collection of dependencies
+  std::set<cmCPackIFWPackage*> Dependencies;
+  // Collection of unresolved dependencies
+  std::set<DependenceStruct*> AlienDependencies;
+  // Collection of unresolved automatic dependency on
+  std::set<DependenceStruct*> AlienAutoDependOn;
+  // Patch to package directory
+  std::string Directory;
+};
+
+#endif // cmCPackIFWPackage_h
diff --git a/Source/CPack/IFW/cmCPackIFWRepository.cxx b/Source/CPack/IFW/cmCPackIFWRepository.cxx
new file mode 100644
index 0000000..a01fc4e
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWRepository.cxx
@@ -0,0 +1,287 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackIFWRepository.h"
+
+#include "cmCPackIFWGenerator.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+#include "cmXMLWriter.h"
+
+#include <stddef.h>
+
+cmCPackIFWRepository::cmCPackIFWRepository()
+  : Update(cmCPackIFWRepository::None)
+{
+}
+
+bool cmCPackIFWRepository::IsValid() const
+{
+  bool valid = true;
+
+  switch (this->Update) {
+    case cmCPackIFWRepository::None:
+      valid = !this->Url.empty();
+      break;
+    case cmCPackIFWRepository::Add:
+      valid = !this->Url.empty();
+      break;
+    case cmCPackIFWRepository::Remove:
+      valid = !this->Url.empty();
+      break;
+    case cmCPackIFWRepository::Replace:
+      valid = !this->OldUrl.empty() && !this->NewUrl.empty();
+      break;
+  }
+
+  return valid;
+}
+
+bool cmCPackIFWRepository::ConfigureFromOptions()
+{
+  // Name;
+  if (this->Name.empty()) {
+    return false;
+  }
+
+  std::string prefix =
+    "CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(this->Name) + "_";
+
+  // Update
+  if (this->IsOn(prefix + "ADD")) {
+    this->Update = cmCPackIFWRepository::Add;
+  } else if (IsOn(prefix + "REMOVE")) {
+    this->Update = cmCPackIFWRepository::Remove;
+  } else if (IsOn(prefix + "REPLACE")) {
+    this->Update = cmCPackIFWRepository::Replace;
+  } else {
+    this->Update = cmCPackIFWRepository::None;
+  }
+
+  // Url
+  if (const char* url = this->GetOption(prefix + "URL")) {
+    this->Url = url;
+  } else {
+    this->Url.clear();
+  }
+
+  // Old url
+  if (const char* oldUrl = this->GetOption(prefix + "OLD_URL")) {
+    this->OldUrl = oldUrl;
+  } else {
+    this->OldUrl.clear();
+  }
+
+  // New url
+  if (const char* newUrl = this->GetOption(prefix + "NEW_URL")) {
+    this->NewUrl = newUrl;
+  } else {
+    this->NewUrl.clear();
+  }
+
+  // Enabled
+  if (this->IsOn(prefix + "DISABLED")) {
+    this->Enabled = "0";
+  } else {
+    this->Enabled.clear();
+  }
+
+  // Username
+  if (const char* username = this->GetOption(prefix + "USERNAME")) {
+    this->Username = username;
+  } else {
+    this->Username.clear();
+  }
+
+  // Password
+  if (const char* password = this->GetOption(prefix + "PASSWORD")) {
+    this->Password = password;
+  } else {
+    this->Password.clear();
+  }
+
+  // DisplayName
+  if (const char* displayName = this->GetOption(prefix + "DISPLAY_NAME")) {
+    this->DisplayName = displayName;
+  } else {
+    this->DisplayName.clear();
+  }
+
+  return this->IsValid();
+}
+
+/** \class cmCPackeIFWUpdatesPatcher
+ * \brief Helper class that parses and patch Updates.xml file (QtIFW)
+ */
+class cmCPackeIFWUpdatesPatcher : public cmXMLParser
+{
+public:
+  cmCPackeIFWUpdatesPatcher(cmCPackIFWRepository* r, cmXMLWriter& x)
+    : repository(r)
+    , xout(x)
+    , patched(false)
+  {
+  }
+
+  cmCPackIFWRepository* repository;
+  cmXMLWriter& xout;
+  bool patched;
+
+protected:
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    this->xout.StartElement(name);
+    this->StartFragment(atts);
+  }
+
+  void StartFragment(const char** atts)
+  {
+    for (size_t i = 0; atts[i]; i += 2) {
+      const char* key = atts[i];
+      const char* value = atts[i + 1];
+      this->xout.Attribute(key, value);
+    }
+  }
+
+  void EndElement(const std::string& name) override
+  {
+    if (name == "Updates" && !this->patched) {
+      this->repository->WriteRepositoryUpdates(this->xout);
+      this->patched = true;
+    }
+    this->xout.EndElement();
+    if (this->patched) {
+      return;
+    }
+    if (name == "Checksum") {
+      this->repository->WriteRepositoryUpdates(this->xout);
+      this->patched = true;
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    std::string content(data, data + length);
+    if (content.empty() || content == " " || content == "  " ||
+        content == "\n") {
+      return;
+    }
+    this->xout.Content(content);
+  }
+};
+
+bool cmCPackIFWRepository::PatchUpdatesXml()
+{
+  // Lazy directory initialization
+  if (this->Directory.empty() && this->Generator) {
+    this->Directory = this->Generator->toplevel;
+  }
+
+  // Filenames
+  std::string updatesXml = this->Directory + "/repository/Updates.xml";
+  std::string updatesPatchXml =
+    this->Directory + "/repository/UpdatesPatch.xml";
+
+  // Output stream
+  cmGeneratedFileStream fout(updatesPatchXml.data());
+  cmXMLWriter xout(fout);
+
+  xout.StartDocument();
+
+  this->WriteGeneratedByToStrim(xout);
+
+  // Patch
+  {
+    cmCPackeIFWUpdatesPatcher patcher(this, xout);
+    patcher.ParseFile(updatesXml.data());
+  }
+
+  xout.EndDocument();
+
+  fout.Close();
+
+  return cmSystemTools::RenameFile(updatesPatchXml.data(), updatesXml.data());
+}
+
+void cmCPackIFWRepository::WriteRepositoryConfig(cmXMLWriter& xout)
+{
+  xout.StartElement("Repository");
+
+  // Url
+  xout.Element("Url", this->Url);
+  // Enabled
+  if (!this->Enabled.empty()) {
+    xout.Element("Enabled", this->Enabled);
+  }
+  // Username
+  if (!this->Username.empty()) {
+    xout.Element("Username", this->Username);
+  }
+  // Password
+  if (!this->Password.empty()) {
+    xout.Element("Password", this->Password);
+  }
+  // DisplayName
+  if (!this->DisplayName.empty()) {
+    xout.Element("DisplayName", this->DisplayName);
+  }
+
+  xout.EndElement();
+}
+
+void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout)
+{
+  xout.StartElement("Repository");
+
+  switch (this->Update) {
+    case cmCPackIFWRepository::None:
+      break;
+    case cmCPackIFWRepository::Add:
+      xout.Attribute("action", "add");
+      break;
+    case cmCPackIFWRepository::Remove:
+      xout.Attribute("action", "remove");
+      break;
+    case cmCPackIFWRepository::Replace:
+      xout.Attribute("action", "replace");
+      break;
+  }
+
+  // Url
+  if (this->Update == cmCPackIFWRepository::Add ||
+      this->Update == cmCPackIFWRepository::Remove) {
+    xout.Attribute("url", this->Url);
+  } else if (Update == cmCPackIFWRepository::Replace) {
+    xout.Attribute("oldUrl", this->OldUrl);
+    xout.Attribute("newUrl", this->NewUrl);
+  }
+  // Enabled
+  if (!this->Enabled.empty()) {
+    xout.Attribute("enabled", this->Enabled);
+  }
+  // Username
+  if (!this->Username.empty()) {
+    xout.Attribute("username", this->Username);
+  }
+  // Password
+  if (!this->Password.empty()) {
+    xout.Attribute("password", this->Password);
+  }
+  // DisplayName
+  if (!this->DisplayName.empty()) {
+    xout.Attribute("displayname", this->DisplayName);
+  }
+
+  xout.EndElement();
+}
+
+void cmCPackIFWRepository::WriteRepositoryUpdates(cmXMLWriter& xout)
+{
+  if (!this->RepositoryUpdate.empty()) {
+    xout.StartElement("RepositoryUpdate");
+    for (cmCPackIFWRepository* r : this->RepositoryUpdate) {
+      r->WriteRepositoryUpdate(xout);
+    }
+    xout.EndElement();
+  }
+}
diff --git a/Source/CPack/IFW/cmCPackIFWRepository.h b/Source/CPack/IFW/cmCPackIFWRepository.h
new file mode 100644
index 0000000..227cfae
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWRepository.h
@@ -0,0 +1,88 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackIFWRepository_h
+#define cmCPackIFWRepository_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackIFWCommon.h"
+
+#include <string>
+#include <vector>
+
+class cmXMLWriter;
+
+/** \class cmCPackIFWRepository
+ * \brief A remote repository to be created CPack IFW generator
+ */
+class cmCPackIFWRepository : public cmCPackIFWCommon
+{
+public:
+  // Types
+
+  enum Action
+  {
+    None,
+    Add,
+    Remove,
+    Replace
+  };
+
+  typedef std::vector<cmCPackIFWRepository*> RepositoriesVector;
+
+public:
+  // Constructor
+
+  /**
+   * Construct repository
+   */
+  cmCPackIFWRepository();
+
+public:
+  // Configuration
+
+  /// Internal repository name
+  std::string Name;
+
+  /// Optional update action
+  Action Update;
+
+  /// Is points to a list of available components
+  std::string Url;
+
+  /// Is points to a list that will replaced
+  std::string OldUrl;
+
+  /// Is points to a list that will replace to
+  std::string NewUrl;
+
+  /// With "0" disabling this repository
+  std::string Enabled;
+
+  /// Is used as user on a protected repository
+  std::string Username;
+
+  /// Is password to use on a protected repository
+  std::string Password;
+
+  /// Is optional string to display instead of the URL
+  std::string DisplayName;
+
+public:
+  // Internal implementation
+
+  bool IsValid() const;
+
+  bool ConfigureFromOptions();
+
+  bool PatchUpdatesXml();
+
+  void WriteRepositoryConfig(cmXMLWriter& xout);
+  void WriteRepositoryUpdate(cmXMLWriter& xout);
+  void WriteRepositoryUpdates(cmXMLWriter& xout);
+
+  RepositoriesVector RepositoryUpdate;
+  std::string Directory;
+};
+
+#endif // cmCPackIFWRepository_h
diff --git a/Source/CPack/OSXLauncherScript.scpt b/Source/CPack/OSXLauncherScript.scpt
new file mode 100644
index 0000000..342cf8c
--- /dev/null
+++ b/Source/CPack/OSXLauncherScript.scpt
diff --git a/Source/CPack/OSXScriptLauncher.cxx b/Source/CPack/OSXScriptLauncher.cxx
new file mode 100644
index 0000000..d3de02b
--- /dev/null
+++ b/Source/CPack/OSXScriptLauncher.cxx
@@ -0,0 +1,120 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmsys/FStream.hxx"
+#include "cmsys/Process.h"
+#include "cmsys/SystemTools.hxx"
+#include <iostream>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+// For the PATH_MAX constant
+#include <sys/syslimits.h>
+
+#define DebugError(x)                                                         \
+  ofs << x << std::endl;                                                      \
+  std::cout << x << std::endl
+
+int main(int argc, char* argv[])
+{
+  // if ( cmsys::SystemTools::FileExists(
+  cmsys::ofstream ofs("/tmp/output.txt");
+
+  CFStringRef fileName;
+  CFBundleRef appBundle;
+  CFURLRef scriptFileURL;
+  UInt8* path;
+
+  // get CF URL for script
+  if (!(appBundle = CFBundleGetMainBundle())) {
+    DebugError("Cannot get main bundle");
+    return 1;
+  }
+  fileName = CFSTR("RuntimeScript");
+  if (!(scriptFileURL =
+          CFBundleCopyResourceURL(appBundle, fileName, nullptr, nullptr))) {
+    DebugError("CFBundleCopyResourceURL failed");
+    return 1;
+  }
+
+  // create path string
+  if (!(path = new UInt8[PATH_MAX])) {
+    return 1;
+  }
+
+  // get the file system path of the url as a cstring
+  // in an encoding suitable for posix apis
+  if (CFURLGetFileSystemRepresentation(scriptFileURL, true, path, PATH_MAX) ==
+      false) {
+    DebugError("CFURLGetFileSystemRepresentation failed");
+    return 1;
+  }
+
+  // dispose of the CF variable
+  CFRelease(scriptFileURL);
+
+  std::string fullScriptPath = reinterpret_cast<char*>(path);
+  delete[] path;
+
+  if (!cmsys::SystemTools::FileExists(fullScriptPath.c_str())) {
+    return 1;
+  }
+
+  std::string scriptDirectory =
+    cmsys::SystemTools::GetFilenamePath(fullScriptPath);
+  ofs << fullScriptPath << std::endl;
+  std::vector<const char*> args;
+  args.push_back(fullScriptPath.c_str());
+  int cc;
+  for (cc = 1; cc < argc; ++cc) {
+    args.push_back(argv[cc]);
+  }
+  args.push_back(nullptr);
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*args.begin());
+  cmsysProcess_SetWorkingDirectory(cp, scriptDirectory.c_str());
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  cmsysProcess_SetTimeout(cp, 0);
+  cmsysProcess_Execute(cp);
+
+  std::vector<char> tempOutput;
+  char* data;
+  int length;
+  while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
+    // Translate NULL characters in the output into valid text.
+    for (int i = 0; i < length; ++i) {
+      if (data[i] == '\0') {
+        data[i] = ' ';
+      }
+    }
+    std::cout.write(data, length);
+  }
+
+  cmsysProcess_WaitForExit(cp, nullptr);
+
+  bool result = true;
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
+    if (cmsysProcess_GetExitValue(cp) != 0) {
+      result = false;
+    }
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
+    const char* exception_str = cmsysProcess_GetExceptionString(cp);
+    std::cerr << exception_str << std::endl;
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
+    const char* error_str = cmsysProcess_GetErrorString(cp);
+    std::cerr << error_str << std::endl;
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
+    const char* error_str = "Process terminated due to timeout\n";
+    std::cerr << error_str << std::endl;
+    result = false;
+  }
+
+  cmsysProcess_Delete(cp);
+
+  return 0;
+}
diff --git a/Source/CPack/WiX/cmCMakeToWixPath.cxx b/Source/CPack/WiX/cmCMakeToWixPath.cxx
new file mode 100644
index 0000000..0b0e42a
--- /dev/null
+++ b/Source/CPack/WiX/cmCMakeToWixPath.cxx
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCMakeToWixPath.h"
+
+#include "cmSystemTools.h"
+
+#include <string>
+#include <vector>
+
+#ifdef __CYGWIN__
+#include <sys/cygwin.h>
+std::string CMakeToWixPath(const std::string& cygpath)
+{
+  std::vector<char> winpath_chars;
+  ssize_t winpath_size;
+
+  // Get the required buffer size.
+  winpath_size =
+    cygwin_conv_path(CCP_POSIX_TO_WIN_A, cygpath.c_str(), nullptr, 0);
+  if (winpath_size <= 0) {
+    return cygpath;
+  }
+
+  winpath_chars.assign(static_cast<size_t>(winpath_size) + 1, '\0');
+
+  winpath_size = cygwin_conv_path(CCP_POSIX_TO_WIN_A, cygpath.c_str(),
+                                  winpath_chars.data(), winpath_size);
+  if (winpath_size < 0) {
+    return cygpath;
+  }
+
+  return cmSystemTools::TrimWhitespace(winpath_chars.data());
+}
+#else
+std::string CMakeToWixPath(const std::string& path)
+{
+  return path;
+}
+#endif
diff --git a/Source/CPack/WiX/cmCMakeToWixPath.h b/Source/CPack/WiX/cmCMakeToWixPath.h
new file mode 100644
index 0000000..8bb9e04
--- /dev/null
+++ b/Source/CPack/WiX/cmCMakeToWixPath.h
@@ -0,0 +1,12 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCMakeToWixPath_h
+#define cmCMakeToWixPath_h
+
+#include "cmConfigure.h" //IWYU pragma: keep
+
+#include <string>
+
+std::string CMakeToWixPath(const std::string& cygpath);
+
+#endif // cmCMakeToWixPath_h
diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
new file mode 100644
index 0000000..a0bc0ea
--- /dev/null
+++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
@@ -0,0 +1,1162 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackWIXGenerator.h"
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackLog.h"
+#include "cmCryptoHash.h"
+#include "cmGeneratedFileStream.h"
+#include "cmInstalledFile.h"
+#include "cmSystemTools.h"
+#include "cmUuid.h"
+#include <algorithm>
+
+#include "cmWIXDirectoriesSourceWriter.h"
+#include "cmWIXFeaturesSourceWriter.h"
+#include "cmWIXFilesSourceWriter.h"
+#include "cmWIXRichTextFormatWriter.h"
+#include "cmWIXSourceWriter.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/Encoding.hxx"
+#include "cmsys/FStream.hxx"
+#include "cmsys/SystemTools.hxx"
+
+#ifdef _WIN32
+#include <rpc.h> // for GUID generation (windows only)
+#else
+#include <uuid/uuid.h> // for GUID generation (libuuid)
+#endif
+
+#include "cmCMakeToWixPath.h"
+
+cmCPackWIXGenerator::cmCPackWIXGenerator()
+  : Patch(0)
+  , ComponentGuidType(cmWIXSourceWriter::WIX_GENERATED_GUID)
+{
+}
+
+cmCPackWIXGenerator::~cmCPackWIXGenerator()
+{
+  if (this->Patch) {
+    delete this->Patch;
+  }
+}
+
+int cmCPackWIXGenerator::InitializeInternal()
+{
+  componentPackageMethod = ONE_PACKAGE;
+  this->Patch = new cmWIXPatch(this->Logger);
+
+  return this->Superclass::InitializeInternal();
+}
+
+bool cmCPackWIXGenerator::RunWiXCommand(std::string const& command)
+{
+  std::string logFileName = this->CPackTopLevel + "/wix.log";
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Running WiX command: " << command
+                                                               << std::endl);
+
+  std::string output;
+
+  int returnValue = 0;
+  bool status = cmSystemTools::RunSingleCommand(command.c_str(), &output,
+                                                &output, &returnValue, 0,
+                                                cmSystemTools::OUTPUT_NONE);
+
+  cmsys::ofstream logFile(logFileName.c_str(), std::ios::app);
+  logFile << command << std::endl;
+  logFile << output;
+  logFile.close();
+
+  if (!status || returnValue) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running WiX candle. "
+                                         "Please check '"
+                    << logFileName << "' for errors." << std::endl);
+
+    return false;
+  }
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::RunCandleCommand(std::string const& sourceFile,
+                                           std::string const& objectFile)
+{
+  std::string executable;
+  if (!RequireOption("CPACK_WIX_CANDLE_EXECUTABLE", executable)) {
+    return false;
+  }
+
+  std::ostringstream command;
+  command << QuotePath(executable);
+  command << " -nologo";
+  command << " -arch " << GetArchitecture();
+  command << " -out " << QuotePath(objectFile);
+
+  for (std::string const& ext : CandleExtensions) {
+    command << " -ext " << QuotePath(ext);
+  }
+
+  AddCustomFlags("CPACK_WIX_CANDLE_EXTRA_FLAGS", command);
+
+  command << " " << QuotePath(sourceFile);
+
+  return RunWiXCommand(command.str());
+}
+
+bool cmCPackWIXGenerator::RunLightCommand(std::string const& objectFiles)
+{
+  std::string executable;
+  if (!RequireOption("CPACK_WIX_LIGHT_EXECUTABLE", executable)) {
+    return false;
+  }
+
+  std::ostringstream command;
+  command << QuotePath(executable);
+  command << " -nologo";
+  command << " -out " << QuotePath(CMakeToWixPath(packageFileNames.at(0)));
+
+  for (std::string const& ext : this->LightExtensions) {
+    command << " -ext " << QuotePath(ext);
+  }
+
+  const char* const cultures = GetOption("CPACK_WIX_CULTURES");
+  if (cultures) {
+    command << " -cultures:" << cultures;
+  }
+
+  AddCustomFlags("CPACK_WIX_LIGHT_EXTRA_FLAGS", command);
+
+  command << " " << objectFiles;
+
+  return RunWiXCommand(command.str());
+}
+
+int cmCPackWIXGenerator::PackageFiles()
+{
+  if (!PackageFilesImpl() || cmSystemTools::GetErrorOccuredFlag()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Fatal WiX Generator Error"
+                    << std::endl);
+    return false;
+  }
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::InitializeWiXConfiguration()
+{
+  if (!ReadListFile("CPackWIX.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while executing CPackWIX.cmake"
+                    << std::endl);
+    return false;
+  }
+
+  if (GetOption("CPACK_WIX_PRODUCT_GUID") == 0) {
+    std::string guid = GenerateGUID();
+    SetOption("CPACK_WIX_PRODUCT_GUID", guid.c_str());
+
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                  "CPACK_WIX_PRODUCT_GUID implicitly set to " << guid << " . "
+                                                              << std::endl);
+  }
+
+  if (GetOption("CPACK_WIX_UPGRADE_GUID") == 0) {
+    std::string guid = GenerateGUID();
+    SetOption("CPACK_WIX_UPGRADE_GUID", guid.c_str());
+
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING, "CPACK_WIX_UPGRADE_GUID implicitly set to "
+        << guid << " . "
+                   "Please refer to the documentation on how and why "
+                   "you might want to set this explicitly."
+        << std::endl);
+  }
+
+  if (!RequireOption("CPACK_TOPLEVEL_DIRECTORY", this->CPackTopLevel)) {
+    return false;
+  }
+
+  if (GetOption("CPACK_WIX_LICENSE_RTF") == 0) {
+    std::string licenseFilename = this->CPackTopLevel + "/License.rtf";
+    SetOption("CPACK_WIX_LICENSE_RTF", licenseFilename.c_str());
+
+    if (!CreateLicenseFile()) {
+      return false;
+    }
+  }
+
+  if (GetOption("CPACK_PACKAGE_VENDOR") == 0) {
+    std::string defaultVendor = "Humanity";
+    SetOption("CPACK_PACKAGE_VENDOR", defaultVendor.c_str());
+
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                  "CPACK_PACKAGE_VENDOR implicitly set to "
+                    << defaultVendor << " . " << std::endl);
+  }
+
+  if (GetOption("CPACK_WIX_UI_REF") == 0) {
+    std::string defaultRef = "WixUI_InstallDir";
+
+    if (!this->Components.empty()) {
+      defaultRef = "WixUI_FeatureTree";
+    }
+
+    SetOption("CPACK_WIX_UI_REF", defaultRef.c_str());
+  }
+
+  const char* packageContact = GetOption("CPACK_PACKAGE_CONTACT");
+  if (packageContact != 0 && GetOption("CPACK_WIX_PROPERTY_ARPCONTACT") == 0) {
+    SetOption("CPACK_WIX_PROPERTY_ARPCONTACT", packageContact);
+  }
+
+  CollectExtensions("CPACK_WIX_EXTENSIONS", this->CandleExtensions);
+  CollectExtensions("CPACK_WIX_CANDLE_EXTENSIONS", this->CandleExtensions);
+
+  this->LightExtensions.insert("WixUIExtension");
+  CollectExtensions("CPACK_WIX_EXTENSIONS", this->LightExtensions);
+  CollectExtensions("CPACK_WIX_LIGHT_EXTENSIONS", this->LightExtensions);
+
+  const char* patchFilePath = GetOption("CPACK_WIX_PATCH_FILE");
+  if (patchFilePath) {
+    std::vector<std::string> patchFilePaths;
+    cmSystemTools::ExpandListArgument(patchFilePath, patchFilePaths);
+
+    for (std::string const& p : patchFilePaths) {
+      if (!this->Patch->LoadFragments(p)) {
+        return false;
+      }
+    }
+  }
+
+  // if install folder is supposed to be set absolutely, the default
+  // component guid "*" cannot be used
+  if (cmSystemTools::IsOn(GetOption("CPACK_WIX_SKIP_PROGRAM_FOLDER"))) {
+    this->ComponentGuidType = cmWIXSourceWriter::CMAKE_GENERATED_GUID;
+  }
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::PackageFilesImpl()
+{
+  if (!InitializeWiXConfiguration()) {
+    return false;
+  }
+
+  CreateWiXVariablesIncludeFile();
+  CreateWiXPropertiesIncludeFile();
+  CreateWiXProductFragmentIncludeFile();
+
+  if (!CreateWiXSourceFiles()) {
+    return false;
+  }
+
+  AppendUserSuppliedExtraSources();
+
+  std::set<std::string> usedBaseNames;
+
+  std::ostringstream objectFiles;
+  for (std::string const& sourceFilename : this->WixSources) {
+    std::string baseName =
+      cmSystemTools::GetFilenameWithoutLastExtension(sourceFilename);
+
+    unsigned int counter = 0;
+    std::string uniqueBaseName = baseName;
+
+    while (usedBaseNames.find(uniqueBaseName) != usedBaseNames.end()) {
+      std::ostringstream tmp;
+      tmp << baseName << ++counter;
+      uniqueBaseName = tmp.str();
+    }
+
+    usedBaseNames.insert(uniqueBaseName);
+
+    std::string objectFilename =
+      this->CPackTopLevel + "/" + uniqueBaseName + ".wixobj";
+
+    if (!RunCandleCommand(CMakeToWixPath(sourceFilename),
+                          CMakeToWixPath(objectFilename))) {
+      return false;
+    }
+
+    objectFiles << " " << QuotePath(CMakeToWixPath(objectFilename));
+  }
+
+  AppendUserSuppliedExtraObjects(objectFiles);
+
+  return RunLightCommand(objectFiles.str());
+}
+
+void cmCPackWIXGenerator::AppendUserSuppliedExtraSources()
+{
+  const char* cpackWixExtraSources = GetOption("CPACK_WIX_EXTRA_SOURCES");
+  if (!cpackWixExtraSources)
+    return;
+
+  cmSystemTools::ExpandListArgument(cpackWixExtraSources, this->WixSources);
+}
+
+void cmCPackWIXGenerator::AppendUserSuppliedExtraObjects(std::ostream& stream)
+{
+  const char* cpackWixExtraObjects = GetOption("CPACK_WIX_EXTRA_OBJECTS");
+  if (!cpackWixExtraObjects)
+    return;
+
+  std::vector<std::string> expandedExtraObjects;
+
+  cmSystemTools::ExpandListArgument(cpackWixExtraObjects,
+                                    expandedExtraObjects);
+
+  for (std::string const& obj : expandedExtraObjects) {
+    stream << " " << QuotePath(obj);
+  }
+}
+
+void cmCPackWIXGenerator::CreateWiXVariablesIncludeFile()
+{
+  std::string includeFilename = this->CPackTopLevel + "/cpack_variables.wxi";
+
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename,
+                                this->ComponentGuidType,
+                                cmWIXSourceWriter::INCLUDE_ELEMENT_ROOT);
+
+  CopyDefinition(includeFile, "CPACK_WIX_PRODUCT_GUID");
+  CopyDefinition(includeFile, "CPACK_WIX_UPGRADE_GUID");
+  CopyDefinition(includeFile, "CPACK_PACKAGE_VENDOR");
+  CopyDefinition(includeFile, "CPACK_PACKAGE_NAME");
+  CopyDefinition(includeFile, "CPACK_PACKAGE_VERSION");
+  CopyDefinition(includeFile, "CPACK_WIX_LICENSE_RTF", DefinitionType::PATH);
+  CopyDefinition(includeFile, "CPACK_WIX_PRODUCT_ICON", DefinitionType::PATH);
+  CopyDefinition(includeFile, "CPACK_WIX_UI_BANNER", DefinitionType::PATH);
+  CopyDefinition(includeFile, "CPACK_WIX_UI_DIALOG", DefinitionType::PATH);
+  SetOptionIfNotSet("CPACK_WIX_PROGRAM_MENU_FOLDER",
+                    GetOption("CPACK_PACKAGE_NAME"));
+  CopyDefinition(includeFile, "CPACK_WIX_PROGRAM_MENU_FOLDER");
+  CopyDefinition(includeFile, "CPACK_WIX_UI_REF");
+}
+
+void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
+{
+  std::string includeFilename = this->CPackTopLevel + "/properties.wxi";
+
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename,
+                                this->ComponentGuidType,
+                                cmWIXSourceWriter::INCLUDE_ELEMENT_ROOT);
+
+  std::string prefix = "CPACK_WIX_PROPERTY_";
+  std::vector<std::string> options = GetOptions();
+
+  for (std::string const& name : options) {
+    if (name.length() > prefix.length() &&
+        name.substr(0, prefix.length()) == prefix) {
+      std::string id = name.substr(prefix.length());
+      std::string value = GetOption(name.c_str());
+
+      includeFile.BeginElement("Property");
+      includeFile.AddAttribute("Id", id);
+      includeFile.AddAttribute("Value", value);
+      includeFile.EndElement("Property");
+    }
+  }
+
+  if (GetOption("CPACK_WIX_PROPERTY_ARPINSTALLLOCATION") == 0) {
+    includeFile.BeginElement("Property");
+    includeFile.AddAttribute("Id", "INSTALL_ROOT");
+    includeFile.AddAttribute("Secure", "yes");
+
+    includeFile.BeginElement("RegistrySearch");
+    includeFile.AddAttribute("Id", "FindInstallLocation");
+    includeFile.AddAttribute("Root", "HKLM");
+    includeFile.AddAttribute(
+      "Key", "Software\\Microsoft\\Windows\\"
+             "CurrentVersion\\Uninstall\\[WIX_UPGRADE_DETECTED]");
+    includeFile.AddAttribute("Name", "InstallLocation");
+    includeFile.AddAttribute("Type", "raw");
+    includeFile.EndElement("RegistrySearch");
+    includeFile.EndElement("Property");
+
+    includeFile.BeginElement("SetProperty");
+    includeFile.AddAttribute("Id", "ARPINSTALLLOCATION");
+    includeFile.AddAttribute("Value", "[INSTALL_ROOT]");
+    includeFile.AddAttribute("After", "CostFinalize");
+    includeFile.EndElement("SetProperty");
+  }
+}
+
+void cmCPackWIXGenerator::CreateWiXProductFragmentIncludeFile()
+{
+  std::string includeFilename = this->CPackTopLevel + "/product_fragment.wxi";
+
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename,
+                                this->ComponentGuidType,
+                                cmWIXSourceWriter::INCLUDE_ELEMENT_ROOT);
+
+  this->Patch->ApplyFragment("#PRODUCT", includeFile);
+}
+
+void cmCPackWIXGenerator::CopyDefinition(cmWIXSourceWriter& source,
+                                         std::string const& name,
+                                         DefinitionType type)
+{
+  const char* value = GetOption(name.c_str());
+  if (value) {
+    if (type == DefinitionType::PATH) {
+      AddDefinition(source, name, CMakeToWixPath(value));
+    } else {
+      AddDefinition(source, name, value);
+    }
+  }
+}
+
+void cmCPackWIXGenerator::AddDefinition(cmWIXSourceWriter& source,
+                                        std::string const& name,
+                                        std::string const& value)
+{
+  std::ostringstream tmp;
+  tmp << name << "=\"" << value << '"';
+
+  source.AddProcessingInstruction("define", tmp.str());
+}
+
+bool cmCPackWIXGenerator::CreateWiXSourceFiles()
+{
+  // if install folder is supposed to be set absolutely, the default
+  // component guid "*" cannot be used
+  std::string directoryDefinitionsFilename =
+    this->CPackTopLevel + "/directories.wxs";
+
+  this->WixSources.push_back(directoryDefinitionsFilename);
+
+  cmWIXDirectoriesSourceWriter directoryDefinitions(
+    this->Logger, directoryDefinitionsFilename, this->ComponentGuidType);
+  directoryDefinitions.BeginElement("Fragment");
+
+  std::string installRoot;
+  if (!RequireOption("CPACK_PACKAGE_INSTALL_DIRECTORY", installRoot)) {
+    return false;
+  }
+
+  directoryDefinitions.BeginElement("Directory");
+  directoryDefinitions.AddAttribute("Id", "TARGETDIR");
+  directoryDefinitions.AddAttribute("Name", "SourceDir");
+
+  size_t installRootSize =
+    directoryDefinitions.BeginInstallationPrefixDirectory(GetRootFolderId(),
+                                                          installRoot);
+
+  std::string fileDefinitionsFilename = this->CPackTopLevel + "/files.wxs";
+
+  this->WixSources.push_back(fileDefinitionsFilename);
+
+  cmWIXFilesSourceWriter fileDefinitions(this->Logger, fileDefinitionsFilename,
+                                         this->ComponentGuidType);
+
+  fileDefinitions.BeginElement("Fragment");
+
+  std::string featureDefinitionsFilename =
+    this->CPackTopLevel + "/features.wxs";
+
+  this->WixSources.push_back(featureDefinitionsFilename);
+
+  cmWIXFeaturesSourceWriter featureDefinitions(
+    this->Logger, featureDefinitionsFilename, this->ComponentGuidType);
+
+  featureDefinitions.BeginElement("Fragment");
+
+  featureDefinitions.BeginElement("Feature");
+  featureDefinitions.AddAttribute("Id", "ProductFeature");
+  featureDefinitions.AddAttribute("Display", "expand");
+  featureDefinitions.AddAttribute("Absent", "disallow");
+  featureDefinitions.AddAttribute("ConfigurableDirectory", "INSTALL_ROOT");
+
+  std::string cpackPackageName;
+  if (!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName)) {
+    return false;
+  }
+
+  std::string featureTitle = cpackPackageName;
+  if (const char* title = GetOption("CPACK_WIX_ROOT_FEATURE_TITLE")) {
+    featureTitle = title;
+  }
+  featureDefinitions.AddAttribute("Title", featureTitle);
+  if (const char* desc = GetOption("CPACK_WIX_ROOT_FEATURE_DESCRIPTION")) {
+    featureDefinitions.AddAttribute("Description", desc);
+  }
+  featureDefinitions.AddAttribute("Level", "1");
+  this->Patch->ApplyFragment("#PRODUCTFEATURE", featureDefinitions);
+
+  const char* package = GetOption("CPACK_WIX_CMAKE_PACKAGE_REGISTRY");
+  if (package) {
+    featureDefinitions.CreateCMakePackageRegistryEntry(
+      package, GetOption("CPACK_WIX_UPGRADE_GUID"));
+  }
+
+  if (!CreateFeatureHierarchy(featureDefinitions)) {
+    return false;
+  }
+
+  featureDefinitions.EndElement("Feature");
+
+  std::set<cmWIXShortcuts::Type> emittedShortcutTypes;
+
+  cmWIXShortcuts globalShortcuts;
+  if (Components.empty()) {
+    AddComponentsToFeature(toplevel, "ProductFeature", directoryDefinitions,
+                           fileDefinitions, featureDefinitions,
+                           globalShortcuts);
+
+    globalShortcuts.AddShortcutTypes(emittedShortcutTypes);
+  } else {
+    for (auto const& i : this->Components) {
+      cmCPackComponent const& component = i.second;
+
+      std::string componentPath = toplevel;
+      componentPath += "/";
+      componentPath += component.Name;
+
+      std::string const componentFeatureId = "CM_C_" + component.Name;
+
+      cmWIXShortcuts featureShortcuts;
+      AddComponentsToFeature(componentPath, componentFeatureId,
+                             directoryDefinitions, fileDefinitions,
+                             featureDefinitions, featureShortcuts);
+
+      featureShortcuts.AddShortcutTypes(emittedShortcutTypes);
+
+      if (!CreateShortcuts(component.Name, componentFeatureId,
+                           featureShortcuts, false, fileDefinitions,
+                           featureDefinitions)) {
+        return false;
+      }
+    }
+  }
+
+  bool emitUninstallShortcut =
+    emittedShortcutTypes.find(cmWIXShortcuts::START_MENU) !=
+    emittedShortcutTypes.end();
+
+  if (!CreateShortcuts(std::string(), "ProductFeature", globalShortcuts,
+                       emitUninstallShortcut, fileDefinitions,
+                       featureDefinitions)) {
+    return false;
+  }
+
+  featureDefinitions.EndElement("Fragment");
+  fileDefinitions.EndElement("Fragment");
+
+  directoryDefinitions.EndInstallationPrefixDirectory(installRootSize);
+
+  if (emittedShortcutTypes.find(cmWIXShortcuts::START_MENU) !=
+      emittedShortcutTypes.end()) {
+    directoryDefinitions.EmitStartMenuFolder(
+      GetOption("CPACK_WIX_PROGRAM_MENU_FOLDER"));
+  }
+
+  if (emittedShortcutTypes.find(cmWIXShortcuts::DESKTOP) !=
+      emittedShortcutTypes.end()) {
+    directoryDefinitions.EmitDesktopFolder();
+  }
+
+  if (emittedShortcutTypes.find(cmWIXShortcuts::STARTUP) !=
+      emittedShortcutTypes.end()) {
+    directoryDefinitions.EmitStartupFolder();
+  }
+
+  directoryDefinitions.EndElement("Directory");
+  directoryDefinitions.EndElement("Fragment");
+
+  if (!GenerateMainSourceFileFromTemplate()) {
+    return false;
+  }
+
+  return this->Patch->CheckForUnappliedFragments();
+}
+
+std::string cmCPackWIXGenerator::GetRootFolderId() const
+{
+  if (cmSystemTools::IsOn(GetOption("CPACK_WIX_SKIP_PROGRAM_FOLDER"))) {
+    return "";
+  }
+
+  std::string result = "ProgramFiles<64>Folder";
+
+  const char* rootFolderId = GetOption("CPACK_WIX_ROOT_FOLDER_ID");
+  if (rootFolderId) {
+    result = rootFolderId;
+  }
+
+  if (GetArchitecture() == "x86") {
+    cmSystemTools::ReplaceString(result, "<64>", "");
+  } else {
+    cmSystemTools::ReplaceString(result, "<64>", "64");
+  }
+
+  return result;
+}
+
+bool cmCPackWIXGenerator::GenerateMainSourceFileFromTemplate()
+{
+  std::string wixTemplate = FindTemplate("WIX.template.in");
+  if (GetOption("CPACK_WIX_TEMPLATE") != 0) {
+    wixTemplate = GetOption("CPACK_WIX_TEMPLATE");
+  }
+
+  if (wixTemplate.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Could not find CPack WiX template file WIX.template.in"
+                    << std::endl);
+    return false;
+  }
+
+  std::string mainSourceFilePath = this->CPackTopLevel + "/main.wxs";
+
+  if (!ConfigureFile(wixTemplate.c_str(), mainSourceFilePath.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed creating '"
+                    << mainSourceFilePath << "'' from template." << std::endl);
+
+    return false;
+  }
+
+  this->WixSources.push_back(mainSourceFilePath);
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::CreateFeatureHierarchy(
+  cmWIXFeaturesSourceWriter& featureDefinitions)
+{
+  for (auto const& i : ComponentGroups) {
+    cmCPackComponentGroup const& group = i.second;
+    if (group.ParentGroup == 0) {
+      featureDefinitions.EmitFeatureForComponentGroup(group, *this->Patch);
+    }
+  }
+
+  for (auto const& i : this->Components) {
+    cmCPackComponent const& component = i.second;
+
+    if (!component.Group) {
+      featureDefinitions.EmitFeatureForComponent(component, *this->Patch);
+    }
+  }
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::AddComponentsToFeature(
+  std::string const& rootPath, std::string const& featureId,
+  cmWIXDirectoriesSourceWriter& directoryDefinitions,
+  cmWIXFilesSourceWriter& fileDefinitions,
+  cmWIXFeaturesSourceWriter& featureDefinitions, cmWIXShortcuts& shortcuts)
+{
+  featureDefinitions.BeginElement("FeatureRef");
+  featureDefinitions.AddAttribute("Id", featureId);
+
+  std::vector<std::string> cpackPackageExecutablesList;
+  const char* cpackPackageExecutables = GetOption("CPACK_PACKAGE_EXECUTABLES");
+  if (cpackPackageExecutables) {
+    cmSystemTools::ExpandListArgument(cpackPackageExecutables,
+                                      cpackPackageExecutablesList);
+    if (cpackPackageExecutablesList.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
+        "<text label>."
+          << std::endl);
+      return false;
+    }
+  }
+
+  std::vector<std::string> cpackPackageDesktopLinksList;
+  const char* cpackPackageDesktopLinks =
+    GetOption("CPACK_CREATE_DESKTOP_LINKS");
+  if (cpackPackageDesktopLinks) {
+    cmSystemTools::ExpandListArgument(cpackPackageDesktopLinks,
+                                      cpackPackageDesktopLinksList);
+  }
+
+  AddDirectoryAndFileDefinitions(
+    rootPath, "INSTALL_ROOT", directoryDefinitions, fileDefinitions,
+    featureDefinitions, cpackPackageExecutablesList,
+    cpackPackageDesktopLinksList, shortcuts);
+
+  featureDefinitions.EndElement("FeatureRef");
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::CreateShortcuts(
+  std::string const& cpackComponentName, std::string const& featureId,
+  cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
+  cmWIXFilesSourceWriter& fileDefinitions,
+  cmWIXFeaturesSourceWriter& featureDefinitions)
+{
+  if (!shortcuts.empty(cmWIXShortcuts::START_MENU)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::START_MENU, cpackComponentName, featureId, "",
+          shortcuts, emitUninstallShortcut, fileDefinitions,
+          featureDefinitions)) {
+      return false;
+    }
+  }
+
+  if (!shortcuts.empty(cmWIXShortcuts::DESKTOP)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::DESKTOP, cpackComponentName, featureId, "DESKTOP",
+          shortcuts, false, fileDefinitions, featureDefinitions)) {
+      return false;
+    }
+  }
+
+  if (!shortcuts.empty(cmWIXShortcuts::STARTUP)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::STARTUP, cpackComponentName, featureId, "STARTUP",
+          shortcuts, false, fileDefinitions, featureDefinitions)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::CreateShortcutsOfSpecificType(
+  cmWIXShortcuts::Type type, std::string const& cpackComponentName,
+  std::string const& featureId, std::string const& idPrefix,
+  cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
+  cmWIXFilesSourceWriter& fileDefinitions,
+  cmWIXFeaturesSourceWriter& featureDefinitions)
+{
+  std::string directoryId;
+  switch (type) {
+    case cmWIXShortcuts::START_MENU:
+      directoryId = "PROGRAM_MENU_FOLDER";
+      break;
+    case cmWIXShortcuts::DESKTOP:
+      directoryId = "DesktopFolder";
+      break;
+    case cmWIXShortcuts::STARTUP:
+      directoryId = "StartupFolder";
+      break;
+    default:
+      return false;
+  }
+
+  featureDefinitions.BeginElement("FeatureRef");
+  featureDefinitions.AddAttribute("Id", featureId);
+
+  std::string cpackVendor;
+  if (!RequireOption("CPACK_PACKAGE_VENDOR", cpackVendor)) {
+    return false;
+  }
+
+  std::string cpackPackageName;
+  if (!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName)) {
+    return false;
+  }
+
+  std::string idSuffix;
+  if (!cpackComponentName.empty()) {
+    idSuffix += "_";
+    idSuffix += cpackComponentName;
+  }
+
+  std::string componentId = "CM_SHORTCUT";
+  if (idPrefix.size()) {
+    componentId += "_" + idPrefix;
+  }
+
+  componentId += idSuffix;
+
+  fileDefinitions.BeginElement("DirectoryRef");
+  fileDefinitions.AddAttribute("Id", directoryId);
+
+  fileDefinitions.BeginElement("Component");
+  fileDefinitions.AddAttribute("Id", componentId);
+  fileDefinitions.AddAttribute(
+    "Guid", fileDefinitions.CreateGuidFromComponentId(componentId));
+
+  this->Patch->ApplyFragment(componentId, fileDefinitions);
+
+  std::string registryKey =
+    std::string("Software\\") + cpackVendor + "\\" + cpackPackageName;
+
+  shortcuts.EmitShortcuts(type, registryKey, cpackComponentName,
+                          fileDefinitions);
+
+  if (type == cmWIXShortcuts::START_MENU) {
+    fileDefinitions.EmitRemoveFolder("CM_REMOVE_PROGRAM_MENU_FOLDER" +
+                                     idSuffix);
+  }
+
+  if (emitUninstallShortcut) {
+    fileDefinitions.EmitUninstallShortcut(cpackPackageName);
+  }
+
+  fileDefinitions.EndElement("Component");
+  fileDefinitions.EndElement("DirectoryRef");
+
+  featureDefinitions.EmitComponentRef(componentId);
+  featureDefinitions.EndElement("FeatureRef");
+
+  return true;
+}
+
+bool cmCPackWIXGenerator::CreateLicenseFile()
+{
+  std::string licenseSourceFilename;
+  if (!RequireOption("CPACK_RESOURCE_FILE_LICENSE", licenseSourceFilename)) {
+    return false;
+  }
+
+  std::string licenseDestinationFilename;
+  if (!RequireOption("CPACK_WIX_LICENSE_RTF", licenseDestinationFilename)) {
+    return false;
+  }
+
+  std::string extension = GetRightmostExtension(licenseSourceFilename);
+
+  if (extension == ".rtf") {
+    cmSystemTools::CopyAFile(licenseSourceFilename.c_str(),
+                             licenseDestinationFilename.c_str());
+  } else if (extension == ".txt") {
+    cmWIXRichTextFormatWriter rtfWriter(licenseDestinationFilename);
+
+    cmsys::ifstream licenseSource(licenseSourceFilename.c_str());
+
+    std::string line;
+    while (std::getline(licenseSource, line)) {
+      rtfWriter.AddText(line);
+      rtfWriter.AddText("\n");
+    }
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "unsupported WiX License file extension '"
+                    << extension << "'" << std::endl);
+
+    return false;
+  }
+
+  return true;
+}
+
+void cmCPackWIXGenerator::AddDirectoryAndFileDefinitions(
+  std::string const& topdir, std::string const& directoryId,
+  cmWIXDirectoriesSourceWriter& directoryDefinitions,
+  cmWIXFilesSourceWriter& fileDefinitions,
+  cmWIXFeaturesSourceWriter& featureDefinitions,
+  std::vector<std::string> const& packageExecutables,
+  std::vector<std::string> const& desktopExecutables,
+  cmWIXShortcuts& shortcuts)
+{
+  cmsys::Directory dir;
+  dir.Load(topdir.c_str());
+
+  std::string relativeDirectoryPath =
+    cmSystemTools::RelativePath(toplevel.c_str(), topdir.c_str());
+
+  if (relativeDirectoryPath.empty()) {
+    relativeDirectoryPath = ".";
+  }
+
+  cmInstalledFile const* directoryInstalledFile = this->GetInstalledFile(
+    this->RelativePathWithoutComponentPrefix(relativeDirectoryPath));
+
+  bool emptyDirectory = dir.GetNumberOfFiles() == 2;
+  bool createDirectory = false;
+
+  if (emptyDirectory) {
+    createDirectory = true;
+  }
+
+  if (directoryInstalledFile) {
+    if (directoryInstalledFile->HasProperty("CPACK_WIX_ACL")) {
+      createDirectory = true;
+    }
+  }
+
+  if (createDirectory) {
+    std::string componentId = fileDefinitions.EmitComponentCreateFolder(
+      directoryId, GenerateGUID(), directoryInstalledFile);
+    featureDefinitions.EmitComponentRef(componentId);
+  }
+
+  if (emptyDirectory) {
+    return;
+  }
+
+  for (size_t i = 0; i < dir.GetNumberOfFiles(); ++i) {
+    std::string fileName = dir.GetFile(static_cast<unsigned long>(i));
+
+    if (fileName == "." || fileName == "..") {
+      continue;
+    }
+
+    std::string fullPath = topdir + "/" + fileName;
+
+    std::string relativePath =
+      cmSystemTools::RelativePath(toplevel.c_str(), fullPath.c_str());
+
+    std::string id = PathToId(relativePath);
+
+    if (cmSystemTools::FileIsDirectory(fullPath.c_str())) {
+      std::string subDirectoryId = std::string("CM_D") + id;
+
+      directoryDefinitions.BeginElement("Directory");
+      directoryDefinitions.AddAttribute("Id", subDirectoryId);
+      directoryDefinitions.AddAttribute("Name", fileName);
+      this->Patch->ApplyFragment(subDirectoryId, directoryDefinitions);
+
+      AddDirectoryAndFileDefinitions(
+        fullPath, subDirectoryId, directoryDefinitions, fileDefinitions,
+        featureDefinitions, packageExecutables, desktopExecutables, shortcuts);
+
+      directoryDefinitions.EndElement("Directory");
+    } else {
+      cmInstalledFile const* installedFile = this->GetInstalledFile(
+        this->RelativePathWithoutComponentPrefix(relativePath));
+
+      if (installedFile) {
+        shortcuts.CreateFromProperties(id, directoryId, *installedFile);
+      }
+
+      std::string componentId = fileDefinitions.EmitComponentFile(
+        directoryId, id, fullPath, *(this->Patch), installedFile);
+
+      featureDefinitions.EmitComponentRef(componentId);
+
+      for (size_t j = 0; j < packageExecutables.size(); ++j) {
+        std::string const& executableName = packageExecutables[j++];
+        std::string const& textLabel = packageExecutables[j];
+
+        if (cmSystemTools::LowerCase(fileName) ==
+            cmSystemTools::LowerCase(executableName) + ".exe") {
+          cmWIXShortcut shortcut;
+          shortcut.label = textLabel;
+          shortcut.workingDirectoryId = directoryId;
+          shortcuts.insert(cmWIXShortcuts::START_MENU, id, shortcut);
+
+          if (!desktopExecutables.empty() &&
+              std::find(desktopExecutables.begin(), desktopExecutables.end(),
+                        executableName) != desktopExecutables.end()) {
+            shortcuts.insert(cmWIXShortcuts::DESKTOP, id, shortcut);
+          }
+        }
+      }
+    }
+  }
+}
+
+bool cmCPackWIXGenerator::RequireOption(std::string const& name,
+                                        std::string& value) const
+{
+  const char* tmp = GetOption(name.c_str());
+  if (tmp) {
+    value = tmp;
+
+    return true;
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Required variable "
+                    << name << " not set" << std::endl);
+
+    return false;
+  }
+}
+
+std::string cmCPackWIXGenerator::GetArchitecture() const
+{
+  std::string void_p_size;
+  RequireOption("CPACK_WIX_SIZEOF_VOID_P", void_p_size);
+
+  if (void_p_size == "8") {
+    return "x64";
+  } else {
+    return "x86";
+  }
+}
+
+std::string cmCPackWIXGenerator::GenerateGUID()
+{
+#ifdef _WIN32
+  UUID guid;
+  UuidCreate(&guid);
+
+  unsigned short* tmp = 0;
+  UuidToStringW(&guid, &tmp);
+
+  std::string result =
+    cmsys::Encoding::ToNarrow(reinterpret_cast<wchar_t*>(tmp));
+  RpcStringFreeW(&tmp);
+#else
+  uuid_t guid;
+  char guid_ch[37] = { 0 };
+
+  uuid_generate(guid);
+  uuid_unparse(guid, guid_ch);
+  std::string result = guid_ch;
+#endif
+
+  return cmSystemTools::UpperCase(result);
+}
+
+std::string cmCPackWIXGenerator::QuotePath(std::string const& path)
+{
+  return std::string("\"") + path + '"';
+}
+
+std::string cmCPackWIXGenerator::GetRightmostExtension(
+  std::string const& filename)
+{
+  std::string extension;
+
+  std::string::size_type i = filename.rfind(".");
+  if (i != std::string::npos) {
+    extension = filename.substr(i);
+  }
+
+  return cmSystemTools::LowerCase(extension);
+}
+
+std::string cmCPackWIXGenerator::PathToId(std::string const& path)
+{
+  id_map_t::const_iterator i = PathToIdMap.find(path);
+  if (i != PathToIdMap.end())
+    return i->second;
+
+  std::string id = CreateNewIdForPath(path);
+  return id;
+}
+
+std::string cmCPackWIXGenerator::CreateNewIdForPath(std::string const& path)
+{
+  std::vector<std::string> components;
+  cmSystemTools::SplitPath(path.c_str(), components, false);
+
+  size_t replacementCount = 0;
+
+  std::string identifier;
+  std::string currentComponent;
+
+  for (size_t i = 1; i < components.size(); ++i) {
+    if (i != 1)
+      identifier += '.';
+
+    currentComponent =
+      NormalizeComponentForId(components[i], replacementCount);
+
+    identifier += currentComponent;
+  }
+
+  std::string idPrefix = "P";
+  size_t replacementPercent = replacementCount * 100 / identifier.size();
+  if (replacementPercent > 33 || identifier.size() > 60) {
+    identifier = CreateHashedId(path, currentComponent);
+    idPrefix = "H";
+  }
+
+  std::ostringstream result;
+  result << idPrefix << "_" << identifier;
+
+  size_t ambiguityCount = ++IdAmbiguityCounter[identifier];
+
+  if (ambiguityCount > 999) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while trying to generate a unique Id for '"
+                    << path << "'" << std::endl);
+
+    return std::string();
+  } else if (ambiguityCount > 1) {
+    result << "_" << ambiguityCount;
+  }
+
+  std::string resultString = result.str();
+
+  PathToIdMap[path] = resultString;
+
+  return resultString;
+}
+
+std::string cmCPackWIXGenerator::CreateHashedId(
+  std::string const& path, std::string const& normalizedFilename)
+{
+  cmCryptoHash sha1(cmCryptoHash::AlgoSHA1);
+  std::string const hash = sha1.HashString(path);
+
+  std::string identifier;
+  identifier += hash.substr(0, 7) + "_";
+
+  const size_t maxFileNameLength = 52;
+  if (normalizedFilename.length() > maxFileNameLength) {
+    identifier += normalizedFilename.substr(0, maxFileNameLength - 3);
+    identifier += "...";
+  } else {
+    identifier += normalizedFilename;
+  }
+
+  return identifier;
+}
+
+std::string cmCPackWIXGenerator::NormalizeComponentForId(
+  std::string const& component, size_t& replacementCount)
+{
+  std::string result;
+  result.resize(component.size());
+
+  for (size_t i = 0; i < component.size(); ++i) {
+    char c = component[i];
+    if (IsLegalIdCharacter(c)) {
+      result[i] = c;
+    } else {
+      result[i] = '_';
+      ++replacementCount;
+    }
+  }
+
+  return result;
+}
+
+bool cmCPackWIXGenerator::IsLegalIdCharacter(char c)
+{
+  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+    (c >= 'A' && c <= 'Z') || c == '_' || c == '.';
+}
+
+void cmCPackWIXGenerator::CollectExtensions(std::string const& variableName,
+                                            extension_set_t& extensions)
+{
+  const char* variableContent = GetOption(variableName.c_str());
+  if (!variableContent)
+    return;
+
+  std::vector<std::string> list;
+  cmSystemTools::ExpandListArgument(variableContent, list);
+  extensions.insert(list.begin(), list.end());
+}
+
+void cmCPackWIXGenerator::AddCustomFlags(std::string const& variableName,
+                                         std::ostream& stream)
+{
+  const char* variableContent = GetOption(variableName.c_str());
+  if (!variableContent)
+    return;
+
+  std::vector<std::string> list;
+  cmSystemTools::ExpandListArgument(variableContent, list);
+
+  for (std::string const& i : list) {
+    stream << " " << QuotePath(i);
+  }
+}
+
+std::string cmCPackWIXGenerator::RelativePathWithoutComponentPrefix(
+  std::string const& path)
+{
+  if (this->Components.empty()) {
+    return path;
+  }
+
+  std::string::size_type pos = path.find('/');
+
+  return path.substr(pos + 1);
+}
diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.h b/Source/CPack/WiX/cmCPackWIXGenerator.h
new file mode 100644
index 0000000..128a04d
--- /dev/null
+++ b/Source/CPack/WiX/cmCPackWIXGenerator.h
@@ -0,0 +1,166 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackWIXGenerator_h
+#define cmCPackWIXGenerator_h
+
+#include "cmCPackGenerator.h"
+
+#include "cmWIXPatch.h"
+#include "cmWIXShortcut.h"
+
+#include <map>
+#include <string>
+
+class cmWIXSourceWriter;
+class cmWIXDirectoriesSourceWriter;
+class cmWIXFilesSourceWriter;
+class cmWIXFeaturesSourceWriter;
+
+/** \class cmCPackWIXGenerator
+ * \brief A generator for WIX files
+ */
+class cmCPackWIXGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackWIXGenerator, cmCPackGenerator);
+
+  cmCPackWIXGenerator();
+  ~cmCPackWIXGenerator();
+
+protected:
+  virtual int InitializeInternal();
+
+  virtual int PackageFiles();
+
+  virtual const char* GetOutputExtension() { return ".msi"; }
+
+  virtual enum CPackSetDestdirSupport SupportsSetDestdir() const
+  {
+    return SETDESTDIR_UNSUPPORTED;
+  }
+
+  virtual bool SupportsAbsoluteDestination() const { return false; }
+
+  virtual bool SupportsComponentInstallation() const { return true; }
+
+private:
+  typedef std::map<std::string, std::string> id_map_t;
+  typedef std::map<std::string, size_t> ambiguity_map_t;
+  typedef std::set<std::string> extension_set_t;
+
+  enum class DefinitionType
+  {
+    STRING,
+    PATH
+  };
+
+  bool InitializeWiXConfiguration();
+
+  bool PackageFilesImpl();
+
+  void CreateWiXVariablesIncludeFile();
+
+  void CreateWiXPropertiesIncludeFile();
+
+  void CreateWiXProductFragmentIncludeFile();
+
+  void CopyDefinition(cmWIXSourceWriter& source, std::string const& name,
+                      DefinitionType type = DefinitionType::STRING);
+
+  void AddDefinition(cmWIXSourceWriter& source, std::string const& name,
+                     std::string const& value);
+
+  bool CreateWiXSourceFiles();
+
+  std::string GetRootFolderId() const;
+
+  bool GenerateMainSourceFileFromTemplate();
+
+  bool CreateFeatureHierarchy(cmWIXFeaturesSourceWriter& featureDefinitions);
+
+  bool AddComponentsToFeature(
+    std::string const& rootPath, std::string const& featureId,
+    cmWIXDirectoriesSourceWriter& directoryDefinitions,
+    cmWIXFilesSourceWriter& fileDefinitions,
+    cmWIXFeaturesSourceWriter& featureDefinitions, cmWIXShortcuts& shortcuts);
+
+  bool CreateShortcuts(std::string const& cpackComponentName,
+                       std::string const& featureId,
+                       cmWIXShortcuts const& shortcuts,
+                       bool emitUninstallShortcut,
+                       cmWIXFilesSourceWriter& fileDefinitions,
+                       cmWIXFeaturesSourceWriter& featureDefinitions);
+
+  bool CreateShortcutsOfSpecificType(
+    cmWIXShortcuts::Type type, std::string const& cpackComponentName,
+    std::string const& featureId, std::string const& idPrefix,
+    cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
+    cmWIXFilesSourceWriter& fileDefinitions,
+    cmWIXFeaturesSourceWriter& featureDefinitions);
+
+  void AppendUserSuppliedExtraSources();
+
+  void AppendUserSuppliedExtraObjects(std::ostream& stream);
+
+  bool CreateLicenseFile();
+
+  bool RunWiXCommand(std::string const& command);
+
+  bool RunCandleCommand(std::string const& sourceFile,
+                        std::string const& objectFile);
+
+  bool RunLightCommand(std::string const& objectFiles);
+
+  void AddDirectoryAndFileDefinitions(
+    std::string const& topdir, std::string const& directoryId,
+    cmWIXDirectoriesSourceWriter& directoryDefinitions,
+    cmWIXFilesSourceWriter& fileDefinitions,
+    cmWIXFeaturesSourceWriter& featureDefinitions,
+    std::vector<std::string> const& packageExecutables,
+    std::vector<std::string> const& desktopExecutables,
+    cmWIXShortcuts& shortcuts);
+
+  bool RequireOption(std::string const& name, std::string& value) const;
+
+  std::string GetArchitecture() const;
+
+  static std::string GenerateGUID();
+
+  static std::string QuotePath(std::string const& path);
+
+  static std::string GetRightmostExtension(std::string const& filename);
+
+  std::string PathToId(std::string const& path);
+
+  std::string CreateNewIdForPath(std::string const& path);
+
+  static std::string CreateHashedId(std::string const& path,
+                                    std::string const& normalizedFilename);
+
+  std::string NormalizeComponentForId(std::string const& component,
+                                      size_t& replacementCount);
+
+  static bool IsLegalIdCharacter(char c);
+
+  void CollectExtensions(std::string const& variableName,
+                         extension_set_t& extensions);
+
+  void AddCustomFlags(std::string const& variableName, std::ostream& stream);
+
+  std::string RelativePathWithoutComponentPrefix(std::string const& path);
+
+  std::vector<std::string> WixSources;
+  id_map_t PathToIdMap;
+  ambiguity_map_t IdAmbiguityCounter;
+
+  extension_set_t CandleExtensions;
+  extension_set_t LightExtensions;
+
+  std::string CPackTopLevel;
+
+  cmWIXPatch* Patch;
+
+  cmWIXSourceWriter::GuidType ComponentGuidType;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXAccessControlList.cxx b/Source/CPack/WiX/cmWIXAccessControlList.cxx
new file mode 100644
index 0000000..1603bf8
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXAccessControlList.cxx
@@ -0,0 +1,126 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXAccessControlList.h"
+
+#include "cmCPackGenerator.h"
+
+#include "cmSystemTools.h"
+
+cmWIXAccessControlList::cmWIXAccessControlList(
+  cmCPackLog* logger, cmInstalledFile const& installedFile,
+  cmWIXSourceWriter& sourceWriter)
+  : Logger(logger)
+  , InstalledFile(installedFile)
+  , SourceWriter(sourceWriter)
+{
+}
+
+bool cmWIXAccessControlList::Apply()
+{
+  std::vector<std::string> entries;
+  this->InstalledFile.GetPropertyAsList("CPACK_WIX_ACL", entries);
+
+  for (std::string const& entry : entries) {
+    this->CreatePermissionElement(entry);
+  }
+
+  return true;
+}
+
+void cmWIXAccessControlList::CreatePermissionElement(std::string const& entry)
+{
+  std::string::size_type pos = entry.find('=');
+  if (pos == std::string::npos) {
+    this->ReportError(entry, "Did not find mandatory '='");
+    return;
+  }
+
+  std::string user_and_domain = entry.substr(0, pos);
+  std::string permission_string = entry.substr(pos + 1);
+
+  pos = user_and_domain.find('@');
+  std::string user;
+  std::string domain;
+  if (pos != std::string::npos) {
+    user = user_and_domain.substr(0, pos);
+    domain = user_and_domain.substr(pos + 1);
+  } else {
+    user = user_and_domain;
+  }
+
+  std::vector<std::string> permissions =
+    cmSystemTools::tokenize(permission_string, ",");
+
+  this->SourceWriter.BeginElement("Permission");
+  this->SourceWriter.AddAttribute("User", user);
+  if (!domain.empty()) {
+    this->SourceWriter.AddAttribute("Domain", domain);
+  }
+  for (std::string const& permission : permissions) {
+    this->EmitBooleanAttribute(entry,
+                               cmSystemTools::TrimWhitespace(permission));
+  }
+  this->SourceWriter.EndElement("Permission");
+}
+
+void cmWIXAccessControlList::ReportError(std::string const& entry,
+                                         std::string const& message)
+{
+  cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed processing ACL entry '"
+                  << entry << "': " << message << std::endl);
+}
+
+bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name)
+{
+  static const char* validAttributes[] = {
+    /* clang-format needs this comment to break after the opening brace */
+    "Append",
+    "ChangePermission",
+    "CreateChild",
+    "CreateFile",
+    "CreateLink",
+    "CreateSubkeys",
+    "Delete",
+    "DeleteChild",
+    "EnumerateSubkeys",
+    "Execute",
+    "FileAllRights",
+    "GenericAll",
+    "GenericExecute",
+    "GenericRead",
+    "GenericWrite",
+    "Notify",
+    "Read",
+    "ReadAttributes",
+    "ReadExtendedAttributes",
+    "ReadPermission",
+    "SpecificRightsAll",
+    "Synchronize",
+    "TakeOwnership",
+    "Traverse",
+    "Write",
+    "WriteAttributes",
+    "WriteExtendedAttributes",
+    0
+  };
+
+  size_t i = 0;
+  while (validAttributes[i]) {
+    if (name == validAttributes[i++])
+      return true;
+  }
+
+  return false;
+}
+
+void cmWIXAccessControlList::EmitBooleanAttribute(std::string const& entry,
+                                                  std::string const& name)
+{
+  if (!this->IsBooleanAttribute(name)) {
+    std::ostringstream message;
+    message << "Unknown boolean attribute '" << name << "'";
+    this->ReportError(entry, message.str());
+  }
+
+  this->SourceWriter.AddAttribute(name, "yes");
+}
diff --git a/Source/CPack/WiX/cmWIXAccessControlList.h b/Source/CPack/WiX/cmWIXAccessControlList.h
new file mode 100644
index 0000000..2a23f2f
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXAccessControlList.h
@@ -0,0 +1,34 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXAccessControlList_h
+#define cmWIXAccessControlList_h
+
+#include "cmWIXSourceWriter.h"
+
+#include "cmCPackLog.h"
+#include "cmInstalledFile.h"
+
+class cmWIXAccessControlList
+{
+public:
+  cmWIXAccessControlList(cmCPackLog* logger,
+                         cmInstalledFile const& installedFile,
+                         cmWIXSourceWriter& sourceWriter);
+
+  bool Apply();
+
+private:
+  void CreatePermissionElement(std::string const& entry);
+
+  void ReportError(std::string const& entry, std::string const& message);
+
+  bool IsBooleanAttribute(std::string const& name);
+
+  void EmitBooleanAttribute(std::string const& entry, std::string const& name);
+
+  cmCPackLog* Logger;
+  cmInstalledFile const& InstalledFile;
+  cmWIXSourceWriter& SourceWriter;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
new file mode 100644
index 0000000..975dffb
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
@@ -0,0 +1,82 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXDirectoriesSourceWriter.h"
+
+cmWIXDirectoriesSourceWriter::cmWIXDirectoriesSourceWriter(
+  cmCPackLog* logger, std::string const& filename, GuidType componentGuidType)
+  : cmWIXSourceWriter(logger, filename, componentGuidType)
+{
+}
+
+void cmWIXDirectoriesSourceWriter::EmitStartMenuFolder(
+  std::string const& startMenuFolder)
+{
+  BeginElement("Directory");
+  AddAttribute("Id", "ProgramMenuFolder");
+
+  BeginElement("Directory");
+  AddAttribute("Id", "PROGRAM_MENU_FOLDER");
+  AddAttribute("Name", startMenuFolder);
+  EndElement("Directory");
+
+  EndElement("Directory");
+}
+
+void cmWIXDirectoriesSourceWriter::EmitDesktopFolder()
+{
+  BeginElement("Directory");
+  AddAttribute("Id", "DesktopFolder");
+  AddAttribute("Name", "Desktop");
+  EndElement("Directory");
+}
+
+void cmWIXDirectoriesSourceWriter::EmitStartupFolder()
+{
+  BeginElement("Directory");
+  AddAttribute("Id", "StartupFolder");
+  AddAttribute("Name", "Startup");
+  EndElement("Directory");
+}
+
+size_t cmWIXDirectoriesSourceWriter::BeginInstallationPrefixDirectory(
+  std::string const& programFilesFolderId,
+  std::string const& installRootString)
+{
+  size_t offset = 1;
+  if (!programFilesFolderId.empty()) {
+    BeginElement("Directory");
+    AddAttribute("Id", programFilesFolderId);
+    offset = 0;
+  }
+
+  std::vector<std::string> installRoot;
+
+  cmSystemTools::SplitPath(installRootString.c_str(), installRoot);
+
+  if (!installRoot.empty() && installRoot.back().empty()) {
+    installRoot.pop_back();
+  }
+
+  for (size_t i = 1; i < installRoot.size(); ++i) {
+    BeginElement("Directory");
+
+    if (i == installRoot.size() - 1) {
+      AddAttribute("Id", "INSTALL_ROOT");
+    } else {
+      std::ostringstream tmp;
+      tmp << "INSTALL_PREFIX_" << i;
+      AddAttribute("Id", tmp.str());
+    }
+
+    AddAttribute("Name", installRoot[i]);
+  }
+
+  return installRoot.size() - offset;
+}
+
+void cmWIXDirectoriesSourceWriter::EndInstallationPrefixDirectory(size_t size)
+{
+  for (size_t i = 0; i < size; ++i) {
+    EndElement("Directory");
+  }
+}
diff --git a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h
new file mode 100644
index 0000000..8233331
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h
@@ -0,0 +1,34 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXDirectoriesSourceWriter_h
+#define cmWIXDirectoriesSourceWriter_h
+
+#include "cmWIXSourceWriter.h"
+
+#include "cmCPackGenerator.h"
+
+#include <string>
+
+/** \class cmWIXDirectoriesSourceWriter
+ * \brief Helper class to generate directories.wxs
+ */
+class cmWIXDirectoriesSourceWriter : public cmWIXSourceWriter
+{
+public:
+  cmWIXDirectoriesSourceWriter(cmCPackLog* logger, std::string const& filename,
+                               GuidType componentGuidType);
+
+  void EmitStartMenuFolder(std::string const& startMenuFolder);
+
+  void EmitDesktopFolder();
+
+  void EmitStartupFolder();
+
+  size_t BeginInstallationPrefixDirectory(
+    std::string const& programFilesFolderId,
+    std::string const& installRootString);
+
+  void EndInstallationPrefixDirectory(size_t size);
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
new file mode 100644
index 0000000..a7a0648
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
@@ -0,0 +1,91 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXFeaturesSourceWriter.h"
+
+cmWIXFeaturesSourceWriter::cmWIXFeaturesSourceWriter(
+  cmCPackLog* logger, std::string const& filename, GuidType componentGuidType)
+  : cmWIXSourceWriter(logger, filename, componentGuidType)
+{
+}
+
+void cmWIXFeaturesSourceWriter::CreateCMakePackageRegistryEntry(
+  std::string const& package, std::string const& upgradeGuid)
+{
+  BeginElement("Component");
+  AddAttribute("Id", "CM_PACKAGE_REGISTRY");
+  AddAttribute("Directory", "TARGETDIR");
+  AddAttribute("Guid", CreateGuidFromComponentId("CM_PACKAGE_REGISTRY"));
+
+  std::string registryKey =
+    std::string("Software\\Kitware\\CMake\\Packages\\") + package;
+
+  BeginElement("RegistryValue");
+  AddAttribute("Root", "HKLM");
+  AddAttribute("Key", registryKey);
+  AddAttribute("Name", upgradeGuid);
+  AddAttribute("Type", "string");
+  AddAttribute("Value", "[INSTALL_ROOT]");
+  AddAttribute("KeyPath", "yes");
+  EndElement("RegistryValue");
+
+  EndElement("Component");
+}
+
+void cmWIXFeaturesSourceWriter::EmitFeatureForComponentGroup(
+  cmCPackComponentGroup const& group, cmWIXPatch& patch)
+{
+  BeginElement("Feature");
+  AddAttribute("Id", "CM_G_" + group.Name);
+
+  if (group.IsExpandedByDefault) {
+    AddAttribute("Display", "expand");
+  }
+
+  AddAttributeUnlessEmpty("Title", group.DisplayName);
+  AddAttributeUnlessEmpty("Description", group.Description);
+
+  patch.ApplyFragment("CM_G_" + group.Name, *this);
+
+  for (cmCPackComponentGroup* subgroup : group.Subgroups) {
+    EmitFeatureForComponentGroup(*subgroup, patch);
+  }
+
+  for (cmCPackComponent* component : group.Components) {
+    EmitFeatureForComponent(*component, patch);
+  }
+
+  EndElement("Feature");
+}
+
+void cmWIXFeaturesSourceWriter::EmitFeatureForComponent(
+  cmCPackComponent const& component, cmWIXPatch& patch)
+{
+  BeginElement("Feature");
+  AddAttribute("Id", "CM_C_" + component.Name);
+
+  AddAttributeUnlessEmpty("Title", component.DisplayName);
+  AddAttributeUnlessEmpty("Description", component.Description);
+
+  if (component.IsRequired) {
+    AddAttribute("Absent", "disallow");
+  }
+
+  if (component.IsHidden) {
+    AddAttribute("Display", "hidden");
+  }
+
+  if (component.IsDisabledByDefault) {
+    AddAttribute("Level", "2");
+  }
+
+  patch.ApplyFragment("CM_C_" + component.Name, *this);
+
+  EndElement("Feature");
+}
+
+void cmWIXFeaturesSourceWriter::EmitComponentRef(std::string const& id)
+{
+  BeginElement("ComponentRef");
+  AddAttribute("Id", id);
+  EndElement("ComponentRef");
+}
diff --git a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
new file mode 100644
index 0000000..e751ca7
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
@@ -0,0 +1,32 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXFeaturesSourceWriter_h
+#define cmWIXFeaturesSourceWriter_h
+
+#include "cmWIXPatch.h"
+#include "cmWIXSourceWriter.h"
+
+#include "cmCPackGenerator.h"
+
+/** \class cmWIXFeaturesSourceWriter
+ * \brief Helper class to generate features.wxs
+ */
+class cmWIXFeaturesSourceWriter : public cmWIXSourceWriter
+{
+public:
+  cmWIXFeaturesSourceWriter(cmCPackLog* logger, std::string const& filename,
+                            GuidType componentGuidType);
+
+  void CreateCMakePackageRegistryEntry(std::string const& package,
+                                       std::string const& upgradeGuid);
+
+  void EmitFeatureForComponentGroup(const cmCPackComponentGroup& group,
+                                    cmWIXPatch& patch);
+
+  void EmitFeatureForComponent(const cmCPackComponent& component,
+                               cmWIXPatch& patch);
+
+  void EmitComponentRef(std::string const& id);
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
new file mode 100644
index 0000000..dd3caf9
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
@@ -0,0 +1,166 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXFilesSourceWriter.h"
+
+#include "cmWIXAccessControlList.h"
+
+#include "cmInstalledFile.h"
+
+#include "cmSystemTools.h"
+#include "cmUuid.h"
+
+#include "cm_sys_stat.h"
+
+#include "cmCMakeToWixPath.h"
+
+cmWIXFilesSourceWriter::cmWIXFilesSourceWriter(cmCPackLog* logger,
+                                               std::string const& filename,
+                                               GuidType componentGuidType)
+  : cmWIXSourceWriter(logger, filename, componentGuidType)
+{
+}
+
+void cmWIXFilesSourceWriter::EmitShortcut(std::string const& id,
+                                          cmWIXShortcut const& shortcut,
+                                          std::string const& shortcutPrefix,
+                                          size_t shortcutIndex)
+{
+  std::ostringstream shortcutId;
+  shortcutId << shortcutPrefix << id;
+
+  if (shortcutIndex > 0) {
+    shortcutId << "_" << shortcutIndex;
+  }
+
+  std::string fileId = std::string("CM_F") + id;
+
+  BeginElement("Shortcut");
+  AddAttribute("Id", shortcutId.str());
+  AddAttribute("Name", shortcut.label);
+  std::string target = "[#" + fileId + "]";
+  AddAttribute("Target", target);
+  AddAttribute("WorkingDirectory", shortcut.workingDirectoryId);
+  EndElement("Shortcut");
+}
+
+void cmWIXFilesSourceWriter::EmitRemoveFolder(std::string const& id)
+{
+  BeginElement("RemoveFolder");
+  AddAttribute("Id", id);
+  AddAttribute("On", "uninstall");
+  EndElement("RemoveFolder");
+}
+
+void cmWIXFilesSourceWriter::EmitInstallRegistryValue(
+  std::string const& registryKey, std::string const& cpackComponentName,
+  std::string const& suffix)
+{
+  std::string valueName;
+  if (!cpackComponentName.empty()) {
+    valueName = cpackComponentName + "_";
+  }
+
+  valueName += "installed";
+  valueName += suffix;
+
+  BeginElement("RegistryValue");
+  AddAttribute("Root", "HKCU");
+  AddAttribute("Key", registryKey);
+  AddAttribute("Name", valueName);
+  AddAttribute("Type", "integer");
+  AddAttribute("Value", "1");
+  AddAttribute("KeyPath", "yes");
+  EndElement("RegistryValue");
+}
+
+void cmWIXFilesSourceWriter::EmitUninstallShortcut(
+  std::string const& packageName)
+{
+  BeginElement("Shortcut");
+  AddAttribute("Id", "UNINSTALL");
+  AddAttribute("Name", "Uninstall " + packageName);
+  AddAttribute("Description", "Uninstalls " + packageName);
+  AddAttribute("Target", "[SystemFolder]msiexec.exe");
+  AddAttribute("Arguments", "/x [ProductCode]");
+  EndElement("Shortcut");
+}
+
+std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
+  std::string const& directoryId, std::string const& guid,
+  cmInstalledFile const* installedFile)
+{
+  std::string componentId = std::string("CM_C_EMPTY_") + directoryId;
+
+  BeginElement("DirectoryRef");
+  AddAttribute("Id", directoryId);
+
+  BeginElement("Component");
+  AddAttribute("Id", componentId);
+  AddAttribute("Guid", guid);
+
+  BeginElement("CreateFolder");
+
+  if (installedFile) {
+    cmWIXAccessControlList acl(Logger, *installedFile, *this);
+    acl.Apply();
+  }
+
+  EndElement("CreateFolder");
+  EndElement("Component");
+  EndElement("DirectoryRef");
+
+  return componentId;
+}
+
+std::string cmWIXFilesSourceWriter::EmitComponentFile(
+  std::string const& directoryId, std::string const& id,
+  std::string const& filePath, cmWIXPatch& patch,
+  cmInstalledFile const* installedFile)
+{
+  std::string componentId = std::string("CM_C") + id;
+  std::string fileId = std::string("CM_F") + id;
+
+  std::string guid = CreateGuidFromComponentId(componentId);
+
+  BeginElement("DirectoryRef");
+  AddAttribute("Id", directoryId);
+
+  BeginElement("Component");
+  AddAttribute("Id", componentId);
+  AddAttribute("Guid", guid);
+
+  if (installedFile) {
+    if (installedFile->GetPropertyAsBool("CPACK_NEVER_OVERWRITE")) {
+      AddAttribute("NeverOverwrite", "yes");
+    }
+    if (installedFile->GetPropertyAsBool("CPACK_PERMANENT")) {
+      AddAttribute("Permanent", "yes");
+    }
+  }
+
+  patch.ApplyFragment(componentId, *this);
+  BeginElement("File");
+  AddAttribute("Id", fileId);
+  AddAttribute("Source", CMakeToWixPath(filePath));
+  AddAttribute("KeyPath", "yes");
+
+  mode_t fileMode = 0;
+  cmSystemTools::GetPermissions(filePath.c_str(), fileMode);
+
+  if (!(fileMode & S_IWRITE)) {
+    AddAttribute("ReadOnly", "yes");
+  }
+  patch.ApplyFragment(fileId, *this);
+
+  if (installedFile) {
+    cmWIXAccessControlList acl(Logger, *installedFile, *this);
+    acl.Apply();
+  }
+
+  EndElement("File");
+
+  EndElement("Component");
+  EndElement("DirectoryRef");
+
+  return componentId;
+}
diff --git a/Source/CPack/WiX/cmWIXFilesSourceWriter.h b/Source/CPack/WiX/cmWIXFilesSourceWriter.h
new file mode 100644
index 0000000..dc9c636
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXFilesSourceWriter.h
@@ -0,0 +1,43 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXFilesSourceWriter_h
+#define cmWIXFilesSourceWriter_h
+
+#include "cmWIXSourceWriter.h"
+
+#include "cmWIXPatch.h"
+#include "cmWIXShortcut.h"
+
+#include "cmCPackGenerator.h"
+
+/** \class cmWIXFilesSourceWriter
+ * \brief Helper class to generate files.wxs
+ */
+class cmWIXFilesSourceWriter : public cmWIXSourceWriter
+{
+public:
+  cmWIXFilesSourceWriter(cmCPackLog* logger, std::string const& filename,
+                         GuidType componentGuidType);
+
+  void EmitShortcut(std::string const& id, cmWIXShortcut const& shortcut,
+                    std::string const& shortcutPrefix, size_t shortcutIndex);
+
+  void EmitRemoveFolder(std::string const& id);
+
+  void EmitInstallRegistryValue(std::string const& registryKey,
+                                std::string const& cpackComponentName,
+                                std::string const& suffix);
+
+  void EmitUninstallShortcut(std::string const& packageName);
+
+  std::string EmitComponentCreateFolder(std::string const& directoryId,
+                                        std::string const& guid,
+                                        cmInstalledFile const* installedFile);
+
+  std::string EmitComponentFile(std::string const& directoryId,
+                                std::string const& id,
+                                std::string const& filePath, cmWIXPatch& patch,
+                                cmInstalledFile const* installedFile);
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXPatch.cxx b/Source/CPack/WiX/cmWIXPatch.cxx
new file mode 100644
index 0000000..dec95fb
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXPatch.cxx
@@ -0,0 +1,90 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXPatch.h"
+
+#include "cmCPackGenerator.h"
+
+cmWIXPatch::cmWIXPatch(cmCPackLog* logger)
+  : Logger(logger)
+{
+}
+
+bool cmWIXPatch::LoadFragments(std::string const& patchFilePath)
+{
+  cmWIXPatchParser parser(Fragments, Logger);
+  if (!parser.ParseFile(patchFilePath.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed parsing XML patch file: '"
+                    << patchFilePath << "'" << std::endl);
+    return false;
+  }
+
+  return true;
+}
+
+void cmWIXPatch::ApplyFragment(std::string const& id,
+                               cmWIXSourceWriter& writer)
+{
+  cmWIXPatchParser::fragment_map_t::iterator i = Fragments.find(id);
+  if (i == Fragments.end())
+    return;
+
+  const cmWIXPatchElement& fragment = i->second;
+  for (auto const& attr : fragment.attributes) {
+    writer.AddAttribute(attr.first, attr.second);
+  }
+  this->ApplyElementChildren(fragment, writer);
+
+  Fragments.erase(i);
+}
+
+void cmWIXPatch::ApplyElementChildren(const cmWIXPatchElement& element,
+                                      cmWIXSourceWriter& writer)
+{
+  for (cmWIXPatchNode* node : element.children) {
+    switch (node->type()) {
+      case cmWIXPatchNode::ELEMENT:
+        ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
+        break;
+      case cmWIXPatchNode::TEXT:
+        writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text);
+        break;
+    }
+  }
+}
+
+void cmWIXPatch::ApplyElement(const cmWIXPatchElement& element,
+                              cmWIXSourceWriter& writer)
+{
+  writer.BeginElement(element.name);
+
+  for (auto const& attr : element.attributes) {
+    writer.AddAttribute(attr.first, attr.second);
+  }
+
+  this->ApplyElementChildren(element, writer);
+
+  writer.EndElement(element.name);
+}
+
+bool cmWIXPatch::CheckForUnappliedFragments()
+{
+  std::string fragmentList;
+  for (auto const& fragment : Fragments) {
+    if (!fragmentList.empty()) {
+      fragmentList += ", ";
+    }
+
+    fragmentList += "'";
+    fragmentList += fragment.first;
+    fragmentList += "'";
+  }
+
+  if (!fragmentList.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Some XML patch fragments did not have matching IDs: "
+                    << fragmentList << std::endl);
+    return false;
+  }
+
+  return true;
+}
diff --git a/Source/CPack/WiX/cmWIXPatch.h b/Source/CPack/WiX/cmWIXPatch.h
new file mode 100644
index 0000000..a4c9e71
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXPatch.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXPatch_h
+#define cmWIXPatch_h
+
+#include "cmWIXPatchParser.h"
+#include "cmWIXSourceWriter.h"
+
+#include <string>
+
+/** \class cmWIXPatch
+ * \brief Class that maintains and applies patch fragments
+ */
+class cmWIXPatch
+{
+public:
+  cmWIXPatch(cmCPackLog* logger);
+
+  bool LoadFragments(std::string const& patchFilePath);
+
+  void ApplyFragment(std::string const& id, cmWIXSourceWriter& writer);
+
+  bool CheckForUnappliedFragments();
+
+private:
+  void ApplyElementChildren(const cmWIXPatchElement& element,
+                            cmWIXSourceWriter& writer);
+
+  void ApplyElement(const cmWIXPatchElement& element,
+                    cmWIXSourceWriter& writer);
+
+  cmCPackLog* Logger;
+
+  cmWIXPatchParser::fragment_map_t Fragments;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXPatchParser.cxx b/Source/CPack/WiX/cmWIXPatchParser.cxx
new file mode 100644
index 0000000..c6ca944
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXPatchParser.cxx
@@ -0,0 +1,160 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXPatchParser.h"
+
+#include "cmCPackGenerator.h"
+
+#include "cm_expat.h"
+
+cmWIXPatchNode::Type cmWIXPatchText::type()
+{
+  return cmWIXPatchNode::TEXT;
+}
+
+cmWIXPatchNode::Type cmWIXPatchElement::type()
+{
+  return cmWIXPatchNode::ELEMENT;
+}
+
+cmWIXPatchNode::~cmWIXPatchNode()
+{
+}
+
+cmWIXPatchElement::~cmWIXPatchElement()
+{
+  for (cmWIXPatchNode* child : children) {
+    delete child;
+  }
+}
+
+cmWIXPatchParser::cmWIXPatchParser(fragment_map_t& fragments,
+                                   cmCPackLog* logger)
+  : Logger(logger)
+  , State(BEGIN_DOCUMENT)
+  , Valid(true)
+  , Fragments(fragments)
+{
+}
+
+void cmWIXPatchParser::StartElement(const std::string& name, const char** atts)
+{
+  if (State == BEGIN_DOCUMENT) {
+    if (name == "CPackWiXPatch") {
+      State = BEGIN_FRAGMENTS;
+    } else {
+      ReportValidationError("Expected root element 'CPackWiXPatch'");
+    }
+  } else if (State == BEGIN_FRAGMENTS) {
+    if (name == "CPackWiXFragment") {
+      State = INSIDE_FRAGMENT;
+      StartFragment(atts);
+    } else {
+      ReportValidationError("Expected 'CPackWixFragment' element");
+    }
+  } else if (State == INSIDE_FRAGMENT) {
+    cmWIXPatchElement& parent = *ElementStack.back();
+
+    cmWIXPatchElement* element = new cmWIXPatchElement;
+    parent.children.push_back(element);
+
+    element->name = name;
+
+    for (size_t i = 0; atts[i]; i += 2) {
+      std::string key = atts[i];
+      std::string value = atts[i + 1];
+
+      element->attributes[key] = value;
+    }
+
+    ElementStack.push_back(element);
+  }
+}
+
+void cmWIXPatchParser::StartFragment(const char** attributes)
+{
+  cmWIXPatchElement* new_element = nullptr;
+  /* find the id of for fragment */
+  for (size_t i = 0; attributes[i]; i += 2) {
+    const std::string key = attributes[i];
+    const std::string value = attributes[i + 1];
+
+    if (key == "Id") {
+      if (Fragments.find(value) != Fragments.end()) {
+        std::ostringstream tmp;
+        tmp << "Invalid reuse of 'CPackWixFragment' 'Id': " << value;
+        ReportValidationError(tmp.str());
+      }
+
+      new_element = &Fragments[value];
+      ElementStack.push_back(new_element);
+    }
+  }
+
+  /* add any additional attributes for the fragment */
+  if (!new_element) {
+    ReportValidationError("No 'Id' specified for 'CPackWixFragment' element");
+  } else {
+    for (size_t i = 0; attributes[i]; i += 2) {
+      const std::string key = attributes[i];
+      const std::string value = attributes[i + 1];
+
+      if (key != "Id") {
+        new_element->attributes[key] = value;
+      }
+    }
+  }
+}
+
+void cmWIXPatchParser::EndElement(const std::string& name)
+{
+  if (State == INSIDE_FRAGMENT) {
+    if (name == "CPackWiXFragment") {
+      State = BEGIN_FRAGMENTS;
+      ElementStack.clear();
+    } else {
+      ElementStack.pop_back();
+    }
+  }
+}
+
+void cmWIXPatchParser::CharacterDataHandler(const char* data, int length)
+{
+  const char* whitespace = "\x20\x09\x0d\x0a";
+
+  if (State == INSIDE_FRAGMENT) {
+    cmWIXPatchElement& parent = *ElementStack.back();
+
+    std::string text(data, length);
+
+    std::string::size_type first = text.find_first_not_of(whitespace);
+    std::string::size_type last = text.find_last_not_of(whitespace);
+
+    if (first != std::string::npos && last != std::string::npos) {
+      cmWIXPatchText* text_node = new cmWIXPatchText;
+      text_node->text = text.substr(first, last - first + 1);
+
+      parent.children.push_back(text_node);
+    }
+  }
+}
+
+void cmWIXPatchParser::ReportError(int line, int column, const char* msg)
+{
+  cmCPackLogger(cmCPackLog::LOG_ERROR,
+                "Error while processing XML patch file at "
+                  << line << ":" << column << ":  " << msg << std::endl);
+  Valid = false;
+}
+
+void cmWIXPatchParser::ReportValidationError(std::string const& message)
+{
+  ReportError(
+    XML_GetCurrentLineNumber(static_cast<XML_Parser>(this->Parser)),
+    XML_GetCurrentColumnNumber(static_cast<XML_Parser>(this->Parser)),
+    message.c_str());
+}
+
+bool cmWIXPatchParser::IsValid() const
+{
+  return Valid;
+}
diff --git a/Source/CPack/WiX/cmWIXPatchParser.h b/Source/CPack/WiX/cmWIXPatchParser.h
new file mode 100644
index 0000000..52c7e35
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXPatchParser.h
@@ -0,0 +1,90 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackWIXPatchParser_h
+#define cmCPackWIXPatchParser_h
+
+#include "cmCPackLog.h"
+
+#include "cmXMLParser.h"
+
+#include <map>
+#include <vector>
+
+struct cmWIXPatchNode
+{
+  enum Type
+  {
+    TEXT,
+    ELEMENT
+  };
+
+  virtual ~cmWIXPatchNode();
+
+  virtual Type type() = 0;
+};
+
+struct cmWIXPatchText : public cmWIXPatchNode
+{
+  virtual Type type();
+
+  std::string text;
+};
+
+struct cmWIXPatchElement : cmWIXPatchNode
+{
+  virtual Type type();
+
+  ~cmWIXPatchElement();
+
+  typedef std::vector<cmWIXPatchNode*> child_list_t;
+  typedef std::map<std::string, std::string> attributes_t;
+
+  std::string name;
+  child_list_t children;
+  attributes_t attributes;
+};
+
+/** \class cmWIXPatchParser
+ * \brief Helper class that parses XML patch files (CPACK_WIX_PATCH_FILE)
+ */
+class cmWIXPatchParser : public cmXMLParser
+{
+public:
+  typedef std::map<std::string, cmWIXPatchElement> fragment_map_t;
+
+  cmWIXPatchParser(fragment_map_t& Fragments, cmCPackLog* logger);
+
+private:
+  virtual void StartElement(const std::string& name, const char** atts);
+
+  void StartFragment(const char** attributes);
+
+  virtual void EndElement(const std::string& name);
+
+  virtual void CharacterDataHandler(const char* data, int length);
+
+  virtual void ReportError(int line, int column, const char* msg);
+
+  void ReportValidationError(std::string const& message);
+
+  bool IsValid() const;
+
+  cmCPackLog* Logger;
+
+  enum ParserState
+  {
+    BEGIN_DOCUMENT,
+    BEGIN_FRAGMENTS,
+    INSIDE_FRAGMENT
+  };
+
+  ParserState State;
+
+  bool Valid;
+
+  fragment_map_t& Fragments;
+
+  std::vector<cmWIXPatchElement*> ElementStack;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx b/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
new file mode 100644
index 0000000..2c99a22
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
@@ -0,0 +1,186 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXRichTextFormatWriter.h"
+
+#include "cmVersion.h"
+
+cmWIXRichTextFormatWriter::cmWIXRichTextFormatWriter(
+  std::string const& filename)
+  : File(filename.c_str(), std::ios::binary)
+{
+  StartGroup();
+  WriteHeader();
+  WriteDocumentPrefix();
+}
+
+cmWIXRichTextFormatWriter::~cmWIXRichTextFormatWriter()
+{
+  EndGroup();
+
+  /* I haven't seen this in the RTF spec but
+   *  wordpad terminates its RTF like this */
+  File << "\r\n";
+  File.put(0);
+}
+
+void cmWIXRichTextFormatWriter::AddText(std::string const& text)
+{
+  typedef unsigned char rtf_byte_t;
+
+  for (size_t i = 0; i < text.size(); ++i) {
+    rtf_byte_t c = rtf_byte_t(text[i]);
+
+    switch (c) {
+      case '\\':
+        File << "\\\\";
+        break;
+      case '{':
+        File << "\\{";
+        break;
+      case '}':
+        File << "\\}";
+        break;
+      case '\n':
+        File << "\\par\r\n";
+        break;
+      case '\r':
+        continue;
+      default: {
+        if (c <= 0x7F) {
+          File << c;
+        } else {
+          if (c <= 0xC0) {
+            EmitInvalidCodepoint(c);
+          } else if (c < 0xE0 && i + 1 < text.size()) {
+            EmitUnicodeCodepoint((text[i + 1] & 0x3F) | ((c & 0x1F) << 6));
+            i += 1;
+          } else if (c < 0xF0 && i + 2 < text.size()) {
+            EmitUnicodeCodepoint((text[i + 2] & 0x3F) |
+                                 ((text[i + 1] & 0x3F) << 6) |
+                                 ((c & 0xF) << 12));
+            i += 2;
+          } else if (c < 0xF8 && i + 3 < text.size()) {
+            EmitUnicodeCodepoint(
+              (text[i + 3] & 0x3F) | ((text[i + 2] & 0x3F) << 6) |
+              ((text[i + 1] & 0x3F) << 12) | ((c & 0x7) << 18));
+            i += 3;
+          } else {
+            EmitInvalidCodepoint(c);
+          }
+        }
+      } break;
+    }
+  }
+}
+
+void cmWIXRichTextFormatWriter::WriteHeader()
+{
+  ControlWord("rtf1");
+  ControlWord("ansi");
+  ControlWord("ansicpg1252");
+  ControlWord("deff0");
+  ControlWord("deflang1031");
+
+  WriteFontTable();
+  WriteColorTable();
+  WriteGenerator();
+}
+
+void cmWIXRichTextFormatWriter::WriteFontTable()
+{
+  StartGroup();
+  ControlWord("fonttbl");
+
+  StartGroup();
+  ControlWord("f0");
+  ControlWord("fswiss");
+  ControlWord("fcharset0 Arial;");
+  EndGroup();
+
+  EndGroup();
+}
+
+void cmWIXRichTextFormatWriter::WriteColorTable()
+{
+  StartGroup();
+  ControlWord("colortbl ;");
+  ControlWord("red255");
+  ControlWord("green0");
+  ControlWord("blue0;");
+  ControlWord("red0");
+  ControlWord("green255");
+  ControlWord("blue0;");
+  ControlWord("red0");
+  ControlWord("green0");
+  ControlWord("blue255;");
+  EndGroup();
+}
+
+void cmWIXRichTextFormatWriter::WriteGenerator()
+{
+  StartGroup();
+  NewControlWord("generator");
+  File << " CPack WiX Generator (" << cmVersion::GetCMakeVersion() << ");";
+  EndGroup();
+}
+
+void cmWIXRichTextFormatWriter::WriteDocumentPrefix()
+{
+  ControlWord("viewkind4");
+  ControlWord("uc1");
+  ControlWord("pard");
+  ControlWord("f0");
+  ControlWord("fs20");
+}
+
+void cmWIXRichTextFormatWriter::ControlWord(std::string const& keyword)
+{
+  File << "\\" << keyword;
+}
+
+void cmWIXRichTextFormatWriter::NewControlWord(std::string const& keyword)
+{
+  File << "\\*\\" << keyword;
+}
+
+void cmWIXRichTextFormatWriter::StartGroup()
+{
+  File.put('{');
+}
+
+void cmWIXRichTextFormatWriter::EndGroup()
+{
+  File.put('}');
+}
+
+void cmWIXRichTextFormatWriter::EmitUnicodeCodepoint(int c)
+{
+  // Do not emit byte order mark (BOM)
+  if (c == 0xFEFF) {
+    return;
+  } else if (c <= 0xFFFF) {
+    EmitUnicodeSurrogate(c);
+  } else {
+    c -= 0x10000;
+    EmitUnicodeSurrogate(((c >> 10) & 0x3FF) + 0xD800);
+    EmitUnicodeSurrogate((c & 0x3FF) + 0xDC00);
+  }
+}
+
+void cmWIXRichTextFormatWriter::EmitUnicodeSurrogate(int c)
+{
+  ControlWord("u");
+  if (c <= 32767) {
+    File << c;
+  } else {
+    File << (c - 65536);
+  }
+  File << "?";
+}
+
+void cmWIXRichTextFormatWriter::EmitInvalidCodepoint(int c)
+{
+  ControlWord("cf1 ");
+  File << "[INVALID-BYTE-" << int(c) << "]";
+  ControlWord("cf0 ");
+}
diff --git a/Source/CPack/WiX/cmWIXRichTextFormatWriter.h b/Source/CPack/WiX/cmWIXRichTextFormatWriter.h
new file mode 100644
index 0000000..21be8ee
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXRichTextFormatWriter.h
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXRichTextFormatWriter_h
+#define cmWIXRichTextFormatWriter_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/FStream.hxx"
+#include <string>
+
+/** \class cmWIXRichtTextFormatWriter
+ * \brief Helper class to generate Rich Text Format (RTF) documents
+ * from plain text (e.g. for license and welcome text)
+ */
+class cmWIXRichTextFormatWriter
+{
+public:
+  cmWIXRichTextFormatWriter(std::string const& filename);
+  ~cmWIXRichTextFormatWriter();
+
+  void AddText(std::string const& text);
+
+private:
+  void WriteHeader();
+  void WriteFontTable();
+  void WriteColorTable();
+  void WriteGenerator();
+
+  void WriteDocumentPrefix();
+
+  void ControlWord(std::string const& keyword);
+  void NewControlWord(std::string const& keyword);
+
+  void StartGroup();
+  void EndGroup();
+
+  void EmitUnicodeCodepoint(int c);
+  void EmitUnicodeSurrogate(int c);
+
+  void EmitInvalidCodepoint(int c);
+
+  cmsys::ofstream File;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXShortcut.cxx b/Source/CPack/WiX/cmWIXShortcut.cxx
new file mode 100644
index 0000000..cd1988a
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXShortcut.cxx
@@ -0,0 +1,103 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXShortcut.h"
+
+#include "cmWIXFilesSourceWriter.h"
+
+void cmWIXShortcuts::insert(Type type, std::string const& id,
+                            cmWIXShortcut const& shortcut)
+{
+  this->Shortcuts[type][id].push_back(shortcut);
+}
+
+bool cmWIXShortcuts::empty(Type type) const
+{
+  return this->Shortcuts.find(type) == this->Shortcuts.end();
+}
+
+bool cmWIXShortcuts::EmitShortcuts(
+  Type type, std::string const& registryKey,
+  std::string const& cpackComponentName,
+  cmWIXFilesSourceWriter& fileDefinitions) const
+{
+  shortcut_type_map_t::const_iterator i = this->Shortcuts.find(type);
+
+  if (i == this->Shortcuts.end()) {
+    return false;
+  }
+
+  shortcut_id_map_t const& id_map = i->second;
+
+  std::string shortcutPrefix;
+  std::string registrySuffix;
+
+  switch (type) {
+    case START_MENU:
+      shortcutPrefix = "CM_S";
+      break;
+    case DESKTOP:
+      shortcutPrefix = "CM_DS";
+      registrySuffix = "_desktop";
+      break;
+    case STARTUP:
+      shortcutPrefix = "CM_SS";
+      registrySuffix = "_startup";
+      break;
+    default:
+      return false;
+  }
+
+  for (auto const& j : id_map) {
+    std::string const& id = j.first;
+    shortcut_list_t const& shortcutList = j.second;
+
+    for (size_t shortcutListIndex = 0; shortcutListIndex < shortcutList.size();
+         ++shortcutListIndex) {
+      cmWIXShortcut const& shortcut = shortcutList[shortcutListIndex];
+      fileDefinitions.EmitShortcut(id, shortcut, shortcutPrefix,
+                                   shortcutListIndex);
+    }
+  }
+
+  fileDefinitions.EmitInstallRegistryValue(registryKey, cpackComponentName,
+                                           registrySuffix);
+
+  return true;
+}
+
+void cmWIXShortcuts::AddShortcutTypes(std::set<Type>& types)
+{
+  for (auto const& shortcut : this->Shortcuts) {
+    types.insert(shortcut.first);
+  }
+}
+
+void cmWIXShortcuts::CreateFromProperties(std::string const& id,
+                                          std::string const& directoryId,
+                                          cmInstalledFile const& installedFile)
+{
+  CreateFromProperty("CPACK_START_MENU_SHORTCUTS", START_MENU, id, directoryId,
+                     installedFile);
+
+  CreateFromProperty("CPACK_DESKTOP_SHORTCUTS", DESKTOP, id, directoryId,
+                     installedFile);
+
+  CreateFromProperty("CPACK_STARTUP_SHORTCUTS", STARTUP, id, directoryId,
+                     installedFile);
+}
+
+void cmWIXShortcuts::CreateFromProperty(std::string const& propertyName,
+                                        Type type, std::string const& id,
+                                        std::string const& directoryId,
+                                        cmInstalledFile const& installedFile)
+{
+  std::vector<std::string> list;
+  installedFile.GetPropertyAsList(propertyName, list);
+
+  for (std::string const& label : list) {
+    cmWIXShortcut shortcut;
+    shortcut.label = label;
+    shortcut.workingDirectoryId = directoryId;
+    insert(type, id, shortcut);
+  }
+}
diff --git a/Source/CPack/WiX/cmWIXShortcut.h b/Source/CPack/WiX/cmWIXShortcut.h
new file mode 100644
index 0000000..23ddc6a
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXShortcut.h
@@ -0,0 +1,60 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXShortcut_h
+#define cmWIXShortcut_h
+
+#include "cmInstalledFile.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmWIXFilesSourceWriter;
+
+struct cmWIXShortcut
+{
+  std::string label;
+  std::string workingDirectoryId;
+};
+
+class cmWIXShortcuts
+{
+public:
+  enum Type
+  {
+    START_MENU,
+    DESKTOP,
+    STARTUP
+  };
+
+  typedef std::vector<cmWIXShortcut> shortcut_list_t;
+  typedef std::map<std::string, shortcut_list_t> shortcut_id_map_t;
+
+  void insert(Type type, std::string const& id, cmWIXShortcut const& shortcut);
+
+  bool empty(Type type) const;
+
+  bool EmitShortcuts(Type type, std::string const& registryKey,
+                     std::string const& cpackComponentName,
+                     cmWIXFilesSourceWriter& fileDefinitions) const;
+
+  void AddShortcutTypes(std::set<Type>& types);
+
+  void CreateFromProperties(std::string const& id,
+                            std::string const& directoryId,
+                            cmInstalledFile const& installedFile);
+
+private:
+  typedef std::map<Type, shortcut_id_map_t> shortcut_type_map_t;
+
+  void CreateFromProperty(std::string const& propertyName, Type type,
+                          std::string const& id,
+                          std::string const& directoryId,
+                          cmInstalledFile const& installedFile);
+
+  shortcut_type_map_t Shortcuts;
+  shortcut_id_map_t EmptyIdMap;
+};
+
+#endif
diff --git a/Source/CPack/WiX/cmWIXSourceWriter.cxx b/Source/CPack/WiX/cmWIXSourceWriter.cxx
new file mode 100644
index 0000000..dc730e0
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXSourceWriter.cxx
@@ -0,0 +1,182 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmWIXSourceWriter.h"
+
+#include "cmCPackGenerator.h"
+
+#include "cmUuid.h"
+
+#include <windows.h>
+
+cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
+                                     std::string const& filename,
+                                     GuidType componentGuidType,
+                                     RootElementType rootElementType)
+  : Logger(logger)
+  , File(filename.c_str())
+  , State(DEFAULT)
+  , SourceFilename(filename)
+  , ComponentGuidType(componentGuidType)
+{
+  WriteXMLDeclaration();
+
+  if (rootElementType == INCLUDE_ELEMENT_ROOT) {
+    BeginElement("Include");
+  } else {
+    BeginElement("Wix");
+  }
+
+  AddAttribute("xmlns", "http://schemas.microsoft.com/wix/2006/wi");
+}
+
+cmWIXSourceWriter::~cmWIXSourceWriter()
+{
+  if (Elements.size() > 1) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, Elements.size() - 1
+                    << " WiX elements were still open when closing '"
+                    << SourceFilename << "'" << std::endl);
+    return;
+  }
+
+  EndElement(Elements.back());
+}
+
+void cmWIXSourceWriter::BeginElement(std::string const& name)
+{
+  if (State == BEGIN) {
+    File << ">";
+  }
+
+  File << "\n";
+  Indent(Elements.size());
+  File << "<" << name;
+
+  Elements.push_back(name);
+  State = BEGIN;
+}
+
+void cmWIXSourceWriter::EndElement(std::string const& name)
+{
+  if (Elements.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "can not end WiX element with no open elements in '"
+                    << SourceFilename << "'" << std::endl);
+    return;
+  }
+
+  if (Elements.back() != name) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "WiX element <"
+                    << Elements.back() << "> can not be closed by </" << name
+                    << "> in '" << SourceFilename << "'" << std::endl);
+    return;
+  }
+
+  if (State == DEFAULT) {
+    File << "\n";
+    Indent(Elements.size() - 1);
+    File << "</" << Elements.back() << ">";
+  } else {
+    File << "/>";
+  }
+
+  Elements.pop_back();
+  State = DEFAULT;
+}
+
+void cmWIXSourceWriter::AddTextNode(std::string const& text)
+{
+  if (State == BEGIN) {
+    File << ">";
+  }
+
+  if (Elements.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "can not add text without open WiX element in '"
+                    << SourceFilename << "'" << std::endl);
+    return;
+  }
+
+  File << this->EscapeAttributeValue(text);
+  State = DEFAULT;
+}
+
+void cmWIXSourceWriter::AddProcessingInstruction(std::string const& target,
+                                                 std::string const& content)
+{
+  if (State == BEGIN) {
+    File << ">";
+  }
+
+  File << "\n";
+  Indent(Elements.size());
+  File << "<?" << target << " " << content << "?>";
+
+  State = DEFAULT;
+}
+
+void cmWIXSourceWriter::AddAttribute(std::string const& key,
+                                     std::string const& value)
+{
+  File << " " << key << "=\"" << EscapeAttributeValue(value) << '"';
+}
+
+void cmWIXSourceWriter::AddAttributeUnlessEmpty(std::string const& key,
+                                                std::string const& value)
+{
+  if (!value.empty()) {
+    AddAttribute(key, value);
+  }
+}
+
+std::string cmWIXSourceWriter::CreateGuidFromComponentId(
+  std::string const& componentId)
+{
+  std::string guid = "*";
+  if (this->ComponentGuidType == CMAKE_GENERATED_GUID) {
+    std::string md5 = cmSystemTools::ComputeStringMD5(componentId);
+    cmUuid uuid;
+    std::vector<unsigned char> ns;
+    guid = uuid.FromMd5(ns, md5);
+  }
+  return guid;
+}
+
+void cmWIXSourceWriter::WriteXMLDeclaration()
+{
+  File << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+}
+
+void cmWIXSourceWriter::Indent(size_t count)
+{
+  for (size_t i = 0; i < count; ++i) {
+    File << "    ";
+  }
+}
+
+std::string cmWIXSourceWriter::EscapeAttributeValue(std::string const& value)
+{
+  std::string result;
+  result.reserve(value.size());
+
+  for (char c : value) {
+    switch (c) {
+      case '<':
+        result += "&lt;";
+        break;
+      case '>':
+        result += "&gt;";
+        break;
+      case '&':
+        result += "&amp;";
+        break;
+      case '"':
+        result += "&quot;";
+        break;
+      default:
+        result += c;
+        break;
+    }
+  }
+
+  return result;
+}
diff --git a/Source/CPack/WiX/cmWIXSourceWriter.h b/Source/CPack/WiX/cmWIXSourceWriter.h
new file mode 100644
index 0000000..4af1ed6
--- /dev/null
+++ b/Source/CPack/WiX/cmWIXSourceWriter.h
@@ -0,0 +1,80 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmWIXSourceWriter_h
+#define cmWIXSourceWriter_h
+
+#include "cmCPackLog.h"
+
+#include "cmsys/FStream.hxx"
+
+#include <string>
+#include <vector>
+
+/** \class cmWIXSourceWriter
+ * \brief Helper class to generate XML WiX source files
+ */
+class cmWIXSourceWriter
+{
+public:
+  enum GuidType
+  {
+    WIX_GENERATED_GUID,
+    CMAKE_GENERATED_GUID
+  };
+
+  enum RootElementType
+  {
+    WIX_ELEMENT_ROOT,
+    INCLUDE_ELEMENT_ROOT
+  };
+
+  cmWIXSourceWriter(cmCPackLog* logger, std::string const& filename,
+                    GuidType componentGuidType,
+                    RootElementType rootElementType = WIX_ELEMENT_ROOT);
+
+  ~cmWIXSourceWriter();
+
+  void BeginElement(std::string const& name);
+
+  void EndElement(std::string const& name);
+
+  void AddTextNode(std::string const& text);
+
+  void AddProcessingInstruction(std::string const& target,
+                                std::string const& content);
+
+  void AddAttribute(std::string const& key, std::string const& value);
+
+  void AddAttributeUnlessEmpty(std::string const& key,
+                               std::string const& value);
+
+  std::string CreateGuidFromComponentId(std::string const& componentId);
+
+protected:
+  cmCPackLog* Logger;
+
+private:
+  enum State
+  {
+    DEFAULT,
+    BEGIN
+  };
+
+  void WriteXMLDeclaration();
+
+  void Indent(size_t count);
+
+  static std::string EscapeAttributeValue(std::string const& value);
+
+  cmsys::ofstream File;
+
+  State State;
+
+  std::vector<std::string> Elements;
+
+  std::string SourceFilename;
+
+  GuidType ComponentGuidType;
+};
+
+#endif
diff --git a/Source/CPack/bills-comments.txt b/Source/CPack/bills-comments.txt
new file mode 100644
index 0000000..1aaf9af
--- /dev/null
+++ b/Source/CPack/bills-comments.txt
@@ -0,0 +1,68 @@
+cpack.cxx
+
+cmCPackGenerators  -- creates cmCPackGenericGenerator's via NewGenerator
+  - a cmCPackGenericGenerator factory
+
+
+cmCPackGenericGenerator::Initialize
+   this->InitializeInternal
+     CPACK_INCLUDE_TOPLEVEL_DIRECTORY = 0 turns off
+
+
+// binary package run
+cmCPackGenericGenerator::ProcessGenerator   // DoPackage
+  cmCPackGenericGenerator::PrepareNames  -- sets a bunch of CPACK_vars
+  cmCPackGenericGenerator::InstallProject
+     run preinstall  (make preinstall/fast)
+     call ReadListFile(cmake_install.cmake)
+  glob recurse in install directory to get list of files
+     this->CompressFiles with the list of files
+
+
+// source package run
+cmCPackGenericGenerator::ProcessGenerator   // DoPackage
+  cmCPackGenericGenerator::PrepareNames  -- sets a bunch of CPACK_vars
+  cmCPackGenericGenerator::InstallProject  -->
+     if set CPACK_INSTALLED_DIRECTORIES
+        glob the files in that directory
+        copy those files to the tmp install directory _CPack something
+  glob recurse in install directory to get list of files
+     this->CompressFiles with the list of files
+
+
+cmCPackGenericGenerator::InstallProject is used for both source and binary
+packages.  It is controlled based on values set in CPACK_ variables.
+
+
+InstallProject
+   1. CPACK_INSTALL_COMMANDS       - a list of commands used to install the package
+
+   2. CPACK_INSTALLED_DIRECTORIES  - copy this directory to CPACK_TEMPORARY_DIRECTORY
+
+   3. CPACK_INSTALL_CMAKE_PROJECTS - a cmake install script
+         - run make preinstall
+         - run cmake_install.cmake
+             - set CMAKE_INSTALL_PREFIX to the temp directory
+             - CPACK_BUILD_CONFIG check this and set the BUILD_TYPE to it
+              - ReadListFile on the install script  cmake_install.cmake
+         - run strip on the executables and libraries if CPACK_STRIP_FILES is TRUE
+
+Recommendations:
+
+rename cmCPackGenerators  to cmCPackGeneratorFactory
+
+rename cmCPackGenericGenerator  -->  cmCPackGenerator
+
+rename cmCPackGenericGenerator::ProcessGenerator  -> cmCPackGenerator::DoPackage
+
+
+break up cmCPackGenerator::InstallProject so it calls the following:
+
+// run user provided install commands
+  cmCPackGenerator::RunInstallCommands();
+// copy entire directories that need no processing like source trees
+  cmCPackGenerator::CopyPreInstalledDirectories();
+// run the cmake install scripts if provided
+  cmCPackGenerator::RunCMakeInstallScripts()
+
+-
diff --git a/Source/CPack/cmCPack7zGenerator.cxx b/Source/CPack/cmCPack7zGenerator.cxx
new file mode 100644
index 0000000..f0c41a2
--- /dev/null
+++ b/Source/CPack/cmCPack7zGenerator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPack7zGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPack7zGenerator::cmCPack7zGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressNone, "7zip")
+{
+}
+
+cmCPack7zGenerator::~cmCPack7zGenerator()
+{
+}
diff --git a/Source/CPack/cmCPack7zGenerator.h b/Source/CPack/cmCPack7zGenerator.h
new file mode 100644
index 0000000..8af4c4a
--- /dev/null
+++ b/Source/CPack/cmCPack7zGenerator.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPack7zGenerator_h
+#define cmCPack7zGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPack7zGenerator
+ * \brief A generator for 7z files
+ */
+class cmCPack7zGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPack7zGenerator, cmCPackArchiveGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPack7zGenerator();
+  ~cmCPack7zGenerator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".7z"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx
new file mode 100644
index 0000000..641be38
--- /dev/null
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -0,0 +1,267 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackArchiveGenerator.h"
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+
+#include <ostream>
+#include <utility>
+#include <vector>
+
+cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
+                                                 std::string const& format)
+{
+  this->Compress = t;
+  this->ArchiveFormat = format;
+}
+
+cmCPackArchiveGenerator::~cmCPackArchiveGenerator()
+{
+}
+
+std::string cmCPackArchiveGenerator::GetArchiveComponentFileName(
+  const std::string& component, bool isGroupName)
+{
+  std::string componentUpper(cmSystemTools::UpperCase(component));
+  std::string packageFileName;
+
+  if (this->IsSet("CPACK_ARCHIVE_" + componentUpper + "_FILE_NAME")) {
+    packageFileName +=
+      this->GetOption("CPACK_ARCHIVE_" + componentUpper + "_FILE_NAME");
+  } else if (this->IsSet("CPACK_ARCHIVE_FILE_NAME")) {
+    packageFileName += GetComponentPackageFileName(
+      this->GetOption("CPACK_ARCHIVE_FILE_NAME"), component, isGroupName);
+  } else {
+    packageFileName += GetComponentPackageFileName(
+      this->GetOption("CPACK_PACKAGE_FILE_NAME"), component, isGroupName);
+  }
+
+  packageFileName += this->GetOutputExtension();
+
+  return packageFileName;
+}
+
+int cmCPackArchiveGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
+  return this->Superclass::InitializeInternal();
+}
+int cmCPackArchiveGenerator::addOneComponentToArchive(
+  cmArchiveWrite& archive, cmCPackComponent* component)
+{
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "   - packaging component: " << component->Name << std::endl);
+  // Add the files of this component to the archive
+  std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+  localToplevel += "/" + component->Name;
+  // Change to local toplevel
+  cmWorkingDirectory workdir(localToplevel);
+  std::string filePrefix;
+  if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
+    filePrefix = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    filePrefix += "/";
+  }
+  const char* installPrefix =
+    this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
+  if (installPrefix && installPrefix[0] == '/' && installPrefix[1] != 0) {
+    // add to file prefix and remove the leading '/'
+    filePrefix += installPrefix + 1;
+    filePrefix += "/";
+  }
+  for (std::string const& file : component->Files) {
+    std::string rp = filePrefix + file;
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file: " << rp << std::endl);
+    archive.Add(rp, 0, nullptr, false);
+    if (!archive) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: "
+                      << archive.GetError() << std::endl);
+      return 0;
+    }
+  }
+  return 1;
+}
+
+/*
+ * The macro will open/create a file 'filename'
+ * an declare and open the associated
+ * cmArchiveWrite 'archive' object.
+ */
+#define DECLARE_AND_OPEN_ARCHIVE(filename, archive)                           \
+  cmGeneratedFileStream gf;                                                   \
+  gf.Open((filename).c_str(), false, true);                                   \
+  if (!GenerateHeader(&gf)) {                                                 \
+    cmCPackLogger(cmCPackLog::LOG_ERROR,                                      \
+                  "Problem to generate Header for archive < "                 \
+                    << (filename) << ">." << std::endl);                      \
+    return 0;                                                                 \
+  }                                                                           \
+  cmArchiveWrite archive(gf, this->Compress, this->ArchiveFormat);            \
+  if (!(archive)) {                                                           \
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < "       \
+                    << (filename) << ">. ERROR =" << (archive).GetError()     \
+                    << std::endl);                                            \
+    return 0;                                                                 \
+  }
+
+int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
+{
+  packageFileNames.clear();
+  // The default behavior is to have one package by component group
+  // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+  if (!ignoreGroup) {
+    for (auto const& compG : this->ComponentGroups) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Packaging component group: " << compG.first << std::endl);
+      // Begin the archive for this group
+      std::string packageFileName = std::string(toplevel) + "/" +
+        this->GetArchiveComponentFileName(compG.first, true);
+
+      // open a block in order to automatically close archive
+      // at the end of the block
+      {
+        DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
+        // 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);
+        }
+      }
+      // add the generated package to package file names list
+      packageFileNames.push_back(packageFileName);
+    }
+    // Handle Orphan components (components not belonging to any groups)
+    for (auto& comp : this->Components) {
+      // Does the component belong to a group?
+      if (comp.second.Group == nullptr) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE, "Component <"
+            << comp.second.Name
+            << "> does not belong to any group, package it separately."
+            << std::endl);
+        std::string localToplevel(
+          this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+        std::string packageFileName = std::string(toplevel);
+
+        localToplevel += "/" + comp.first;
+        packageFileName +=
+          "/" + this->GetArchiveComponentFileName(comp.first, false);
+
+        {
+          DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
+          // Add the files of this component to the archive
+          addOneComponentToArchive(archive, &(comp.second));
+        }
+        // add the generated package to package file names list
+        packageFileNames.push_back(packageFileName);
+      }
+    }
+  }
+  // CPACK_COMPONENTS_IGNORE_GROUPS is set
+  // We build 1 package per component
+  else {
+    for (auto& comp : this->Components) {
+      std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+      std::string packageFileName = std::string(toplevel);
+
+      localToplevel += "/" + comp.first;
+      packageFileName +=
+        "/" + this->GetArchiveComponentFileName(comp.first, false);
+
+      {
+        DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
+        // Add the files of this component to the archive
+        addOneComponentToArchive(archive, &(comp.second));
+      }
+      // add the generated package to package file names list
+      packageFileNames.push_back(packageFileName);
+    }
+  }
+  return 1;
+}
+
+int cmCPackArchiveGenerator::PackageComponentsAllInOne()
+{
+  // reset the package file names
+  packageFileNames.clear();
+  packageFileNames.push_back(std::string(toplevel));
+  packageFileNames[0] += "/";
+
+  if (this->IsSet("CPACK_ARCHIVE_FILE_NAME")) {
+    packageFileNames[0] += this->GetOption("CPACK_ARCHIVE_FILE_NAME");
+  } else {
+    packageFileNames[0] += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  }
+
+  packageFileNames[0] += this->GetOutputExtension();
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Packaging all groups in one package..."
+                "(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE is set)"
+                  << std::endl);
+  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
+
+  // 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));
+  }
+
+  // archive goes out of scope so it will finalized and closed.
+  return 1;
+}
+
+int cmCPackArchiveGenerator::PackageFiles()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+
+  if (WantsComponentInstallation()) {
+    // CASE 1 : COMPONENT ALL-IN-ONE package
+    // If ALL COMPONENTS in ONE package has been requested
+    // then the package file is unique and should be open here.
+    if (componentPackageMethod == ONE_PACKAGE) {
+      return PackageComponentsAllInOne();
+    }
+    // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
+    // There will be 1 package for each component group
+    // however one may require to ignore component group and
+    // in this case you'll get 1 package for each component.
+    return PackageComponents(componentPackageMethod ==
+                             ONE_PACKAGE_PER_COMPONENT);
+  }
+
+  // CASE 3 : NON COMPONENT package.
+  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
+  cmWorkingDirectory workdir(toplevel);
+  for (std::string const& file : files) {
+    // Get the relative path to the file
+    std::string rp =
+      cmSystemTools::RelativePath(toplevel.c_str(), file.c_str());
+    archive.Add(rp, 0, nullptr, false);
+    if (!archive) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< "
+                      << file << "> to archive <" << packageFileNames[0]
+                      << "> .ERROR =" << archive.GetError() << std::endl);
+      return 0;
+    }
+  }
+  // The destructor of cmArchiveWrite will close and finish the write
+  return 1;
+}
+
+int cmCPackArchiveGenerator::GenerateHeader(std::ostream* /*unused*/)
+{
+  return 1;
+}
+
+bool cmCPackArchiveGenerator::SupportsComponentInstallation() const
+{
+  // The Component installation support should only
+  // be activated if explicitly requested by the user
+  // (for backward compatibility reason)
+  return IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL");
+}
diff --git a/Source/CPack/cmCPackArchiveGenerator.h b/Source/CPack/cmCPackArchiveGenerator.h
new file mode 100644
index 0000000..9983854
--- /dev/null
+++ b/Source/CPack/cmCPackArchiveGenerator.h
@@ -0,0 +1,76 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackArchiveGenerator_h
+#define cmCPackArchiveGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmArchiveWrite.h"
+#include "cmCPackGenerator.h"
+
+#include <iosfwd>
+#include <string>
+
+class cmCPackComponent;
+
+/** \class cmCPackArchiveGenerator
+ * \brief A generator base for libarchive generation.
+ * The generator itself uses the libarchive wrapper
+ * \ref cmArchiveWrite.
+ *
+ */
+class cmCPackArchiveGenerator : public cmCPackGenerator
+{
+public:
+  typedef cmCPackGenerator Superclass;
+
+  /**
+   * Construct generator
+   */
+  cmCPackArchiveGenerator(cmArchiveWrite::Compress, std::string const& format);
+  ~cmCPackArchiveGenerator() override;
+  // Used to add a header to the archive
+  virtual int GenerateHeader(std::ostream* os);
+  // component support
+  bool SupportsComponentInstallation() const override;
+
+private:
+  // get archive component filename
+  std::string GetArchiveComponentFileName(const std::string& component,
+                                          bool isGroupName);
+
+protected:
+  int InitializeInternal() override;
+  /**
+   * Add the files belonging to the specified component
+   * to the provided (already opened) archive.
+   * @param[in,out] archive the archive object
+   * @param[in] component the component whose file will be added to archive
+   */
+  int addOneComponentToArchive(cmArchiveWrite& archive,
+                               cmCPackComponent* component);
+
+  /**
+   * The main package file method.
+   * If component install was required this
+   * method will call either PackageComponents or
+   * PackageComponentsAllInOne.
+   */
+  int PackageFiles() override;
+  /**
+   * The method used to package files when component
+   * install is used. This will create one
+   * archive for each component group.
+   */
+  int PackageComponents(bool ignoreGroup);
+  /**
+   * Special case of component install where all
+   * components will be put in a single installer.
+   */
+  int PackageComponentsAllInOne();
+  const char* GetOutputExtension() override = 0;
+  cmArchiveWrite::Compress Compress;
+  std::string ArchiveFormat;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackBundleGenerator.cxx b/Source/CPack/cmCPackBundleGenerator.cxx
new file mode 100644
index 0000000..f47ca7a
--- /dev/null
+++ b/Source/CPack/cmCPackBundleGenerator.cxx
@@ -0,0 +1,282 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackBundleGenerator.h"
+
+#include <sstream>
+#include <vector>
+
+#include "cmCPackLog.h"
+#include "cmSystemTools.h"
+
+cmCPackBundleGenerator::cmCPackBundleGenerator()
+{
+}
+
+cmCPackBundleGenerator::~cmCPackBundleGenerator()
+{
+}
+
+int cmCPackBundleGenerator::InitializeInternal()
+{
+  const char* name = this->GetOption("CPACK_BUNDLE_NAME");
+  if (nullptr == name) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_BUNDLE_NAME must be set to use the Bundle generator."
+                    << std::endl);
+
+    return 0;
+  }
+
+  if (this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")) {
+    const std::string codesign_path = cmSystemTools::FindProgram(
+      "codesign", std::vector<std::string>(), false);
+
+    if (codesign_path.empty()) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
+                      << std::endl);
+      return 0;
+    }
+    this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
+  }
+
+  return this->Superclass::InitializeInternal();
+}
+
+const char* cmCPackBundleGenerator::GetPackagingInstallPrefix()
+{
+  this->InstallPrefix = "/";
+  this->InstallPrefix += this->GetOption("CPACK_BUNDLE_NAME");
+  this->InstallPrefix += ".app/Contents/Resources";
+
+  return this->InstallPrefix.c_str();
+}
+
+int cmCPackBundleGenerator::ConstructBundle()
+{
+
+  // Get required arguments ...
+  const std::string cpack_bundle_name = this->GetOption("CPACK_BUNDLE_NAME")
+    ? this->GetOption("CPACK_BUNDLE_NAME")
+    : "";
+  if (cpack_bundle_name.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_NAME must be set."
+                    << std::endl);
+
+    return 0;
+  }
+
+  const std::string cpack_bundle_plist = this->GetOption("CPACK_BUNDLE_PLIST")
+    ? this->GetOption("CPACK_BUNDLE_PLIST")
+    : "";
+  if (cpack_bundle_plist.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_PLIST must be set."
+                    << std::endl);
+
+    return 0;
+  }
+
+  const std::string cpack_bundle_icon = this->GetOption("CPACK_BUNDLE_ICON")
+    ? this->GetOption("CPACK_BUNDLE_ICON")
+    : "";
+  if (cpack_bundle_icon.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
+                    << std::endl);
+
+    return 0;
+  }
+
+  // Get optional arguments ...
+  const std::string cpack_bundle_startup_command =
+    this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
+    ? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
+    : "";
+
+  // The staging directory contains everything that will end-up inside the
+  // final disk image ...
+  std::ostringstream staging;
+  staging << toplevel;
+
+  std::ostringstream contents;
+  contents << staging.str() << "/" << cpack_bundle_name << ".app/"
+           << "Contents";
+
+  std::ostringstream application;
+  application << contents.str() << "/"
+              << "MacOS";
+
+  std::ostringstream resources;
+  resources << contents.str() << "/"
+            << "Resources";
+
+  // Install a required, user-provided bundle metadata file ...
+  std::ostringstream plist_source;
+  plist_source << cpack_bundle_plist;
+
+  std::ostringstream plist_target;
+  plist_target << contents.str() << "/"
+               << "Info.plist";
+
+  if (!this->CopyFile(plist_source, plist_target)) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Error copying plist.  Check the value of CPACK_BUNDLE_PLIST."
+        << std::endl);
+
+    return 0;
+  }
+
+  // Install a user-provided bundle icon ...
+  std::ostringstream icon_source;
+  icon_source << cpack_bundle_icon;
+
+  std::ostringstream icon_target;
+  icon_target << resources.str() << "/" << cpack_bundle_name << ".icns";
+
+  if (!this->CopyFile(icon_source, icon_target)) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Error copying bundle icon.  Check the value of CPACK_BUNDLE_ICON."
+        << std::endl);
+
+    return 0;
+  }
+
+  // Optionally a user-provided startup command (could be an
+  // executable or a script) ...
+  if (!cpack_bundle_startup_command.empty()) {
+    std::ostringstream command_source;
+    command_source << cpack_bundle_startup_command;
+
+    std::ostringstream command_target;
+    command_target << application.str() << "/" << cpack_bundle_name;
+
+    if (!this->CopyFile(command_source, command_target)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error copying startup command. "
+                    " Check the value of CPACK_BUNDLE_STARTUP_COMMAND."
+                      << std::endl);
+
+      return 0;
+    }
+
+    cmSystemTools::SetPermissions(command_target.str().c_str(), 0777);
+  }
+
+  return 1;
+}
+
+int cmCPackBundleGenerator::PackageFiles()
+{
+  if (!this->ConstructBundle()) {
+    return 0;
+  }
+
+  if (!this->SignBundle(toplevel)) {
+    return 0;
+  }
+
+  return this->CreateDMG(toplevel, packageFileNames[0]);
+}
+
+bool cmCPackBundleGenerator::SupportsComponentInstallation() const
+{
+  return false;
+}
+
+int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
+{
+  const std::string cpack_apple_cert_app =
+    this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
+    ? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
+    : "";
+
+  // codesign the application.
+  if (!cpack_apple_cert_app.empty()) {
+    std::string output;
+    std::string bundle_path;
+    bundle_path = src_dir + "/";
+    bundle_path += this->GetOption("CPACK_BUNDLE_NAME");
+    bundle_path += ".app";
+
+    // A list of additional files to sign, ie. frameworks and plugins.
+    const std::string sign_parameter =
+      this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_PARAMETER")
+      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_PARAMETER")
+      : "--deep -f";
+
+    const std::string sign_files =
+      this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
+      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
+      : "";
+
+    std::vector<std::string> relFiles;
+    cmSystemTools::ExpandListArgument(sign_files, relFiles);
+
+    // sign the files supplied by the user, ie. frameworks.
+    for (auto const& file : relFiles) {
+      std::ostringstream temp_sign_file_cmd;
+      temp_sign_file_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
+      temp_sign_file_cmd << " " << sign_parameter << " -s \""
+                         << cpack_apple_cert_app;
+      temp_sign_file_cmd << "\" -i ";
+      temp_sign_file_cmd << this->GetOption("CPACK_APPLE_BUNDLE_ID");
+      temp_sign_file_cmd << " \"";
+      temp_sign_file_cmd << bundle_path;
+      temp_sign_file_cmd << file << "\"";
+
+      if (!this->RunCommand(temp_sign_file_cmd, &output)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error signing file:" << bundle_path << file << std::endl
+                                            << output << std::endl);
+
+        return 0;
+      }
+    }
+
+    // sign main binary
+    std::ostringstream temp_sign_binary_cmd;
+    temp_sign_binary_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
+    temp_sign_binary_cmd << " " << sign_parameter << " -s \""
+                         << cpack_apple_cert_app;
+    temp_sign_binary_cmd << "\" \"" << bundle_path << "\"";
+
+    if (!this->RunCommand(temp_sign_binary_cmd, &output)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error signing the application binary." << std::endl
+                                                            << output
+                                                            << std::endl);
+
+      return 0;
+    }
+
+    // sign app bundle
+    std::ostringstream temp_codesign_cmd;
+    temp_codesign_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
+    temp_codesign_cmd << " " << sign_parameter << " -s \""
+                      << cpack_apple_cert_app << "\"";
+    if (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")) {
+      temp_codesign_cmd << " --entitlements ";
+      temp_codesign_cmd << this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS");
+    }
+    temp_codesign_cmd << " \"" << bundle_path << "\"";
+
+    if (!this->RunCommand(temp_codesign_cmd, &output)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error signing the application package." << std::endl
+                                                             << output
+                                                             << std::endl);
+
+      return 0;
+    }
+
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Application has been codesigned"
+                    << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                  (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
+                     ? "with entitlement sandboxing"
+                     : "without entitlement sandboxing")
+                    << std::endl);
+  }
+
+  return 1;
+}
diff --git a/Source/CPack/cmCPackBundleGenerator.h b/Source/CPack/cmCPackBundleGenerator.h
new file mode 100644
index 0000000..27bac3a
--- /dev/null
+++ b/Source/CPack/cmCPackBundleGenerator.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackBundleGenerator_h
+#define cmCPackBundleGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+#include "cmCPackDragNDropGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackBundleGenerator
+ * \brief A generator for OSX bundles
+ *
+ * Based on Gimp.app
+ */
+class cmCPackBundleGenerator : public cmCPackDragNDropGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackBundleGenerator, cmCPackDragNDropGenerator);
+
+  cmCPackBundleGenerator();
+  ~cmCPackBundleGenerator() override;
+
+protected:
+  int InitializeInternal() override;
+  const char* GetPackagingInstallPrefix() override;
+  int ConstructBundle();
+  int SignBundle(const std::string& src_dir);
+  int PackageFiles() override;
+  bool SupportsComponentInstallation() const override;
+
+  std::string InstallPrefix;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackComponentGroup.cxx b/Source/CPack/cmCPackComponentGroup.cxx
new file mode 100644
index 0000000..f888a5f
--- /dev/null
+++ b/Source/CPack/cmCPackComponentGroup.cxx
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackComponentGroup.h"
+
+#include "cmSystemTools.h"
+
+#include <string>
+
+unsigned long cmCPackComponent::GetInstalledSize(
+  const std::string& installDir) const
+{
+  if (this->TotalSize != 0) {
+    return this->TotalSize;
+  }
+
+  for (std::string const& file : this->Files) {
+    std::string path = installDir;
+    path += '/';
+    path += file;
+    this->TotalSize += cmSystemTools::FileLength(path);
+  }
+
+  return this->TotalSize;
+}
+
+unsigned long cmCPackComponent::GetInstalledSizeInKbytes(
+  const std::string& installDir) const
+{
+  unsigned long result = (GetInstalledSize(installDir) + 512) / 1024;
+  return result ? result : 1;
+}
diff --git a/Source/CPack/cmCPackComponentGroup.h b/Source/CPack/cmCPackComponentGroup.h
new file mode 100644
index 0000000..f2907db
--- /dev/null
+++ b/Source/CPack/cmCPackComponentGroup.h
@@ -0,0 +1,146 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackComponentGroup_h
+#define cmCPackComponentGroup_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmCPackComponentGroup;
+
+/** \class cmCPackInstallationType
+ * \brief A certain type of installation, which encompasses a
+ * set of components.
+ */
+class cmCPackInstallationType
+{
+public:
+  /// The name of the installation type (used to reference this
+  /// installation type).
+  std::string Name;
+
+  /// The name of the installation type as displayed to the user.
+  std::string DisplayName;
+
+  /// The index number of the installation type. This is an arbitrary
+  /// numbering from 1 to the number of installation types.
+  unsigned Index;
+};
+
+/** \class cmCPackComponent
+ * \brief A single component to be installed by CPack.
+ */
+class cmCPackComponent
+{
+public:
+  cmCPackComponent()
+    : Group(nullptr)
+    , IsRequired(true)
+    , IsHidden(false)
+    , IsDisabledByDefault(false)
+    , IsDownloaded(false)
+    , TotalSize(0)
+  {
+  }
+
+  /// The name of the component (used to reference the component).
+  std::string Name;
+
+  /// The name of the component as displayed to the user.
+  std::string DisplayName;
+
+  /// The component group that contains this component (if any).
+  cmCPackComponentGroup* Group;
+
+  /// Whether this component group must always be installed.
+  bool IsRequired : 1;
+
+  /// Whether this component group is hidden. A hidden component group
+  /// is always installed. However, it may still be shown to the user.
+  bool IsHidden : 1;
+
+  /// Whether this component defaults to "disabled".
+  bool IsDisabledByDefault : 1;
+
+  /// Whether this component should be downloaded on-the-fly. If false,
+  /// the component will be a part of the installation package.
+  bool IsDownloaded : 1;
+
+  /// A description of this component.
+  std::string Description;
+
+  /// The installation types that this component is a part of.
+  std::vector<cmCPackInstallationType*> InstallationTypes;
+
+  /// If IsDownloaded is true, the name of the archive file that
+  /// contains the files that are part of this component.
+  std::string ArchiveFile;
+
+  /// The file to pass to --component-plist when using the
+  /// productbuild generator.
+  std::string Plist;
+
+  /// The components that this component depends on.
+  std::vector<cmCPackComponent*> Dependencies;
+
+  /// The components that depend on this component.
+  std::vector<cmCPackComponent*> ReverseDependencies;
+
+  /// The list of installed files that are part of this component.
+  std::vector<std::string> Files;
+
+  /// The list of installed directories that are part of this component.
+  std::vector<std::string> Directories;
+
+  /// Get the total installed size of all of the files in this
+  /// component, in bytes. installDir is the directory into which the
+  /// component was installed.
+  unsigned long GetInstalledSize(const std::string& installDir) const;
+
+  /// Identical to GetInstalledSize, but returns the result in
+  /// kilobytes.
+  unsigned long GetInstalledSizeInKbytes(const std::string& installDir) const;
+
+private:
+  mutable unsigned long TotalSize;
+};
+
+/** \class cmCPackComponentGroup
+ * \brief A component group to be installed by CPack.
+ */
+class cmCPackComponentGroup
+{
+public:
+  cmCPackComponentGroup()
+    : ParentGroup(nullptr)
+  {
+  }
+
+  /// The name of the group (used to reference the group).
+  std::string Name;
+
+  /// The name of the component as displayed to the user.
+  std::string DisplayName;
+
+  /// The description of this component group.
+  std::string Description;
+
+  /// Whether the name of the component will be shown in bold.
+  bool IsBold : 1;
+
+  /// Whether the section should be expanded by default
+  bool IsExpandedByDefault : 1;
+
+  /// The components within this group.
+  std::vector<cmCPackComponent*> Components;
+
+  /// The parent group of this component group (if any).
+  cmCPackComponentGroup* ParentGroup;
+
+  /// The subgroups of this group.
+  std::vector<cmCPackComponentGroup*> Subgroups;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackConfigure.h.in b/Source/CPack/cmCPackConfigure.h.in
new file mode 100644
index 0000000..8ac1661
--- /dev/null
+++ b/Source/CPack/cmCPackConfigure.h.in
@@ -0,0 +1,2 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx
new file mode 100644
index 0000000..2119f78
--- /dev/null
+++ b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx
@@ -0,0 +1,74 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackCygwinBinaryGenerator.h"
+
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include "cmsys/SystemTools.hxx"
+
+cmCPackCygwinBinaryGenerator::cmCPackCygwinBinaryGenerator()
+{
+}
+
+cmCPackCygwinBinaryGenerator::~cmCPackCygwinBinaryGenerator()
+{
+}
+
+int cmCPackCygwinBinaryGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
+  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
+  return this->Superclass::InitializeInternal();
+}
+
+int cmCPackCygwinBinaryGenerator::PackageFiles()
+{
+  std::string packageName = this->GetOption("CPACK_PACKAGE_NAME");
+  packageName += "-";
+  packageName += this->GetOption("CPACK_PACKAGE_VERSION");
+  packageName = cmsys::SystemTools::LowerCase(packageName);
+  std::string manifest = "/usr/share/doc/";
+  manifest += packageName;
+  manifest += "/MANIFEST";
+  std::string manifestFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  // Create a MANIFEST file that contains all of the files in
+  // the tar file
+  std::string tempdir = manifestFile;
+  manifestFile += manifest;
+  // create an extra scope to force the stream
+  // to create the file before the super class is called
+  {
+    cmGeneratedFileStream ofs(manifestFile.c_str());
+    for (std::vector<std::string>::const_iterator i = files.begin();
+         i != files.end(); ++i) {
+      // remove the temp dir and replace with /usr
+      ofs << (*i).substr(tempdir.size()) << "\n";
+    }
+    ofs << manifest << "\n";
+  }
+  // add the manifest file to the list of all files
+  files.push_back(manifestFile);
+
+  // create the bzip2 tar file
+  return this->Superclass::PackageFiles();
+}
+
+const char* cmCPackCygwinBinaryGenerator::GetOutputExtension()
+{
+  this->OutputExtension = "-";
+  const char* patchNumber = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
+  if (!patchNumber) {
+    patchNumber = "1";
+    cmCPackLogger(cmCPackLog::LOG_WARNING,
+                  "CPACK_CYGWIN_PATCH_NUMBER not specified using 1"
+                    << std::endl);
+  }
+  this->OutputExtension += patchNumber;
+  this->OutputExtension += ".tar.bz2";
+  return this->OutputExtension.c_str();
+}
diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.h b/Source/CPack/cmCPackCygwinBinaryGenerator.h
new file mode 100644
index 0000000..f87a134
--- /dev/null
+++ b/Source/CPack/cmCPackCygwinBinaryGenerator.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackCygwinBinaryGenerator_h
+#define cmCPackCygwinBinaryGenerator_h
+
+#include "cmCPackTarBZip2Generator.h"
+
+/** \class cmCPackCygwinBinaryGenerator
+ * \brief A generator for TarBZip2 files
+ */
+class cmCPackCygwinBinaryGenerator : public cmCPackTarBZip2Generator
+{
+public:
+  cmCPackTypeMacro(cmCPackCygwinBinaryGenerator, cmCPackTarBZip2Generator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackCygwinBinaryGenerator();
+  ~cmCPackCygwinBinaryGenerator() override;
+
+protected:
+  virtual int InitializeInternal();
+  int PackageFiles();
+  virtual const char* GetOutputExtension();
+  std::string OutputExtension;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.cxx b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
new file mode 100644
index 0000000..2c289f6
--- /dev/null
+++ b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
@@ -0,0 +1,157 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackCygwinSourceGenerator.h"
+
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include "cmsys/SystemTools.hxx"
+
+// Includes needed for implementation of RenameFile.  This is not in
+// system tools because it is not implemented robustly enough to move
+// files across directories.
+#ifdef _WIN32
+#include "cm_sys_stat.h"
+#include <windows.h>
+#endif
+
+cmCPackCygwinSourceGenerator::cmCPackCygwinSourceGenerator()
+{
+}
+
+cmCPackCygwinSourceGenerator::~cmCPackCygwinSourceGenerator()
+{
+}
+
+int cmCPackCygwinSourceGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
+  return this->Superclass::InitializeInternal();
+}
+
+int cmCPackCygwinSourceGenerator::PackageFiles()
+{
+  // Create a tar file of the sources
+  std::string packageDirFileName =
+    this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  packageDirFileName += ".tar.bz2";
+  packageFileNames[0] = packageDirFileName;
+  std::string output;
+  // skip one parent up to the cmCPackTarBZip2Generator
+  // to create tar.bz2 file with the list of source
+  // files
+  this->Compress = cmArchiveWrite::CompressBZip2;
+  if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
+    return 0;
+  }
+  // Now create a tar file that contains the above .tar.bz2 file
+  // and the CPACK_CYGWIN_PATCH_FILE and CPACK_TOPLEVEL_DIRECTORY
+  // files
+  std::string compressOutFile = packageDirFileName;
+  // at this point compressOutFile is the full path to
+  // _CPack_Package/.../package-2.5.0.tar.bz2
+  // we want to create a tar _CPack_Package/.../package-2.5.0-1-src.tar.bz2
+  // with these
+  //   _CPack_Package/.../package-2.5.0-1.patch
+  //   _CPack_Package/.../package-2.5.0-1.sh
+  //   _CPack_Package/.../package-2.5.0.tar.bz2
+  // the -1 is CPACK_CYGWIN_PATCH_NUMBER
+
+  // first copy the patch file and the .sh file
+  // to the toplevel cpack temp dir
+
+  // copy the patch file into place
+  if (!this->GetOption("CPACK_CYGWIN_PATCH_FILE")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "No patch file specified for cygwin sources.");
+    return 0;
+  }
+  if (!cmSystemTools::CopyFileAlways(
+        this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
+        this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: ["
+                    << this->GetOption("CPACK_CYGWIN_PATCH_FILE") << "]\nto\n["
+                    << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
+    return 0;
+  }
+  if (!this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "No build script specified for cygwin sources.");
+    return 0;
+  }
+  // copy the build script into place
+  if (!cmSystemTools::CopyFileAlways(
+        this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
+        this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: "
+                    << this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT") << "\nto\n"
+                    << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
+    return 0;
+  }
+  std::string outerTarFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  outerTarFile += "-";
+  const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
+  if (!patch) {
+    cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
+                    << " not specified, defaulting to 1\n");
+    patch = "1";
+  }
+  outerTarFile += patch;
+  outerTarFile += "-src.tar.bz2";
+  std::string tmpDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  std::string buildScript = tmpDir;
+  buildScript += "/";
+  buildScript += cmSystemTools::GetFilenameName(
+    this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"));
+  std::string patchFile = tmpDir;
+  patchFile += "/";
+  patchFile +=
+    cmSystemTools::GetFilenameName(this->GetOption("CPACK_CYGWIN_PATCH_FILE"));
+
+  std::string file = cmSystemTools::GetFilenameName(compressOutFile);
+  std::string sourceTar = cmSystemTools::GetFilenamePath(compressOutFile);
+  sourceTar += "/";
+  sourceTar += file;
+  /* reset list of file to be packaged */
+  files.clear();
+  // a source release in cygwin should have the build script used
+  // to build the package, the patch file that is different from the
+  // regular upstream version of the sources, and a bziped tar file
+  // of the original sources
+  files.push_back(buildScript);
+  files.push_back(patchFile);
+  files.push_back(sourceTar);
+  /* update the name of the produced package */
+  packageFileNames[0] = outerTarFile;
+  /* update the toplevel dir */
+  toplevel = tmpDir;
+  if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
+    return 0;
+  }
+  return 1;
+}
+
+const char* cmCPackCygwinSourceGenerator::GetPackagingInstallPrefix()
+{
+  this->InstallPrefix = "/";
+  this->InstallPrefix += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  return this->InstallPrefix.c_str();
+}
+
+const char* cmCPackCygwinSourceGenerator::GetOutputExtension()
+{
+  this->OutputExtension = "-";
+  const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
+  if (!patch) {
+    cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
+                    << " not specified, defaulting to 1\n");
+    patch = "1";
+  }
+  this->OutputExtension += patch;
+  this->OutputExtension += "-src.tar.bz2";
+  return this->OutputExtension.c_str();
+}
diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.h b/Source/CPack/cmCPackCygwinSourceGenerator.h
new file mode 100644
index 0000000..a909b15
--- /dev/null
+++ b/Source/CPack/cmCPackCygwinSourceGenerator.h
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackCygwinSourceGenerator_h
+#define cmCPackCygwinSourceGenerator_h
+
+#include "cmCPackTarBZip2Generator.h"
+
+/** \class cmCPackCygwinSourceGenerator
+ * \brief A generator for cygwin source files
+ */
+class cmCPackCygwinSourceGenerator : public cmCPackTarBZip2Generator
+{
+public:
+  cmCPackTypeMacro(cmCPackCygwinSourceGenerator, cmCPackTarBZip2Generator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackCygwinSourceGenerator();
+  ~cmCPackCygwinSourceGenerator() override;
+
+protected:
+  const char* GetPackagingInstallPrefix();
+  virtual int InitializeInternal();
+  int PackageFiles();
+  virtual const char* GetOutputExtension();
+  std::string InstallPrefix;
+  std::string OutputExtension;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx
new file mode 100644
index 0000000..7fc3c26
--- /dev/null
+++ b/Source/CPack/cmCPackDebGenerator.cxx
@@ -0,0 +1,695 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackDebGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmCryptoHash.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cm_sys_stat.h"
+
+#include "cmsys/Glob.hxx"
+#include <ostream>
+#include <set>
+#include <string.h>
+#include <utility>
+
+cmCPackDebGenerator::cmCPackDebGenerator()
+{
+}
+
+cmCPackDebGenerator::~cmCPackDebGenerator()
+{
+}
+
+int cmCPackDebGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
+  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
+    this->SetOption("CPACK_SET_DESTDIR", "I_ON");
+  }
+  return this->Superclass::InitializeInternal();
+}
+
+int cmCPackDebGenerator::PackageOnePack(std::string const& initialTopLevel,
+                                        std::string const& packageName)
+{
+  int retval = 1;
+  // Begin the archive for this pack
+  std::string localToplevel(initialTopLevel);
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(
+    std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) + "-" +
+    packageName + this->GetOutputExtension());
+
+  localToplevel += "/" + packageName;
+  /* replace the TEMP DIRECTORY with the component one */
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
+  /* replace proposed CPACK_OUTPUT_FILE_NAME */
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
+  /* replace the TEMPORARY package file name */
+  this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                  packageFileName.c_str());
+  // Tell CPackDeb.cmake the name of the component GROUP.
+  this->SetOption("CPACK_DEB_PACKAGE_COMPONENT", packageName.c_str());
+  // Tell CPackDeb.cmake the path where the component is.
+  std::string component_path = "/";
+  component_path += packageName;
+  this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
+                  component_path.c_str());
+  if (!this->ReadListFile("CPackDeb.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
+                    << std::endl);
+    retval = 0;
+    return retval;
+  }
+
+  cmsys::Glob gl;
+  std::string findExpr(this->GetOption("GEN_WDIR"));
+  findExpr += "/*";
+  gl.RecurseOn();
+  gl.SetRecurseListDirs(true);
+  if (!gl.FindFiles(findExpr)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find any files in the installed directory"
+                    << std::endl);
+    return 0;
+  }
+  packageFiles = gl.GetFiles();
+
+  int res = createDeb();
+  if (res != 1) {
+    retval = 0;
+  }
+  // add the generated package to package file names list
+  packageFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  packageFileName += "/";
+  packageFileName += this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
+  packageFileNames.push_back(packageFileName);
+  return retval;
+}
+
+int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
+{
+  int retval = 1;
+  /* Reset package file name list it will be populated during the
+   * component packaging run*/
+  packageFileNames.clear();
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+
+  // The default behavior is to have one package by component group
+  // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+  if (!ignoreGroup) {
+    for (auto const& compG : this->ComponentGroups) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Packaging component group: " << compG.first << std::endl);
+      // Begin the archive for this group
+      retval &= PackageOnePack(initialTopLevel, compG.first);
+    }
+    // Handle Orphan components (components not belonging to any groups)
+    for (auto const& comp : this->Components) {
+      // Does the component belong to a group?
+      if (comp.second.Group == nullptr) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE, "Component <"
+            << comp.second.Name
+            << "> does not belong to any group, package it separately."
+            << std::endl);
+        // Begin the archive for this orphan component
+        retval &= PackageOnePack(initialTopLevel, comp.first);
+      }
+    }
+  }
+  // CPACK_COMPONENTS_IGNORE_GROUPS is set
+  // We build 1 package per component
+  else {
+    for (auto const& comp : this->Components) {
+      retval &= PackageOnePack(initialTopLevel, comp.first);
+    }
+  }
+  return retval;
+}
+
+//----------------------------------------------------------------------
+int cmCPackDebGenerator::PackageComponentsAllInOne(
+  const std::string& compInstDirName)
+{
+  int retval = 1;
+  /* Reset package file name list it will be populated during the
+   * component packaging run*/
+  packageFileNames.clear();
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Packaging all groups in one package..."
+                "(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
+                  << std::endl);
+
+  // The ALL GROUPS in ONE package case
+  std::string localToplevel(initialTopLevel);
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(
+    std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
+    this->GetOutputExtension());
+  // all GROUP in one vs all COMPONENT in one
+  // if must be here otherwise non component paths have a trailing / while
+  // components don't
+  if (!compInstDirName.empty()) {
+    localToplevel += "/" + compInstDirName;
+  }
+
+  /* replace the TEMP DIRECTORY with the component one */
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
+  /* replace proposed CPACK_OUTPUT_FILE_NAME */
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
+  /* replace the TEMPORARY package file name */
+  this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                  packageFileName.c_str());
+
+  if (!compInstDirName.empty()) {
+    // Tell CPackDeb.cmake the path where the component is.
+    std::string component_path = "/";
+    component_path += compInstDirName;
+    this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
+                    component_path.c_str());
+  }
+  if (!this->ReadListFile("CPackDeb.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
+                    << std::endl);
+    retval = 0;
+    return retval;
+  }
+
+  cmsys::Glob gl;
+  std::string findExpr(this->GetOption("GEN_WDIR"));
+  findExpr += "/*";
+  gl.RecurseOn();
+  gl.SetRecurseListDirs(true);
+  if (!gl.FindFiles(findExpr)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find any files in the installed directory"
+                    << std::endl);
+    return 0;
+  }
+  packageFiles = gl.GetFiles();
+
+  int res = createDeb();
+  if (res != 1) {
+    retval = 0;
+  }
+  // add the generated package to package file names list
+  packageFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  packageFileName += "/";
+  packageFileName += this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
+  packageFileNames.push_back(packageFileName);
+  return retval;
+}
+
+int cmCPackDebGenerator::PackageFiles()
+{
+  /* Are we in the component packaging case */
+  if (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");
+    }
+    // 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);
+  }
+  // CASE 3 : NON COMPONENT package.
+  return PackageComponentsAllInOne("");
+}
+
+int cmCPackDebGenerator::createDeb()
+{
+  // debian-binary file
+  const std::string strGenWDIR(this->GetOption("GEN_WDIR"));
+  const std::string dbfilename = strGenWDIR + "/debian-binary";
+  { // the scope is needed for cmGeneratedFileStream
+    cmGeneratedFileStream out(dbfilename.c_str());
+    out << "2.0";
+    out << std::endl; // required for valid debian package
+  }
+
+  // control file
+  std::string ctlfilename = strGenWDIR + "/control";
+
+  // debian policy enforce lower case for package name
+  // mandatory entries:
+  std::string debian_pkg_name = cmsys::SystemTools::LowerCase(
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME"));
+  const char* debian_pkg_version =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
+  const char* debian_pkg_section =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SECTION");
+  const char* debian_pkg_priority =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PRIORITY");
+  const char* debian_pkg_arch =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
+  const char* maintainer =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
+  const char* desc = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
+
+  // optional entries
+  const char* debian_pkg_dep =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DEPENDS");
+  const char* debian_pkg_rec =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_RECOMMENDS");
+  const char* debian_pkg_sug =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SUGGESTS");
+  const char* debian_pkg_url =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_HOMEPAGE");
+  const char* debian_pkg_predep =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PREDEPENDS");
+  const char* debian_pkg_enhances =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ENHANCES");
+  const char* debian_pkg_breaks =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_BREAKS");
+  const char* debian_pkg_conflicts =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONFLICTS");
+  const char* debian_pkg_provides =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PROVIDES");
+  const char* debian_pkg_replaces =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_REPLACES");
+  const char* debian_pkg_source =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
+
+  { // the scope is needed for cmGeneratedFileStream
+    cmGeneratedFileStream out(ctlfilename.c_str());
+    out << "Package: " << debian_pkg_name << "\n";
+    out << "Version: " << debian_pkg_version << "\n";
+    out << "Section: " << debian_pkg_section << "\n";
+    out << "Priority: " << debian_pkg_priority << "\n";
+    out << "Architecture: " << debian_pkg_arch << "\n";
+    if (debian_pkg_source && *debian_pkg_source) {
+      out << "Source: " << debian_pkg_source << "\n";
+    }
+    if (debian_pkg_dep && *debian_pkg_dep) {
+      out << "Depends: " << debian_pkg_dep << "\n";
+    }
+    if (debian_pkg_rec && *debian_pkg_rec) {
+      out << "Recommends: " << debian_pkg_rec << "\n";
+    }
+    if (debian_pkg_sug && *debian_pkg_sug) {
+      out << "Suggests: " << debian_pkg_sug << "\n";
+    }
+    if (debian_pkg_url && *debian_pkg_url) {
+      out << "Homepage: " << debian_pkg_url << "\n";
+    }
+    if (debian_pkg_predep && *debian_pkg_predep) {
+      out << "Pre-Depends: " << debian_pkg_predep << "\n";
+    }
+    if (debian_pkg_enhances && *debian_pkg_enhances) {
+      out << "Enhances: " << debian_pkg_enhances << "\n";
+    }
+    if (debian_pkg_breaks && *debian_pkg_breaks) {
+      out << "Breaks: " << debian_pkg_breaks << "\n";
+    }
+    if (debian_pkg_conflicts && *debian_pkg_conflicts) {
+      out << "Conflicts: " << debian_pkg_conflicts << "\n";
+    }
+    if (debian_pkg_provides && *debian_pkg_provides) {
+      out << "Provides: " << debian_pkg_provides << "\n";
+    }
+    if (debian_pkg_replaces && *debian_pkg_replaces) {
+      out << "Replaces: " << debian_pkg_replaces << "\n";
+    }
+    unsigned long totalSize = 0;
+    {
+      std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+      dirName += '/';
+      for (std::string const& file : packageFiles) {
+        totalSize += cmSystemTools::FileLength(file);
+      }
+    }
+    out << "Installed-Size: " << (totalSize + 1023) / 1024 << "\n";
+    out << "Maintainer: " << maintainer << "\n";
+    out << "Description: " << desc << "\n";
+    out << std::endl;
+  }
+
+  const std::string shlibsfilename = strGenWDIR + "/shlibs";
+
+  const char* debian_pkg_shlibs =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SHLIBS");
+  const bool gen_shibs = this->IsOn("CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS") &&
+    debian_pkg_shlibs && *debian_pkg_shlibs;
+  if (gen_shibs) {
+    cmGeneratedFileStream out(shlibsfilename.c_str());
+    out << debian_pkg_shlibs;
+    out << std::endl;
+  }
+
+  const std::string postinst = strGenWDIR + "/postinst";
+  const std::string postrm = strGenWDIR + "/postrm";
+  if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
+    cmGeneratedFileStream out(postinst.c_str());
+    out << "#!/bin/sh\n\n"
+           "set -e\n\n"
+           "if [ \"$1\" = \"configure\" ]; then\n"
+           "\tldconfig\n"
+           "fi\n";
+  }
+  if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
+    cmGeneratedFileStream out(postrm.c_str());
+    out << "#!/bin/sh\n\n"
+           "set -e\n\n"
+           "if [ \"$1\" = \"remove\" ]; then\n"
+           "\tldconfig\n"
+           "fi\n";
+  }
+
+  cmArchiveWrite::Compress tar_compression_type = cmArchiveWrite::CompressGZip;
+  const char* debian_compression_type =
+    this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE");
+  if (!debian_compression_type) {
+    debian_compression_type = "gzip";
+  }
+
+  std::string compression_suffix;
+  if (!strcmp(debian_compression_type, "lzma")) {
+    compression_suffix = ".lzma";
+    tar_compression_type = cmArchiveWrite::CompressLZMA;
+  } else if (!strcmp(debian_compression_type, "xz")) {
+    compression_suffix = ".xz";
+    tar_compression_type = cmArchiveWrite::CompressXZ;
+  } else if (!strcmp(debian_compression_type, "bzip2")) {
+    compression_suffix = ".bz2";
+    tar_compression_type = cmArchiveWrite::CompressBZip2;
+  } else if (!strcmp(debian_compression_type, "gzip")) {
+    compression_suffix = ".gz";
+    tar_compression_type = cmArchiveWrite::CompressGZip;
+  } else if (!strcmp(debian_compression_type, "none")) {
+    compression_suffix.clear();
+    tar_compression_type = cmArchiveWrite::CompressNone;
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error unrecognized compression type: "
+                    << debian_compression_type << std::endl);
+  }
+
+  const char* debian_archive_type =
+    this->GetOption("GEN_CPACK_DEBIAN_ARCHIVE_TYPE");
+  if (!debian_archive_type) {
+    debian_archive_type = "paxr";
+  }
+
+  std::string filename_data_tar =
+    strGenWDIR + "/data.tar" + compression_suffix;
+
+  // atomic file generation for data.tar
+  {
+    cmGeneratedFileStream fileStream_data_tar;
+    fileStream_data_tar.Open(filename_data_tar.c_str(), false, true);
+    if (!fileStream_data_tar) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
+                      << filename_data_tar << "\" for writing" << std::endl);
+      return 0;
+    }
+    cmArchiveWrite data_tar(fileStream_data_tar, tar_compression_type,
+                            debian_archive_type);
+
+    // uid/gid should be the one of the root user, and this root user has
+    // always uid/gid equal to 0.
+    data_tar.SetUIDAndGID(0u, 0u);
+    data_tar.SetUNAMEAndGNAME("root", "root");
+
+    // now add all directories which have to be compressed
+    // 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 = strGenWDIR.length();
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \""
+                    << strGenWDIR << "\", 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 != strGenWDIR) {
+        // the last one IS strGenWDIR, but we do not want this one:
+        // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
+        // should not add XXX/application
+        orderedFiles.insert(currentPath);
+        currentPath = cmSystemTools::CollapseCombinedPath(currentPath, "..");
+      }
+    }
+
+    for (std::string const& file : orderedFiles) {
+      cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << file << "\""
+                                                        << std::endl);
+      std::string::size_type slashPos = file.find('/', topLevelLength + 1);
+      std::string relativeDir =
+        file.substr(topLevelLength, slashPos - topLevelLength);
+      cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \""
+                      << relativeDir << "\"" << std::endl);
+
+#ifdef WIN32
+      std::string mode_t_adt_filename = file + ":cmake_mode_t";
+      cmsys::ifstream permissionStream(mode_t_adt_filename.c_str());
+
+      mode_t permissions = 0;
+
+      if (permissionStream) {
+        permissionStream >> std::oct >> permissions;
+      }
+
+      if (permissions != 0) {
+        data_tar.SetPermissions(permissions);
+      } else if (cmSystemTools::FileIsDirectory(file)) {
+        data_tar.SetPermissions(0755);
+      } else {
+        data_tar.ClearPermissions();
+      }
+#endif
+
+      // do not recurse because the loop will do it
+      if (!data_tar.Add(file, topLevelLength, ".", false)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: " << file << std::endl
+                        << "#error:" << data_tar.GetError() << std::endl);
+        return 0;
+      }
+    }
+  } // scope for file generation
+
+  std::string md5filename = strGenWDIR + "/md5sums";
+  {
+    // the scope is needed for cmGeneratedFileStream
+    cmGeneratedFileStream out(md5filename.c_str());
+
+    std::string topLevelWithTrailingSlash =
+      this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+    topLevelWithTrailingSlash += '/';
+    for (std::string const& file : packageFiles) {
+      // hash only regular files
+      if (cmSystemTools::FileIsDirectory(file) ||
+          cmSystemTools::FileIsSymlink(file)) {
+        continue;
+      }
+
+      std::string output =
+        cmSystemTools::ComputeFileHash(file, cmCryptoHash::AlgoMD5);
+      if (output.empty()) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem computing the md5 of "
+                        << file << std::endl);
+      }
+
+      output += "  " + file + "\n";
+      // debian md5sums entries are like this:
+      // 014f3604694729f3bf19263bac599765  usr/bin/ccmake
+      // thus strip the full path (with the trailing slash)
+      cmSystemTools::ReplaceString(output, topLevelWithTrailingSlash.c_str(),
+                                   "");
+      out << output;
+    }
+    // each line contains a eol.
+    // Do not end the md5sum file with yet another (invalid)
+  }
+
+  std::string filename_control_tar = strGenWDIR + "/control.tar.gz";
+  // atomic file generation for control.tar
+  {
+    cmGeneratedFileStream fileStream_control_tar;
+    fileStream_control_tar.Open(filename_control_tar.c_str(), false, true);
+    if (!fileStream_control_tar) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
+                      << filename_control_tar << "\" for writing"
+                      << std::endl);
+      return 0;
+    }
+    cmArchiveWrite control_tar(fileStream_control_tar,
+                               cmArchiveWrite::CompressGZip,
+                               debian_archive_type);
+
+    // sets permissions and uid/gid for the files
+    control_tar.SetUIDAndGID(0u, 0u);
+    control_tar.SetUNAMEAndGNAME("root", "root");
+
+    /* permissions are set according to
+    https://www.debian.org/doc/debian-policy/ch-files.html#s-permissions-owners
+    and
+    https://lintian.debian.org/tags/control-file-has-bad-permissions.html
+    */
+    const mode_t permission644 = 0644;
+    const mode_t permissionExecute = 0111;
+    const mode_t permission755 = permission644 | permissionExecute;
+
+    // for md5sum and control (that we have generated here), we use 644
+    // (RW-R--R--)
+    // so that deb lintian doesn't warn about it
+    control_tar.SetPermissions(permission644);
+
+    // adds control and md5sums
+    if (!control_tar.Add(md5filename, strGenWDIR.length(), ".") ||
+        !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), ".")) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                      << std::endl
+                      << "#top level directory: " << strGenWDIR << std::endl
+                      << "#file: \"control\" or \"md5sums\"" << std::endl
+                      << "#error:" << control_tar.GetError() << std::endl);
+      return 0;
+    }
+
+    // adds generated shlibs file
+    if (gen_shibs) {
+      if (!control_tar.Add(shlibsfilename, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"shlibs\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
+      }
+    }
+
+    // adds LDCONFIG related files
+    if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
+      control_tar.SetPermissions(permission755);
+      if (!control_tar.Add(postinst, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"postinst\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
+      }
+      control_tar.SetPermissions(permission644);
+    }
+
+    if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
+      control_tar.SetPermissions(permission755);
+      if (!control_tar.Add(postrm, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"postinst\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
+      }
+      control_tar.SetPermissions(permission644);
+    }
+
+    // for the other files, we use
+    // -either the original permission on the files
+    // -either a permission strictly defined by the Debian policies
+    const char* controlExtra =
+      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA");
+    if (controlExtra) {
+      // permissions are now controlled by the original file permissions
+
+      const bool permissionStrictPolicy =
+        this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION");
+
+      static const char* strictFiles[] = { "config", "postinst", "postrm",
+                                           "preinst", "prerm" };
+      std::set<std::string> setStrictFiles(
+        strictFiles,
+        strictFiles + sizeof(strictFiles) / sizeof(strictFiles[0]));
+
+      // default
+      control_tar.ClearPermissions();
+
+      std::vector<std::string> controlExtraList;
+      cmSystemTools::ExpandListArgument(controlExtra, controlExtraList);
+      for (std::string const& i : controlExtraList) {
+        std::string filenamename = cmsys::SystemTools::GetFilenameName(i);
+        std::string localcopy = strGenWDIR + "/" + filenamename;
+
+        if (permissionStrictPolicy) {
+          control_tar.SetPermissions(setStrictFiles.count(filenamename)
+                                       ? permission755
+                                       : permission644);
+        }
+
+        // if we can copy the file, it means it does exist, let's add it:
+        if (cmsys::SystemTools::CopyFileIfDifferent(i, localcopy)) {
+          control_tar.Add(localcopy, strGenWDIR.length(), ".");
+        }
+      }
+    }
+  }
+
+  // ar -r your-package-name.deb debian-binary control.tar.* data.tar.*
+  // A debian package .deb is simply an 'ar' archive. The only subtle
+  // 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 outputDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  std::string const outputName = this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
+  std::string const outputPath = outputDir + "/" + outputName;
+  std::string const tlDir = strGenWDIR + "/";
+  cmGeneratedFileStream debStream;
+  debStream.Open(outputPath.c_str(), false, true);
+  cmArchiveWrite deb(debStream, cmArchiveWrite::CompressNone, "arbsd");
+  if (!deb.Add(tlDir + "debian-binary", tlDir.length()) ||
+      !deb.Add(tlDir + "control.tar.gz", tlDir.length()) ||
+      !deb.Add(tlDir + "data.tar" + compression_suffix, tlDir.length())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error creating debian package:"
+                    << std::endl
+                    << "#top level directory: " << outputDir << std::endl
+                    << "#file: " << outputName << std::endl
+                    << "#error:" << deb.GetError() << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+bool cmCPackDebGenerator::SupportsComponentInstallation() const
+{
+  return IsOn("CPACK_DEB_COMPONENT_INSTALL");
+}
+
+std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
+    return componentName;
+  }
+
+  if (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));
+  }
+  return componentName;
+}
diff --git a/Source/CPack/cmCPackDebGenerator.h b/Source/CPack/cmCPackDebGenerator.h
new file mode 100644
index 0000000..b4f0c79
--- /dev/null
+++ b/Source/CPack/cmCPackDebGenerator.h
@@ -0,0 +1,71 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackDebGenerator_h
+#define cmCPackDebGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackGenerator.h"
+
+#include <string>
+#include <vector>
+
+/** \class cmCPackDebGenerator
+ * \brief A generator for Debian packages
+ *
+ */
+class cmCPackDebGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackDebGenerator, cmCPackGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackDebGenerator();
+  ~cmCPackDebGenerator() override;
+
+  static bool CanGenerate()
+  {
+#ifdef __APPLE__
+    // on MacOS enable CPackDeb iff dpkg is found
+    std::vector<std::string> locations;
+    locations.push_back("/sw/bin");        // Fink
+    locations.push_back("/opt/local/bin"); // MacPorts
+    return cmSystemTools::FindProgram("dpkg", locations) != "" ? true : false;
+#else
+    // legacy behavior on other systems
+    return true;
+#endif
+  }
+
+protected:
+  int InitializeInternal() override;
+  /**
+   * This method factors out the work done in component packaging case.
+   */
+  int PackageOnePack(std::string const& initialToplevel,
+                     std::string const& packageName);
+  /**
+   * The method used to package files when component
+   * install is used. This will create one
+   * archive for each component group.
+   */
+  int PackageComponents(bool ignoreGroup);
+  /**
+   * Special case of component install where all
+   * components will be put in a single installer.
+   */
+  int PackageComponentsAllInOne(const std::string& compInstDirName);
+  int PackageFiles() override;
+  const char* GetOutputExtension() override { return ".deb"; }
+  bool SupportsComponentInstallation() const override;
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) override;
+
+private:
+  int createDeb();
+  std::vector<std::string> packageFiles;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx
new file mode 100644
index 0000000..bb35623
--- /dev/null
+++ b/Source/CPack/cmCPackDragNDropGenerator.cxx
@@ -0,0 +1,907 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackDragNDropGenerator.h"
+
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <iomanip>
+#include <map>
+#include <stdlib.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#ifdef HAVE_CoreServices
+// For the old LocaleStringToLangAndRegionCodes() function, to convert
+// to the old Script Manager RegionCode values needed for the 'LPic' data
+// structure used for generating multi-lingual SLAs.
+#include <CoreServices/CoreServices.h>
+#endif
+
+static const char* SLAHeader =
+  "data 'LPic' (5000) {\n"
+  "    $\"0002 0011 0003 0001 0000 0000 0002 0000\"\n"
+  "    $\"0008 0003 0000 0001 0004 0000 0004 0005\"\n"
+  "    $\"0000 000E 0006 0001 0005 0007 0000 0007\"\n"
+  "    $\"0008 0000 0047 0009 0000 0034 000A 0001\"\n"
+  "    $\"0035 000B 0001 0020 000C 0000 0011 000D\"\n"
+  "    $\"0000 005B 0004 0000 0033 000F 0001 000C\"\n"
+  "    $\"0010 0000 000B 000E 0000\"\n"
+  "};\n"
+  "\n";
+
+static const char* SLASTREnglish =
+  "resource 'STR#' (5002, \"English\") {\n"
+  "    {\n"
+  "        \"English\",\n"
+  "        \"Agree\",\n"
+  "        \"Disagree\",\n"
+  "        \"Print\",\n"
+  "        \"Save...\",\n"
+  "        \"You agree to the License Agreement terms when you click \"\n"
+  "        \"the \\\"Agree\\\" button.\",\n"
+  "        \"Software License Agreement\",\n"
+  "        \"This text cannot be saved.  This disk may be full or locked, "
+  "or the \"\n"
+  "        \"file may be locked.\",\n"
+  "        \"Unable to print.  Make sure you have selected a printer.\"\n"
+  "    }\n"
+  "};\n"
+  "\n";
+
+cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
+  : singleLicense(false)
+{
+  // default to one package file for components
+  this->componentPackageMethod = ONE_PACKAGE;
+}
+
+cmCPackDragNDropGenerator::~cmCPackDragNDropGenerator()
+{
+}
+
+int cmCPackDragNDropGenerator::InitializeInternal()
+{
+  // Starting with Xcode 4.3, look in "/Applications/Xcode.app" first:
+  //
+  std::vector<std::string> paths;
+  paths.push_back("/Applications/Xcode.app/Contents/Developer/Tools");
+  paths.push_back("/Developer/Tools");
+
+  const std::string hdiutil_path =
+    cmSystemTools::FindProgram("hdiutil", std::vector<std::string>(), false);
+  if (hdiutil_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate hdiutil command"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_COMMAND_HDIUTIL", hdiutil_path.c_str());
+
+  const std::string setfile_path =
+    cmSystemTools::FindProgram("SetFile", paths, false);
+  if (setfile_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate SetFile command"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_COMMAND_SETFILE", setfile_path.c_str());
+
+  const std::string rez_path = cmSystemTools::FindProgram("Rez", paths, false);
+  if (rez_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate Rez command"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str());
+
+  if (this->IsSet("CPACK_DMG_SLA_DIR")) {
+    slaDirectory = this->GetOption("CPACK_DMG_SLA_DIR");
+    if (!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE")) {
+      std::string license_file =
+        this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
+      if (!license_file.empty() &&
+          (license_file.find("CPack.GenericLicense.txt") ==
+           std::string::npos)) {
+        cmCPackLogger(
+          cmCPackLog::LOG_OUTPUT,
+          "Both CPACK_DMG_SLA_DIR and CPACK_RESOURCE_FILE_LICENSE specified, "
+          "using CPACK_RESOURCE_FILE_LICENSE as a license for all languages."
+            << std::endl);
+        singleLicense = true;
+      }
+    }
+    if (!this->IsSet("CPACK_DMG_SLA_LANGUAGES")) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPACK_DMG_SLA_DIR set but no languages defined "
+                    "(set CPACK_DMG_SLA_LANGUAGES)"
+                      << std::endl);
+      return 0;
+    }
+    if (!cmSystemTools::FileExists(slaDirectory, false)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_DMG_SLA_DIR does not exist"
+                      << std::endl);
+      return 0;
+    }
+
+    std::vector<std::string> languages;
+    cmSystemTools::ExpandListArgument(
+      this->GetOption("CPACK_DMG_SLA_LANGUAGES"), languages);
+    if (languages.empty()) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPACK_DMG_SLA_LANGUAGES set but empty" << std::endl);
+      return 0;
+    }
+    for (auto const& language : languages) {
+      std::string license = slaDirectory + "/" + language + ".license.txt";
+      if (!singleLicense && !cmSystemTools::FileExists(license)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing license file "
+                        << language << ".license.txt" << std::endl);
+        return 0;
+      }
+      std::string menu = slaDirectory + "/" + language + ".menu.txt";
+      if (!cmSystemTools::FileExists(menu)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing menu file "
+                        << language << ".menu.txt" << std::endl);
+        return 0;
+      }
+    }
+  }
+
+  return this->Superclass::InitializeInternal();
+}
+
+const char* cmCPackDragNDropGenerator::GetOutputExtension()
+{
+  return ".dmg";
+}
+
+int cmCPackDragNDropGenerator::PackageFiles()
+{
+  // gather which directories to make dmg files for
+  // multiple directories occur if packaging components or groups separately
+
+  // monolith
+  if (this->Components.empty()) {
+    return this->CreateDMG(toplevel, packageFileNames[0]);
+  }
+
+  // component install
+  std::vector<std::string> package_files;
+
+  std::map<std::string, cmCPackComponent>::iterator compIt;
+  for (compIt = this->Components.begin(); compIt != this->Components.end();
+       ++compIt) {
+    std::string name = GetComponentInstallDirNameSuffix(compIt->first);
+    package_files.push_back(name);
+  }
+  std::sort(package_files.begin(), package_files.end());
+  package_files.erase(std::unique(package_files.begin(), package_files.end()),
+                      package_files.end());
+
+  // loop to create dmg files
+  packageFileNames.clear();
+  for (auto const& package_file : package_files) {
+    std::string full_package_name = std::string(toplevel) + std::string("/");
+    if (package_file == "ALL_IN_ONE") {
+      full_package_name += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    } else {
+      full_package_name += package_file;
+    }
+    full_package_name += std::string(GetOutputExtension());
+    packageFileNames.push_back(full_package_name);
+
+    std::string src_dir = toplevel;
+    src_dir += "/";
+    src_dir += package_file;
+
+    if (0 == this->CreateDMG(src_dir, full_package_name)) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
+                                         std::ostringstream& target)
+{
+  if (!cmSystemTools::CopyFileIfDifferent(source.str().c_str(),
+                                          target.str().c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error copying "
+                    << source.str() << " to " << target.str() << std::endl);
+
+    return false;
+  }
+
+  return true;
+}
+
+bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target,
+                                                size_t size)
+{
+  cmsys::ofstream fout(target.str().c_str(), std::ios::out | std::ios::binary);
+  if (!fout) {
+    return false;
+  }
+
+  // Seek to desired size - 1 byte
+  fout.seekp(size - 1, std::ios::beg);
+  char byte = 0;
+  // Write one byte to ensure file grows
+  fout.write(&byte, 1);
+
+  return true;
+}
+
+bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
+                                           std::string* output)
+{
+  int exit_code = 1;
+
+  bool result = cmSystemTools::RunSingleCommand(command.str().c_str(), output,
+                                                output, &exit_code, nullptr,
+                                                this->GeneratorVerbose, 0);
+
+  if (!result || exit_code) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error executing: " << command.str()
+                                                             << std::endl);
+
+    return false;
+  }
+
+  return true;
+}
+
+int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
+                                         const std::string& output_file)
+{
+  // Get optional arguments ...
+  const std::string cpack_package_icon = this->GetOption("CPACK_PACKAGE_ICON")
+    ? this->GetOption("CPACK_PACKAGE_ICON")
+    : "";
+
+  const std::string cpack_dmg_volume_name =
+    this->GetOption("CPACK_DMG_VOLUME_NAME")
+    ? this->GetOption("CPACK_DMG_VOLUME_NAME")
+    : this->GetOption("CPACK_PACKAGE_FILE_NAME");
+
+  const std::string cpack_dmg_format = this->GetOption("CPACK_DMG_FORMAT")
+    ? this->GetOption("CPACK_DMG_FORMAT")
+    : "UDZO";
+
+  // Get optional arguments ...
+  std::string cpack_license_file =
+    this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
+    ? this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
+    : "";
+
+  const std::string cpack_dmg_background_image =
+    this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
+    ? this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
+    : "";
+
+  const std::string cpack_dmg_ds_store = this->GetOption("CPACK_DMG_DS_STORE")
+    ? this->GetOption("CPACK_DMG_DS_STORE")
+    : "";
+
+  const std::string cpack_dmg_languages =
+    this->GetOption("CPACK_DMG_SLA_LANGUAGES")
+    ? this->GetOption("CPACK_DMG_SLA_LANGUAGES")
+    : "";
+
+  const std::string cpack_dmg_ds_store_setup_script =
+    this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
+    ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
+    : "";
+
+  const bool cpack_dmg_disable_applications_symlink =
+    this->IsOn("CPACK_DMG_DISABLE_APPLICATIONS_SYMLINK");
+
+  // only put license on dmg if is user provided
+  if (!cpack_license_file.empty() &&
+      cpack_license_file.find("CPack.GenericLicense.txt") !=
+        std::string::npos) {
+    cpack_license_file = "";
+  }
+
+  // use sla_dir if both sla_dir and license_file are set
+  if (!cpack_license_file.empty() && !slaDirectory.empty() && !singleLicense) {
+    cpack_license_file = "";
+  }
+
+  // The staging directory contains everything that will end-up inside the
+  // final disk image ...
+  std::ostringstream staging;
+  staging << src_dir;
+
+  // Add a symlink to /Applications so users can drag-and-drop the bundle
+  // into it unless this behaviour was disabled
+  if (!cpack_dmg_disable_applications_symlink) {
+    std::ostringstream application_link;
+    application_link << staging.str() << "/Applications";
+    cmSystemTools::CreateSymlink("/Applications", application_link.str());
+  }
+
+  // Optionally add a custom volume icon ...
+  if (!cpack_package_icon.empty()) {
+    std::ostringstream package_icon_source;
+    package_icon_source << cpack_package_icon;
+
+    std::ostringstream package_icon_destination;
+    package_icon_destination << staging.str() << "/.VolumeIcon.icns";
+
+    if (!this->CopyFile(package_icon_source, package_icon_destination)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error copying disk volume icon.  "
+                    "Check the value of CPACK_PACKAGE_ICON."
+                      << std::endl);
+
+      return 0;
+    }
+  }
+
+  // Optionally add a custom .DS_Store file
+  // (e.g. for setting background/layout) ...
+  if (!cpack_dmg_ds_store.empty()) {
+    std::ostringstream package_settings_source;
+    package_settings_source << cpack_dmg_ds_store;
+
+    std::ostringstream package_settings_destination;
+    package_settings_destination << staging.str() << "/.DS_Store";
+
+    if (!this->CopyFile(package_settings_source,
+                        package_settings_destination)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error copying disk volume settings file.  "
+                    "Check the value of CPACK_DMG_DS_STORE."
+                      << std::endl);
+
+      return 0;
+    }
+  }
+
+  // Optionally add a custom background image ...
+  // Make sure the background file type is the same as the custom image
+  // and that the file is hidden so it doesn't show up.
+  if (!cpack_dmg_background_image.empty()) {
+    const std::string extension =
+      cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image);
+    std::ostringstream package_background_source;
+    package_background_source << cpack_dmg_background_image;
+
+    std::ostringstream package_background_destination;
+    package_background_destination << staging.str()
+                                   << "/.background/background" << extension;
+
+    if (!this->CopyFile(package_background_source,
+                        package_background_destination)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error copying disk volume background image.  "
+                    "Check the value of CPACK_DMG_BACKGROUND_IMAGE."
+                      << std::endl);
+
+      return 0;
+    }
+  }
+
+  bool remount_image =
+    !cpack_package_icon.empty() || !cpack_dmg_ds_store_setup_script.empty();
+
+  std::string temp_image_format = "UDZO";
+
+  // Create 1 MB dummy padding file in staging area when we need to remount
+  // image, so we have enough space for storing changes ...
+  if (remount_image) {
+    std::ostringstream dummy_padding;
+    dummy_padding << staging.str() << "/.dummy-padding-file";
+    if (!this->CreateEmptyFile(dummy_padding, 1048576)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error creating dummy padding file."
+                      << std::endl);
+
+      return 0;
+    }
+    temp_image_format = "UDRW";
+  }
+
+  // Create a temporary read-write disk image ...
+  std::string temp_image = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  temp_image += "/temp.dmg";
+
+  std::string create_error;
+  std::ostringstream temp_image_command;
+  temp_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+  temp_image_command << " create";
+  temp_image_command << " -ov";
+  temp_image_command << " -srcfolder \"" << staging.str() << "\"";
+  temp_image_command << " -volname \"" << cpack_dmg_volume_name << "\"";
+  temp_image_command << " -fs HFS+";
+  temp_image_command << " -format " << temp_image_format;
+  temp_image_command << " \"" << temp_image << "\"";
+
+  if (!this->RunCommand(temp_image_command, &create_error)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error generating temporary disk image." << std::endl
+                                                           << create_error
+                                                           << std::endl);
+
+    return 0;
+  }
+
+  if (remount_image) {
+    // Store that we have a failure so that we always unmount the image
+    // before we exit.
+    bool had_error = false;
+
+    std::ostringstream attach_command;
+    attach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+    attach_command << " attach";
+    attach_command << " \"" << temp_image << "\"";
+
+    std::string attach_output;
+    if (!this->RunCommand(attach_command, &attach_output)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error attaching temporary disk image." << std::endl);
+
+      return 0;
+    }
+
+    cmsys::RegularExpression mountpoint_regex(".*(/Volumes/[^\n]+)\n.*");
+    mountpoint_regex.find(attach_output.c_str());
+    std::string const temp_mount = mountpoint_regex.match(1);
+    std::string const temp_mount_name =
+      temp_mount.substr(sizeof("/Volumes/") - 1);
+
+    // Remove dummy padding file so we have enough space on RW image ...
+    std::ostringstream dummy_padding;
+    dummy_padding << temp_mount << "/.dummy-padding-file";
+    if (!cmSystemTools::RemoveFile(dummy_padding.str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error removing dummy padding file."
+                      << std::endl);
+
+      had_error = true;
+    }
+
+    // Optionally set the custom icon flag for the image ...
+    if (!had_error && !cpack_package_icon.empty()) {
+      std::string error;
+      std::ostringstream setfile_command;
+      setfile_command << this->GetOption("CPACK_COMMAND_SETFILE");
+      setfile_command << " -a C";
+      setfile_command << " \"" << temp_mount << "\"";
+
+      if (!this->RunCommand(setfile_command, &error)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error assigning custom icon to temporary disk image."
+                        << std::endl
+                        << error << std::endl);
+
+        had_error = true;
+      }
+    }
+
+    // Optionally we can execute a custom apple script to generate
+    // the .DS_Store for the volume folder ...
+    if (!had_error && !cpack_dmg_ds_store_setup_script.empty()) {
+      std::ostringstream setup_script_command;
+      setup_script_command << "osascript"
+                           << " \"" << cpack_dmg_ds_store_setup_script << "\""
+                           << " \"" << temp_mount_name << "\"";
+      std::string error;
+      if (!this->RunCommand(setup_script_command, &error)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error executing custom script on disk image."
+                        << std::endl
+                        << error << std::endl);
+
+        had_error = true;
+      }
+    }
+
+    std::ostringstream detach_command;
+    detach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+    detach_command << " detach";
+    detach_command << " \"" << temp_mount << "\"";
+
+    if (!this->RunCommand(detach_command)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error detaching temporary disk image." << std::endl);
+
+      return 0;
+    }
+
+    if (had_error) {
+      return 0;
+    }
+  }
+
+  if (!cpack_license_file.empty() || !slaDirectory.empty()) {
+    // Use old hardcoded style if sla_dir is not set
+    bool oldStyle = slaDirectory.empty();
+    std::string sla_r = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    sla_r += "/sla.r";
+
+    std::vector<std::string> languages;
+    if (!oldStyle) {
+      cmSystemTools::ExpandListArgument(cpack_dmg_languages, languages);
+    }
+
+    cmGeneratedFileStream ofs(sla_r.c_str());
+    ofs << "#include <CoreServices/CoreServices.r>\n\n";
+    if (oldStyle) {
+      ofs << SLAHeader;
+      ofs << "\n";
+    } else {
+      /*
+       * LPic Layout
+       * (https://github.com/pypt/dmg-add-license/blob/master/main.c)
+       * as far as I can tell (no official documentation seems to exist):
+       * struct LPic {
+       *  uint16_t default_language; // points to a resid, defaulting to 0,
+       *                             // which is the first set language
+       *  uint16_t length;
+       *  struct {
+       *    uint16_t language_code;
+       *    uint16_t resid;
+       *    uint16_t encoding; // Encoding from TextCommon.h,
+       *                       // forcing MacRoman (0) for now. Might need to
+       *                       // allow overwrite per license by user later
+       *  } item[1];
+       * }
+       */
+
+      // Create vector first for readability, then iterate to write to ofs
+      std::vector<uint16_t> header_data;
+      header_data.push_back(0);
+      header_data.push_back(languages.size());
+      for (size_t i = 0; i < languages.size(); ++i) {
+        CFStringRef language_cfstring = CFStringCreateWithCString(
+          nullptr, languages[i].c_str(), kCFStringEncodingUTF8);
+        CFStringRef iso_language =
+          CFLocaleCreateCanonicalLanguageIdentifierFromString(
+            nullptr, language_cfstring);
+        if (!iso_language) {
+          cmCPackLogger(cmCPackLog::LOG_ERROR, languages[i]
+                          << " is not a recognized language" << std::endl);
+        }
+        char iso_language_cstr[65];
+        CFStringGetCString(iso_language, iso_language_cstr,
+                           sizeof(iso_language_cstr) - 1,
+                           kCFStringEncodingMacRoman);
+        LangCode lang = 0;
+        RegionCode region = 0;
+#ifdef HAVE_CoreServices
+        OSStatus err =
+          LocaleStringToLangAndRegionCodes(iso_language_cstr, &lang, &region);
+        if (err != noErr)
+#endif
+        {
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "No language/region code available for "
+                          << iso_language_cstr << std::endl);
+          return 0;
+        }
+#ifdef HAVE_CoreServices
+        header_data.push_back(region);
+        header_data.push_back(i);
+        header_data.push_back(0);
+#endif
+      }
+      ofs << "data 'LPic' (5000) {\n";
+      ofs << std::hex << std::uppercase << std::setfill('0');
+
+      for (size_t i = 0; i < header_data.size(); ++i) {
+        if (i % 8 == 0) {
+          ofs << "    $\"";
+        }
+
+        ofs << std::setw(4) << header_data[i];
+
+        if (i % 8 == 7 || i == header_data.size() - 1) {
+          ofs << "\"\n";
+        } else {
+          ofs << " ";
+        }
+      }
+      ofs << "};\n\n";
+      // Reset ofs options
+      ofs << std::dec << std::nouppercase << std::setfill(' ');
+    }
+
+    bool have_write_license_error = false;
+    std::string error;
+
+    if (oldStyle) {
+      if (!this->WriteLicense(ofs, 0, "", cpack_license_file, &error)) {
+        have_write_license_error = true;
+      }
+    } else {
+      for (size_t i = 0; i < languages.size() && !have_write_license_error;
+           ++i) {
+        if (singleLicense) {
+          if (!this->WriteLicense(ofs, i + 5000, languages[i],
+                                  cpack_license_file, &error)) {
+            have_write_license_error = true;
+          }
+        } else {
+          if (!this->WriteLicense(ofs, i + 5000, languages[i], "", &error)) {
+            have_write_license_error = true;
+          }
+        }
+      }
+    }
+
+    ofs.Close();
+
+    if (have_write_license_error) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error writing license file to SLA."
+                      << std::endl
+                      << error << std::endl);
+      return 0;
+    }
+
+    if (temp_image_format != "UDZO") {
+      temp_image_format = "UDZO";
+      // convert to UDZO to enable unflatten/flatten
+      std::string temp_udzo = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+      temp_udzo += "/temp-udzo.dmg";
+
+      std::ostringstream udco_image_command;
+      udco_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+      udco_image_command << " convert \"" << temp_image << "\"";
+      udco_image_command << " -format UDZO";
+      udco_image_command << " -ov -o \"" << temp_udzo << "\"";
+
+      if (!this->RunCommand(udco_image_command, &error)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Error converting to UDCO dmg for adding SLA."
+                        << std::endl
+                        << error << std::endl);
+        return 0;
+      }
+      temp_image = temp_udzo;
+    }
+
+    // unflatten dmg
+    std::ostringstream unflatten_command;
+    unflatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+    unflatten_command << " unflatten ";
+    unflatten_command << "\"" << temp_image << "\"";
+
+    if (!this->RunCommand(unflatten_command, &error)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error unflattening dmg for adding SLA." << std::endl
+                                                             << error
+                                                             << std::endl);
+      return 0;
+    }
+
+    // Rez the SLA
+    std::ostringstream embed_sla_command;
+    embed_sla_command << this->GetOption("CPACK_COMMAND_REZ");
+    const char* sysroot = this->GetOption("CPACK_OSX_SYSROOT");
+    if (sysroot && sysroot[0] != '\0') {
+      embed_sla_command << " -isysroot \"" << sysroot << "\"";
+    }
+    embed_sla_command << " \"" << sla_r << "\"";
+    embed_sla_command << " -a -o ";
+    embed_sla_command << "\"" << temp_image << "\"";
+
+    if (!this->RunCommand(embed_sla_command, &error)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding SLA." << std::endl
+                                                               << error
+                                                               << std::endl);
+      return 0;
+    }
+
+    // flatten dmg
+    std::ostringstream flatten_command;
+    flatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+    flatten_command << " flatten ";
+    flatten_command << "\"" << temp_image << "\"";
+
+    if (!this->RunCommand(flatten_command, &error)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error flattening dmg for adding SLA." << std::endl
+                                                           << error
+                                                           << std::endl);
+      return 0;
+    }
+  }
+
+  // Create the final compressed read-only disk image ...
+  std::ostringstream final_image_command;
+  final_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
+  final_image_command << " convert \"" << temp_image << "\"";
+  final_image_command << " -format ";
+  final_image_command << cpack_dmg_format;
+  final_image_command << " -imagekey";
+  final_image_command << " zlib-level=9";
+  final_image_command << " -o \"" << output_file << "\"";
+
+  std::string convert_error;
+
+  if (!this->RunCommand(final_image_command, &convert_error)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error compressing disk image."
+                    << std::endl
+                    << convert_error << std::endl);
+
+    return 0;
+  }
+
+  return 1;
+}
+
+bool cmCPackDragNDropGenerator::SupportsComponentInstallation() const
+{
+  return true;
+}
+
+std::string cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  // we want to group components together that go in the same dmg package
+  std::string package_file_name = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+
+  // we have 3 mutually exclusive modes to work in
+  // 1. all components in one package
+  // 2. each group goes in its own package with left over
+  //    components in their own package
+  // 3. ignore groups - if grouping is defined, it is ignored
+  //    and each component goes in its own package
+
+  if (this->componentPackageMethod == ONE_PACKAGE) {
+    return "ALL_IN_ONE";
+  }
+
+  if (this->componentPackageMethod == ONE_PACKAGE_PER_GROUP) {
+    // We have to find the name of the COMPONENT GROUP
+    // the current COMPONENT belongs to.
+    std::string groupVar =
+      "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
+    const char* _groupName = GetOption(groupVar);
+    if (_groupName) {
+      std::string groupName = _groupName;
+
+      groupName =
+        GetComponentPackageFileName(package_file_name, groupName, true);
+      return groupName;
+    }
+  }
+
+  return GetComponentPackageFileName(package_file_name, componentName, false);
+}
+
+bool cmCPackDragNDropGenerator::WriteLicense(
+  cmGeneratedFileStream& outputStream, int licenseNumber,
+  std::string licenseLanguage, const std::string& licenseFile,
+  std::string* error)
+{
+  if (!licenseFile.empty() && !singleLicense) {
+    licenseNumber = 5002;
+    licenseLanguage = "English";
+  }
+
+  // License header
+  outputStream << "data 'TEXT' (" << licenseNumber << ", \"" << licenseLanguage
+               << "\") {\n";
+  // License body
+  std::string actual_license = !licenseFile.empty()
+    ? licenseFile
+    : (slaDirectory + "/" + licenseLanguage + ".license.txt");
+  cmsys::ifstream license_ifs;
+  license_ifs.open(actual_license.c_str());
+  if (license_ifs.is_open()) {
+    while (license_ifs.good()) {
+      std::string line;
+      std::getline(license_ifs, line);
+      if (!line.empty()) {
+        EscapeQuotesAndBackslashes(line);
+        std::vector<std::string> lines;
+        if (!this->BreakLongLine(line, lines, error)) {
+          return false;
+        }
+        for (auto const& l : lines) {
+          outputStream << "        \"" << l << "\"\n";
+        }
+      }
+      outputStream << "        \"\\n\"\n";
+    }
+    license_ifs.close();
+  }
+
+  // End of License
+  outputStream << "};\n\n";
+  if (!licenseFile.empty() && !singleLicense) {
+    outputStream << SLASTREnglish;
+  } else {
+    // Menu header
+    outputStream << "resource 'STR#' (" << licenseNumber << ", \""
+                 << licenseLanguage << "\") {\n";
+    outputStream << "    {\n";
+
+    // Menu body
+    cmsys::ifstream menu_ifs;
+    menu_ifs.open(
+      (slaDirectory + "/" + licenseLanguage + ".menu.txt").c_str());
+    if (menu_ifs.is_open()) {
+      size_t lines_written = 0;
+      while (menu_ifs.good()) {
+        // Lines written from original file, not from broken up lines
+        std::string line;
+        std::getline(menu_ifs, line);
+        if (!line.empty()) {
+          EscapeQuotesAndBackslashes(line);
+          std::vector<std::string> lines;
+          if (!this->BreakLongLine(line, lines, error)) {
+            return false;
+          }
+          for (size_t i = 0; i < lines.size(); ++i) {
+            std::string comma;
+            // We need a comma after every complete string,
+            // but not on the very last line
+            if (lines_written != 8 && i == lines.size() - 1) {
+              comma = ",";
+            } else {
+              comma = "";
+            }
+            outputStream << "        \"" << lines[i] << "\"" << comma << "\n";
+          }
+          ++lines_written;
+        }
+      }
+      menu_ifs.close();
+    }
+
+    // End of menu
+    outputStream << "    }\n";
+    outputStream << "};\n";
+    outputStream << "\n";
+  }
+
+  return true;
+}
+
+bool cmCPackDragNDropGenerator::BreakLongLine(const std::string& line,
+                                              std::vector<std::string>& lines,
+                                              std::string* error)
+{
+  const size_t max_line_length = 512;
+  for (size_t i = 0; i < line.size(); i += max_line_length) {
+    size_t line_length = max_line_length;
+    if (i + line_length > line.size()) {
+      line_length = line.size() - i;
+    } else {
+      while (line_length > 0 && line[i + line_length - 1] != ' ') {
+        line_length = line_length - 1;
+      }
+    }
+
+    if (line_length == 0) {
+      *error = "Please make sure there are no words "
+               "(or character sequences not broken up by spaces or newlines) "
+               "in your license file which are more than 512 characters long.";
+      return false;
+    }
+    lines.push_back(line.substr(i, line_length));
+  }
+  return true;
+}
+
+void cmCPackDragNDropGenerator::EscapeQuotesAndBackslashes(std::string& line)
+{
+  std::string::size_type backslash_pos = line.find('\\');
+  while (backslash_pos != std::string::npos) {
+    line.replace(backslash_pos, 1, "\\\\");
+    backslash_pos = line.find('\\', backslash_pos + 2);
+  }
+
+  std::string::size_type quote_pos = line.find('\"');
+  while (quote_pos != std::string::npos) {
+    line.replace(quote_pos, 1, "\\\"");
+    quote_pos = line.find('\"', quote_pos + 2);
+  }
+}
diff --git a/Source/CPack/cmCPackDragNDropGenerator.h b/Source/CPack/cmCPackDragNDropGenerator.h
new file mode 100644
index 0000000..d8c5c83
--- /dev/null
+++ b/Source/CPack/cmCPackDragNDropGenerator.h
@@ -0,0 +1,55 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackDragNDropGenerator_h
+#define cmCPackDragNDropGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <sstream>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "cmCPackGenerator.h"
+
+class cmGeneratedFileStream;
+
+/** \class cmCPackDragNDropGenerator
+ * \brief A generator for OSX drag-n-drop installs
+ */
+class cmCPackDragNDropGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackDragNDropGenerator, cmCPackGenerator);
+
+  cmCPackDragNDropGenerator();
+  ~cmCPackDragNDropGenerator() override;
+
+protected:
+  int InitializeInternal() override;
+  const char* GetOutputExtension() override;
+  int PackageFiles() override;
+  bool SupportsComponentInstallation() const override;
+
+  bool CopyFile(std::ostringstream& source, std::ostringstream& target);
+  bool CreateEmptyFile(std::ostringstream& target, size_t size);
+  bool RunCommand(std::ostringstream& command, std::string* output = 0);
+
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) override;
+
+  int CreateDMG(const std::string& src_dir, const std::string& output_file);
+
+private:
+  std::string slaDirectory;
+  bool singleLicense;
+
+  bool WriteLicense(cmGeneratedFileStream& outputStream, int licenseNumber,
+                    std::string licenseLanguage,
+                    const std::string& licenseFile, std::string* error);
+  bool BreakLongLine(const std::string& line, std::vector<std::string>& lines,
+                     std::string* error);
+  void EscapeQuotesAndBackslashes(std::string& line);
+};
+
+#endif
diff --git a/Source/CPack/cmCPackFreeBSDGenerator.cxx b/Source/CPack/cmCPackFreeBSDGenerator.cxx
new file mode 100644
index 0000000..91ae1a2
--- /dev/null
+++ b/Source/CPack/cmCPackFreeBSDGenerator.cxx
@@ -0,0 +1,359 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackFreeBSDGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+// Needed for ::open() and ::stat()
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <pkg.h>
+
+#include <algorithm>
+
+cmCPackFreeBSDGenerator::cmCPackFreeBSDGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ, "paxr")
+{
+}
+
+int cmCPackFreeBSDGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr/local");
+  this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
+  return this->Superclass::InitializeInternal();
+}
+
+cmCPackFreeBSDGenerator::~cmCPackFreeBSDGenerator()
+{
+}
+
+// This is a wrapper, for use only in stream-based output,
+// that will output a string in UCL escaped fashion (in particular,
+// quotes and backslashes are escaped). The list of characters
+// to escape is taken from https://github.com/vstakhov/libucl
+// (which is the reference implementation pkg(8) refers to).
+class EscapeQuotes
+{
+public:
+  const std::string& value;
+
+  EscapeQuotes(const std::string& s)
+    : value(s)
+  {
+  }
+};
+
+// Output a string as "string" with escaping applied.
+cmGeneratedFileStream& operator<<(cmGeneratedFileStream& s,
+                                  const EscapeQuotes& v)
+{
+  s << '"';
+  for (std::string::size_type i = 0; i < v.value.length(); ++i) {
+    char c = v.value[i];
+    switch (c) {
+      case '\n':
+        s << "\\n";
+        break;
+      case '\r':
+        s << "\\r";
+        break;
+      case '\b':
+        s << "\\b";
+        break;
+      case '\t':
+        s << "\\t";
+        break;
+      case '\f':
+        s << "\\f";
+        break;
+      case '\\':
+        s << "\\\\";
+        break;
+      case '"':
+        s << "\\\"";
+        break;
+      default:
+        s << c;
+        break;
+    }
+  }
+  s << '"';
+  return s;
+}
+
+// The following classes are all helpers for writing out the UCL
+// manifest file (it also looks like JSON). ManifestKey just has
+// a (string-valued) key; subclasses add a specific kind of
+// value-type to the key, and implement write_value() to output
+// the corresponding UCL.
+class ManifestKey
+{
+public:
+  std::string key;
+
+  ManifestKey(const std::string& k)
+    : key(k)
+  {
+  }
+
+  virtual ~ManifestKey() {}
+
+  // Output the value associated with this key to the stream @p s.
+  // Format is to be decided by subclasses.
+  virtual void write_value(cmGeneratedFileStream& s) const = 0;
+};
+
+// Basic string-value (e.g. "name": "cmake")
+class ManifestKeyValue : public ManifestKey
+{
+public:
+  std::string value;
+
+  ManifestKeyValue(const std::string& k, const std::string& v)
+    : ManifestKey(k)
+    , value(v)
+  {
+  }
+
+  void write_value(cmGeneratedFileStream& s) const override
+  {
+    s << EscapeQuotes(value);
+  }
+};
+
+// List-of-strings values (e.g. "licenses": ["GPLv2", "LGPLv2"])
+class ManifestKeyListValue : public ManifestKey
+{
+public:
+  typedef std::vector<std::string> VList;
+  VList value;
+
+  ManifestKeyListValue(const std::string& k)
+    : ManifestKey(k)
+  {
+  }
+
+  ManifestKeyListValue& operator<<(const std::string& v)
+  {
+    value.push_back(v);
+    return *this;
+  }
+
+  ManifestKeyListValue& operator<<(const std::vector<std::string>& v)
+  {
+    for (VList::const_iterator it = v.begin(); it != v.end(); ++it) {
+      (*this) << (*it);
+    }
+    return *this;
+  }
+
+  void write_value(cmGeneratedFileStream& s) const override
+  {
+    bool with_comma = false;
+
+    s << '[';
+    for (VList::const_iterator it = value.begin(); it != value.end(); ++it) {
+      s << (with_comma ? ',' : ' ');
+      s << EscapeQuotes(*it);
+      with_comma = true;
+    }
+    s << " ]";
+  }
+};
+
+// Deps: actually a dictionary, but we'll treat it as a
+// list so we only name the deps, and produce dictionary-
+// like output via write_value()
+class ManifestKeyDepsValue : public ManifestKeyListValue
+{
+public:
+  ManifestKeyDepsValue(const std::string& k)
+    : ManifestKeyListValue(k)
+  {
+  }
+
+  void write_value(cmGeneratedFileStream& s) const override
+  {
+    s << "{\n";
+    for (VList::const_iterator it = value.begin(); it != value.end(); ++it) {
+      s << "  \"" << *it << "\": {\"origin\": \"" << *it << "\"},\n";
+    }
+    s << '}';
+  }
+};
+
+// Write one of the key-value classes (above) to the stream @p s
+cmGeneratedFileStream& operator<<(cmGeneratedFileStream& s,
+                                  const ManifestKey& v)
+{
+  s << '"' << v.key << "\": ";
+  v.write_value(s);
+  s << ",\n";
+  return s;
+}
+
+// Look up variable; if no value is set, returns an empty string;
+// basically a wrapper that handles the NULL-ptr return from GetOption().
+std::string cmCPackFreeBSDGenerator::var_lookup(const char* var_name)
+{
+  const char* pv = this->GetOption(var_name);
+  if (!pv) {
+    return std::string();
+  } else {
+    return pv;
+  }
+}
+
+// Produce UCL in the given @p manifest file for the common
+// manifest fields (common to the compact and regular formats),
+// by reading the CPACK_FREEBSD_* variables.
+void cmCPackFreeBSDGenerator::write_manifest_fields(
+  cmGeneratedFileStream& manifest)
+{
+  manifest << ManifestKeyValue("name",
+                               var_lookup("CPACK_FREEBSD_PACKAGE_NAME"));
+  manifest << ManifestKeyValue("origin",
+                               var_lookup("CPACK_FREEBSD_PACKAGE_ORIGIN"));
+  manifest << ManifestKeyValue("version",
+                               var_lookup("CPACK_FREEBSD_PACKAGE_VERSION"));
+  manifest << ManifestKeyValue("maintainer",
+                               var_lookup("CPACK_FREEBSD_PACKAGE_MAINTAINER"));
+  manifest << ManifestKeyValue("comment",
+                               var_lookup("CPACK_FREEBSD_PACKAGE_COMMENT"));
+  manifest << ManifestKeyValue(
+    "desc", var_lookup("CPACK_FREEBSD_PACKAGE_DESCRIPTION"));
+  manifest << ManifestKeyValue("www", var_lookup("CPACK_FREEBSD_PACKAGE_WWW"));
+  std::vector<std::string> licenses;
+  cmSystemTools::ExpandListArgument(
+    var_lookup("CPACK_FREEBSD_PACKAGE_LICENSE"), licenses);
+  std::string licenselogic("single");
+  if (licenses.size() < 1) {
+    cmSystemTools::SetFatalErrorOccured();
+  } else if (licenses.size() > 1) {
+    licenselogic = var_lookup("CPACK_FREEBSD_PACKAGE_LICENSE_LOGIC");
+  }
+  manifest << ManifestKeyValue("licenselogic", licenselogic);
+  manifest << (ManifestKeyListValue("licenses") << licenses);
+  std::vector<std::string> categories;
+  cmSystemTools::ExpandListArgument(
+    var_lookup("CPACK_FREEBSD_PACKAGE_CATEGORIES"), categories);
+  manifest << (ManifestKeyListValue("categories") << categories);
+  manifest << ManifestKeyValue("prefix", var_lookup("CMAKE_INSTALL_PREFIX"));
+  std::vector<std::string> deps;
+  cmSystemTools::ExpandListArgument(var_lookup("CPACK_FREEBSD_PACKAGE_DEPS"),
+                                    deps);
+  if (deps.size() > 0) {
+    manifest << (ManifestKeyDepsValue("deps") << deps);
+  }
+}
+
+// Package only actual files; others are ignored (in particular,
+// intermediate subdirectories are ignored).
+static bool ignore_file(const std::string& filename)
+{
+  struct stat statbuf;
+
+  if (!((stat(filename.c_str(), &statbuf) >= 0) &&
+        ((statbuf.st_mode & S_IFMT) == S_IFREG))) {
+    return true;
+  }
+  // May be other reasons to return false
+  return false;
+}
+
+// Write the given list of @p files to the manifest stream @p s,
+// as the UCL field "files" (which is dictionary-valued, to
+// associate filenames with hashes). All the files are transformed
+// to paths relative to @p toplevel, with a leading / (since the paths
+// in FreeBSD package files are supposed to be absolute).
+void write_manifest_files(cmGeneratedFileStream& s,
+                          const std::string& toplevel,
+                          const std::vector<std::string>& files)
+{
+  const char* c_toplevel = toplevel.c_str();
+  std::vector<std::string>::const_iterator it;
+
+  s << "\"files\": {\n";
+  for (it = files.begin(); it != files.end(); ++it) {
+    s << "  \"/" << cmSystemTools::RelativePath(c_toplevel, it->c_str())
+      << "\": \""
+      << "<sha256>"
+      << "\",\n";
+  }
+  s << "  },\n";
+}
+
+static bool has_suffix(const std::string& str, const std::string& suffix)
+{
+  return str.size() >= suffix.size() &&
+    str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+int cmCPackFreeBSDGenerator::PackageFiles()
+{
+  if (!this->ReadListFile("CPackFreeBSD.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error while execution CPackFreeBSD.cmake" << std::endl);
+    return 0;
+  }
+
+  std::vector<std::string>::const_iterator fileIt;
+  std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
+  cmSystemTools::ChangeDirectory(toplevel);
+
+  files.erase(std::remove_if(files.begin(), files.end(), ignore_file),
+              files.end());
+
+  std::string manifestname = toplevel + "/+MANIFEST";
+  {
+    cmGeneratedFileStream manifest(manifestname.c_str());
+    manifest << "{\n";
+    write_manifest_fields(manifest);
+    write_manifest_files(manifest, toplevel, files);
+    manifest << "}\n";
+  }
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+
+  if (WantsComponentInstallation()) {
+    // CASE 1 : COMPONENT ALL-IN-ONE package
+    // If ALL COMPONENTS in ONE package has been requested
+    // then the package file is unique and should be open here.
+    if (componentPackageMethod == ONE_PACKAGE) {
+      return PackageComponentsAllInOne();
+    }
+    // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
+    // There will be 1 package for each component group
+    // however one may require to ignore component group and
+    // in this case you'll get 1 package for each component.
+    return PackageComponents(componentPackageMethod ==
+                             ONE_PACKAGE_PER_COMPONENT);
+  }
+
+  std::string output_dir =
+    cmSystemTools::CollapseCombinedPath(toplevel, "../");
+  pkg_create_from_manifest(output_dir.c_str(), ::TXZ, toplevel.c_str(),
+                           manifestname.c_str(), NULL);
+
+  std::string broken_suffix = std::string("-") +
+    var_lookup("CPACK_TOPLEVEL_TAG") + std::string(GetOutputExtension());
+  for (std::vector<std::string>::iterator it = packageFileNames.begin();
+       it != packageFileNames.end(); ++it) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Packagefile " << *it << std::endl);
+    if (has_suffix(*it, broken_suffix)) {
+      it->replace(it->size() - broken_suffix.size(), std::string::npos,
+                  GetOutputExtension());
+      break;
+    }
+  }
+
+  cmSystemTools::ChangeDirectory(dir);
+  return 1;
+}
diff --git a/Source/CPack/cmCPackFreeBSDGenerator.h b/Source/CPack/cmCPackFreeBSDGenerator.h
new file mode 100644
index 0000000..99d2e24
--- /dev/null
+++ b/Source/CPack/cmCPackFreeBSDGenerator.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackFreeBSDGenerator_h
+#define cmCPackFreeBSDGenerator_h
+
+#include <cmConfigure.h>
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+class cmGeneratedFileStream;
+
+/** \class cmCPackFreeBSDGenerator
+ * \brief A generator for FreeBSD package files (TXZ with a manifest)
+ *
+ */
+class cmCPackFreeBSDGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackFreeBSDGenerator, cmCPackArchiveGenerator);
+  /**
+   * Construct generator
+   */
+  cmCPackFreeBSDGenerator();
+  ~cmCPackFreeBSDGenerator() override;
+
+  int InitializeInternal() override;
+  int PackageFiles() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".txz"; }
+
+  std::string var_lookup(const char* var_name);
+  void write_manifest_fields(cmGeneratedFileStream&);
+};
+
+#endif
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx
new file mode 100644
index 0000000..69e53e1
--- /dev/null
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -0,0 +1,1501 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackGenerator.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <memory> // IWYU pragma: keep
+#include <utility>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackLog.h"
+#include "cmCryptoHash.h"
+#include "cmFSPermissions.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateSnapshot.h"
+#include "cmVersion.h"
+#include "cmWorkingDirectory.h"
+#include "cmXMLSafe.h"
+#include "cmake.h"
+
+#if defined(__HAIKU__)
+#include <FindDirectory.h>
+#include <StorageDefs.h>
+#endif
+
+cmCPackGenerator::cmCPackGenerator()
+{
+  this->GeneratorVerbose = cmSystemTools::OUTPUT_NONE;
+  this->MakefileMap = nullptr;
+  this->Logger = nullptr;
+  this->componentPackageMethod = ONE_PACKAGE_PER_GROUP;
+}
+
+cmCPackGenerator::~cmCPackGenerator()
+{
+  this->MakefileMap = nullptr;
+}
+
+void cmCPackGeneratorProgress(const char* msg, float prog, void* ptr)
+{
+  cmCPackGenerator* self = static_cast<cmCPackGenerator*>(ptr);
+  self->DisplayVerboseOutput(msg, prog);
+}
+
+void cmCPackGenerator::DisplayVerboseOutput(const char* msg, float progress)
+{
+  (void)progress;
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "" << msg << std::endl);
+}
+
+int cmCPackGenerator::PrepareNames()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Create temp directory." << std::endl);
+
+  // checks CPACK_SET_DESTDIR support
+  if (IsOn("CPACK_SET_DESTDIR")) {
+    if (SETDESTDIR_UNSUPPORTED == SupportsSetDestdir()) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR, "CPACK_SET_DESTDIR is set to ON but the '"
+          << Name << "' generator does NOT support it." << std::endl);
+      return 0;
+    }
+    if (SETDESTDIR_SHOULD_NOT_BE_USED == SupportsSetDestdir()) {
+      cmCPackLogger(cmCPackLog::LOG_WARNING,
+                    "CPACK_SET_DESTDIR is set to ON but it is "
+                      << "usually a bad idea to do that with '" << Name
+                      << "' generator. Use at your own risk." << std::endl);
+    }
+  }
+
+  std::string tempDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
+  tempDirectory += "/_CPack_Packages/";
+  const char* toplevelTag = this->GetOption("CPACK_TOPLEVEL_TAG");
+  if (toplevelTag) {
+    tempDirectory += toplevelTag;
+    tempDirectory += "/";
+  }
+  tempDirectory += this->GetOption("CPACK_GENERATOR");
+  std::string topDirectory = tempDirectory;
+  const char* pfname = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  if (!pfname) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_PACKAGE_FILE_NAME not specified" << std::endl);
+    return 0;
+  }
+  std::string outName = pfname;
+  tempDirectory += "/" + outName;
+  if (!this->GetOutputExtension()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "No output extension specified"
+                    << std::endl);
+    return 0;
+  }
+  outName += this->GetOutputExtension();
+  const char* pdir = this->GetOption("CPACK_PACKAGE_DIRECTORY");
+  if (!pdir) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPACK_PACKAGE_DIRECTORY not specified" << std::endl);
+    return 0;
+  }
+
+  std::string destFile = pdir;
+  this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_PREFIX", destFile.c_str());
+  destFile += "/" + outName;
+  std::string outFile = topDirectory + "/" + outName;
+  this->SetOptionIfNotSet("CPACK_TOPLEVEL_DIRECTORY", topDirectory.c_str());
+  this->SetOptionIfNotSet("CPACK_TEMPORARY_DIRECTORY", tempDirectory.c_str());
+  this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_NAME", outName.c_str());
+  this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_PATH", destFile.c_str());
+  this->SetOptionIfNotSet("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                          outFile.c_str());
+  this->SetOptionIfNotSet("CPACK_INSTALL_DIRECTORY", this->GetInstallPath());
+  this->SetOptionIfNotSet(
+    "CPACK_NATIVE_INSTALL_DIRECTORY",
+    cmsys::SystemTools::ConvertToOutputPath(this->GetInstallPath()).c_str());
+  this->SetOptionIfNotSet("CPACK_TEMPORARY_INSTALL_DIRECTORY",
+                          tempDirectory.c_str());
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "Look for: CPACK_PACKAGE_DESCRIPTION_FILE" << std::endl);
+  const char* descFileName = this->GetOption("CPACK_PACKAGE_DESCRIPTION_FILE");
+  if (descFileName) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for: " << descFileName
+                                                      << std::endl);
+    if (!cmSystemTools::FileExists(descFileName)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot find description file name: ["
+                      << descFileName << "]" << std::endl);
+      return 0;
+    }
+    cmsys::ifstream ifs(descFileName);
+    if (!ifs) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Cannot open description file name: " << descFileName
+                                                          << std::endl);
+      return 0;
+    }
+    std::ostringstream ostr;
+    std::string line;
+
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                  "Read description file: " << descFileName << std::endl);
+    while (ifs && cmSystemTools::GetLineFromStream(ifs, line)) {
+      ostr << cmXMLSafe(line) << std::endl;
+    }
+    this->SetOptionIfNotSet("CPACK_PACKAGE_DESCRIPTION", ostr.str().c_str());
+  }
+  if (!this->GetOption("CPACK_PACKAGE_DESCRIPTION")) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Project description not specified. Please specify "
+      "CPACK_PACKAGE_DESCRIPTION or CPACK_PACKAGE_DESCRIPTION_FILE."
+        << std::endl);
+    return 0;
+  }
+  const char* algoSignature = this->GetOption("CPACK_PACKAGE_CHECKSUM");
+  if (algoSignature) {
+    if (!cmCryptoHash::New(algoSignature)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot recognize algorithm: "
+                      << algoSignature << std::endl);
+      return 0;
+    }
+  }
+
+  this->SetOptionIfNotSet("CPACK_REMOVE_TOPLEVEL_DIRECTORY", "1");
+
+  return 1;
+}
+
+int cmCPackGenerator::InstallProject()
+{
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Install projects" << std::endl);
+  this->CleanTemporaryDirectory();
+
+  std::string bareTempInstallDirectory =
+    this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
+  std::string tempInstallDirectoryStr = bareTempInstallDirectory;
+  bool setDestDir = cmSystemTools::IsOn(this->GetOption("CPACK_SET_DESTDIR")) |
+    cmSystemTools::IsInternallyOn(this->GetOption("CPACK_SET_DESTDIR"));
+  if (!setDestDir) {
+    tempInstallDirectoryStr += this->GetPackagingInstallPrefix();
+  }
+
+  const char* tempInstallDirectory = tempInstallDirectoryStr.c_str();
+  int res = 1;
+  if (!cmsys::SystemTools::MakeDirectory(bareTempInstallDirectory.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem creating temporary directory: "
+                    << (tempInstallDirectory ? tempInstallDirectory : "(NULL)")
+                    << std::endl);
+    return 0;
+  }
+
+  if (setDestDir) {
+    std::string destDir = "DESTDIR=";
+    destDir += tempInstallDirectory;
+    cmSystemTools::PutEnv(destDir);
+  } else {
+    // Make sure there is no destdir
+    cmSystemTools::PutEnv("DESTDIR=");
+  }
+
+  // prepare default created directory permissions
+  mode_t default_dir_mode_v = 0;
+  mode_t* default_dir_mode = nullptr;
+  const char* default_dir_install_permissions =
+    this->GetOption("CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS");
+  if (default_dir_install_permissions && *default_dir_install_permissions) {
+    std::vector<std::string> items;
+    cmSystemTools::ExpandListArgument(default_dir_install_permissions, items);
+    for (const auto& arg : items) {
+      if (!cmFSPermissions::stringToModeT(arg, default_dir_mode_v)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Invalid permission value '"
+                        << arg
+                        << "'."
+                           " CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS "
+                           "value is invalid."
+                        << std::endl);
+        return 0;
+      }
+    }
+
+    default_dir_mode = &default_dir_mode_v;
+  }
+
+  // If the CPackConfig file sets CPACK_INSTALL_COMMANDS then run them
+  // as listed
+  if (!this->InstallProjectViaInstallCommands(setDestDir,
+                                              tempInstallDirectory)) {
+    return 0;
+  }
+
+  // If the CPackConfig file sets CPACK_INSTALL_SCRIPT then run them
+  // as listed
+  if (!this->InstallProjectViaInstallScript(setDestDir,
+                                            tempInstallDirectory)) {
+    return 0;
+  }
+
+  // If the CPackConfig file sets CPACK_INSTALLED_DIRECTORIES
+  // then glob it and copy it to CPACK_TEMPORARY_DIRECTORY
+  // This is used in Source packaging
+  if (!this->InstallProjectViaInstalledDirectories(
+        setDestDir, tempInstallDirectory, default_dir_mode)) {
+    return 0;
+  }
+
+  // If the project is a CMAKE project then run pre-install
+  // and then read the cmake_install script to run it
+  if (!this->InstallProjectViaInstallCMakeProjects(
+        setDestDir, bareTempInstallDirectory, default_dir_mode)) {
+    return 0;
+  }
+
+  if (setDestDir) {
+    cmSystemTools::PutEnv("DESTDIR=");
+  }
+
+  return res;
+}
+
+int cmCPackGenerator::InstallProjectViaInstallCommands(
+  bool setDestDir, const std::string& tempInstallDirectory)
+{
+  (void)setDestDir;
+  const char* installCommands = this->GetOption("CPACK_INSTALL_COMMANDS");
+  if (installCommands && *installCommands) {
+    std::string tempInstallDirectoryEnv = "CMAKE_INSTALL_PREFIX=";
+    tempInstallDirectoryEnv += tempInstallDirectory;
+    cmSystemTools::PutEnv(tempInstallDirectoryEnv);
+    std::vector<std::string> installCommandsVector;
+    cmSystemTools::ExpandListArgument(installCommands, installCommandsVector);
+    for (std::string const& ic : installCommandsVector) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ic << std::endl);
+      std::string output;
+      int retVal = 1;
+      bool resB =
+        cmSystemTools::RunSingleCommand(ic.c_str(), &output, &output, &retVal,
+                                        nullptr, this->GeneratorVerbose, 0);
+      if (!resB || retVal) {
+        std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+        tmpFile += "/InstallOutput.log";
+        cmGeneratedFileStream ofs(tmpFile.c_str());
+        ofs << "# Run command: " << ic << std::endl
+            << "# Output:" << std::endl
+            << output << std::endl;
+        cmCPackLogger(
+          cmCPackLog::LOG_ERROR, "Problem running install command: "
+            << ic << std::endl
+            << "Please check " << tmpFile << " for errors" << std::endl);
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+int cmCPackGenerator::InstallProjectViaInstalledDirectories(
+  bool setDestDir, const std::string& tempInstallDirectory,
+  const mode_t* default_dir_mode)
+{
+  (void)setDestDir;
+  (void)tempInstallDirectory;
+  std::vector<cmsys::RegularExpression> ignoreFilesRegex;
+  const char* cpackIgnoreFiles = this->GetOption("CPACK_IGNORE_FILES");
+  if (cpackIgnoreFiles) {
+    std::vector<std::string> ignoreFilesRegexString;
+    cmSystemTools::ExpandListArgument(cpackIgnoreFiles,
+                                      ignoreFilesRegexString);
+    for (std::string const& ifr : ignoreFilesRegexString) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                    "Create ignore files regex for: " << ifr << std::endl);
+      ignoreFilesRegex.push_back(ifr.c_str());
+    }
+  }
+  const char* installDirectories =
+    this->GetOption("CPACK_INSTALLED_DIRECTORIES");
+  if (installDirectories && *installDirectories) {
+    std::vector<std::string> installDirectoriesVector;
+    cmSystemTools::ExpandListArgument(installDirectories,
+                                      installDirectoriesVector);
+    if (installDirectoriesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "CPACK_INSTALLED_DIRECTORIES should contain pairs of <directory> and "
+        "<subdirectory>. The <subdirectory> can be '.' to be installed in "
+        "the toplevel directory of installation."
+          << std::endl);
+      return 0;
+    }
+    std::vector<std::string>::iterator it;
+    const std::string& tempDir = tempInstallDirectory;
+    for (it = installDirectoriesVector.begin();
+         it != installDirectoriesVector.end(); ++it) {
+      std::vector<std::pair<std::string, std::string>> symlinkedFiles;
+      cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
+      cmsys::Glob gl;
+      std::string top = *it;
+      it++;
+      std::string subdir = *it;
+      std::string findExpr = top;
+      findExpr += "/*";
+      cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                    "- Install directory: " << top << std::endl);
+      gl.RecurseOn();
+      gl.SetRecurseListDirs(true);
+      if (!gl.FindFiles(findExpr)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Cannot find any files in the installed directory"
+                        << std::endl);
+        return 0;
+      }
+      files = gl.GetFiles();
+      std::vector<std::string>::iterator gfit;
+      std::vector<cmsys::RegularExpression>::iterator regIt;
+      for (std::string const& gf : files) {
+        bool skip = false;
+        std::string inFile = gf;
+        if (cmSystemTools::FileIsDirectory(gf)) {
+          inFile += '/';
+        }
+        for (cmsys::RegularExpression& reg : ignoreFilesRegex) {
+          if (reg.find(inFile.c_str())) {
+            cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                          "Ignore file: " << inFile << std::endl);
+            skip = true;
+          }
+        }
+        if (skip) {
+          continue;
+        }
+        std::string filePath = tempDir;
+        filePath += "/" + subdir + "/" +
+          cmSystemTools::RelativePath(top.c_str(), gf.c_str());
+        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy file: "
+                        << inFile << " -> " << filePath << std::endl);
+        /* If the file is a symlink we will have to re-create it */
+        if (cmSystemTools::FileIsSymlink(inFile)) {
+          std::string targetFile;
+          std::string inFileRelative =
+            cmSystemTools::RelativePath(top.c_str(), inFile.c_str());
+          cmSystemTools::ReadSymlink(inFile, targetFile);
+          symlinkedFiles.push_back(
+            std::pair<std::string, std::string>(targetFile, inFileRelative));
+        }
+        /* If it is not a symlink then do a plain copy */
+        else if (!(cmSystemTools::CopyFileIfDifferent(inFile.c_str(),
+                                                      filePath.c_str()) &&
+                   cmSystemTools::CopyFileTime(inFile.c_str(),
+                                               filePath.c_str()))) {
+          cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying file: "
+                          << inFile << " -> " << filePath << std::endl);
+          return 0;
+        }
+      }
+      /* rebuild symlinks in the installed tree */
+      if (!symlinkedFiles.empty()) {
+        std::string curDir = cmSystemTools::GetCurrentWorkingDirectory();
+        std::string goToDir = tempDir;
+        goToDir += "/" + subdir;
+        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Change dir to: " << goToDir
+                                                               << std::endl);
+        cmWorkingDirectory workdir(goToDir);
+        for (auto const& symlinked : symlinkedFiles) {
+          cmCPackLogger(cmCPackLog::LOG_DEBUG, "Will create a symlink: "
+                          << symlinked.second << "--> " << symlinked.first
+                          << std::endl);
+          // make sure directory exists for symlink
+          std::string destDir =
+            cmSystemTools::GetFilenamePath(symlinked.second);
+          if (!destDir.empty() &&
+              !cmSystemTools::MakeDirectory(destDir, default_dir_mode)) {
+            cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create dir: "
+                            << destDir << "\nTrying to create symlink: "
+                            << symlinked.second << "--> " << symlinked.first
+                            << std::endl);
+          }
+          if (!cmSystemTools::CreateSymlink(symlinked.first,
+                                            symlinked.second)) {
+            cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create symlink: "
+                            << symlinked.second << "--> " << symlinked.first
+                            << std::endl);
+            return 0;
+          }
+        }
+        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Going back to: " << curDir
+                                                               << std::endl);
+      }
+    }
+  }
+  return 1;
+}
+
+int cmCPackGenerator::InstallProjectViaInstallScript(
+  bool setDestDir, const std::string& tempInstallDirectory)
+{
+  const char* cmakeScripts = this->GetOption("CPACK_INSTALL_SCRIPT");
+  if (cmakeScripts && *cmakeScripts) {
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Install scripts: " << cmakeScripts
+                                                                << std::endl);
+    std::vector<std::string> cmakeScriptsVector;
+    cmSystemTools::ExpandListArgument(cmakeScripts, cmakeScriptsVector);
+    for (std::string const& installScript : cmakeScriptsVector) {
+
+      cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                    "- Install script: " << installScript << std::endl);
+
+      if (setDestDir) {
+        // For DESTDIR based packaging, use the *project* CMAKE_INSTALL_PREFIX
+        // underneath the tempInstallDirectory. The value of the project's
+        // CMAKE_INSTALL_PREFIX is sent in here as the value of the
+        // CPACK_INSTALL_PREFIX variable.
+
+        std::string dir;
+        if (this->GetOption("CPACK_INSTALL_PREFIX")) {
+          dir += this->GetOption("CPACK_INSTALL_PREFIX");
+        }
+        this->SetOption("CMAKE_INSTALL_PREFIX", dir.c_str());
+        cmCPackLogger(
+          cmCPackLog::LOG_DEBUG,
+          "- Using DESTDIR + CPACK_INSTALL_PREFIX... (this->SetOption)"
+            << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'"
+                                                            << std::endl);
+      } else {
+        this->SetOption("CMAKE_INSTALL_PREFIX", tempInstallDirectory.c_str());
+
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "- Using non-DESTDIR install... (this->SetOption)"
+                        << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "- Setting CMAKE_INSTALL_PREFIX to '"
+                        << tempInstallDirectory << "'" << std::endl);
+      }
+
+      this->SetOptionIfNotSet("CMAKE_CURRENT_BINARY_DIR",
+                              tempInstallDirectory.c_str());
+      this->SetOptionIfNotSet("CMAKE_CURRENT_SOURCE_DIR",
+                              tempInstallDirectory.c_str());
+      int res = this->MakefileMap->ReadListFile(installScript.c_str());
+      if (cmSystemTools::GetErrorOccuredFlag() || !res) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
+  bool setDestDir, const std::string& baseTempInstallDirectory,
+  const mode_t* default_dir_mode)
+{
+  const char* cmakeProjects = this->GetOption("CPACK_INSTALL_CMAKE_PROJECTS");
+  const char* cmakeGenerator = this->GetOption("CPACK_CMAKE_GENERATOR");
+  std::string absoluteDestFiles;
+  if (cmakeProjects && *cmakeProjects) {
+    if (!cmakeGenerator) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPACK_INSTALL_CMAKE_PROJECTS is specified, but "
+                    "CPACK_CMAKE_GENERATOR is not. CPACK_CMAKE_GENERATOR "
+                    "is required to install the project."
+                      << std::endl);
+      return 0;
+    }
+    std::vector<std::string> cmakeProjectsVector;
+    cmSystemTools::ExpandListArgument(cmakeProjects, cmakeProjectsVector);
+    std::vector<std::string>::iterator it;
+    for (it = cmakeProjectsVector.begin(); it != cmakeProjectsVector.end();
+         ++it) {
+      if (it + 1 == cmakeProjectsVector.end() ||
+          it + 2 == cmakeProjectsVector.end() ||
+          it + 3 == cmakeProjectsVector.end()) {
+        cmCPackLogger(
+          cmCPackLog::LOG_ERROR,
+          "Not enough items on list: CPACK_INSTALL_CMAKE_PROJECTS. "
+          "CPACK_INSTALL_CMAKE_PROJECTS should hold quadruplet of install "
+          "directory, install project name, install component, and install "
+          "subdirectory."
+            << std::endl);
+        return 0;
+      }
+      std::string installDirectory = *it;
+      ++it;
+      std::string installProjectName = *it;
+      ++it;
+      std::string installComponent = *it;
+      ++it;
+      std::string installSubDirectory = *it;
+      std::string installFile = installDirectory + "/cmake_install.cmake";
+
+      std::vector<std::string> componentsVector;
+
+      bool componentInstall = false;
+      /*
+       * We do a component install iff
+       *    - the CPack generator support component
+       *    - the user did not request Monolithic install
+       *      (this works at CPack time too)
+       */
+      if (this->SupportsComponentInstallation() &
+          !(this->IsOn("CPACK_MONOLITHIC_INSTALL"))) {
+        // Determine the installation types for this project (if provided).
+        std::string installTypesVar = "CPACK_" +
+          cmSystemTools::UpperCase(installComponent) + "_INSTALL_TYPES";
+        const char* installTypes = this->GetOption(installTypesVar);
+        if (installTypes && *installTypes) {
+          std::vector<std::string> installTypesVector;
+          cmSystemTools::ExpandListArgument(installTypes, installTypesVector);
+          for (std::string const& installType : installTypesVector) {
+            this->GetInstallationType(installProjectName, installType);
+          }
+        }
+
+        // Determine the set of components that will be used in this project
+        std::string componentsVar =
+          "CPACK_COMPONENTS_" + cmSystemTools::UpperCase(installComponent);
+        const char* components = this->GetOption(componentsVar);
+        if (components && *components) {
+          cmSystemTools::ExpandListArgument(components, componentsVector);
+          for (std::string const& comp : componentsVector) {
+            GetComponent(installProjectName, comp);
+          }
+          componentInstall = true;
+        }
+      }
+      if (componentsVector.empty()) {
+        componentsVector.push_back(installComponent);
+      }
+
+      const char* buildConfigCstr = this->GetOption("CPACK_BUILD_CONFIG");
+      std::string buildConfig = buildConfigCstr ? buildConfigCstr : "";
+      cmGlobalGenerator* globalGenerator =
+        this->MakefileMap->GetCMakeInstance()->CreateGlobalGenerator(
+          cmakeGenerator);
+      if (!globalGenerator) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Specified package generator not found. "
+                      "CPACK_CMAKE_GENERATOR value is invalid."
+                        << std::endl);
+        return 0;
+      }
+      // set the global flag for unix style paths on cmSystemTools as
+      // soon as the generator is set.  This allows gmake to be used
+      // on windows.
+      cmSystemTools::SetForceUnixPaths(globalGenerator->GetForceUnixPaths());
+
+      // Does this generator require pre-install?
+      if (const char* preinstall =
+            globalGenerator->GetPreinstallTargetName()) {
+        std::string buildCommand = globalGenerator->GenerateCMakeBuildCommand(
+          preinstall, buildConfig, "", false);
+        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                      "- Install command: " << buildCommand << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Run preinstall target for: "
+                        << installProjectName << std::endl);
+        std::string output;
+        int retVal = 1;
+        bool resB = cmSystemTools::RunSingleCommand(
+          buildCommand.c_str(), &output, &output, &retVal,
+          installDirectory.c_str(), this->GeneratorVerbose, 0);
+        if (!resB || retVal) {
+          std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+          tmpFile += "/PreinstallOutput.log";
+          cmGeneratedFileStream ofs(tmpFile.c_str());
+          ofs << "# Run command: " << buildCommand << std::endl
+              << "# Directory: " << installDirectory << std::endl
+              << "# Output:" << std::endl
+              << output << std::endl;
+          cmCPackLogger(
+            cmCPackLog::LOG_ERROR, "Problem running install command: "
+              << buildCommand << std::endl
+              << "Please check " << tmpFile << " for errors" << std::endl);
+          return 0;
+        }
+      }
+      delete globalGenerator;
+
+      cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                    "- Install project: " << installProjectName << std::endl);
+
+      // Run the installation for each component
+      for (std::string const& component : componentsVector) {
+        std::string tempInstallDirectory = baseTempInstallDirectory;
+        installComponent = component;
+        if (componentInstall) {
+          cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Install component: "
+                          << installComponent << std::endl);
+        }
+
+        cmake cm(cmake::RoleScript);
+        cm.SetHomeDirectory("");
+        cm.SetHomeOutputDirectory("");
+        cm.GetCurrentSnapshot().SetDefaultDefinitions();
+        cm.AddCMakePaths();
+        cm.SetProgressCallback(cmCPackGeneratorProgress, this);
+        cm.SetTrace(this->Trace);
+        cm.SetTraceExpand(this->TraceExpand);
+        cmGlobalGenerator gg(&cm);
+        cmMakefile mf(&gg, cm.GetCurrentSnapshot());
+        if (!installSubDirectory.empty() && installSubDirectory != "/" &&
+            installSubDirectory != ".") {
+          tempInstallDirectory += installSubDirectory;
+        }
+        if (componentInstall) {
+          tempInstallDirectory += "/";
+          // Some CPack generators would rather chose
+          // the local installation directory suffix.
+          // Some (e.g. RPM) use
+          //  one install directory for each component **GROUP**
+          // instead of the default
+          //  one install directory for each component.
+          tempInstallDirectory +=
+            GetComponentInstallDirNameSuffix(installComponent);
+          if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
+            tempInstallDirectory += "/";
+            tempInstallDirectory += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+          }
+        }
+
+        const char* default_dir_inst_permissions =
+          this->GetOption("CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS");
+        if (default_dir_inst_permissions && *default_dir_inst_permissions) {
+          mf.AddDefinition("CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS",
+                           default_dir_inst_permissions);
+        }
+
+        if (!setDestDir) {
+          tempInstallDirectory += this->GetPackagingInstallPrefix();
+        }
+
+        if (setDestDir) {
+          // For DESTDIR based packaging, use the *project*
+          // CMAKE_INSTALL_PREFIX underneath the tempInstallDirectory. The
+          // value of the project's CMAKE_INSTALL_PREFIX is sent in here as
+          // the value of the CPACK_INSTALL_PREFIX variable.
+          //
+          // If DESTDIR has been 'internally set ON' this means that
+          // the underlying CPack specific generator did ask for that
+          // In this case we may override CPACK_INSTALL_PREFIX with
+          // CPACK_PACKAGING_INSTALL_PREFIX
+          // I know this is tricky and awkward but it's the price for
+          // CPACK_SET_DESTDIR backward compatibility.
+          if (cmSystemTools::IsInternallyOn(
+                this->GetOption("CPACK_SET_DESTDIR"))) {
+            this->SetOption("CPACK_INSTALL_PREFIX",
+                            this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX"));
+          }
+          std::string dir;
+          if (this->GetOption("CPACK_INSTALL_PREFIX")) {
+            dir += this->GetOption("CPACK_INSTALL_PREFIX");
+          }
+          mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str());
+
+          cmCPackLogger(
+            cmCPackLog::LOG_DEBUG,
+            "- Using DESTDIR + CPACK_INSTALL_PREFIX... (mf.AddDefinition)"
+              << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'"
+                                                              << std::endl);
+
+          // Make sure that DESTDIR + CPACK_INSTALL_PREFIX directory
+          // exists:
+          //
+          if (cmSystemTools::StringStartsWith(dir.c_str(), "/")) {
+            dir = tempInstallDirectory + dir;
+          } else {
+            dir = tempInstallDirectory + "/" + dir;
+          }
+          /*
+           *  We must re-set DESTDIR for each component
+           *  We must not add the CPACK_INSTALL_PREFIX part because
+           *  it will be added using the override of CMAKE_INSTALL_PREFIX
+           *  The main reason for this awkward trick is that
+           *  are using DESTDIR for 2 different reasons:
+           *     - Because it was asked by the CPack Generator or the user
+           *       using CPACK_SET_DESTDIR
+           *     - Because it was already used for component install
+           *       in order to put things in subdirs...
+           */
+          cmSystemTools::PutEnv(std::string("DESTDIR=") +
+                                tempInstallDirectory);
+          cmCPackLogger(cmCPackLog::LOG_DEBUG, "- Creating directory: '"
+                          << dir << "'" << std::endl);
+
+          if (!cmsys::SystemTools::MakeDirectory(dir, default_dir_mode)) {
+            cmCPackLogger(
+              cmCPackLog::LOG_ERROR,
+              "Problem creating temporary directory: " << dir << std::endl);
+            return 0;
+          }
+        } else {
+          mf.AddDefinition("CMAKE_INSTALL_PREFIX",
+                           tempInstallDirectory.c_str());
+
+          if (!cmsys::SystemTools::MakeDirectory(tempInstallDirectory,
+                                                 default_dir_mode)) {
+            cmCPackLogger(cmCPackLog::LOG_ERROR,
+                          "Problem creating temporary directory: "
+                            << tempInstallDirectory << std::endl);
+            return 0;
+          }
+
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "- Using non-DESTDIR install... (mf.AddDefinition)"
+                          << std::endl);
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "- Setting CMAKE_INSTALL_PREFIX to '"
+                          << tempInstallDirectory << "'" << std::endl);
+        }
+
+        if (!buildConfig.empty()) {
+          mf.AddDefinition("BUILD_TYPE", buildConfig.c_str());
+        }
+        std::string installComponentLowerCase =
+          cmSystemTools::LowerCase(installComponent);
+        if (installComponentLowerCase != "all") {
+          mf.AddDefinition("CMAKE_INSTALL_COMPONENT",
+                           installComponent.c_str());
+        }
+
+        // strip on TRUE, ON, 1, one or several file names, but not on
+        // FALSE, OFF, 0 and an empty string
+        if (!cmSystemTools::IsOff(this->GetOption("CPACK_STRIP_FILES"))) {
+          mf.AddDefinition("CMAKE_INSTALL_DO_STRIP", "1");
+        }
+        // Remember the list of files before installation
+        // of the current component (if we are in component install)
+        const char* InstallPrefix = tempInstallDirectory.c_str();
+        std::vector<std::string> filesBefore;
+        std::string findExpr(InstallPrefix);
+        if (componentInstall) {
+          cmsys::Glob glB;
+          findExpr += "/*";
+          glB.RecurseOn();
+          glB.SetRecurseListDirs(true);
+          glB.FindFiles(findExpr);
+          filesBefore = glB.GetFiles();
+          std::sort(filesBefore.begin(), filesBefore.end());
+        }
+
+        // If CPack was asked to warn on ABSOLUTE INSTALL DESTINATION
+        // then forward request to cmake_install.cmake script
+        if (this->IsOn("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION")) {
+          mf.AddDefinition("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", "1");
+        }
+        // If current CPack generator does support
+        // ABSOLUTE INSTALL DESTINATION or CPack has been asked for
+        // then ask cmake_install.cmake script to error out
+        // as soon as it occurs (before installing file)
+        if (!SupportsAbsoluteDestination() ||
+            this->IsOn("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION")) {
+          mf.AddDefinition("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", "1");
+        }
+        // do installation
+        int res = mf.ReadListFile(installFile.c_str());
+        // forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES
+        // to CPack (may be used by generators like CPack RPM or DEB)
+        // in order to transparently handle ABSOLUTE PATH
+        if (mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
+          mf.AddDefinition(
+            "CPACK_ABSOLUTE_DESTINATION_FILES",
+            mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
+        }
+
+        // Now rebuild the list of files after installation
+        // of the current component (if we are in component install)
+        if (componentInstall) {
+          cmsys::Glob glA;
+          glA.RecurseOn();
+          glA.SetRecurseListDirs(true);
+          glA.SetRecurseThroughSymlinks(false);
+          glA.FindFiles(findExpr);
+          std::vector<std::string> filesAfter = glA.GetFiles();
+          std::sort(filesAfter.begin(), filesAfter.end());
+          std::vector<std::string>::iterator diff;
+          std::vector<std::string> result(filesAfter.size());
+          diff = std::set_difference(filesAfter.begin(), filesAfter.end(),
+                                     filesBefore.begin(), filesBefore.end(),
+                                     result.begin());
+
+          std::vector<std::string>::iterator fit;
+          std::string localFileName;
+          // Populate the File field of each component
+          for (fit = result.begin(); fit != diff; ++fit) {
+            localFileName =
+              cmSystemTools::RelativePath(InstallPrefix, fit->c_str());
+            localFileName =
+              localFileName.substr(localFileName.find_first_not_of('/'));
+            Components[installComponent].Files.push_back(localFileName);
+            cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file <"
+                            << localFileName << "> to component <"
+                            << installComponent << ">" << std::endl);
+          }
+        }
+
+        if (nullptr != mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) {
+          if (!absoluteDestFiles.empty()) {
+            absoluteDestFiles += ";";
+          }
+          absoluteDestFiles +=
+            mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES");
+          cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                        "Got some ABSOLUTE DESTINATION FILES: "
+                          << absoluteDestFiles << std::endl);
+          // define component specific var
+          if (componentInstall) {
+            std::string absoluteDestFileComponent =
+              std::string("CPACK_ABSOLUTE_DESTINATION_FILES") + "_" +
+              GetComponentInstallDirNameSuffix(installComponent);
+            if (nullptr != this->GetOption(absoluteDestFileComponent)) {
+              std::string absoluteDestFilesListComponent =
+                this->GetOption(absoluteDestFileComponent);
+              absoluteDestFilesListComponent += ";";
+              absoluteDestFilesListComponent +=
+                mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES");
+              this->SetOption(absoluteDestFileComponent,
+                              absoluteDestFilesListComponent.c_str());
+            } else {
+              this->SetOption(
+                absoluteDestFileComponent,
+                mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES"));
+            }
+          }
+        }
+        if (cmSystemTools::GetErrorOccuredFlag() || !res) {
+          return 0;
+        }
+      }
+    }
+  }
+  this->SetOption("CPACK_ABSOLUTE_DESTINATION_FILES",
+                  absoluteDestFiles.c_str());
+  return 1;
+}
+
+bool cmCPackGenerator::ReadListFile(const char* moduleName)
+{
+  bool retval;
+  std::string fullPath = this->MakefileMap->GetModulesFile(moduleName);
+  retval = this->MakefileMap->ReadListFile(fullPath.c_str());
+  // include FATAL_ERROR and ERROR in the return status
+  retval = retval && (!cmSystemTools::GetErrorOccuredFlag());
+  return retval;
+}
+
+void cmCPackGenerator::SetOptionIfNotSet(const std::string& op,
+                                         const char* value)
+{
+  const char* def = this->MakefileMap->GetDefinition(op);
+  if (def && *def) {
+    return;
+  }
+  this->SetOption(op, value);
+}
+
+void cmCPackGenerator::SetOption(const std::string& op, const char* value)
+{
+  if (!value) {
+    this->MakefileMap->RemoveDefinition(op);
+    return;
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, this->GetNameOfClass()
+                  << "::SetOption(" << op << ", " << value << ")"
+                  << std::endl);
+  this->MakefileMap->AddDefinition(op, value);
+}
+
+int cmCPackGenerator::DoPackage()
+{
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package using " << this->Name
+                                                                << std::endl);
+
+  // Prepare CPack internal name and check
+  // values for many CPACK_xxx vars
+  if (!this->PrepareNames()) {
+    return 0;
+  }
+
+  // Digest Component grouping specification
+  if (!this->PrepareGroupingKind()) {
+    return 0;
+  }
+
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_REMOVE_TOPLEVEL_DIRECTORY"))) {
+    const char* toplevelDirectory =
+      this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    if (cmSystemTools::FileExists(toplevelDirectory)) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove toplevel directory: "
+                      << toplevelDirectory << std::endl);
+      if (!cmSystemTools::RepeatedRemoveDirectory(toplevelDirectory)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem removing toplevel directory: "
+                        << toplevelDirectory << std::endl);
+        return 0;
+      }
+    }
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "About to install project "
+                  << std::endl);
+
+  if (!this->InstallProject()) {
+    return 0;
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Done install project " << std::endl);
+
+  const char* tempPackageFileName =
+    this->GetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME");
+  const char* tempDirectory = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
+  cmsys::Glob gl;
+  std::string findExpr = tempDirectory;
+  findExpr += "/*";
+  gl.RecurseOn();
+  gl.SetRecurseListDirs(true);
+  gl.SetRecurseThroughSymlinks(false);
+  if (!gl.FindFiles(findExpr)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find any files in the packaging tree" << std::endl);
+    return 0;
+  }
+
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package" << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Package files to: "
+                  << (tempPackageFileName ? tempPackageFileName : "(NULL)")
+                  << std::endl);
+  if (cmSystemTools::FileExists(tempPackageFileName)) {
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove old package file"
+                    << std::endl);
+    cmSystemTools::RemoveFile(tempPackageFileName);
+  }
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY"))) {
+    tempDirectory = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  }
+
+  // The files to be installed
+  files = gl.GetFiles();
+
+  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.push_back(tempPackageFileName ? tempPackageFileName : "");
+  toplevel = tempDirectory;
+  { // scope that enables package generators to run internal scripts with
+    // latest CMake policies enabled
+    cmMakefile::ScopePushPop pp{ this->MakefileMap };
+    this->MakefileMap->SetPolicyVersion(cmVersion::GetCMakeVersion());
+
+    if (!this->PackageFiles() || cmSystemTools::GetErrorOccuredFlag()) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem compressing the directory"
+                      << std::endl);
+      return 0;
+    }
+  }
+
+  /* Prepare checksum algorithm*/
+  const char* algo = this->GetOption("CPACK_PACKAGE_CHECKSUM");
+  std::unique_ptr<cmCryptoHash> crypto = cmCryptoHash::New(algo ? algo : "");
+
+  /*
+   * Copy the generated packages to final destination
+   *  - there may be several of them
+   *  - the initially provided name may have changed
+   *    (because the specific generator did 'normalize' it)
+   */
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Copying final package(s) ["
+                  << packageFileNames.size() << "]:" << std::endl);
+  /* now copy package one by one */
+  for (std::string const& pkgFileName : packageFileNames) {
+    std::string tmpPF(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"));
+    std::string filename(cmSystemTools::GetFilenameName(pkgFileName));
+    tempPackageFileName = pkgFileName.c_str();
+    tmpPF += "/" + filename;
+    const char* packageFileName = tmpPF.c_str();
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy final package(s): "
+                    << (tempPackageFileName ? tempPackageFileName : "(NULL)")
+                    << " to " << (packageFileName ? packageFileName : "(NULL)")
+                    << std::endl);
+    if (!cmSystemTools::CopyFileIfDifferent(tempPackageFileName,
+                                            packageFileName)) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR, "Problem copying the package: "
+          << (tempPackageFileName ? tempPackageFileName : "(NULL)") << " to "
+          << (packageFileName ? packageFileName : "(NULL)") << std::endl);
+      return 0;
+    }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- package: "
+                    << packageFileName << " generated." << std::endl);
+
+    /* Generate checksum file */
+    if (crypto) {
+      std::string hashFile(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"));
+      hashFile += "/" + filename;
+      hashFile += "." + cmSystemTools::LowerCase(algo);
+      cmsys::ofstream outF(hashFile.c_str());
+      if (!outF) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create checksum file: "
+                        << hashFile << std::endl);
+        return 0;
+      }
+      outF << crypto->HashFile(packageFileName) << "  " << filename << "\n";
+      cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- checksum file: "
+                      << hashFile << " generated." << std::endl);
+    }
+  }
+
+  return 1;
+}
+
+int cmCPackGenerator::Initialize(const std::string& name, cmMakefile* mf)
+{
+  this->MakefileMap = mf;
+  this->Name = name;
+  // set the running generator name
+  this->SetOption("CPACK_GENERATOR", this->Name.c_str());
+  // Load the project specific config file
+  const char* config = this->GetOption("CPACK_PROJECT_CONFIG_FILE");
+  if (config) {
+    mf->ReadListFile(config);
+  }
+  int result = this->InitializeInternal();
+  if (cmSystemTools::GetErrorOccuredFlag()) {
+    return 0;
+  }
+
+  // If a generator subclass did not already set this option in its
+  // InitializeInternal implementation, and the project did not already set
+  // it, the default value should be:
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/");
+
+  return result;
+}
+
+int cmCPackGenerator::InitializeInternal()
+{
+  return 1;
+}
+
+bool cmCPackGenerator::IsSet(const std::string& name) const
+{
+  return this->MakefileMap->IsSet(name);
+}
+
+bool cmCPackGenerator::IsOn(const std::string& name) const
+{
+  return cmSystemTools::IsOn(GetOption(name));
+}
+
+bool cmCPackGenerator::IsSetToOff(const std::string& op) const
+{
+  const char* ret = this->MakefileMap->GetDefinition(op);
+  if (ret && *ret) {
+    return cmSystemTools::IsOff(ret);
+  }
+  return false;
+}
+
+bool cmCPackGenerator::IsSetToEmpty(const std::string& op) const
+{
+  const char* ret = this->MakefileMap->GetDefinition(op);
+  if (ret) {
+    return !*ret;
+  }
+  return false;
+}
+
+const char* cmCPackGenerator::GetOption(const std::string& op) const
+{
+  const char* ret = this->MakefileMap->GetDefinition(op);
+  if (!ret) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                  "Warning, GetOption return NULL for: " << op << std::endl);
+  }
+  return ret;
+}
+
+std::vector<std::string> cmCPackGenerator::GetOptions() const
+{
+  return this->MakefileMap->GetDefinitions();
+}
+
+int cmCPackGenerator::PackageFiles()
+{
+  return 0;
+}
+
+const char* cmCPackGenerator::GetInstallPath()
+{
+  if (!this->InstallPath.empty()) {
+    return this->InstallPath.c_str();
+  }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  std::string prgfiles;
+  std::string sysDrive;
+  if (cmsys::SystemTools::GetEnv("ProgramFiles", prgfiles)) {
+    this->InstallPath = prgfiles;
+  } else if (cmsys::SystemTools::GetEnv("SystemDrive", sysDrive)) {
+    this->InstallPath = sysDrive;
+    this->InstallPath += "/Program Files";
+  } else {
+    this->InstallPath = "c:/Program Files";
+  }
+  this->InstallPath += "/";
+  this->InstallPath += this->GetOption("CPACK_PACKAGE_NAME");
+  this->InstallPath += "-";
+  this->InstallPath += this->GetOption("CPACK_PACKAGE_VERSION");
+#elif defined(__HAIKU__)
+  char dir[B_PATH_NAME_LENGTH];
+  if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir)) ==
+      B_OK) {
+    this->InstallPath = dir;
+  } else {
+    this->InstallPath = "/boot/system";
+  }
+#else
+  this->InstallPath = "/usr/local/";
+#endif
+  return this->InstallPath.c_str();
+}
+
+const char* cmCPackGenerator::GetPackagingInstallPrefix()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "GetPackagingInstallPrefix: '"
+                  << this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX") << "'"
+                  << std::endl);
+
+  return this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
+}
+
+std::string cmCPackGenerator::FindTemplate(const char* name)
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
+                  << (name ? name : "(NULL)") << std::endl);
+  std::string ffile = this->MakefileMap->GetModulesFile(name);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Found template: " << ffile
+                                                          << std::endl);
+  return ffile;
+}
+
+bool cmCPackGenerator::ConfigureString(const std::string& inString,
+                                       std::string& outString)
+{
+  this->MakefileMap->ConfigureString(inString, outString, true, false);
+  return true;
+}
+
+bool cmCPackGenerator::ConfigureFile(const char* inName, const char* outName,
+                                     bool copyOnly /* = false */)
+{
+  return this->MakefileMap->ConfigureFile(inName, outName, copyOnly, true,
+                                          false) == 1;
+}
+
+int cmCPackGenerator::CleanTemporaryDirectory()
+{
+  std::string tempInstallDirectoryWithPostfix =
+    this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
+  const char* tempInstallDirectory = tempInstallDirectoryWithPostfix.c_str();
+  if (cmsys::SystemTools::FileExists(tempInstallDirectory)) {
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "- Clean temporary : " << tempInstallDirectory << std::endl);
+    if (!cmSystemTools::RepeatedRemoveDirectory(tempInstallDirectory)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem removing temporary directory: "
+                      << tempInstallDirectory << std::endl);
+      return 0;
+    }
+  }
+  return 1;
+}
+
+cmInstalledFile const* cmCPackGenerator::GetInstalledFile(
+  std::string const& name) const
+{
+  cmake const* cm = this->MakefileMap->GetCMakeInstance();
+  return cm->GetInstalledFile(name);
+}
+
+int cmCPackGenerator::PrepareGroupingKind()
+{
+  // find a component package method specified by the user
+  ComponentPackageMethod method = UNKNOWN_COMPONENT_PACKAGE_METHOD;
+
+  if (this->GetOption("CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE")) {
+    method = ONE_PACKAGE;
+  }
+
+  if (this->GetOption("CPACK_COMPONENTS_IGNORE_GROUPS")) {
+    method = ONE_PACKAGE_PER_COMPONENT;
+  }
+
+  if (this->GetOption("CPACK_COMPONENTS_ONE_PACKAGE_PER_GROUP")) {
+    method = ONE_PACKAGE_PER_GROUP;
+  }
+
+  std::string groupingType;
+
+  // Second way to specify grouping
+  if (nullptr != this->GetOption("CPACK_COMPONENTS_GROUPING")) {
+    groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
+  }
+
+  if (!groupingType.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
+                    << this->Name << "]"
+                    << " requested component grouping = " << groupingType
+                    << std::endl);
+    if (groupingType == "ALL_COMPONENTS_IN_ONE") {
+      method = ONE_PACKAGE;
+    } else if (groupingType == "IGNORE") {
+      method = ONE_PACKAGE_PER_COMPONENT;
+    } else if (groupingType == "ONE_PER_GROUP") {
+      method = ONE_PACKAGE_PER_GROUP;
+    } else {
+      cmCPackLogger(
+        cmCPackLog::LOG_WARNING, "["
+          << this->Name << "]"
+          << " requested component grouping type <" << groupingType
+          << "> UNKNOWN not in (ALL_COMPONENTS_IN_ONE,IGNORE,ONE_PER_GROUP)"
+          << std::endl);
+    }
+  }
+
+  // Some components were defined but NO group
+  // fallback to default if not group based
+  if (method == ONE_PACKAGE_PER_GROUP && this->ComponentGroups.empty() &&
+      !this->Components.empty()) {
+    if (componentPackageMethod == ONE_PACKAGE) {
+      method = ONE_PACKAGE;
+    } else {
+      method = ONE_PACKAGE_PER_COMPONENT;
+    }
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING, "["
+        << this->Name << "]"
+        << " One package per component group requested, "
+        << "but NO component groups exist: Ignoring component group."
+        << std::endl);
+  }
+
+  // if user specified packaging method, override the default packaging method
+  if (method != UNKNOWN_COMPONENT_PACKAGE_METHOD) {
+    componentPackageMethod = method;
+  }
+
+  const char* method_names[] = { "ALL_COMPONENTS_IN_ONE", "IGNORE_GROUPS",
+                                 "ONE_PER_GROUP" };
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
+                  << this->Name << "]"
+                  << " requested component grouping = "
+                  << method_names[componentPackageMethod] << std::endl);
+
+  return 1;
+}
+
+std::string cmCPackGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  return componentName;
+}
+std::string cmCPackGenerator::GetComponentPackageFileName(
+  const std::string& initialPackageFileName,
+  const std::string& groupOrComponentName, bool isGroupName)
+{
+
+  /*
+   * the default behavior is to use the
+   * component [group] name as a suffix
+   */
+  std::string suffix = "-" + groupOrComponentName;
+  /* check if we should use DISPLAY name */
+  std::string dispNameVar = "CPACK_" + Name + "_USE_DISPLAY_NAME_IN_FILENAME";
+  if (IsOn(dispNameVar)) {
+    /* the component Group case */
+    if (isGroupName) {
+      std::string groupDispVar = "CPACK_COMPONENT_GROUP_" +
+        cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+      const char* groupDispName = GetOption(groupDispVar);
+      if (groupDispName) {
+        suffix = "-" + std::string(groupDispName);
+      }
+    }
+    /* the [single] component case */
+    else {
+      std::string dispVar = "CPACK_COMPONENT_" +
+        cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+      const char* dispName = GetOption(dispVar);
+      if (dispName) {
+        suffix = "-" + std::string(dispName);
+      }
+    }
+  }
+  return initialPackageFileName + suffix;
+}
+
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SUPPORTED;
+}
+
+bool cmCPackGenerator::SupportsAbsoluteDestination() const
+{
+  return true;
+}
+
+bool cmCPackGenerator::SupportsComponentInstallation() const
+{
+  return false;
+}
+
+bool cmCPackGenerator::WantsComponentInstallation() const
+{
+  return (!IsOn("CPACK_MONOLITHIC_INSTALL") && SupportsComponentInstallation()
+          // check that we have at least one group or component
+          && (!this->ComponentGroups.empty() || !this->Components.empty()));
+}
+
+cmCPackInstallationType* cmCPackGenerator::GetInstallationType(
+  const std::string& projectName, const std::string& name)
+{
+  (void)projectName;
+  bool hasInstallationType = this->InstallationTypes.count(name) != 0;
+  cmCPackInstallationType* installType = &this->InstallationTypes[name];
+  if (!hasInstallationType) {
+    // Define the installation type
+    std::string macroPrefix =
+      "CPACK_INSTALL_TYPE_" + cmsys::SystemTools::UpperCase(name);
+    installType->Name = name;
+
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
+      installType->DisplayName = displayName;
+    } else {
+      installType->DisplayName = installType->Name;
+    }
+
+    installType->Index = static_cast<unsigned>(this->InstallationTypes.size());
+  }
+  return installType;
+}
+
+cmCPackComponent* cmCPackGenerator::GetComponent(
+  const std::string& projectName, const std::string& name)
+{
+  bool hasComponent = this->Components.count(name) != 0;
+  cmCPackComponent* component = &this->Components[name];
+  if (!hasComponent) {
+    // Define the component
+    std::string macroPrefix =
+      "CPACK_COMPONENT_" + cmsys::SystemTools::UpperCase(name);
+    component->Name = name;
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
+      component->DisplayName = displayName;
+    } else {
+      component->DisplayName = component->Name;
+    }
+    component->IsHidden = this->IsOn(macroPrefix + "_HIDDEN");
+    component->IsRequired = this->IsOn(macroPrefix + "_REQUIRED");
+    component->IsDisabledByDefault = this->IsOn(macroPrefix + "_DISABLED");
+    component->IsDownloaded = this->IsOn(macroPrefix + "_DOWNLOADED") ||
+      cmSystemTools::IsOn(this->GetOption("CPACK_DOWNLOAD_ALL"));
+
+    const char* archiveFile = this->GetOption(macroPrefix + "_ARCHIVE_FILE");
+    if (archiveFile && *archiveFile) {
+      component->ArchiveFile = archiveFile;
+    }
+
+    const char* plist = this->GetOption(macroPrefix + "_PLIST");
+    if (plist && *plist) {
+      component->Plist = plist;
+    }
+
+    const char* groupName = this->GetOption(macroPrefix + "_GROUP");
+    if (groupName && *groupName) {
+      component->Group = GetComponentGroup(projectName, groupName);
+      component->Group->Components.push_back(component);
+    } else {
+      component->Group = nullptr;
+    }
+
+    const char* description = this->GetOption(macroPrefix + "_DESCRIPTION");
+    if (description && *description) {
+      component->Description = description;
+    }
+
+    // Determine the installation types.
+    const char* installTypes = this->GetOption(macroPrefix + "_INSTALL_TYPES");
+    if (installTypes && *installTypes) {
+      std::vector<std::string> installTypesVector;
+      cmSystemTools::ExpandListArgument(installTypes, installTypesVector);
+      std::vector<std::string>::iterator installTypesIt;
+      for (std::string const& installType : installTypesVector) {
+        component->InstallationTypes.push_back(
+          this->GetInstallationType(projectName, installType));
+      }
+    }
+
+    // Determine the component dependencies.
+    const char* depends = this->GetOption(macroPrefix + "_DEPENDS");
+    if (depends && *depends) {
+      std::vector<std::string> dependsVector;
+      cmSystemTools::ExpandListArgument(depends, dependsVector);
+      std::vector<std::string>::iterator dependIt;
+      for (std::string const& depend : dependsVector) {
+        cmCPackComponent* child = GetComponent(projectName, depend);
+        component->Dependencies.push_back(child);
+        child->ReverseDependencies.push_back(component);
+      }
+    }
+  }
+  return component;
+}
+
+cmCPackComponentGroup* cmCPackGenerator::GetComponentGroup(
+  const std::string& projectName, const std::string& name)
+{
+  (void)projectName;
+  std::string macroPrefix =
+    "CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(name);
+  bool hasGroup = this->ComponentGroups.count(name) != 0;
+  cmCPackComponentGroup* group = &this->ComponentGroups[name];
+  if (!hasGroup) {
+    // Define the group
+    group->Name = name;
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
+      group->DisplayName = displayName;
+    } else {
+      group->DisplayName = group->Name;
+    }
+
+    const char* description = this->GetOption(macroPrefix + "_DESCRIPTION");
+    if (description && *description) {
+      group->Description = description;
+    }
+    group->IsBold = this->IsOn(macroPrefix + "_BOLD_TITLE");
+    group->IsExpandedByDefault = this->IsOn(macroPrefix + "_EXPANDED");
+    const char* parentGroupName =
+      this->GetOption(macroPrefix + "_PARENT_GROUP");
+    if (parentGroupName && *parentGroupName) {
+      group->ParentGroup = GetComponentGroup(projectName, parentGroupName);
+      group->ParentGroup->Subgroups.push_back(group);
+    } else {
+      group->ParentGroup = nullptr;
+    }
+  }
+  return group;
+}
diff --git a/Source/CPack/cmCPackGenerator.h b/Source/CPack/cmCPackGenerator.h
new file mode 100644
index 0000000..c22f36b
--- /dev/null
+++ b/Source/CPack/cmCPackGenerator.h
@@ -0,0 +1,329 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackGenerator_h
+#define cmCPackGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cmCPackComponentGroup.h"
+#include "cmSystemTools.h"
+#include "cm_sys_stat.h"
+
+class cmCPackLog;
+class cmInstalledFile;
+class cmMakefile;
+
+/** \class cmCPackGenerator
+ * \brief A superclass of all CPack Generators
+ *
+ */
+class cmCPackGenerator
+{
+public:
+  virtual const char* GetNameOfClass() = 0;
+  /**
+   * If verbose then more information is printed out
+   */
+  void SetVerbose(bool val)
+  {
+    this->GeneratorVerbose =
+      val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE;
+  }
+
+  /**
+   * Put underlying cmake scripts in trace mode.
+   */
+  void SetTrace(bool val) { this->Trace = val; }
+
+  /**
+   * Put underlying cmake scripts in expanded trace mode.
+   */
+  void SetTraceExpand(bool val) { this->TraceExpand = val; }
+
+  /**
+   * Returns true if the generator may work on this system.
+   * Rational:
+   * Some CPack generator may run on some host and may not on others
+   * (with the same system) because some tools are missing. If the tool
+   * is missing then CPack won't activate (in the CPackGeneratorFactory)
+   * this particular generator.
+   */
+  static bool CanGenerate() { return true; }
+
+  /**
+   * Do the actual whole package processing.
+   * Subclass may redefine it but its usually enough
+   * to redefine @ref PackageFiles, because in fact
+   * this method do call:
+   *     - PrepareName
+   *     - clean-up temp dirs
+   *     - InstallProject (with the appropriate method)
+   *     - prepare list of files and/or components to be package
+   *     - PackageFiles
+   *     - Copy produced packages at the expected place
+   * @return 0 if error.
+   */
+  virtual int DoPackage();
+
+  /**
+   * Initialize generator
+   */
+  int Initialize(const std::string& name, cmMakefile* mf);
+
+  /**
+   * Construct generator
+   */
+  cmCPackGenerator();
+  virtual ~cmCPackGenerator();
+
+  //! Set and get the options
+  void SetOption(const std::string& op, const char* value);
+  void SetOptionIfNotSet(const std::string& op, const char* value);
+  const char* GetOption(const std::string& op) const;
+  std::vector<std::string> GetOptions() const;
+  bool IsSet(const std::string& name) const;
+  bool IsOn(const std::string& name) const;
+  bool IsSetToOff(const std::string& op) const;
+  bool IsSetToEmpty(const std::string& op) const;
+
+  //! Set the logger
+  void SetLogger(cmCPackLog* log) { this->Logger = log; }
+
+  //! Display verbose information via logger
+  void DisplayVerboseOutput(const char* msg, float progress);
+
+  bool ReadListFile(const char* moduleName);
+
+protected:
+  /**
+   * Prepare common used names by inspecting
+   * several CPACK_xxx var values.
+   */
+  int PrepareNames();
+
+  /**
+   * Install the project using appropriate method.
+   */
+  int InstallProject();
+
+  int CleanTemporaryDirectory();
+
+  cmInstalledFile const* GetInstalledFile(std::string const& name) const;
+
+  virtual const char* GetOutputExtension() { return ".cpack"; }
+  virtual const char* GetOutputPostfix() { return nullptr; }
+
+  /**
+   * Prepare requested grouping kind from CPACK_xxx vars
+   * CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE
+   * CPACK_COMPONENTS_IGNORE_GROUPS
+   * or
+   * CPACK_COMPONENTS_ONE_PACKAGE_PER_GROUP
+   * @return 1 on success 0 on failure.
+   */
+  virtual int PrepareGroupingKind();
+
+  /**
+   * Some CPack generators may prefer to have
+   * CPack install all components belonging to the same
+   * [component] group to be install in the same directory.
+   * The default behavior is to install each component in
+   * a separate directory.
+   * @param[in] componentName the name of the component to be installed
+   * @return the name suffix the generator wants for the specified component
+   *         default is "componentName"
+   */
+  virtual std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName);
+
+  /**
+   * CPack specific generator may mangle CPACK_PACKAGE_FILE_NAME
+   * with CPACK_COMPONENT_xxxx_<NAME>_DISPLAY_NAME if
+   * CPACK_<GEN>_USE_DISPLAY_NAME_IN_FILENAME is ON.
+   * @param[in] initialPackageFileName the initial package name to be mangled
+   * @param[in] groupOrComponentName the name of the group/component
+   * @param[in] isGroupName true if previous name refers to a group,
+   *            false otherwise
+   */
+  virtual std::string GetComponentPackageFileName(
+    const std::string& initialPackageFileName,
+    const std::string& groupOrComponentName, bool isGroupName);
+
+  /**
+   * Package the list of files and/or components which
+   * has been prepared by the beginning of DoPackage.
+   * @pre the @ref toplevel has been filled-in
+   * @pre the list of file @ref files has been populated
+   * @pre packageFileNames contains at least 1 entry
+   * @post packageFileNames may have been updated and contains
+   *       the list of packages generated by the specific generator.
+   */
+  virtual int PackageFiles();
+  virtual const char* GetInstallPath();
+  virtual const char* GetPackagingInstallPrefix();
+
+  virtual std::string FindTemplate(const char* name);
+  virtual bool ConfigureFile(const char* inName, const char* outName,
+                             bool copyOnly = false);
+  virtual bool ConfigureString(const std::string& input, std::string& output);
+  virtual int InitializeInternal();
+
+  //! Run install commands if specified
+  virtual int InstallProjectViaInstallCommands(
+    bool setDestDir, const std::string& tempInstallDirectory);
+  virtual int InstallProjectViaInstallScript(
+    bool setDestDir, const std::string& tempInstallDirectory);
+  virtual int InstallProjectViaInstalledDirectories(
+    bool setDestDir, const std::string& tempInstallDirectory,
+    const mode_t* default_dir_mode);
+  virtual int InstallProjectViaInstallCMakeProjects(
+    bool setDestDir, const std::string& tempInstallDirectory,
+    const mode_t* default_dir_mode);
+
+  /**
+   * The various level of support of
+   * CPACK_SET_DESTDIR used by the generator.
+   */
+  enum CPackSetDestdirSupport
+  {
+    /* the generator works with or without it */
+    SETDESTDIR_SUPPORTED,
+    /* the generator works best if automatically handled */
+    SETDESTDIR_INTERNALLY_SUPPORTED,
+    /* no official support, use at your own risk */
+    SETDESTDIR_SHOULD_NOT_BE_USED,
+    /* officially NOT supported */
+    SETDESTDIR_UNSUPPORTED
+  };
+
+  /**
+   * Does the CPack generator support CPACK_SET_DESTDIR?
+   * The default legacy value is 'SETDESTDIR_SUPPORTED' generator
+   * have to override it in order change this.
+   * @return CPackSetDestdirSupport
+   */
+  virtual enum CPackSetDestdirSupport SupportsSetDestdir() const;
+
+  /**
+   * Does the CPack generator support absolute path
+   * in INSTALL DESTINATION?
+   * The default legacy value is 'true' generator
+   * have to override it in order change this.
+   * @return true if supported false otherwise
+   */
+  virtual bool SupportsAbsoluteDestination() const;
+
+  /**
+   * Does the CPack generator support component installation?.
+   * Some Generators requires the user to set
+   * CPACK_<GENNAME>_COMPONENT_INSTALL in order to make this
+   * method return true.
+   * @return true if supported, false otherwise
+   */
+  virtual bool SupportsComponentInstallation() const;
+  /**
+   * Does the currently running generator want a component installation.
+   * The generator may support component installation but he may
+   * be requiring monolithic install using CPACK_MONOLITHIC_INSTALL.
+   * @return true if component installation is supported and wanted.
+   */
+  virtual bool WantsComponentInstallation() const;
+  virtual cmCPackInstallationType* GetInstallationType(
+    const std::string& projectName, const std::string& name);
+  virtual cmCPackComponent* GetComponent(const std::string& projectName,
+                                         const std::string& name);
+  virtual cmCPackComponentGroup* GetComponentGroup(
+    const std::string& projectName, const std::string& name);
+
+  cmSystemTools::OutputOption GeneratorVerbose;
+  std::string Name;
+
+  std::string InstallPath;
+
+  /**
+   * The list of package file names.
+   * At beginning of DoPackage the (generic) generator will populate
+   * the list of desired package file names then it will
+   * call the redefined method PackageFiles which is may
+   * either use this set of names (usually on entry there should be
+   * only a single name) or update the vector with the list
+   * of created package file names.
+   */
+  std::vector<std::string> packageFileNames;
+
+  /**
+   * The directory where all the files to be packaged reside.
+   * If the installer support components there will be one
+   * sub-directory for each component. In those directories
+   * one will find the file belonging to the specified component.
+   */
+  std::string toplevel;
+
+  /**
+   * The complete list of files to be packaged.
+   * This list will be populated by DoPackage before
+   * PackageFiles is called.
+   */
+  std::vector<std::string> files;
+
+  std::map<std::string, cmCPackInstallationType> InstallationTypes;
+  /**
+   * The set of components.
+   * If component installation is supported then this map
+   * contains the component specified in CPACK_COMPONENTS_ALL
+   */
+  std::map<std::string, cmCPackComponent> Components;
+  std::map<std::string, cmCPackComponentGroup> ComponentGroups;
+
+  /**
+   * If components are enabled, this enum represents the different
+   * ways of mapping components to package files.
+   */
+  enum ComponentPackageMethod
+  {
+    /* one package for all components */
+    ONE_PACKAGE,
+    /* one package for each component */
+    ONE_PACKAGE_PER_COMPONENT,
+    /* one package for each group,
+     * with left over components in their own package */
+    ONE_PACKAGE_PER_GROUP,
+    UNKNOWN_COMPONENT_PACKAGE_METHOD
+  };
+
+  /**
+   * The component package method
+   * The default is ONE_PACKAGE_PER_GROUP,
+   * and generators may override the default
+   * before PrepareGroupingKind() is called.
+   */
+  ComponentPackageMethod componentPackageMethod;
+
+  cmCPackLog* Logger;
+  bool Trace;
+  bool TraceExpand;
+
+private:
+  cmMakefile* MakefileMap;
+};
+
+#define cmCPackTypeMacro(klass, superclass)                                   \
+  typedef superclass Superclass;                                              \
+  const char* GetNameOfClass() override { return #klass; }                    \
+  static cmCPackGenerator* CreateGenerator() { return new klass; }            \
+  class cmCPackTypeMacro_UseTrailingSemicolon
+
+#define cmCPackLogger(logType, msg)                                           \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    this->Logger->Log(logType, __FILE__, __LINE__,                            \
+                      cmCPackLog_msg.str().c_str());                          \
+  } while (false)
+
+#endif
diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx
new file mode 100644
index 0000000..47e7527
--- /dev/null
+++ b/Source/CPack/cmCPackGeneratorFactory.cxx
@@ -0,0 +1,184 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackGeneratorFactory.h"
+
+#include <ostream>
+#include <utility>
+
+#include "IFW/cmCPackIFWGenerator.h"
+#include "cmAlgorithms.h"
+#include "cmCPack7zGenerator.h"
+#ifdef HAVE_FREEBSD_PKG
+#include "cmCPackFreeBSDGenerator.h"
+#endif
+#include "cmCPackDebGenerator.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmCPackNSISGenerator.h"
+#include "cmCPackSTGZGenerator.h"
+#include "cmCPackTGZGenerator.h"
+#include "cmCPackTXZGenerator.h"
+#include "cmCPackTarBZip2Generator.h"
+#include "cmCPackTarCompressGenerator.h"
+#include "cmCPackZIPGenerator.h"
+
+#ifdef __APPLE__
+#include "cmCPackBundleGenerator.h"
+#include "cmCPackDragNDropGenerator.h"
+#include "cmCPackOSXX11Generator.h"
+#include "cmCPackPackageMakerGenerator.h"
+#include "cmCPackProductBuildGenerator.h"
+#endif
+
+#ifdef __CYGWIN__
+#include "cmCPackCygwinBinaryGenerator.h"
+#include "cmCPackCygwinSourceGenerator.h"
+#endif
+
+#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
+  !defined(__HAIKU__)
+#include "cmCPackRPMGenerator.h"
+#endif
+
+#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_LIBUUID))
+#include "WiX/cmCPackWIXGenerator.h"
+#endif
+
+cmCPackGeneratorFactory::cmCPackGeneratorFactory()
+{
+  if (cmCPackTGZGenerator::CanGenerate()) {
+    this->RegisterGenerator("TGZ", "Tar GZip compression",
+                            cmCPackTGZGenerator::CreateGenerator);
+  }
+  if (cmCPackTXZGenerator::CanGenerate()) {
+    this->RegisterGenerator("TXZ", "Tar XZ compression",
+                            cmCPackTXZGenerator::CreateGenerator);
+  }
+  if (cmCPackSTGZGenerator::CanGenerate()) {
+    this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
+                            cmCPackSTGZGenerator::CreateGenerator);
+  }
+  if (cmCPackNSISGenerator::CanGenerate()) {
+    this->RegisterGenerator("NSIS", "Null Soft Installer",
+                            cmCPackNSISGenerator::CreateGenerator);
+    this->RegisterGenerator("NSIS64", "Null Soft Installer (64-bit)",
+                            cmCPackNSISGenerator::CreateGenerator64);
+  }
+  if (cmCPackIFWGenerator::CanGenerate()) {
+    this->RegisterGenerator("IFW", "Qt Installer Framework",
+                            cmCPackIFWGenerator::CreateGenerator);
+  }
+#ifdef __CYGWIN__
+  if (cmCPackCygwinBinaryGenerator::CanGenerate()) {
+    this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
+                            cmCPackCygwinBinaryGenerator::CreateGenerator);
+  }
+  if (cmCPackCygwinSourceGenerator::CanGenerate()) {
+    this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
+                            cmCPackCygwinSourceGenerator::CreateGenerator);
+  }
+#endif
+
+  if (cmCPackZIPGenerator::CanGenerate()) {
+    this->RegisterGenerator("ZIP", "ZIP file format",
+                            cmCPackZIPGenerator::CreateGenerator);
+  }
+  if (cmCPack7zGenerator::CanGenerate()) {
+    this->RegisterGenerator("7Z", "7-Zip file format",
+                            cmCPack7zGenerator::CreateGenerator);
+  }
+#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_LIBUUID))
+  if (cmCPackWIXGenerator::CanGenerate()) {
+    this->RegisterGenerator("WIX", "MSI file format via WiX tools",
+                            cmCPackWIXGenerator::CreateGenerator);
+  }
+#endif
+  if (cmCPackTarBZip2Generator::CanGenerate()) {
+    this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
+                            cmCPackTarBZip2Generator::CreateGenerator);
+  }
+  if (cmCPackTarCompressGenerator::CanGenerate()) {
+    this->RegisterGenerator("TZ", "Tar Compress compression",
+                            cmCPackTarCompressGenerator::CreateGenerator);
+  }
+  if (cmCPackDebGenerator::CanGenerate()) {
+    this->RegisterGenerator("DEB", "Debian packages",
+                            cmCPackDebGenerator::CreateGenerator);
+  }
+#ifdef __APPLE__
+  if (cmCPackDragNDropGenerator::CanGenerate()) {
+    this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
+                            cmCPackDragNDropGenerator::CreateGenerator);
+  }
+  if (cmCPackBundleGenerator::CanGenerate()) {
+    this->RegisterGenerator("Bundle", "Mac OSX bundle",
+                            cmCPackBundleGenerator::CreateGenerator);
+  }
+  if (cmCPackPackageMakerGenerator::CanGenerate()) {
+    this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
+                            cmCPackPackageMakerGenerator::CreateGenerator);
+  }
+  if (cmCPackOSXX11Generator::CanGenerate()) {
+    this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
+                            cmCPackOSXX11Generator::CreateGenerator);
+  }
+  if (cmCPackProductBuildGenerator::CanGenerate()) {
+    this->RegisterGenerator("productbuild", "Mac OSX pkg",
+                            cmCPackProductBuildGenerator::CreateGenerator);
+  }
+#endif
+#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
+  !defined(__HAIKU__)
+  if (cmCPackRPMGenerator::CanGenerate()) {
+    this->RegisterGenerator("RPM", "RPM packages",
+                            cmCPackRPMGenerator::CreateGenerator);
+  }
+#endif
+#ifdef HAVE_FREEBSD_PKG
+  if (cmCPackFreeBSDGenerator::CanGenerate()) {
+    this->RegisterGenerator("FREEBSD", "FreeBSD pkg(8) packages",
+                            cmCPackFreeBSDGenerator::CreateGenerator);
+  }
+#endif
+}
+
+cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
+{
+  cmDeleteAll(this->Generators);
+}
+
+cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
+  const std::string& name)
+{
+  cmCPackGenerator* gen = this->NewGeneratorInternal(name);
+  if (!gen) {
+    return nullptr;
+  }
+  this->Generators.push_back(gen);
+  gen->SetLogger(this->Logger);
+  return gen;
+}
+
+cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
+  const std::string& name)
+{
+  cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it =
+    this->GeneratorCreators.find(name);
+  if (it == this->GeneratorCreators.end()) {
+    return nullptr;
+  }
+  return (it->second)();
+}
+
+void cmCPackGeneratorFactory::RegisterGenerator(
+  const std::string& name, const char* generatorDescription,
+  CreateGeneratorCall* createGenerator)
+{
+  if (!createGenerator) {
+    cmCPack_Log(this->Logger, cmCPackLog::LOG_ERROR,
+                "Cannot register generator" << std::endl);
+    return;
+  }
+  this->GeneratorCreators[name] = createGenerator;
+  this->GeneratorDescriptions[name] = generatorDescription;
+}
diff --git a/Source/CPack/cmCPackGeneratorFactory.h b/Source/CPack/cmCPackGeneratorFactory.h
new file mode 100644
index 0000000..7f633e4
--- /dev/null
+++ b/Source/CPack/cmCPackGeneratorFactory.h
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackGeneratorFactory_h
+#define cmCPackGeneratorFactory_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCPackGenerator;
+class cmCPackLog;
+
+/** \class cmCPackGeneratorFactory
+ * \brief A container for CPack generators
+ *
+ */
+class cmCPackGeneratorFactory
+{
+public:
+  cmCPackGeneratorFactory();
+  ~cmCPackGeneratorFactory();
+
+  //! Get the generator
+  cmCPackGenerator* NewGenerator(const std::string& name);
+  void DeleteGenerator(cmCPackGenerator* gen);
+
+  typedef cmCPackGenerator* CreateGeneratorCall();
+
+  void RegisterGenerator(const std::string& name,
+                         const char* generatorDescription,
+                         CreateGeneratorCall* createGenerator);
+
+  void SetLogger(cmCPackLog* logger) { this->Logger = logger; }
+
+  typedef std::map<std::string, std::string> DescriptionsMap;
+  const DescriptionsMap& GetGeneratorsList() const
+  {
+    return this->GeneratorDescriptions;
+  }
+
+private:
+  cmCPackGenerator* NewGeneratorInternal(const std::string& name);
+  std::vector<cmCPackGenerator*> Generators;
+
+  typedef std::map<std::string, CreateGeneratorCall*> t_GeneratorCreatorsMap;
+  t_GeneratorCreatorsMap GeneratorCreators;
+  DescriptionsMap GeneratorDescriptions;
+  cmCPackLog* Logger;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackLog.cxx b/Source/CPack/cmCPackLog.cxx
new file mode 100644
index 0000000..a3ca4b5
--- /dev/null
+++ b/Source/CPack/cmCPackLog.cxx
@@ -0,0 +1,180 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackLog.h"
+
+#include <iostream>
+
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+cmCPackLog::cmCPackLog()
+{
+  this->Verbose = false;
+  this->Debug = false;
+  this->Quiet = false;
+  this->NewLine = true;
+
+  this->LastTag = cmCPackLog::NOTAG;
+  this->DefaultOutput = &std::cout;
+  this->DefaultError = &std::cerr;
+
+  this->LogOutput = nullptr;
+  this->LogOutputCleanup = false;
+}
+
+cmCPackLog::~cmCPackLog()
+{
+  this->SetLogOutputStream(nullptr);
+}
+
+void cmCPackLog::SetLogOutputStream(std::ostream* os)
+{
+  if (this->LogOutputCleanup && this->LogOutput) {
+    delete this->LogOutput;
+  }
+  this->LogOutputCleanup = false;
+  this->LogOutput = os;
+}
+
+bool cmCPackLog::SetLogOutputFile(const char* fname)
+{
+  cmGeneratedFileStream* cg = nullptr;
+  if (fname) {
+    cg = new cmGeneratedFileStream(fname);
+  }
+  if (cg && !*cg) {
+    delete cg;
+    cg = nullptr;
+  }
+  this->SetLogOutputStream(cg);
+  if (!cg) {
+    return false;
+  }
+  this->LogOutputCleanup = true;
+  return true;
+}
+
+void cmCPackLog::Log(int tag, const char* file, int line, const char* msg,
+                     size_t length)
+{
+  // By default no logging
+  bool display = false;
+
+  // Display file and line number if debug
+  bool useFileAndLine = this->Debug;
+
+  bool output = false;
+  bool debug = false;
+  bool warning = false;
+  bool error = false;
+  bool verbose = false;
+
+  // When writing in file, add list of tags whenever tag changes.
+  std::string tagString;
+  bool needTagString = false;
+  if (this->LogOutput && this->LastTag != tag) {
+    needTagString = true;
+  }
+
+  if (tag & LOG_OUTPUT) {
+    output = true;
+    display = true;
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
+      }
+      tagString = "VERBOSE";
+    }
+  }
+  if (tag & LOG_WARNING) {
+    warning = true;
+    display = true;
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
+      }
+      tagString = "WARNING";
+    }
+  }
+  if (tag & LOG_ERROR) {
+    error = true;
+    display = true;
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
+      }
+      tagString = "ERROR";
+    }
+  }
+  if (tag & LOG_DEBUG && this->Debug) {
+    debug = true;
+    display = true;
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
+      }
+      tagString = "DEBUG";
+    }
+    useFileAndLine = true;
+  }
+  if (tag & LOG_VERBOSE && this->Verbose) {
+    verbose = true;
+    display = true;
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
+      }
+      tagString = "VERBOSE";
+    }
+  }
+  if (this->Quiet) {
+    display = false;
+  }
+  if (this->LogOutput) {
+    if (needTagString) {
+      *this->LogOutput << "[" << file << ":" << line << " " << tagString
+                       << "] ";
+    }
+    this->LogOutput->write(msg, length);
+  }
+  this->LastTag = tag;
+  if (!display) {
+    return;
+  }
+  if (this->NewLine) {
+    if (error && !this->ErrorPrefix.empty()) {
+      *this->DefaultError << this->ErrorPrefix;
+    } else if (warning && !this->WarningPrefix.empty()) {
+      *this->DefaultError << this->WarningPrefix;
+    } else if (output && !this->OutputPrefix.empty()) {
+      *this->DefaultOutput << this->OutputPrefix;
+    } else if (verbose && !this->VerbosePrefix.empty()) {
+      *this->DefaultOutput << this->VerbosePrefix;
+    } else if (debug && !this->DebugPrefix.empty()) {
+      *this->DefaultOutput << this->DebugPrefix;
+    } else if (!this->Prefix.empty()) {
+      *this->DefaultOutput << this->Prefix;
+    }
+    if (useFileAndLine) {
+      if (error || warning) {
+        *this->DefaultError << file << ":" << line << " ";
+      } else {
+        *this->DefaultOutput << file << ":" << line << " ";
+      }
+    }
+  }
+  if (error || warning) {
+    this->DefaultError->write(msg, length);
+    this->DefaultError->flush();
+  } else {
+    this->DefaultOutput->write(msg, length);
+    this->DefaultOutput->flush();
+  }
+  if (msg[length - 1] == '\n' || length > 2) {
+    this->NewLine = true;
+  }
+
+  if (error) {
+    cmSystemTools::SetErrorOccured();
+  }
+}
diff --git a/Source/CPack/cmCPackLog.h b/Source/CPack/cmCPackLog.h
new file mode 100644
index 0000000..10deda4
--- /dev/null
+++ b/Source/CPack/cmCPackLog.h
@@ -0,0 +1,140 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackLog_h
+#define cmCPackLog_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <ostream>
+#include <string.h>
+#include <string>
+
+#define cmCPack_Log(ctSelf, logType, msg)                                     \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    (ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str()); \
+  } while (false)
+
+/** \class cmCPackLog
+ * \brief A container for CPack generators
+ *
+ */
+class cmCPackLog
+{
+public:
+  cmCPackLog();
+  ~cmCPackLog();
+
+  enum __log_tags
+  {
+    NOTAG = 0,
+    LOG_OUTPUT = 0x1,
+    LOG_VERBOSE = 0x2,
+    LOG_DEBUG = 0x4,
+    LOG_WARNING = 0x8,
+    LOG_ERROR = 0x10
+  };
+
+  //! Various signatures for logging.
+  void Log(const char* file, int line, const char* msg)
+  {
+    this->Log(LOG_OUTPUT, file, line, msg);
+  }
+  void Log(const char* file, int line, const char* msg, size_t length)
+  {
+    this->Log(LOG_OUTPUT, file, line, msg, length);
+  }
+  void Log(int tag, const char* file, int line, const char* msg)
+  {
+    this->Log(tag, file, line, msg, strlen(msg));
+  }
+  void Log(int tag, const char* file, int line, const char* msg,
+           size_t length);
+
+  //! Set Verbose
+  void VerboseOn() { this->SetVerbose(true); }
+  void VerboseOff() { this->SetVerbose(true); }
+  void SetVerbose(bool verb) { this->Verbose = verb; }
+  bool GetVerbose() { return this->Verbose; }
+
+  //! Set Debug
+  void DebugOn() { this->SetDebug(true); }
+  void DebugOff() { this->SetDebug(true); }
+  void SetDebug(bool verb) { this->Debug = verb; }
+  bool GetDebug() { return this->Debug; }
+
+  //! Set Quiet
+  void QuietOn() { this->SetQuiet(true); }
+  void QuietOff() { this->SetQuiet(true); }
+  void SetQuiet(bool verb) { this->Quiet = verb; }
+  bool GetQuiet() { return this->Quiet; }
+
+  //! Set the output stream
+  void SetOutputStream(std::ostream* os) { this->DefaultOutput = os; }
+
+  //! Set the error stream
+  void SetErrorStream(std::ostream* os) { this->DefaultError = os; }
+
+  //! Set the log output stream
+  void SetLogOutputStream(std::ostream* os);
+
+  //! Set the log output file. The cmCPackLog will try to create file. If it
+  // cannot, it will report an error.
+  bool SetLogOutputFile(const char* fname);
+
+  //! Set the various prefixes for the logging. SetPrefix sets the generic
+  // prefix that overwrittes missing ones.
+  void SetPrefix(std::string const& pfx) { this->Prefix = pfx; }
+  void SetOutputPrefix(std::string const& pfx) { this->OutputPrefix = pfx; }
+  void SetVerbosePrefix(std::string const& pfx) { this->VerbosePrefix = pfx; }
+  void SetDebugPrefix(std::string const& pfx) { this->DebugPrefix = pfx; }
+  void SetWarningPrefix(std::string const& pfx) { this->WarningPrefix = pfx; }
+  void SetErrorPrefix(std::string const& pfx) { this->ErrorPrefix = pfx; }
+
+private:
+  bool Verbose;
+  bool Debug;
+  bool Quiet;
+
+  bool NewLine;
+
+  int LastTag;
+
+  std::string Prefix;
+  std::string OutputPrefix;
+  std::string VerbosePrefix;
+  std::string DebugPrefix;
+  std::string WarningPrefix;
+  std::string ErrorPrefix;
+
+  std::ostream* DefaultOutput;
+  std::ostream* DefaultError;
+
+  std::string LogOutputFileName;
+  std::ostream* LogOutput;
+  // Do we need to cleanup log output stream
+  bool LogOutputCleanup;
+};
+
+class cmCPackLogWrite
+{
+public:
+  cmCPackLogWrite(const char* data, size_t length)
+    : Data(data)
+    , Length(length)
+  {
+  }
+
+  const char* Data;
+  size_t Length;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const cmCPackLogWrite& c)
+{
+  os.write(c.Data, c.Length);
+  os.flush();
+  return os;
+}
+
+#endif
diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
new file mode 100644
index 0000000..ddf104c
--- /dev/null
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
@@ -0,0 +1,909 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackNSISGenerator.h"
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <map>
+#include <sstream>
+#include <stdlib.h>
+#include <string.h>
+#include <utility>
+
+/* NSIS uses different command line syntax on Windows and others */
+#ifdef _WIN32
+#define NSIS_OPT "/"
+#else
+#define NSIS_OPT "-"
+#endif
+
+cmCPackNSISGenerator::cmCPackNSISGenerator(bool nsis64)
+{
+  Nsis64 = nsis64;
+}
+
+cmCPackNSISGenerator::~cmCPackNSISGenerator()
+{
+}
+
+int cmCPackNSISGenerator::PackageFiles()
+{
+  // TODO: Fix nsis to force out file name
+
+  std::string nsisInFileName = this->FindTemplate("NSIS.template.in");
+  if (nsisInFileName.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPack error: Could not find NSIS installer template file."
+                    << std::endl);
+    return false;
+  }
+  std::string nsisInInstallOptions =
+    this->FindTemplate("NSIS.InstallOptions.ini.in");
+  if (nsisInInstallOptions.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "CPack error: Could not find NSIS installer options file."
+                    << std::endl);
+    return false;
+  }
+
+  std::string nsisFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  std::string tmpFile = nsisFileName;
+  tmpFile += "/NSISOutput.log";
+  std::string nsisInstallOptions = nsisFileName + "/NSIS.InstallOptions.ini";
+  nsisFileName += "/project.nsi";
+  std::ostringstream str;
+  for (std::string const& file : files) {
+    std::string outputDir = "$INSTDIR";
+    std::string fileN =
+      cmSystemTools::RelativePath(toplevel.c_str(), file.c_str());
+    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) {
+        const std::string componentName = fileN.substr(0, pos);
+        outputDir = CustomComponentInstallDirectory(componentName);
+      } else {
+        outputDir = CustomComponentInstallDirectory(fileN);
+      }
+
+      // Strip off the component part of the path.
+      fileN = fileN.substr(pos + 1);
+    }
+    std::replace(fileN.begin(), fileN.end(), '/', '\\');
+
+    str << "  Delete \"" << outputDir << "\\" << fileN << "\"" << std::endl;
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Files: " << str.str()
+                                                           << std::endl);
+  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_FILES", str.str().c_str());
+  std::vector<std::string> dirs;
+  this->GetListOfSubdirectories(toplevel.c_str(), dirs);
+  std::ostringstream dstr;
+  for (std::string const& dir : dirs) {
+    std::string componentName;
+    std::string fileN =
+      cmSystemTools::RelativePath(toplevel.c_str(), dir.c_str());
+    if (fileN.empty()) {
+      continue;
+    }
+    if (!Components.empty()) {
+      // If this is a component installation, strip off the component
+      // part of the path.
+      std::string::size_type slash = fileN.find('/');
+      if (slash != std::string::npos) {
+        // If this is a component installation, determine which component it
+        // is.
+        componentName = fileN.substr(0, slash);
+
+        // Strip off the component part of the path.
+        fileN = fileN.substr(slash + 1);
+      }
+    }
+    std::replace(fileN.begin(), fileN.end(), '/', '\\');
+
+    const std::string componentOutputDir =
+      CustomComponentInstallDirectory(componentName);
+
+    dstr << "  RMDir \"" << componentOutputDir << "\\" << fileN << "\""
+         << std::endl;
+    if (!componentName.empty()) {
+      this->Components[componentName].Directories.push_back(fileN);
+    }
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Dirs: " << dstr.str()
+                                                          << std::endl);
+  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_DIRECTORIES", dstr.str().c_str());
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
+                  << nsisInFileName << " to " << nsisFileName << std::endl);
+  if (this->IsSet("CPACK_NSIS_MUI_ICON") ||
+      this->IsSet("CPACK_NSIS_MUI_UNIICON")) {
+    std::string installerIconCode;
+    if (this->IsSet("CPACK_NSIS_MUI_ICON")) {
+      installerIconCode += "!define MUI_ICON \"";
+      installerIconCode += this->GetOption("CPACK_NSIS_MUI_ICON");
+      installerIconCode += "\"\n";
+    }
+    if (this->IsSet("CPACK_NSIS_MUI_UNIICON")) {
+      installerIconCode += "!define MUI_UNICON \"";
+      installerIconCode += this->GetOption("CPACK_NSIS_MUI_UNIICON");
+      installerIconCode += "\"\n";
+    }
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_ICON_CODE",
+                            installerIconCode.c_str());
+  }
+  if (this->IsSet("CPACK_PACKAGE_ICON")) {
+    std::string installerIconCode = "!define MUI_HEADERIMAGE_BITMAP \"";
+    installerIconCode += this->GetOption("CPACK_PACKAGE_ICON");
+    installerIconCode += "\"\n";
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_ICON_CODE",
+                            installerIconCode.c_str());
+  }
+
+  if (this->IsSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP")) {
+    std::string installerBitmapCode =
+      "!define MUI_WELCOMEFINISHPAGE_BITMAP \"";
+    installerBitmapCode +=
+      this->GetOption("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP");
+    installerBitmapCode += "\"\n";
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE",
+                            installerBitmapCode.c_str());
+  }
+
+  if (this->IsSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP")) {
+    std::string installerBitmapCode =
+      "!define MUI_UNWELCOMEFINISHPAGE_BITMAP \"";
+    installerBitmapCode +=
+      this->GetOption("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP");
+    installerBitmapCode += "\"\n";
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE",
+                            installerBitmapCode.c_str());
+  }
+
+  if (this->IsSet("CPACK_NSIS_MUI_FINISHPAGE_RUN")) {
+    std::string installerRunCode = "!define MUI_FINISHPAGE_RUN \"$INSTDIR\\";
+    installerRunCode += this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
+    installerRunCode += "\\";
+    installerRunCode += this->GetOption("CPACK_NSIS_MUI_FINISHPAGE_RUN");
+    installerRunCode += "\"\n";
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_FINISHPAGE_RUN_CODE",
+                            installerRunCode.c_str());
+  }
+
+  // Setup all of the component sections
+  if (this->Components.empty()) {
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLATION_TYPES", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_PAGE_COMPONENTS", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_FULL_INSTALL",
+                            "File /r \"${INST_DIR}\\*.*\"");
+    this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTIONS", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTION_LIST", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_SECTION_SELECTED_VARS", "");
+  } else {
+    std::string componentCode;
+    std::string sectionList;
+    std::string selectedVarsList;
+    std::string componentDescriptions;
+    std::string groupDescriptions;
+    std::string installTypesCode;
+    std::string defines;
+    std::ostringstream macrosOut;
+    bool anyDownloadedComponents = false;
+
+    // Create installation types. The order is significant, so we first fill
+    // in a vector based on the indices, and print them in that order.
+    std::vector<cmCPackInstallationType*> installTypes(
+      this->InstallationTypes.size());
+    for (auto& installType : this->InstallationTypes) {
+      installTypes[installType.second.Index - 1] = &installType.second;
+    }
+    for (cmCPackInstallationType* installType : installTypes) {
+      installTypesCode += "InstType \"";
+      installTypesCode += installType->DisplayName;
+      installTypesCode += "\"\n";
+    }
+
+    // Create installation groups first
+    for (auto& group : this->ComponentGroups) {
+      if (group.second.ParentGroup == nullptr) {
+        componentCode +=
+          this->CreateComponentGroupDescription(&group.second, macrosOut);
+      }
+
+      // Add the group description, if any.
+      if (!group.second.Description.empty()) {
+        groupDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${" +
+          group.first + "} \"" +
+          this->TranslateNewlines(group.second.Description) + "\"\n";
+      }
+    }
+
+    // Create the remaining components, which aren't associated with groups.
+    for (auto& comp : this->Components) {
+      if (comp.second.Files.empty()) {
+        // NSIS cannot cope with components that have no files.
+        continue;
+      }
+
+      anyDownloadedComponents =
+        anyDownloadedComponents || comp.second.IsDownloaded;
+
+      if (!comp.second.Group) {
+        componentCode +=
+          this->CreateComponentDescription(&comp.second, macrosOut);
+      }
+
+      // Add this component to the various section lists.
+      sectionList += "  !insertmacro \"${MacroName}\" \"";
+      sectionList += comp.first;
+      sectionList += "\"\n";
+      selectedVarsList += "Var " + comp.first + "_selected\n";
+      selectedVarsList += "Var " + comp.first + "_was_installed\n";
+
+      // Add the component description, if any.
+      if (!comp.second.Description.empty()) {
+        componentDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${" +
+          comp.first + "} \"" +
+          this->TranslateNewlines(comp.second.Description) + "\"\n";
+      }
+    }
+
+    componentCode += macrosOut.str();
+
+    if (componentDescriptions.empty() && groupDescriptions.empty()) {
+      // Turn off the "Description" box
+      this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC",
+                              "!define MUI_COMPONENTSPAGE_NODESC");
+    } else {
+      componentDescriptions = "!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN\n" +
+        componentDescriptions + groupDescriptions +
+        "!insertmacro MUI_FUNCTION_DESCRIPTION_END\n";
+      this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC",
+                              componentDescriptions.c_str());
+    }
+
+    if (anyDownloadedComponents) {
+      defines += "!define CPACK_USES_DOWNLOAD\n";
+      if (cmSystemTools::IsOn(this->GetOption("CPACK_ADD_REMOVE"))) {
+        defines += "!define CPACK_NSIS_ADD_REMOVE\n";
+      }
+    }
+
+    this->SetOptionIfNotSet("CPACK_NSIS_INSTALLATION_TYPES",
+                            installTypesCode.c_str());
+    this->SetOptionIfNotSet("CPACK_NSIS_PAGE_COMPONENTS",
+                            "!insertmacro MUI_PAGE_COMPONENTS");
+    this->SetOptionIfNotSet("CPACK_NSIS_FULL_INSTALL", "");
+    this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTIONS",
+                            componentCode.c_str());
+    this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTION_LIST",
+                            sectionList.c_str());
+    this->SetOptionIfNotSet("CPACK_NSIS_SECTION_SELECTED_VARS",
+                            selectedVarsList.c_str());
+    this->SetOption("CPACK_NSIS_DEFINES", defines.c_str());
+  }
+
+  this->ConfigureFile(nsisInInstallOptions.c_str(),
+                      nsisInstallOptions.c_str());
+  this->ConfigureFile(nsisInFileName.c_str(), nsisFileName.c_str());
+  std::string nsisCmd = "\"";
+  nsisCmd += this->GetOption("CPACK_INSTALLER_PROGRAM");
+  nsisCmd += "\" \"" + nsisFileName + "\"";
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << nsisCmd << std::endl);
+  std::string output;
+  int retVal = 1;
+  bool res =
+    cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output, &output, &retVal,
+                                    nullptr, this->GeneratorVerbose, 0);
+  if (!res || retVal) {
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << nsisCmd << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running NSIS command: "
+                    << nsisCmd << std::endl
+                    << "Please check " << tmpFile << " for errors"
+                    << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+int cmCPackNSISGenerator::InitializeInternal()
+{
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY"))) {
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING,
+      "NSIS Generator cannot work with CPACK_INCLUDE_TOPLEVEL_DIRECTORY set. "
+      "This option will be reset to 0 (for this generator only)."
+        << std::endl);
+    this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", nullptr);
+  }
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackNSISGenerator::Initialize()"
+                  << std::endl);
+  std::vector<std::string> path;
+  std::string nsisPath;
+  bool gotRegValue = false;
+
+#ifdef _WIN32
+  if (Nsis64) {
+    if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                          "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode",
+                          nsisPath, cmsys::SystemTools::KeyWOW64_64)) {
+      gotRegValue = true;
+    }
+    if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                          "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
+                          cmsys::SystemTools::KeyWOW64_64)) {
+      gotRegValue = true;
+    }
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode",
+                        nsisPath, cmsys::SystemTools::KeyWOW64_32)) {
+    gotRegValue = true;
+  }
+  if (!gotRegValue &&
+      cmsys::SystemTools::ReadRegistryValue(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode", nsisPath)) {
+    gotRegValue = true;
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
+                        cmsys::SystemTools::KeyWOW64_32)) {
+    gotRegValue = true;
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath)) {
+    gotRegValue = true;
+  }
+
+  if (gotRegValue) {
+    path.push_back(nsisPath);
+  }
+#endif
+
+  nsisPath = cmSystemTools::FindProgram("makensis", path, false);
+
+  if (nsisPath.empty()) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Cannot find NSIS compiler makensis: likely it is not installed, "
+      "or not in your PATH"
+        << std::endl);
+
+    if (!gotRegValue) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "Could not read NSIS registry value. This is usually caused by "
+        "NSIS not being installed. Please install NSIS from "
+        "http://nsis.sourceforge.net"
+          << std::endl);
+    }
+
+    return 0;
+  }
+
+  std::string nsisCmd = "\"" + nsisPath + "\" " NSIS_OPT "VERSION";
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Test NSIS version: " << nsisCmd
+                                                               << std::endl);
+  std::string output;
+  int retVal = 1;
+  bool resS =
+    cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output, &output, &retVal,
+                                    nullptr, this->GeneratorVerbose, 0);
+  cmsys::RegularExpression versionRex("v([0-9]+.[0-9]+)");
+  cmsys::RegularExpression versionRexCVS("v(.*)\\.cvs");
+  if (!resS || retVal ||
+      (!versionRex.find(output) && !versionRexCVS.find(output))) {
+    const char* topDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    std::string tmpFile = topDir ? topDir : ".";
+    tmpFile += "/NSISOutput.log";
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << nsisCmd << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Problem checking NSIS version with command: "
+        << nsisCmd << std::endl
+        << "Please check " << tmpFile << " for errors" << std::endl);
+    return 0;
+  }
+  if (versionRex.find(output)) {
+    double nsisVersion = atof(versionRex.match(1).c_str());
+    double minNSISVersion = 2.09;
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: " << nsisVersion
+                                                          << std::endl);
+    if (nsisVersion < minNSISVersion) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "CPack requires NSIS Version 2.09 or greater.  "
+                    "NSIS found on the system was: "
+                      << nsisVersion << std::endl);
+      return 0;
+    }
+  }
+  if (versionRexCVS.find(output)) {
+    // No version check for NSIS cvs build
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: CVS "
+                    << versionRexCVS.match(1) << std::endl);
+  }
+  this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", nsisPath.c_str());
+  this->SetOptionIfNotSet("CPACK_NSIS_EXECUTABLES_DIRECTORY", "bin");
+  const char* cpackPackageExecutables =
+    this->GetOption("CPACK_PACKAGE_EXECUTABLES");
+  const char* cpackPackageDeskTopLinks =
+    this->GetOption("CPACK_CREATE_DESKTOP_LINKS");
+  const char* cpackNsisExecutablesDirectory =
+    this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
+  std::vector<std::string> cpackPackageDesktopLinksVector;
+  if (cpackPackageDeskTopLinks) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
+                    << cpackPackageDeskTopLinks << std::endl);
+
+    cmSystemTools::ExpandListArgument(cpackPackageDeskTopLinks,
+                                      cpackPackageDesktopLinksVector);
+    for (std::string const& cpdl : cpackPackageDesktopLinksVector) {
+      cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                    "CPACK_CREATE_DESKTOP_LINKS: " << cpdl << std::endl);
+    }
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
+                    << "not set" << std::endl);
+  }
+
+  std::ostringstream str;
+  std::ostringstream deleteStr;
+
+  if (cpackPackageExecutables) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
+                    << cpackPackageExecutables << "." << std::endl);
+    std::vector<std::string> cpackPackageExecutablesVector;
+    cmSystemTools::ExpandListArgument(cpackPackageExecutables,
+                                      cpackPackageExecutablesVector);
+    if (cpackPackageExecutablesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
+        "<icon name>."
+          << std::endl);
+      return 0;
+    }
+    std::vector<std::string>::iterator it;
+    for (it = cpackPackageExecutablesVector.begin();
+         it != cpackPackageExecutablesVector.end(); ++it) {
+      std::string execName = *it;
+      ++it;
+      std::string linkName = *it;
+      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << cpackNsisExecutablesDirectory << "\\"
+          << execName << ".exe\"" << std::endl;
+      deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
+                << ".lnk\"" << std::endl;
+      // see if CPACK_CREATE_DESKTOP_LINK_ExeName is on
+      // if so add a desktop link
+      if (!cpackPackageDesktopLinksVector.empty() &&
+          std::find(cpackPackageDesktopLinksVector.begin(),
+                    cpackPackageDesktopLinksVector.end(),
+                    execName) != cpackPackageDesktopLinksVector.end()) {
+        str << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
+        str << "    CreateShortCut \"$DESKTOP\\" << linkName
+            << ".lnk\" \"$INSTDIR\\" << cpackNsisExecutablesDirectory << "\\"
+            << execName << ".exe\"" << std::endl;
+        deleteStr << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
+        deleteStr << "    Delete \"$DESKTOP\\" << linkName << ".lnk\""
+                  << std::endl;
+      }
+    }
+  }
+
+  this->CreateMenuLinks(str, deleteStr);
+  this->SetOptionIfNotSet("CPACK_NSIS_CREATE_ICONS", str.str().c_str());
+  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_ICONS", deleteStr.str().c_str());
+
+  this->SetOptionIfNotSet("CPACK_NSIS_COMPRESSOR", "lzma");
+
+  return this->Superclass::InitializeInternal();
+}
+
+void cmCPackNSISGenerator::CreateMenuLinks(std::ostream& str,
+                                           std::ostream& deleteStr)
+{
+  const char* cpackMenuLinks = this->GetOption("CPACK_NSIS_MENU_LINKS");
+  if (!cpackMenuLinks) {
+    return;
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "The cpackMenuLinks: " << cpackMenuLinks << "." << std::endl);
+  std::vector<std::string> cpackMenuLinksVector;
+  cmSystemTools::ExpandListArgument(cpackMenuLinks, cpackMenuLinksVector);
+  if (cpackMenuLinksVector.size() % 2 != 0) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "CPACK_NSIS_MENU_LINKS should contain pairs of <shortcut target> and "
+      "<shortcut label>."
+        << std::endl);
+    return;
+  }
+
+  static cmsys::RegularExpression urlRegex(
+    "^(mailto:|(ftps?|https?|news)://).*$");
+
+  std::vector<std::string>::iterator it;
+  for (it = cpackMenuLinksVector.begin(); it != cpackMenuLinksVector.end();
+       ++it) {
+    std::string sourceName = *it;
+    const bool url = urlRegex.find(sourceName);
+
+    // Convert / to \ in filenames, but not in urls:
+    //
+    if (!url) {
+      std::replace(sourceName.begin(), sourceName.end(), '/', '\\');
+    }
+
+    ++it;
+    std::string linkName = *it;
+    if (!url) {
+      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << sourceName << "\"" << std::endl;
+      deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
+                << ".lnk\"" << std::endl;
+    } else {
+      str << "  WriteINIStr \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".url\" \"InternetShortcut\" \"URL\" \"" << sourceName << "\""
+          << std::endl;
+      deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
+                << ".url\"" << std::endl;
+    }
+    // see if CPACK_CREATE_DESKTOP_LINK_ExeName is on
+    // if so add a desktop link
+    std::string desktop = "CPACK_CREATE_DESKTOP_LINK_";
+    desktop += linkName;
+    if (this->IsSet(desktop)) {
+      str << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
+      str << "    CreateShortCut \"$DESKTOP\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << sourceName << "\"" << std::endl;
+      deleteStr << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
+      deleteStr << "    Delete \"$DESKTOP\\" << linkName << ".lnk\""
+                << std::endl;
+    }
+  }
+}
+
+bool cmCPackNSISGenerator::GetListOfSubdirectories(
+  const char* topdir, std::vector<std::string>& dirs)
+{
+  cmsys::Directory dir;
+  dir.Load(topdir);
+  for (unsigned long i = 0; i < dir.GetNumberOfFiles(); ++i) {
+    const char* fileName = dir.GetFile(i);
+    if (strcmp(fileName, ".") != 0 && strcmp(fileName, "..") != 0) {
+      std::string const fullPath =
+        std::string(topdir).append("/").append(fileName);
+      if (cmsys::SystemTools::FileIsDirectory(fullPath) &&
+          !cmsys::SystemTools::FileIsSymlink(fullPath)) {
+        if (!this->GetListOfSubdirectories(fullPath.c_str(), dirs)) {
+          return false;
+        }
+      }
+    }
+  }
+  dirs.push_back(topdir);
+  return true;
+}
+
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackNSISGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
+}
+
+bool cmCPackNSISGenerator::SupportsAbsoluteDestination() const
+{
+  return false;
+}
+
+bool cmCPackNSISGenerator::SupportsComponentInstallation() const
+{
+  return true;
+}
+
+std::string cmCPackNSISGenerator::CreateComponentDescription(
+  cmCPackComponent* component, std::ostream& macrosOut)
+{
+  // Basic description of the component
+  std::string componentCode = "Section ";
+  if (component->IsDisabledByDefault) {
+    componentCode += "/o ";
+  }
+  componentCode += "\"";
+  if (component->IsHidden) {
+    componentCode += "-";
+  }
+  componentCode += component->DisplayName + "\" " + component->Name + "\n";
+  if (component->IsRequired) {
+    componentCode += "  SectionIn RO\n";
+  } else if (!component->InstallationTypes.empty()) {
+    std::ostringstream out;
+    for (cmCPackInstallationType const* installType :
+         component->InstallationTypes) {
+      out << " " << installType->Index;
+    }
+    componentCode += "  SectionIn" + out.str() + "\n";
+  }
+
+  const std::string componentOutputDir =
+    CustomComponentInstallDirectory(component->Name);
+  componentCode += "  SetOutPath \"" + componentOutputDir + "\"\n";
+
+  // Create the actual installation commands
+  if (component->IsDownloaded) {
+    if (component->ArchiveFile.empty()) {
+      // Compute the name of the archive.
+      std::string packagesDir = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+      packagesDir += ".dummy";
+      std::ostringstream out;
+      out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir) << "-"
+          << component->Name << ".zip";
+      component->ArchiveFile = out.str();
+    }
+
+    // Create the directory for the upload area
+    const char* userUploadDirectory =
+      this->GetOption("CPACK_UPLOAD_DIRECTORY");
+    std::string uploadDirectory;
+    if (userUploadDirectory && *userUploadDirectory) {
+      uploadDirectory = userUploadDirectory;
+    } else {
+      uploadDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
+      uploadDirectory += "/CPackUploads";
+    }
+    if (!cmSystemTools::FileExists(uploadDirectory.c_str())) {
+      if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str())) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Unable to create NSIS upload directory "
+                        << uploadDirectory << std::endl);
+        return "";
+      }
+    }
+
+    // Remove the old archive, if one exists
+    std::string archiveFile = uploadDirectory + '/' + component->ArchiveFile;
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "-   Building downloaded component archive: " << archiveFile
+                                                                << std::endl);
+    if (cmSystemTools::FileExists(archiveFile.c_str(), true)) {
+      if (!cmSystemTools::RemoveFile(archiveFile)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to remove archive file "
+                        << archiveFile << std::endl);
+        return "";
+      }
+    }
+
+    // Find a ZIP program
+    if (!this->IsSet("ZIP_EXECUTABLE")) {
+      this->ReadListFile("CPackZIP.cmake");
+
+      if (!this->IsSet("ZIP_EXECUTABLE")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to find ZIP program"
+                        << std::endl);
+        return "";
+      }
+    }
+
+    // The directory where this component's files reside
+    std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+    dirName += '/';
+    dirName += component->Name;
+    dirName += '/';
+
+    // Build the list of files to go into this archive, and determine the
+    // size of the installed component.
+    std::string zipListFileName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+    zipListFileName += "/winZip.filelist";
+    bool needQuotesInFile =
+      cmSystemTools::IsOn(this->GetOption("CPACK_ZIP_NEED_QUOTES"));
+    unsigned long totalSize = 0;
+    { // the scope is needed for cmGeneratedFileStream
+      cmGeneratedFileStream out(zipListFileName.c_str());
+      for (std::string const& file : component->Files) {
+        if (needQuotesInFile) {
+          out << "\"";
+        }
+        out << file;
+        if (needQuotesInFile) {
+          out << "\"";
+        }
+        out << std::endl;
+
+        totalSize += cmSystemTools::FileLength(dirName + file);
+      }
+    }
+
+    // Build the archive in the upload area
+    std::string cmd = this->GetOption("CPACK_ZIP_COMMAND");
+    cmsys::SystemTools::ReplaceString(cmd, "<ARCHIVE>", archiveFile.c_str());
+    cmsys::SystemTools::ReplaceString(cmd, "<FILELIST>",
+                                      zipListFileName.c_str());
+    std::string output;
+    int retVal = -1;
+    int res = cmSystemTools::RunSingleCommand(cmd.c_str(), &output, &output,
+                                              &retVal, dirName.c_str(),
+                                              cmSystemTools::OUTPUT_NONE, 0);
+    if (!res || retVal) {
+      std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+      tmpFile += "/CompressZip.log";
+      cmGeneratedFileStream ofs(tmpFile.c_str());
+      ofs << "# Run command: " << cmd << std::endl
+          << "# Output:" << std::endl
+          << output << std::endl;
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running zip command: "
+                      << cmd << std::endl
+                      << "Please check " << tmpFile << " for errors"
+                      << std::endl);
+      return "";
+    }
+
+    // Create the NSIS code to download this file on-the-fly.
+    unsigned long totalSizeInKbytes = (totalSize + 512) / 1024;
+    if (totalSizeInKbytes == 0) {
+      totalSizeInKbytes = 1;
+    }
+    std::ostringstream out;
+    /* clang-format off */
+    out << "  AddSize " << totalSizeInKbytes << "\n"
+        << "  Push \"" << component->ArchiveFile << "\"\n"
+        << "  Call DownloadFile\n"
+        << "  ZipDLL::extractall \"$INSTDIR\\"
+        << component->ArchiveFile << "\" \"$INSTDIR\"\n"
+        <<  "  Pop $2 ; error message\n"
+                     "  StrCmp $2 \"success\" +2 0\n"
+                     "  MessageBox MB_OK \"Failed to unzip $2\"\n"
+                     "  Delete $INSTDIR\\$0\n";
+    /* clang-format on */
+    componentCode += out.str();
+  } else {
+    componentCode +=
+      "  File /r \"${INST_DIR}\\" + component->Name + "\\*.*\"\n";
+  }
+  componentCode += "SectionEnd\n";
+
+  // Macro used to remove the component
+  macrosOut << "!macro Remove_${" << component->Name << "}\n";
+  macrosOut << "  IntCmp $" << component->Name << "_was_installed 0 noremove_"
+            << component->Name << "\n";
+  std::string path;
+  for (std::string const& pathIt : component->Files) {
+    path = pathIt;
+    std::replace(path.begin(), path.end(), '/', '\\');
+    macrosOut << "  Delete \"" << componentOutputDir << "\\" << path << "\"\n";
+  }
+  for (std::string const& pathIt : component->Directories) {
+    path = pathIt;
+    std::replace(path.begin(), path.end(), '/', '\\');
+    macrosOut << "  RMDir \"" << componentOutputDir << "\\" << path << "\"\n";
+  }
+  macrosOut << "  noremove_" << component->Name << ":\n";
+  macrosOut << "!macroend\n";
+
+  // Macro used to select each of the components that this component
+  // depends on.
+  std::set<cmCPackComponent*> visited;
+  macrosOut << "!macro Select_" << component->Name << "_depends\n";
+  macrosOut << 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 << "!macroend\n";
+  return componentCode;
+}
+
+std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription(
+  cmCPackComponent* component, std::set<cmCPackComponent*>& visited)
+{
+  // Don't visit a component twice
+  if (visited.count(component)) {
+    return std::string();
+  }
+  visited.insert(component);
+
+  std::ostringstream out;
+  for (cmCPackComponent* depend : component->Dependencies) {
+    // Write NSIS code to select this dependency
+    out << "  SectionGetFlags ${" << depend->Name << "} $0\n";
+    out << "  IntOp $0 $0 | ${SF_SELECTED}\n";
+    out << "  SectionSetFlags ${" << depend->Name << "} $0\n";
+    out << "  IntOp $" << depend->Name << "_selected 0 + ${SF_SELECTED}\n";
+    // Recurse
+    out << CreateSelectionDependenciesDescription(depend, visited).c_str();
+  }
+
+  return out.str();
+}
+
+std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription(
+  cmCPackComponent* component, std::set<cmCPackComponent*>& visited)
+{
+  // Don't visit a component twice
+  if (visited.count(component)) {
+    return std::string();
+  }
+  visited.insert(component);
+
+  std::ostringstream out;
+  for (cmCPackComponent* depend : component->ReverseDependencies) {
+    // Write NSIS code to deselect this dependency
+    out << "  SectionGetFlags ${" << depend->Name << "} $0\n";
+    out << "  IntOp $1 ${SF_SELECTED} ~\n";
+    out << "  IntOp $0 $0 & $1\n";
+    out << "  SectionSetFlags ${" << depend->Name << "} $0\n";
+    out << "  IntOp $" << depend->Name << "_selected 0 + 0\n";
+
+    // Recurse
+    out << CreateDeselectionDependenciesDescription(depend, visited).c_str();
+  }
+
+  return out.str();
+}
+
+std::string cmCPackNSISGenerator::CreateComponentGroupDescription(
+  cmCPackComponentGroup* group, std::ostream& macrosOut)
+{
+  if (group->Components.empty() && group->Subgroups.empty()) {
+    // Silently skip empty groups. NSIS doesn't support them.
+    return std::string();
+  }
+
+  std::string code = "SectionGroup ";
+  if (group->IsExpandedByDefault) {
+    code += "/e ";
+  }
+  if (group->IsBold) {
+    code += "\"!" + group->DisplayName + "\" " + group->Name + "\n";
+  } else {
+    code += "\"" + group->DisplayName + "\" " + group->Name + "\n";
+  }
+
+  for (cmCPackComponentGroup* g : group->Subgroups) {
+    code += this->CreateComponentGroupDescription(g, macrosOut);
+  }
+
+  for (cmCPackComponent* comp : group->Components) {
+    if (comp->Files.empty()) {
+      continue;
+    }
+
+    code += this->CreateComponentDescription(comp, macrosOut);
+  }
+  code += "SectionGroupEnd\n";
+  return code;
+}
+
+std::string cmCPackNSISGenerator::CustomComponentInstallDirectory(
+  const std::string& componentName)
+{
+  const char* outputDir =
+    this->GetOption("CPACK_NSIS_" + componentName + "_INSTALL_DIRECTORY");
+  const std::string componentOutputDir = (outputDir ? outputDir : "$INSTDIR");
+  return componentOutputDir;
+}
+
+std::string cmCPackNSISGenerator::TranslateNewlines(std::string str)
+{
+  cmSystemTools::ReplaceString(str, "\n", "$\\r$\\n");
+  return str;
+}
diff --git a/Source/CPack/cmCPackNSISGenerator.h b/Source/CPack/cmCPackNSISGenerator.h
new file mode 100644
index 0000000..fc9ad9a
--- /dev/null
+++ b/Source/CPack/cmCPackNSISGenerator.h
@@ -0,0 +1,88 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackNSISGenerator_h
+#define cmCPackNSISGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackGenerator.h"
+
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmCPackComponent;
+class cmCPackComponentGroup;
+
+/** \class cmCPackNSISGenerator
+ * \brief A generator for NSIS files
+ *
+ * http://people.freebsd.org/~kientzle/libarchive/
+ */
+class cmCPackNSISGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackNSISGenerator, cmCPackGenerator);
+
+  static cmCPackGenerator* CreateGenerator64()
+  {
+    return new cmCPackNSISGenerator(true);
+  }
+
+  /**
+   * Construct generator
+   */
+  cmCPackNSISGenerator(bool nsis64 = false);
+  ~cmCPackNSISGenerator() override;
+
+protected:
+  int InitializeInternal() override;
+  void CreateMenuLinks(std::ostream& str, std::ostream& deleteStr);
+  int PackageFiles() override;
+  const char* GetOutputExtension() override { return ".exe"; }
+  const char* GetOutputPostfix() override { return "win32"; }
+
+  bool GetListOfSubdirectories(const char* dir,
+                               std::vector<std::string>& dirs);
+
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir()
+    const override;
+  bool SupportsAbsoluteDestination() const override;
+  bool SupportsComponentInstallation() const override;
+
+  /// Produce a string that contains the NSIS code to describe a
+  /// particular component. Any added macros will be emitted via
+  /// macrosOut.
+  std::string CreateComponentDescription(cmCPackComponent* component,
+                                         std::ostream& macrosOut);
+
+  /// Produce NSIS code that selects all of the components that this component
+  /// depends on, recursively.
+  std::string CreateSelectionDependenciesDescription(
+    cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
+
+  /// Produce NSIS code that de-selects all of the components that are
+  /// dependent on this component, recursively.
+  std::string CreateDeselectionDependenciesDescription(
+    cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
+
+  /// Produce a string that contains the NSIS code to describe a
+  /// particular component group, including its components. Any
+  /// added macros will be emitted via macrosOut.
+  std::string CreateComponentGroupDescription(cmCPackComponentGroup* group,
+                                              std::ostream& macrosOut);
+
+  /// Returns the custom install directory if available for the specified
+  /// component, otherwise $INSTDIR is returned.
+  std::string CustomComponentInstallDirectory(
+    const std::string& componentName);
+
+  /// Translations any newlines found in the string into \\r\\n, so that the
+  /// resulting string can be used within NSIS.
+  static std::string TranslateNewlines(std::string str);
+
+  bool Nsis64;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx
new file mode 100644
index 0000000..8d3c40c
--- /dev/null
+++ b/Source/CPack/cmCPackOSXX11Generator.cxx
@@ -0,0 +1,277 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackOSXX11Generator.h"
+
+#include <sstream>
+
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cm_sys_stat.h"
+
+cmCPackOSXX11Generator::cmCPackOSXX11Generator()
+{
+}
+
+cmCPackOSXX11Generator::~cmCPackOSXX11Generator()
+{
+}
+
+int cmCPackOSXX11Generator::PackageFiles()
+{
+  // TODO: Use toplevel ?
+  //       It is used! Is this an obsolete comment?
+
+  const char* cpackPackageExecutables =
+    this->GetOption("CPACK_PACKAGE_EXECUTABLES");
+  if (cpackPackageExecutables) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
+                    << cpackPackageExecutables << "." << std::endl);
+    std::ostringstream str;
+    std::ostringstream deleteStr;
+    std::vector<std::string> cpackPackageExecutablesVector;
+    cmSystemTools::ExpandListArgument(cpackPackageExecutables,
+                                      cpackPackageExecutablesVector);
+    if (cpackPackageExecutablesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
+        "<icon name>."
+          << std::endl);
+      return 0;
+    }
+    std::vector<std::string>::iterator it;
+    for (it = cpackPackageExecutablesVector.begin();
+         it != cpackPackageExecutablesVector.end(); ++it) {
+      std::string cpackExecutableName = *it;
+      ++it;
+      this->SetOptionIfNotSet("CPACK_EXECUTABLE_NAME",
+                              cpackExecutableName.c_str());
+    }
+  }
+
+  // Disk image directories
+  std::string diskImageDirectory = toplevel;
+  std::string diskImageBackgroundImageDir =
+    diskImageDirectory + "/.background";
+
+  // App bundle directories
+  std::string packageDirFileName = toplevel;
+  packageDirFileName += "/";
+  packageDirFileName += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  packageDirFileName += ".app";
+  std::string contentsDirectory = packageDirFileName + "/Contents";
+  std::string resourcesDirectory = contentsDirectory + "/Resources";
+  std::string appDirectory = contentsDirectory + "/MacOS";
+  std::string scriptDirectory = resourcesDirectory + "/Scripts";
+  std::string resourceFileName = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  resourceFileName += ".rsrc";
+
+  const char* dir = resourcesDirectory.c_str();
+  const char* appdir = appDirectory.c_str();
+  const char* scrDir = scriptDirectory.c_str();
+  const char* contDir = contentsDirectory.c_str();
+  const char* rsrcFile = resourceFileName.c_str();
+  const char* iconFile = this->GetOption("CPACK_PACKAGE_ICON");
+  if (iconFile) {
+    std::string iconFileName = cmsys::SystemTools::GetFilenameName(iconFile);
+    if (!cmSystemTools::FileExists(iconFile)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find icon file: "
+                      << iconFile
+                      << ". Please check CPACK_PACKAGE_ICON setting."
+                      << std::endl);
+      return 0;
+    }
+    std::string destFileName = resourcesDirectory + "/" + iconFileName;
+    this->ConfigureFile(iconFile, destFileName.c_str(), true);
+    this->SetOptionIfNotSet("CPACK_APPLE_GUI_ICON", iconFileName.c_str());
+  }
+
+  std::string applicationsLinkName = diskImageDirectory + "/Applications";
+  cmSystemTools::CreateSymlink("/Applications", applicationsLinkName);
+
+  if (!this->CopyResourcePlistFile("VolumeIcon.icns", diskImageDirectory,
+                                   ".VolumeIcon.icns", true) ||
+      !this->CopyResourcePlistFile("DS_Store", diskImageDirectory, ".DS_Store",
+                                   true) ||
+      !this->CopyResourcePlistFile("background.png",
+                                   diskImageBackgroundImageDir,
+                                   "background.png", true) ||
+      !this->CopyResourcePlistFile("RuntimeScript", dir) ||
+      !this->CopyResourcePlistFile("OSXX11.Info.plist", contDir,
+                                   "Info.plist") ||
+      !this->CopyResourcePlistFile("OSXX11.main.scpt", scrDir, "main.scpt",
+                                   true) ||
+      !this->CopyResourcePlistFile("OSXScriptLauncher.rsrc", dir, rsrcFile,
+                                   true) ||
+      !this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
+                                   this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                   true)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
+                    << std::endl);
+    return 0;
+  }
+
+  // Two of the files need to have execute permission, so ensure they do:
+  std::string runTimeScript = dir;
+  runTimeScript += "/";
+  runTimeScript += "RuntimeScript";
+
+  std::string appScriptName = appdir;
+  appScriptName += "/";
+  appScriptName += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+
+  mode_t mode;
+  if (cmsys::SystemTools::GetPermissions(runTimeScript.c_str(), mode)) {
+    mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
+    cmsys::SystemTools::SetPermissions(runTimeScript.c_str(), mode);
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "Setting: " << runTimeScript << " to permission: " << mode
+                              << std::endl);
+  }
+
+  if (cmsys::SystemTools::GetPermissions(appScriptName.c_str(), mode)) {
+    mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
+    cmsys::SystemTools::SetPermissions(appScriptName.c_str(), mode);
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "Setting: " << appScriptName << " to permission: " << mode
+                              << std::endl);
+  }
+
+  std::string output;
+  std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  tmpFile += "/hdiutilOutput.log";
+  std::ostringstream dmgCmd;
+  dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
+         << "\" create -ov -fs HFS+ -format UDZO -srcfolder \""
+         << diskImageDirectory << "\" \"" << packageFileNames[0] << "\"";
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress disk image using command: "
+                  << dmgCmd.str() << std::endl);
+  // since we get random dashboard failures with this one
+  // try running it more than once
+  int retVal = 1;
+  int numTries = 10;
+  bool res = false;
+  while (numTries > 0) {
+    res = cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output,
+                                          &output, &retVal, nullptr,
+                                          this->GeneratorVerbose, 0);
+    if (res && !retVal) {
+      numTries = -1;
+      break;
+    }
+    cmSystemTools::Delay(500);
+    numTries--;
+  }
+  if (!res || retVal) {
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << dmgCmd.str() << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
+                    << dmgCmd.str() << std::endl
+                    << "Please check " << tmpFile << " for errors"
+                    << std::endl);
+    return 0;
+  }
+
+  return 1;
+}
+
+int cmCPackOSXX11Generator::InitializeInternal()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackOSXX11Generator::Initialize()"
+                  << std::endl);
+  std::vector<std::string> path;
+  std::string pkgPath = cmSystemTools::FindProgram("hdiutil", path, false);
+  if (pkgPath.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
+                          pkgPath.c_str());
+
+  return this->Superclass::InitializeInternal();
+}
+
+/*
+bool cmCPackOSXX11Generator::CopyCreateResourceFile(const std::string& name)
+{
+  std::string uname = cmSystemTools::UpperCase(name);
+  std::string cpackVar = "CPACK_RESOURCE_FILE_" + uname;
+  const char* inFileName = this->GetOption(cpackVar.c_str());
+  if ( !inFileName )
+    {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPack option: " << cpackVar.c_str()
+                  << " not specified. It should point to "
+                  << (name ? name : "(NULL)")
+                  << ".rtf, " << name
+                  << ".html, or " << name << ".txt file" << std::endl);
+    return false;
+    }
+  if ( !cmSystemTools::FileExists(inFileName) )
+    {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find "
+                  << (name ? name : "(NULL)")
+                  << " resource file: " << inFileName << std::endl);
+    return false;
+    }
+  std::string ext = cmSystemTools::GetFilenameLastExtension(inFileName);
+  if ( ext != ".rtfd" && ext != ".rtf" && ext != ".html" && ext != ".txt" )
+    {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Bad file extension specified: "
+      << ext << ". Currently only .rtfd, .rtf, .html, and .txt files allowed."
+      << std::endl);
+    return false;
+    }
+
+  std::string destFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  destFileName += "/Resources/";
+  destFileName += name + ext;
+
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
+                << (inFileName ? inFileName : "(NULL)")
+                << " to " << destFileName << std::endl);
+  this->ConfigureFile(inFileName, destFileName.c_str());
+  return true;
+}
+*/
+
+bool cmCPackOSXX11Generator::CopyResourcePlistFile(
+  const std::string& name, const std::string& dir,
+  const char* outputFileName /* = 0 */, bool copyOnly /* = false */)
+{
+  std::string inFName = "CPack.";
+  inFName += name;
+  inFName += ".in";
+  std::string inFileName = this->FindTemplate(inFName.c_str());
+  if (inFileName.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find input file: " << inFName << std::endl);
+    return false;
+  }
+
+  if (!outputFileName) {
+    outputFileName = name.c_str();
+  }
+
+  std::string destFileName = dir;
+  destFileName += "/";
+  destFileName += outputFileName;
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
+                  << inFileName << " to " << destFileName << std::endl);
+  this->ConfigureFile(inFileName.c_str(), destFileName.c_str(), copyOnly);
+  return true;
+}
+
+const char* cmCPackOSXX11Generator::GetPackagingInstallPrefix()
+{
+  this->InstallPrefix = "/";
+  this->InstallPrefix += this->GetOption("CPACK_PACKAGE_FILE_NAME");
+  this->InstallPrefix += ".app/Contents/Resources";
+  return this->InstallPrefix.c_str();
+}
diff --git a/Source/CPack/cmCPackOSXX11Generator.h b/Source/CPack/cmCPackOSXX11Generator.h
new file mode 100644
index 0000000..a6461c8
--- /dev/null
+++ b/Source/CPack/cmCPackOSXX11Generator.h
@@ -0,0 +1,42 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackOSXX11Generator_h
+#define cmCPackOSXX11Generator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackOSXX11Generator
+ * \brief A generator for OSX X11 modules
+ *
+ * Based on Gimp.app
+ */
+class cmCPackOSXX11Generator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackOSXX11Generator, cmCPackGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackOSXX11Generator();
+  ~cmCPackOSXX11Generator() override;
+
+protected:
+  virtual int InitializeInternal() override;
+  int PackageFiles() override;
+  const char* GetPackagingInstallPrefix() override;
+  const char* GetOutputExtension() override { return ".dmg"; }
+
+  // bool CopyCreateResourceFile(const std::string& name,
+  //                            const std::string& dir);
+  bool CopyResourcePlistFile(const std::string& name, const std::string& dir,
+                             const char* outputFileName = 0,
+                             bool copyOnly = false);
+  std::string InstallPrefix;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackPKGGenerator.cxx b/Source/CPack/cmCPackPKGGenerator.cxx
new file mode 100644
index 0000000..9ea8540
--- /dev/null
+++ b/Source/CPack/cmCPackPKGGenerator.cxx
@@ -0,0 +1,352 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackPKGGenerator.h"
+
+#include <vector>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+cmCPackPKGGenerator::cmCPackPKGGenerator()
+{
+  this->componentPackageMethod = ONE_PACKAGE;
+}
+
+cmCPackPKGGenerator::~cmCPackPKGGenerator()
+{
+}
+
+bool cmCPackPKGGenerator::SupportsComponentInstallation() const
+{
+  return true;
+}
+
+int cmCPackPKGGenerator::InitializeInternal()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackPKGGenerator::Initialize()"
+                  << std::endl);
+
+  return this->Superclass::InitializeInternal();
+}
+
+std::string cmCPackPKGGenerator::GetPackageName(
+  const cmCPackComponent& component)
+{
+  if (component.ArchiveFile.empty()) {
+    std::string packagesDir = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+    packagesDir += ".dummy";
+    std::ostringstream out;
+    out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir) << "-"
+        << component.Name << ".pkg";
+    return out.str();
+  }
+
+  return component.ArchiveFile + ".pkg";
+}
+
+void cmCPackPKGGenerator::WriteDistributionFile(const char* metapackageFile)
+{
+  std::string distributionTemplate =
+    this->FindTemplate("CPack.distribution.dist.in");
+  if (distributionTemplate.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
+                    << distributionTemplate << std::endl);
+    return;
+  }
+
+  std::string distributionFile = metapackageFile;
+  distributionFile += "/Contents/distribution.dist";
+
+  // Create the choice outline, which provides a tree-based view of
+  // the components in their groups.
+  std::ostringstream choiceOut;
+  cmXMLWriter xout(choiceOut, 1);
+  xout.StartElement("choices-outline");
+
+  // Emit the outline for the groups
+  std::map<std::string, cmCPackComponentGroup>::iterator groupIt;
+  for (groupIt = this->ComponentGroups.begin();
+       groupIt != this->ComponentGroups.end(); ++groupIt) {
+    if (groupIt->second.ParentGroup == nullptr) {
+      CreateChoiceOutline(groupIt->second, xout);
+    }
+  }
+
+  // Emit the outline for the non-grouped components
+  std::map<std::string, cmCPackComponent>::iterator compIt;
+  for (compIt = this->Components.begin(); compIt != this->Components.end();
+       ++compIt) {
+    if (!compIt->second.Group) {
+      xout.StartElement("line");
+      xout.Attribute("choice", compIt->first + "Choice");
+      xout.Content(""); // Avoid self-closing tag.
+      xout.EndElement();
+    }
+  }
+  if (!this->PostFlightComponent.Name.empty()) {
+    xout.StartElement("line");
+    xout.Attribute("choice", PostFlightComponent.Name + "Choice");
+    xout.Content(""); // Avoid self-closing tag.
+    xout.EndElement();
+  }
+  xout.EndElement(); // choices-outline>
+
+  // Create the actual choices
+  for (groupIt = this->ComponentGroups.begin();
+       groupIt != this->ComponentGroups.end(); ++groupIt) {
+    CreateChoice(groupIt->second, xout);
+  }
+  for (compIt = this->Components.begin(); compIt != this->Components.end();
+       ++compIt) {
+    CreateChoice(compIt->second, xout);
+  }
+
+  if (!this->PostFlightComponent.Name.empty()) {
+    CreateChoice(PostFlightComponent, xout);
+  }
+
+  this->SetOption("CPACK_PACKAGEMAKER_CHOICES", choiceOut.str().c_str());
+
+  // Create the distribution.dist file in the metapackage to turn it
+  // into a distribution package.
+  this->ConfigureFile(distributionTemplate.c_str(), distributionFile.c_str());
+}
+
+void cmCPackPKGGenerator::CreateChoiceOutline(
+  const cmCPackComponentGroup& group, cmXMLWriter& xout)
+{
+  xout.StartElement("line");
+  xout.Attribute("choice", group.Name + "Choice");
+  std::vector<cmCPackComponentGroup*>::const_iterator groupIt;
+  for (groupIt = group.Subgroups.begin(); groupIt != group.Subgroups.end();
+       ++groupIt) {
+    CreateChoiceOutline(**groupIt, xout);
+  }
+
+  std::vector<cmCPackComponent*>::const_iterator compIt;
+  for (compIt = group.Components.begin(); compIt != group.Components.end();
+       ++compIt) {
+    xout.StartElement("line");
+    xout.Attribute("choice", (*compIt)->Name + "Choice");
+    xout.Content(""); // Avoid self-closing tag.
+    xout.EndElement();
+  }
+  xout.EndElement();
+}
+
+void cmCPackPKGGenerator::CreateChoice(const cmCPackComponentGroup& group,
+                                       cmXMLWriter& xout)
+{
+  xout.StartElement("choice");
+  xout.Attribute("id", group.Name + "Choice");
+  xout.Attribute("title", group.DisplayName);
+  xout.Attribute("start_selected", "true");
+  xout.Attribute("start_enabled", "true");
+  xout.Attribute("start_visible", "true");
+  if (!group.Description.empty()) {
+    xout.Attribute("description", group.Description);
+  }
+  xout.EndElement();
+}
+
+void cmCPackPKGGenerator::CreateChoice(const cmCPackComponent& component,
+                                       cmXMLWriter& xout)
+{
+  std::string packageId = "com.";
+  packageId += this->GetOption("CPACK_PACKAGE_VENDOR");
+  packageId += '.';
+  packageId += this->GetOption("CPACK_PACKAGE_NAME");
+  packageId += '.';
+  packageId += component.Name;
+
+  xout.StartElement("choice");
+  xout.Attribute("id", component.Name + "Choice");
+  xout.Attribute("title", component.DisplayName);
+  xout.Attribute(
+    "start_selected",
+    component.IsDisabledByDefault && !component.IsRequired ? "false" : "true");
+  xout.Attribute("start_enabled", component.IsRequired ? "false" : "true");
+  xout.Attribute("start_visible", component.IsHidden ? "false" : "true");
+  if (!component.Description.empty()) {
+    xout.Attribute("description", component.Description);
+  }
+  if (!component.Dependencies.empty() ||
+      !component.ReverseDependencies.empty()) {
+    // The "selected" expression is evaluated each time any choice is
+    // selected, for all choices *except* the one that the user
+    // selected. A component is marked selected if it has been
+    // selected (my.choice.selected in Javascript) and all of the
+    // components it depends on have been selected (transitively) or
+    // if any of the components that depend on it have been selected
+    // (transitively). Assume that we have components A, B, C, D, and
+    // E, where each component depends on the previous component (B
+    // depends on A, C depends on B, D depends on C, and E depends on
+    // D). The expression we build for the component C will be
+    //   my.choice.selected && B && A || D || E
+    // This way, selecting C will automatically select everything it depends
+    // on (B and A), while selecting something that depends on C--either D
+    // or E--will automatically cause C to get selected.
+    std::ostringstream selected("my.choice.selected", std::ios_base::ate);
+    std::set<const cmCPackComponent*> visited;
+    AddDependencyAttributes(component, visited, selected);
+    visited.clear();
+    AddReverseDependencyAttributes(component, visited, selected);
+    xout.Attribute("selected", selected.str());
+  }
+  xout.StartElement("pkg-ref");
+  xout.Attribute("id", packageId);
+  xout.EndElement(); // pkg-ref
+  xout.EndElement(); // choice
+
+  // Create a description of the package associated with this
+  // component.
+  std::string relativePackageLocation = "Contents/Packages/";
+  relativePackageLocation += this->GetPackageName(component);
+
+  // Determine the installed size of the package.
+  std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  dirName += '/';
+  dirName += component.Name;
+  dirName += this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
+  unsigned long installedSize = component.GetInstalledSizeInKbytes(dirName);
+
+  xout.StartElement("pkg-ref");
+  xout.Attribute("id", packageId);
+  xout.Attribute("version", this->GetOption("CPACK_PACKAGE_VERSION"));
+  xout.Attribute("installKBytes", installedSize);
+  xout.Attribute("auth", "Admin");
+  xout.Attribute("onConclusion", "None");
+  if (component.IsDownloaded) {
+    xout.Content(this->GetOption("CPACK_DOWNLOAD_SITE"));
+    xout.Content(this->GetPackageName(component));
+  } else {
+    xout.Content("file:./");
+    xout.Content(relativePackageLocation);
+  }
+  xout.EndElement(); // pkg-ref
+}
+
+void cmCPackPKGGenerator::AddDependencyAttributes(
+  const cmCPackComponent& component,
+  std::set<const cmCPackComponent*>& visited, std::ostringstream& out)
+{
+  if (visited.find(&component) != visited.end()) {
+    return;
+  }
+  visited.insert(&component);
+
+  std::vector<cmCPackComponent*>::const_iterator dependIt;
+  for (dependIt = component.Dependencies.begin();
+       dependIt != component.Dependencies.end(); ++dependIt) {
+    out << " && choices['" << (*dependIt)->Name << "Choice'].selected";
+    AddDependencyAttributes(**dependIt, visited, out);
+  }
+}
+
+void cmCPackPKGGenerator::AddReverseDependencyAttributes(
+  const cmCPackComponent& component,
+  std::set<const cmCPackComponent*>& visited, std::ostringstream& out)
+{
+  if (visited.find(&component) != visited.end()) {
+    return;
+  }
+  visited.insert(&component);
+
+  std::vector<cmCPackComponent*>::const_iterator dependIt;
+  for (dependIt = component.ReverseDependencies.begin();
+       dependIt != component.ReverseDependencies.end(); ++dependIt) {
+    out << " || choices['" << (*dependIt)->Name << "Choice'].selected";
+    AddReverseDependencyAttributes(**dependIt, visited, out);
+  }
+}
+
+bool cmCPackPKGGenerator::CopyCreateResourceFile(const std::string& name,
+                                                 const std::string& dirName)
+{
+  std::string uname = cmSystemTools::UpperCase(name);
+  std::string cpackVar = "CPACK_RESOURCE_FILE_" + uname;
+  const char* inFileName = this->GetOption(cpackVar);
+  if (!inFileName) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPack option: "
+                    << cpackVar.c_str()
+                    << " not specified. It should point to "
+                    << (!name.empty() ? name : "<empty>") << ".rtf, " << name
+                    << ".html, or " << name << ".txt file" << std::endl);
+    return false;
+  }
+  if (!cmSystemTools::FileExists(inFileName)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find "
+                    << (!name.empty() ? name : "<empty>")
+                    << " resource file: " << inFileName << std::endl);
+    return false;
+  }
+  std::string ext = cmSystemTools::GetFilenameLastExtension(inFileName);
+  if (ext != ".rtfd" && ext != ".rtf" && ext != ".html" && ext != ".txt") {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Bad file extension specified: "
+        << ext
+        << ". Currently only .rtfd, .rtf, .html, and .txt files allowed."
+        << std::endl);
+    return false;
+  }
+
+  std::string destFileName = dirName;
+  destFileName += '/';
+  destFileName += name + ext;
+
+  // Set this so that distribution.dist gets the right name (without
+  // the path).
+  this->SetOption("CPACK_RESOURCE_FILE_" + uname + "_NOPATH",
+                  (name + ext).c_str());
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Configure file: " << (inFileName ? inFileName : "(NULL)")
+                                   << " to " << destFileName << std::endl);
+  this->ConfigureFile(inFileName, destFileName.c_str());
+  return true;
+}
+
+bool cmCPackPKGGenerator::CopyResourcePlistFile(const std::string& name,
+                                                const char* outName)
+{
+  if (!outName) {
+    outName = name.c_str();
+  }
+
+  std::string inFName = "CPack.";
+  inFName += name;
+  inFName += ".in";
+  std::string inFileName = this->FindTemplate(inFName.c_str());
+  if (inFileName.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find input file: " << inFName << std::endl);
+    return false;
+  }
+
+  std::string destFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  destFileName += "/";
+  destFileName += outName;
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
+                  << inFileName << " to " << destFileName << std::endl);
+  this->ConfigureFile(inFileName.c_str(), destFileName.c_str());
+  return true;
+}
+
+int cmCPackPKGGenerator::CopyInstallScript(const std::string& resdir,
+                                           const std::string& script,
+                                           const std::string& name)
+{
+  std::string dst = resdir;
+  dst += "/";
+  dst += name;
+  cmSystemTools::CopyFileAlways(script, dst);
+  cmSystemTools::SetPermissions(dst.c_str(), 0777);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "copy script : " << script << "\ninto " << dst << std::endl);
+
+  return 1;
+}
diff --git a/Source/CPack/cmCPackPKGGenerator.h b/Source/CPack/cmCPackPKGGenerator.h
new file mode 100644
index 0000000..69286ff
--- /dev/null
+++ b/Source/CPack/cmCPackPKGGenerator.h
@@ -0,0 +1,92 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackPKGGenerator_h
+#define cmCPackPKGGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <set>
+#include <sstream>
+#include <string>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+
+class cmXMLWriter;
+
+/** \class cmCPackPKGGenerator
+ * \brief A generator for pkg files
+ *
+ */
+class cmCPackPKGGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackPKGGenerator, cmCPackGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackPKGGenerator();
+  ~cmCPackPKGGenerator() override;
+
+  bool SupportsComponentInstallation() const override;
+
+protected:
+  int InitializeInternal() override;
+  const char* GetOutputPostfix() override { return "darwin"; }
+
+  // Copies or creates the resource file with the given name to the
+  // package or package staging directory dirName. The variable
+  // CPACK_RESOURCE_FILE_${NAME} (where ${NAME} is the uppercased
+  // version of name) specifies the input file to use for this file,
+  // which will be configured via ConfigureFile.
+  bool CopyCreateResourceFile(const std::string& name,
+                              const std::string& dirName);
+  bool CopyResourcePlistFile(const std::string& name, const char* outName = 0);
+
+  int CopyInstallScript(const std::string& resdir, const std::string& script,
+                        const std::string& name);
+
+  // Retrieve the name of package file that will be generated for this
+  // component. The name is just the file name with extension, and
+  // does not include the subdirectory.
+  std::string GetPackageName(const cmCPackComponent& component);
+
+  // Writes a distribution.dist file, which turns a metapackage into a
+  // full-fledged distribution. This file is used to describe
+  // inter-component dependencies. metapackageFile is the name of the
+  // metapackage for the distribution. Only valid for a
+  // component-based install.
+  void WriteDistributionFile(const char* metapackageFile);
+
+  // Subroutine of WriteDistributionFile that writes out the
+  // dependency attributes for inter-component dependencies.
+  void AddDependencyAttributes(const cmCPackComponent& component,
+                               std::set<const cmCPackComponent*>& visited,
+                               std::ostringstream& out);
+
+  // Subroutine of WriteDistributionFile that writes out the
+  // reverse dependency attributes for inter-component dependencies.
+  void AddReverseDependencyAttributes(
+    const cmCPackComponent& component,
+    std::set<const cmCPackComponent*>& visited, std::ostringstream& out);
+
+  // Generates XML that encodes the hierarchy of component groups and
+  // their components in a form that can be used by distribution
+  // metapackages.
+  void CreateChoiceOutline(const cmCPackComponentGroup& group,
+                           cmXMLWriter& xout);
+
+  /// Create the "choice" XML element to describe a component group
+  /// for the installer GUI.
+  void CreateChoice(const cmCPackComponentGroup& group, cmXMLWriter& xout);
+
+  /// Create the "choice" XML element to describe a component for the
+  /// installer GUI.
+  void CreateChoice(const cmCPackComponent& component, cmXMLWriter& xout);
+
+  // The PostFlight component when creating a metapackage
+  cmCPackComponent PostFlightComponent;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx
new file mode 100644
index 0000000..dbcb022
--- /dev/null
+++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx
@@ -0,0 +1,576 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackPackageMakerGenerator.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <assert.h>
+#include <map>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+static inline unsigned int getVersion(unsigned int major, unsigned int minor)
+{
+  assert(major < 256 && minor < 256);
+  return ((major & 0xFF) << 16 | minor);
+}
+
+cmCPackPackageMakerGenerator::cmCPackPackageMakerGenerator()
+{
+  this->PackageMakerVersion = 0.0;
+  this->PackageCompatibilityVersion = getVersion(10, 4);
+}
+
+cmCPackPackageMakerGenerator::~cmCPackPackageMakerGenerator()
+{
+}
+
+bool cmCPackPackageMakerGenerator::SupportsComponentInstallation() const
+{
+  return this->PackageCompatibilityVersion >= getVersion(10, 4);
+}
+
+int cmCPackPackageMakerGenerator::PackageFiles()
+{
+  // TODO: Use toplevel
+  //       It is used! Is this an obsolete comment?
+
+  std::string resDir; // Where this package's resources will go.
+  std::string packageDirFileName =
+    this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  if (this->Components.empty()) {
+    packageDirFileName += ".pkg";
+    resDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    resDir += "/Resources";
+  } else {
+    packageDirFileName += ".mpkg";
+    if (!cmsys::SystemTools::MakeDirectory(packageDirFileName.c_str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "unable to create package directory " << packageDirFileName
+                                                          << std::endl);
+      return 0;
+    }
+
+    resDir = packageDirFileName;
+    resDir += "/Contents";
+    if (!cmsys::SystemTools::MakeDirectory(resDir.c_str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "unable to create package subdirectory " << resDir
+                                                             << std::endl);
+      return 0;
+    }
+
+    resDir += "/Resources";
+    if (!cmsys::SystemTools::MakeDirectory(resDir.c_str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "unable to create package subdirectory " << resDir
+                                                             << std::endl);
+      return 0;
+    }
+
+    resDir += "/en.lproj";
+  }
+
+  const char* preflight = this->GetOption("CPACK_PREFLIGHT_SCRIPT");
+  const char* postflight = this->GetOption("CPACK_POSTFLIGHT_SCRIPT");
+  const char* postupgrade = this->GetOption("CPACK_POSTUPGRADE_SCRIPT");
+
+  if (this->Components.empty()) {
+    // Create directory structure
+    std::string preflightDirName = resDir + "/PreFlight";
+    std::string postflightDirName = resDir + "/PostFlight";
+    // if preflight or postflight scripts not there create directories
+    // of the same name, I think this makes it work
+    if (!preflight) {
+      if (!cmsys::SystemTools::MakeDirectory(preflightDirName.c_str())) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem creating installer directory: "
+                        << preflightDirName << std::endl);
+        return 0;
+      }
+    }
+    if (!postflight) {
+      if (!cmsys::SystemTools::MakeDirectory(postflightDirName.c_str())) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Problem creating installer directory: "
+                        << postflightDirName << std::endl);
+        return 0;
+      }
+    }
+    // if preflight, postflight, or postupgrade are set
+    // then copy them into the resource directory and make
+    // them executable
+    if (preflight) {
+      this->CopyInstallScript(resDir, preflight, "preflight");
+    }
+    if (postflight) {
+      this->CopyInstallScript(resDir, postflight, "postflight");
+    }
+    if (postupgrade) {
+      this->CopyInstallScript(resDir, postupgrade, "postupgrade");
+    }
+  } else if (postflight) {
+    // create a postflight component to house the script
+    this->PostFlightComponent.Name = "PostFlight";
+    this->PostFlightComponent.DisplayName = "PostFlight";
+    this->PostFlightComponent.Description = "PostFlight";
+    this->PostFlightComponent.IsHidden = true;
+
+    // empty directory for pkg contents
+    std::string packageDir = toplevel + "/" + PostFlightComponent.Name;
+    if (!cmsys::SystemTools::MakeDirectory(packageDir.c_str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem creating component packages directory: "
+                      << packageDir << std::endl);
+      return 0;
+    }
+
+    // create package
+    std::string packageFileDir = packageDirFileName + "/Contents/Packages/";
+    if (!cmsys::SystemTools::MakeDirectory(packageFileDir.c_str())) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "Problem creating component PostFlight Packages directory: "
+          << packageFileDir << std::endl);
+      return 0;
+    }
+    std::string packageFile =
+      packageFileDir + this->GetPackageName(PostFlightComponent);
+    if (!this->GenerateComponentPackage(
+          packageFile.c_str(), packageDir.c_str(), PostFlightComponent)) {
+      return 0;
+    }
+
+    // copy postflight script into resource directory of .pkg
+    std::string resourceDir = packageFile + "/Contents/Resources";
+    this->CopyInstallScript(resourceDir, postflight, "postflight");
+  }
+
+  if (!this->Components.empty()) {
+    // Create the directory where component packages will be built.
+    std::string basePackageDir = packageDirFileName;
+    basePackageDir += "/Contents/Packages";
+    if (!cmsys::SystemTools::MakeDirectory(basePackageDir.c_str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Problem creating component packages directory: "
+                      << basePackageDir << std::endl);
+      return 0;
+    }
+
+    // Create the directory where downloaded component packages will
+    // be placed.
+    const char* userUploadDirectory =
+      this->GetOption("CPACK_UPLOAD_DIRECTORY");
+    std::string uploadDirectory;
+    if (userUploadDirectory && *userUploadDirectory) {
+      uploadDirectory = userUploadDirectory;
+    } else {
+      uploadDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
+      uploadDirectory += "/CPackUploads";
+    }
+
+    // Create packages for each component
+    bool warnedAboutDownloadCompatibility = false;
+
+    std::map<std::string, cmCPackComponent>::iterator compIt;
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
+      std::string packageFile;
+      if (compIt->second.IsDownloaded) {
+        if (this->PackageCompatibilityVersion >= getVersion(10, 5) &&
+            this->PackageMakerVersion >= 3.0) {
+          // Build this package within the upload directory.
+          packageFile = uploadDirectory;
+
+          if (!cmSystemTools::FileExists(uploadDirectory.c_str())) {
+            if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str())) {
+              cmCPackLogger(cmCPackLog::LOG_ERROR,
+                            "Unable to create package upload directory "
+                              << uploadDirectory << std::endl);
+              return 0;
+            }
+          }
+        } else if (!warnedAboutDownloadCompatibility) {
+          if (this->PackageCompatibilityVersion < getVersion(10, 5)) {
+            cmCPackLogger(
+              cmCPackLog::LOG_WARNING,
+              "CPack warning: please set CPACK_OSX_PACKAGE_VERSION to 10.5 "
+              "or greater enable downloaded packages. CPack will build a "
+              "non-downloaded package."
+                << std::endl);
+          }
+
+          if (this->PackageMakerVersion < 3) {
+            cmCPackLogger(cmCPackLog::LOG_WARNING,
+                          "CPack warning: unable to build downloaded "
+                          "packages with PackageMaker versions prior "
+                          "to 3.0. CPack will build a non-downloaded package."
+                            << std::endl);
+          }
+
+          warnedAboutDownloadCompatibility = true;
+        }
+      }
+
+      if (packageFile.empty()) {
+        // Build this package within the overall distribution
+        // metapackage.
+        packageFile = basePackageDir;
+
+        // We're not downloading this component, even if the user
+        // requested it.
+        compIt->second.IsDownloaded = false;
+      }
+
+      packageFile += '/';
+      packageFile += GetPackageName(compIt->second);
+
+      std::string packageDir = toplevel;
+      packageDir += '/';
+      packageDir += compIt->first;
+      if (!this->GenerateComponentPackage(
+            packageFile.c_str(), packageDir.c_str(), compIt->second)) {
+        return 0;
+      }
+    }
+  }
+  this->SetOption("CPACK_MODULE_VERSION_SUFFIX", "");
+
+  // Copy or create all of the resource files we need.
+  if (!this->CopyCreateResourceFile("License", resDir) ||
+      !this->CopyCreateResourceFile("ReadMe", resDir) ||
+      !this->CopyCreateResourceFile("Welcome", resDir) ||
+      !this->CopyResourcePlistFile("Info.plist") ||
+      !this->CopyResourcePlistFile("Description.plist")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
+                    << std::endl);
+    return 0;
+  }
+
+  if (this->Components.empty()) {
+    // Use PackageMaker to build the package.
+    std::ostringstream pkgCmd;
+    pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
+           << "\" -build -p \"" << packageDirFileName << "\"";
+    if (this->Components.empty()) {
+      pkgCmd << " -f \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+    } else {
+      pkgCmd << " -mi \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY")
+             << "/packages/";
+    }
+    pkgCmd << "\" -r \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
+           << "/Resources\" -i \""
+           << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
+           << "/Info.plist\" -d \""
+           << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
+           << "/Description.plist\"";
+    if (this->PackageMakerVersion > 2.0) {
+      pkgCmd << " -v";
+    }
+    if (!RunPackageMaker(pkgCmd.str().c_str(), packageDirFileName.c_str())) {
+      return 0;
+    }
+  } else {
+    // We have built the package in place. Generate the
+    // distribution.dist file to describe it for the installer.
+    WriteDistributionFile(packageDirFileName.c_str());
+  }
+
+  std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  tmpFile += "/hdiutilOutput.log";
+  std::ostringstream dmgCmd;
+  dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
+         << "\" create -ov -fs HFS+ -format UDZO -srcfolder \""
+         << packageDirFileName << "\" \"" << packageFileNames[0] << "\"";
+  std::string output;
+  int retVal = 1;
+  int numTries = 10;
+  bool res = false;
+  while (numTries > 0) {
+    res = cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output,
+                                          &output, &retVal, nullptr,
+                                          this->GeneratorVerbose, 0);
+    if (res && !retVal) {
+      numTries = -1;
+      break;
+    }
+    cmSystemTools::Delay(500);
+    numTries--;
+  }
+  if (!res || retVal) {
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << dmgCmd.str() << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
+                    << dmgCmd.str() << std::endl
+                    << "Please check " << tmpFile << " for errors"
+                    << std::endl);
+    return 0;
+  }
+
+  return 1;
+}
+
+int cmCPackPackageMakerGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
+
+  // Starting with Xcode 4.3, PackageMaker is a separate app, and you
+  // can put it anywhere you want. So... use a variable for its location.
+  // People who put it in unexpected places can use the variable to tell
+  // us where it is.
+  //
+  // Use the following locations, in "most recent installation" order,
+  // to search for the PackageMaker app. Assume people who copy it into
+  // the new Xcode 4.3 app in "/Applications" will copy it into the nested
+  // Applications folder inside the Xcode bundle itself. Or directly in
+  // the "/Applications" directory.
+  //
+  // If found, save result in the CPACK_INSTALLER_PROGRAM variable.
+
+  std::vector<std::string> paths;
+  paths.push_back("/Applications/Xcode.app/Contents/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Applications/Utilities"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Developer/Applications/Utilities"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Developer/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
+
+  std::string pkgPath;
+  const char* inst_program = this->GetOption("CPACK_INSTALLER_PROGRAM");
+  if (inst_program && *inst_program) {
+    pkgPath = inst_program;
+  } else {
+    pkgPath = cmSystemTools::FindProgram("PackageMaker", paths, false);
+    if (pkgPath.empty()) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find PackageMaker compiler"
+                      << std::endl);
+      return 0;
+    }
+    this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", pkgPath.c_str());
+  }
+
+  // Get path to the real PackageMaker, not a symlink:
+  pkgPath = cmSystemTools::GetRealPath(pkgPath);
+  // Up from there to find the version.plist file in the "Contents" dir:
+  std::string contents_dir;
+  contents_dir = cmSystemTools::GetFilenamePath(pkgPath);
+  contents_dir = cmSystemTools::GetFilenamePath(contents_dir);
+
+  std::string versionFile = contents_dir + "/version.plist";
+
+  if (!cmSystemTools::FileExists(versionFile.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find PackageMaker compiler version file: "
+                    << versionFile << std::endl);
+    return 0;
+  }
+
+  cmsys::ifstream ifs(versionFile.c_str());
+  if (!ifs) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot open PackageMaker compiler version file"
+                    << std::endl);
+    return 0;
+  }
+
+  // Check the PackageMaker version
+  cmsys::RegularExpression rexKey("<key>CFBundleShortVersionString</key>");
+  cmsys::RegularExpression rexVersion("<string>([0-9]+.[0-9.]+)</string>");
+  std::string line;
+  bool foundKey = false;
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
+    if (rexKey.find(line)) {
+      foundKey = true;
+      break;
+    }
+  }
+  if (!foundKey) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
+      "Cannot find CFBundleShortVersionString in the PackageMaker compiler "
+      "version file"
+        << std::endl);
+    return 0;
+  }
+  if (!cmSystemTools::GetLineFromStream(ifs, line) || !rexVersion.find(line)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem reading the PackageMaker compiler version file: "
+                    << versionFile << std::endl);
+    return 0;
+  }
+  this->PackageMakerVersion = atof(rexVersion.match(1).c_str());
+  if (this->PackageMakerVersion < 1.0) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Require PackageMaker 1.0 or higher"
+                    << std::endl);
+    return 0;
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "PackageMaker version is: "
+                  << this->PackageMakerVersion << std::endl);
+
+  // Determine the package compatibility version. If it wasn't
+  // specified by the user, we define it based on which features the
+  // user requested.
+  const char* packageCompat = this->GetOption("CPACK_OSX_PACKAGE_VERSION");
+  if (packageCompat && *packageCompat) {
+    unsigned int majorVersion = 10;
+    unsigned int minorVersion = 5;
+    int res = sscanf(packageCompat, "%u.%u", &majorVersion, &minorVersion);
+    if (res == 2) {
+      this->PackageCompatibilityVersion =
+        getVersion(majorVersion, minorVersion);
+    }
+  } else if (this->GetOption("CPACK_DOWNLOAD_SITE")) {
+    this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.5");
+    this->PackageCompatibilityVersion = getVersion(10, 5);
+  } else if (this->GetOption("CPACK_COMPONENTS_ALL")) {
+    this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.4");
+    this->PackageCompatibilityVersion = getVersion(10, 4);
+  } else {
+    this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.3");
+    this->PackageCompatibilityVersion = getVersion(10, 3);
+  }
+
+  std::vector<std::string> no_paths;
+  pkgPath = cmSystemTools::FindProgram("hdiutil", no_paths, false);
+  if (pkgPath.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
+                          pkgPath.c_str());
+
+  return this->Superclass::InitializeInternal();
+}
+
+bool cmCPackPackageMakerGenerator::RunPackageMaker(const char* command,
+                                                   const char* packageFile)
+{
+  std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  tmpFile += "/PackageMakerOutput.log";
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << command << std::endl);
+  std::string output;
+  int retVal = 1;
+  bool res = cmSystemTools::RunSingleCommand(
+    command, &output, &output, &retVal, nullptr, this->GeneratorVerbose, 0);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Done running package maker"
+                  << std::endl);
+  if (!res || retVal) {
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << command << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Problem running PackageMaker command: "
+        << command << std::endl
+        << "Please check " << tmpFile << " for errors" << std::endl);
+    return false;
+  }
+  // sometimes the command finishes but the directory is not yet
+  // created, so try 10 times to see if it shows up
+  int tries = 10;
+  while (tries > 0 && !cmSystemTools::FileExists(packageFile)) {
+    cmSystemTools::Delay(500);
+    tries--;
+  }
+  if (!cmSystemTools::FileExists(packageFile)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running PackageMaker command: "
+                    << command << std::endl
+                    << "Package not created: " << packageFile << std::endl);
+    return false;
+  }
+
+  return true;
+}
+
+bool cmCPackPackageMakerGenerator::GenerateComponentPackage(
+  const char* packageFile, const char* packageDir,
+  const cmCPackComponent& component)
+{
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Building component package: "
+                  << packageFile << std::endl);
+
+  // The command that will be used to run PackageMaker
+  std::ostringstream pkgCmd;
+
+  if (this->PackageCompatibilityVersion < getVersion(10, 5) ||
+      this->PackageMakerVersion < 3.0) {
+    // Create Description.plist and Info.plist files for normal Mac OS
+    // X packages, which work on Mac OS X 10.3 and newer.
+    std::string descriptionFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    descriptionFile += '/' + component.Name + "-Description.plist";
+    cmsys::ofstream out(descriptionFile.c_str());
+    cmXMLWriter xout(out);
+    xout.StartDocument();
+    xout.Doctype("plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
+                 "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
+    xout.StartElement("plist");
+    xout.Attribute("version", "1.4");
+    xout.StartElement("dict");
+    xout.Element("key", "IFPkgDescriptionTitle");
+    xout.Element("string", component.DisplayName);
+    xout.Element("key", "IFPkgDescriptionVersion");
+    xout.Element("string", this->GetOption("CPACK_PACKAGE_VERSION"));
+    xout.Element("key", "IFPkgDescriptionDescription");
+    xout.Element("string", component.Description);
+    xout.EndElement(); // dict
+    xout.EndElement(); // plist
+    xout.EndDocument();
+    out.close();
+
+    // Create the Info.plist file for this component
+    std::string moduleVersionSuffix = ".";
+    moduleVersionSuffix += component.Name;
+    this->SetOption("CPACK_MODULE_VERSION_SUFFIX",
+                    moduleVersionSuffix.c_str());
+    std::string infoFileName = component.Name;
+    infoFileName += "-Info.plist";
+    if (!this->CopyResourcePlistFile("Info.plist", infoFileName.c_str())) {
+      return false;
+    }
+
+    pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
+           << "\" -build -p \"" << packageFile << "\""
+           << " -f \"" << packageDir << "\""
+           << " -i \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "/"
+           << infoFileName << "\""
+           << " -d \"" << descriptionFile << "\"";
+  } else {
+    // Create a "flat" package on Mac OS X 10.5 and newer. Flat
+    // packages are stored in a single file, rather than a directory
+    // like normal packages, and can be downloaded by the installer
+    // on-the-fly in Mac OS X 10.5 or newer. Thus, we need to create
+    // flat packages when the packages will be downloaded on the fly.
+    std::string pkgId = "com.";
+    pkgId += this->GetOption("CPACK_PACKAGE_VENDOR");
+    pkgId += '.';
+    pkgId += this->GetOption("CPACK_PACKAGE_NAME");
+    pkgId += '.';
+    pkgId += component.Name;
+
+    pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
+           << "\" --root \"" << packageDir << "\""
+           << " --id " << pkgId << " --target "
+           << this->GetOption("CPACK_OSX_PACKAGE_VERSION") << " --out \""
+           << packageFile << "\"";
+  }
+
+  // Run PackageMaker
+  return RunPackageMaker(pkgCmd.str().c_str(), packageFile);
+}
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.h b/Source/CPack/cmCPackPackageMakerGenerator.h
new file mode 100644
index 0000000..0575587
--- /dev/null
+++ b/Source/CPack/cmCPackPackageMakerGenerator.h
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackPackageMakerGenerator_h
+#define cmCPackPackageMakerGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackGenerator.h"
+#include "cmCPackPKGGenerator.h"
+
+class cmCPackComponent;
+
+/** \class cmCPackPackageMakerGenerator
+ * \brief A generator for PackageMaker files
+ *
+ * http://developer.apple.com/documentation/Darwin
+ * /Reference/ManPages/man1/packagemaker.1.html
+ */
+class cmCPackPackageMakerGenerator : public cmCPackPKGGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackPackageMakerGenerator, cmCPackPKGGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackPackageMakerGenerator();
+  ~cmCPackPackageMakerGenerator() override;
+  bool SupportsComponentInstallation() const override;
+
+protected:
+  int InitializeInternal() override;
+  int PackageFiles() override;
+  const char* GetOutputExtension() override { return ".dmg"; }
+
+  // Run PackageMaker with the given command line, which will (if
+  // successful) produce the given package file. Returns true if
+  // PackageMaker succeeds, false otherwise.
+  bool RunPackageMaker(const char* command, const char* packageFile);
+
+  // Generate a package in the file packageFile for the given
+  // component.  All of the files within this component are stored in
+  // the directory packageDir. Returns true if successful, false
+  // otherwise.
+  bool GenerateComponentPackage(const char* packageFile,
+                                const char* packageDir,
+                                const cmCPackComponent& component);
+
+  double PackageMakerVersion;
+  unsigned int PackageCompatibilityVersion;
+};
+
+#endif
diff --git a/Source/CPack/cmCPackProductBuildGenerator.cxx b/Source/CPack/cmCPackProductBuildGenerator.cxx
new file mode 100644
index 0000000..6a6dc82
--- /dev/null
+++ b/Source/CPack/cmCPackProductBuildGenerator.cxx
@@ -0,0 +1,258 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackProductBuildGenerator.h"
+
+#include <map>
+#include <sstream>
+#include <stddef.h>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackLog.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+cmCPackProductBuildGenerator::cmCPackProductBuildGenerator()
+{
+  this->componentPackageMethod = ONE_PACKAGE;
+}
+
+cmCPackProductBuildGenerator::~cmCPackProductBuildGenerator()
+{
+}
+
+int cmCPackProductBuildGenerator::PackageFiles()
+{
+  // TODO: Use toplevel
+  //       It is used! Is this an obsolete comment?
+
+  std::string packageDirFileName =
+    this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+
+  // Create the directory where component packages will be built.
+  std::string basePackageDir = packageDirFileName;
+  basePackageDir += "/Contents/Packages";
+  if (!cmsys::SystemTools::MakeDirectory(basePackageDir.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem creating component packages directory: "
+                    << basePackageDir << std::endl);
+    return 0;
+  }
+
+  if (!this->Components.empty()) {
+    std::map<std::string, cmCPackComponent>::iterator compIt;
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
+      std::string packageDir = toplevel;
+      packageDir += '/';
+      packageDir += compIt->first;
+      if (!this->GenerateComponentPackage(basePackageDir,
+                                          GetPackageName(compIt->second),
+                                          packageDir, &compIt->second)) {
+        return 0;
+      }
+    }
+  } else {
+    if (!this->GenerateComponentPackage(basePackageDir,
+                                        this->GetOption("CPACK_PACKAGE_NAME"),
+                                        toplevel, nullptr)) {
+      return 0;
+    }
+  }
+
+  std::string resDir = packageDirFileName + "/Contents";
+
+  if (this->IsSet("CPACK_PRODUCTBUILD_RESOURCES_DIR")) {
+    std::string userResDir =
+      this->GetOption("CPACK_PRODUCTBUILD_RESOURCES_DIR");
+
+    if (!cmSystemTools::CopyADirectory(userResDir, resDir)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
+                      << std::endl);
+      return 0;
+    }
+  }
+
+  // Copy or create all of the resource files we need.
+  if (!this->CopyCreateResourceFile("License", resDir) ||
+      !this->CopyCreateResourceFile("ReadMe", resDir) ||
+      !this->CopyCreateResourceFile("Welcome", resDir)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem copying the License, ReadMe and Welcome files"
+                    << std::endl);
+    return 0;
+  }
+
+  // combine package(s) into a distribution
+  WriteDistributionFile(packageDirFileName.c_str());
+  std::ostringstream pkgCmd;
+
+  std::string version = this->GetOption("CPACK_PACKAGE_VERSION");
+  std::string productbuild = this->GetOption("CPACK_COMMAND_PRODUCTBUILD");
+  std::string identityName;
+  if (const char* n = this->GetOption("CPACK_PRODUCTBUILD_IDENTITY_NAME")) {
+    identityName = n;
+  }
+  std::string keychainPath;
+  if (const char* p = this->GetOption("CPACK_PRODUCTBUILD_KEYCHAIN_PATH")) {
+    keychainPath = p;
+  }
+
+  pkgCmd << productbuild << " --distribution \"" << packageDirFileName
+         << "/Contents/distribution.dist\""
+         << " --package-path \"" << packageDirFileName << "/Contents/Packages"
+         << "\""
+         << " --resources \"" << resDir << "\""
+         << " --version \"" << version << "\""
+         << (identityName.empty() ? "" : " --sign \"" + identityName + "\"")
+         << (keychainPath.empty() ? ""
+                                  : " --keychain \"" + keychainPath + "\"")
+         << " \"" << packageFileNames[0] << "\"";
+
+  // Run ProductBuild
+  return RunProductBuild(pkgCmd.str());
+}
+
+int cmCPackProductBuildGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/Applications");
+
+  std::vector<std::string> no_paths;
+  std::string program =
+    cmSystemTools::FindProgram("pkgbuild", no_paths, false);
+  if (program.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find pkgbuild executable"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_COMMAND_PKGBUILD", program.c_str());
+
+  program = cmSystemTools::FindProgram("productbuild", no_paths, false);
+  if (program.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find productbuild executable"
+                    << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_COMMAND_PRODUCTBUILD", program.c_str());
+
+  return this->Superclass::InitializeInternal();
+}
+
+bool cmCPackProductBuildGenerator::RunProductBuild(const std::string& command)
+{
+  std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  tmpFile += "/ProductBuildOutput.log";
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << command << std::endl);
+  std::string output, error_output;
+  int retVal = 1;
+  bool res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
+                                             &error_output, &retVal, nullptr,
+                                             this->GeneratorVerbose, 0);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Done running command" << std::endl);
+  if (!res || retVal) {
+    cmGeneratedFileStream ofs(tmpFile.c_str());
+    ofs << "# Run command: " << command << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running command: " << command << std::endl
+                                              << "Please check " << tmpFile
+                                              << " for errors" << std::endl);
+    return false;
+  }
+  return true;
+}
+
+bool cmCPackProductBuildGenerator::GenerateComponentPackage(
+  const std::string& packageFileDir, const std::string& packageFileName,
+  const std::string& packageDir, const cmCPackComponent* component)
+{
+  std::string packageFile = packageFileDir;
+  packageFile += '/';
+  packageFile += packageFileName;
+
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Building component package: "
+                  << packageFile << std::endl);
+
+  const char* comp_name = component ? component->Name.c_str() : nullptr;
+
+  const char* preflight = this->GetComponentScript("PREFLIGHT", comp_name);
+  const char* postflight = this->GetComponentScript("POSTFLIGHT", comp_name);
+
+  std::string resDir = packageFileDir;
+  if (component) {
+    resDir += "/";
+    resDir += component->Name;
+  }
+  std::string scriptDir = resDir + "/scripts";
+
+  if (!cmsys::SystemTools::MakeDirectory(scriptDir.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem creating installer directory: " << scriptDir
+                                                           << std::endl);
+    return false;
+  }
+
+  // if preflight, postflight, or postupgrade are set
+  // then copy them into the script directory and make
+  // them executable
+  if (preflight) {
+    this->CopyInstallScript(scriptDir, preflight, "preinstall");
+  }
+  if (postflight) {
+    this->CopyInstallScript(scriptDir, postflight, "postinstall");
+  }
+
+  // The command that will be used to run ProductBuild
+  std::ostringstream pkgCmd;
+
+  std::string pkgId = "com.";
+  pkgId += this->GetOption("CPACK_PACKAGE_VENDOR");
+  pkgId += '.';
+  pkgId += this->GetOption("CPACK_PACKAGE_NAME");
+  if (component) {
+    pkgId += '.';
+    pkgId += component->Name;
+  }
+
+  std::string version = this->GetOption("CPACK_PACKAGE_VERSION");
+  std::string pkgbuild = this->GetOption("CPACK_COMMAND_PKGBUILD");
+  std::string identityName;
+  if (const char* n = this->GetOption("CPACK_PKGBUILD_IDENTITY_NAME")) {
+    identityName = n;
+  }
+  std::string keychainPath;
+  if (const char* p = this->GetOption("CPACK_PKGBUILD_KEYCHAIN_PATH")) {
+    keychainPath = p;
+  }
+
+  pkgCmd << pkgbuild << " --root \"" << packageDir << "\""
+         << " --identifier \"" << pkgId << "\""
+         << " --scripts \"" << scriptDir << "\""
+         << " --version \"" << version << "\""
+         << " --install-location \"/\""
+         << (identityName.empty() ? "" : " --sign \"" + identityName + "\"")
+         << (keychainPath.empty() ? ""
+                                  : " --keychain \"" + keychainPath + "\"")
+         << " \"" << packageFile << "\"";
+
+  if (component && !component->Plist.empty()) {
+    pkgCmd << " --component-plist \"" << component->Plist << "\"";
+  }
+
+  // Run ProductBuild
+  return RunProductBuild(pkgCmd.str());
+}
+
+const char* cmCPackProductBuildGenerator::GetComponentScript(
+  const char* script, const char* component_name)
+{
+  std::string scriptname = std::string("CPACK_") + script + "_";
+  if (component_name) {
+    scriptname += cmSystemTools::UpperCase(component_name);
+    scriptname += "_";
+  }
+  scriptname += "SCRIPT";
+
+  return this->GetOption(scriptname);
+}
diff --git a/Source/CPack/cmCPackProductBuildGenerator.h b/Source/CPack/cmCPackProductBuildGenerator.h
new file mode 100644
index 0000000..015fe4a
--- /dev/null
+++ b/Source/CPack/cmCPackProductBuildGenerator.h
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackProductBuildGenerator_h
+#define cmCPackProductBuildGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+#include "cmCPackGenerator.h"
+#include "cmCPackPKGGenerator.h"
+
+class cmCPackComponent;
+
+/** \class cmCPackProductBuildGenerator
+ * \brief A generator for ProductBuild files
+ *
+ */
+class cmCPackProductBuildGenerator : public cmCPackPKGGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackProductBuildGenerator, cmCPackPKGGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackProductBuildGenerator();
+  ~cmCPackProductBuildGenerator() override;
+
+protected:
+  int InitializeInternal() override;
+  int PackageFiles() override;
+  const char* GetOutputExtension() override { return ".pkg"; }
+
+  // Run ProductBuild with the given command line, which will (if
+  // successful) produce the given package file. Returns true if
+  // ProductBuild succeeds, false otherwise.
+  bool RunProductBuild(const std::string& command);
+
+  // Generate a package in the file packageFile for the given
+  // component.  All of the files within this component are stored in
+  // the directory packageDir. Returns true if successful, false
+  // otherwise.
+  bool GenerateComponentPackage(const std::string& packageFileDir,
+                                const std::string& packageFileName,
+                                const std::string& packageDir,
+                                const cmCPackComponent* component);
+
+  const char* GetComponentScript(const char* script,
+                                 const char* script_component);
+};
+
+#endif
diff --git a/Source/CPack/cmCPackRPMGenerator.cxx b/Source/CPack/cmCPackRPMGenerator.cxx
new file mode 100644
index 0000000..e40b74d
--- /dev/null
+++ b/Source/CPack/cmCPackRPMGenerator.cxx
@@ -0,0 +1,437 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackRPMGenerator.h"
+
+#include <algorithm>
+#include <ctype.h>
+#include <map>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include "cmCPackComponentGroup.h"
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmSystemTools.h"
+
+cmCPackRPMGenerator::cmCPackRPMGenerator()
+{
+}
+
+cmCPackRPMGenerator::~cmCPackRPMGenerator()
+{
+}
+
+int cmCPackRPMGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
+  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
+    this->SetOption("CPACK_SET_DESTDIR", "I_ON");
+  }
+  /* Replace space in CPACK_PACKAGE_NAME in order to avoid
+   * rpmbuild scream on unwanted space in filename issue
+   * Moreover RPM file do not usually embed space in filename
+   */
+  if (this->GetOption("CPACK_PACKAGE_NAME")) {
+    std::string packageName = this->GetOption("CPACK_PACKAGE_NAME");
+    std::replace(packageName.begin(), packageName.end(), ' ', '-');
+    this->SetOption("CPACK_PACKAGE_NAME", packageName.c_str());
+  }
+  /* same for CPACK_PACKAGE_FILE_NAME */
+  if (this->GetOption("CPACK_PACKAGE_FILE_NAME")) {
+    std::string packageName = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    std::replace(packageName.begin(), packageName.end(), ' ', '-');
+    this->SetOption("CPACK_PACKAGE_FILE_NAME", packageName.c_str());
+  }
+  return this->Superclass::InitializeInternal();
+}
+
+void cmCPackRPMGenerator::AddGeneratedPackageNames()
+{
+  // add the generated packages to package file names list
+  std::string fileNames(this->GetOption("GEN_CPACK_OUTPUT_FILES"));
+  const char sep = ';';
+  std::string::size_type pos1 = 0;
+  std::string::size_type pos2 = fileNames.find(sep, pos1 + 1);
+  while (pos2 != std::string::npos) {
+    packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
+    pos1 = pos2 + 1;
+    pos2 = fileNames.find(sep, pos1 + 1);
+  }
+  packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
+}
+
+int cmCPackRPMGenerator::PackageOnePack(std::string const& initialToplevel,
+                                        std::string const& packageName)
+{
+  int retval = 1;
+  // Begin the archive for this pack
+  std::string localToplevel(initialToplevel);
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(
+    GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                packageName, true) +
+    this->GetOutputExtension());
+
+  localToplevel += "/" + packageName;
+  /* replace the TEMP DIRECTORY with the component one */
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
+  /* replace proposed CPACK_OUTPUT_FILE_NAME */
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
+  /* replace the TEMPORARY package file name */
+  this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                  packageFileName.c_str());
+  // Tell CPackRPM.cmake the name of the component NAME.
+  this->SetOption("CPACK_RPM_PACKAGE_COMPONENT", packageName.c_str());
+  // Tell CPackRPM.cmake the path where the component is.
+  std::string component_path = "/";
+  component_path += packageName;
+  this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
+                  component_path.c_str());
+  if (!this->ReadListFile("CPackRPM.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
+                    << std::endl);
+    retval = 0;
+  }
+
+  return retval;
+}
+
+int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
+{
+  int retval = 1;
+  /* Reset package file name list it will be populated during the
+   * component packaging run*/
+  packageFileNames.clear();
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+
+  const char* mainComponent = this->GetOption("CPACK_RPM_MAIN_COMPONENT");
+
+  if (this->IsOn("CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE") &&
+      !this->IsOn("CPACK_RPM_DEBUGINFO_PACKAGE")) {
+    // check if we need to set CPACK_RPM_DEBUGINFO_PACKAGE because non of
+    // the components is setting per component debuginfo package variable
+    bool shouldSet = true;
+
+    if (ignoreGroup) {
+      std::map<std::string, cmCPackComponent>::iterator compIt;
+      for (compIt = this->Components.begin(); compIt != this->Components.end();
+           ++compIt) {
+        std::string component(compIt->first);
+        std::transform(component.begin(), component.end(), component.begin(),
+                       ::toupper);
+
+        if (this->IsOn("CPACK_RPM_" + compIt->first + "_DEBUGINFO_PACKAGE") ||
+            this->IsOn("CPACK_RPM_" + component + "_DEBUGINFO_PACKAGE")) {
+          shouldSet = false;
+          break;
+        }
+      }
+    } else {
+      std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
+      for (compGIt = this->ComponentGroups.begin();
+           compGIt != this->ComponentGroups.end(); ++compGIt) {
+        std::string component(compGIt->first);
+        std::transform(component.begin(), component.end(), component.begin(),
+                       ::toupper);
+
+        if (this->IsOn("CPACK_RPM_" + compGIt->first + "_DEBUGINFO_PACKAGE") ||
+            this->IsOn("CPACK_RPM_" + component + "_DEBUGINFO_PACKAGE")) {
+          shouldSet = false;
+          break;
+        }
+      }
+
+      if (shouldSet) {
+        std::map<std::string, cmCPackComponent>::iterator compIt;
+        for (compIt = this->Components.begin();
+             compIt != this->Components.end(); ++compIt) {
+          // Does the component belong to a group?
+          if (compIt->second.Group == nullptr) {
+            std::string component(compIt->first);
+            std::transform(component.begin(), component.end(),
+                           component.begin(), ::toupper);
+
+            if (this->IsOn("CPACK_RPM_" + compIt->first +
+                           "_DEBUGINFO_PACKAGE") ||
+                this->IsOn("CPACK_RPM_" + component + "_DEBUGINFO_PACKAGE")) {
+              shouldSet = false;
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    if (shouldSet) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Setting "
+                      << "CPACK_RPM_DEBUGINFO_PACKAGE because "
+                      << "CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE is set but "
+                      << " none of the "
+                      << "CPACK_RPM_<component>_DEBUGINFO_PACKAGE variables "
+                      << "are set." << std::endl);
+      this->SetOption("CPACK_RPM_DEBUGINFO_PACKAGE", "ON");
+    }
+  }
+
+  if (mainComponent) {
+    if (this->IsOn("CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE")) {
+      this->SetOption("GENERATE_SPEC_PARTS", "ON");
+    }
+
+    std::string mainComponentUpper(mainComponent);
+    std::transform(mainComponentUpper.begin(), mainComponentUpper.end(),
+                   mainComponentUpper.begin(), ::toupper);
+
+    // The default behavior is to have one package by component group
+    // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+    if (!ignoreGroup) {
+      std::map<std::string, cmCPackComponentGroup>::iterator mainCompGIt =
+        this->ComponentGroups.end();
+
+      std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
+      for (compGIt = this->ComponentGroups.begin();
+           compGIt != this->ComponentGroups.end(); ++compGIt) {
+        std::string component(compGIt->first);
+        std::transform(component.begin(), component.end(), component.begin(),
+                       ::toupper);
+
+        if (mainComponentUpper == component) {
+          // main component will be handled last
+          mainCompGIt = compGIt;
+          continue;
+        }
+
+        cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
+                        << compGIt->first << std::endl);
+        retval &= PackageOnePack(initialTopLevel, compGIt->first);
+      }
+      // Handle Orphan components (components not belonging to any groups)
+      std::map<std::string, cmCPackComponent>::iterator mainCompIt =
+        this->Components.end();
+      std::map<std::string, cmCPackComponent>::iterator compIt;
+      for (compIt = this->Components.begin(); compIt != this->Components.end();
+           ++compIt) {
+        // Does the component belong to a group?
+        if (compIt->second.Group == nullptr) {
+          std::string component(compIt->first);
+          std::transform(component.begin(), component.end(), component.begin(),
+                         ::toupper);
+
+          if (mainComponentUpper == component) {
+            // main component will be handled last
+            mainCompIt = compIt;
+            continue;
+          }
+
+          cmCPackLogger(
+            cmCPackLog::LOG_VERBOSE, "Component <"
+              << compIt->second.Name
+              << "> does not belong to any group, package it separately."
+              << std::endl);
+          retval &= PackageOnePack(initialTopLevel, compIt->first);
+        }
+      }
+
+      if (retval) {
+        this->SetOption("GENERATE_SPEC_PARTS", "OFF");
+
+        if (mainCompGIt != this->ComponentGroups.end()) {
+          retval &= PackageOnePack(initialTopLevel, mainCompGIt->first);
+        } else if (mainCompIt != this->Components.end()) {
+          retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
+        } else {
+          cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT set"
+                          << " to non existing component.\n");
+          retval = 0;
+        }
+      }
+    }
+    // CPACK_COMPONENTS_IGNORE_GROUPS is set
+    // We build 1 package per component
+    else {
+      std::map<std::string, cmCPackComponent>::iterator mainCompIt =
+        this->Components.end();
+
+      std::map<std::string, cmCPackComponent>::iterator compIt;
+      for (compIt = this->Components.begin(); compIt != this->Components.end();
+           ++compIt) {
+        std::string component(compIt->first);
+        std::transform(component.begin(), component.end(), component.begin(),
+                       ::toupper);
+
+        if (mainComponentUpper == component) {
+          // main component will be handled last
+          mainCompIt = compIt;
+          continue;
+        }
+
+        retval &= PackageOnePack(initialTopLevel, compIt->first);
+      }
+
+      if (retval) {
+        this->SetOption("GENERATE_SPEC_PARTS", "OFF");
+
+        if (mainCompIt != this->Components.end()) {
+          retval &= PackageOnePack(initialTopLevel, mainCompIt->first);
+        } else {
+          cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT set"
+                          << " to non existing component.\n");
+          retval = 0;
+        }
+      }
+    }
+  } else if (!this->IsOn("CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE") ||
+             this->Components.size() == 1) {
+    // The default behavior is to have one package by component group
+    // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+    if (!ignoreGroup) {
+      std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
+      for (compGIt = this->ComponentGroups.begin();
+           compGIt != this->ComponentGroups.end(); ++compGIt) {
+        cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
+                        << compGIt->first << std::endl);
+        retval &= PackageOnePack(initialTopLevel, compGIt->first);
+      }
+      // Handle Orphan components (components not belonging to any groups)
+      std::map<std::string, cmCPackComponent>::iterator compIt;
+      for (compIt = this->Components.begin(); compIt != this->Components.end();
+           ++compIt) {
+        // Does the component belong to a group?
+        if (compIt->second.Group == nullptr) {
+          cmCPackLogger(
+            cmCPackLog::LOG_VERBOSE, "Component <"
+              << compIt->second.Name
+              << "> does not belong to any group, package it separately."
+              << std::endl);
+          retval &= PackageOnePack(initialTopLevel, compIt->first);
+        }
+      }
+    }
+    // CPACK_COMPONENTS_IGNORE_GROUPS is set
+    // We build 1 package per component
+    else {
+      std::map<std::string, cmCPackComponent>::iterator compIt;
+      for (compIt = this->Components.begin(); compIt != this->Components.end();
+           ++compIt) {
+        retval &= PackageOnePack(initialTopLevel, compIt->first);
+      }
+    }
+  } else {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "CPACK_RPM_MAIN_COMPONENT not set but"
+        << " it is mandatory with CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE"
+        << " being set.\n");
+    retval = 0;
+  }
+
+  if (retval) {
+    AddGeneratedPackageNames();
+  }
+
+  return retval;
+}
+
+int cmCPackRPMGenerator::PackageComponentsAllInOne(
+  const std::string& compInstDirName)
+{
+  int retval = 1;
+  /* Reset package file name list it will be populated during the
+   * component packaging run*/
+  packageFileNames.clear();
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+
+  if (this->IsOn("CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE")) {
+    this->SetOption("CPACK_RPM_DEBUGINFO_PACKAGE", "ON");
+  }
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Packaging all groups in one package..."
+                "(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
+                  << std::endl);
+
+  // The ALL GROUPS in ONE package case
+  std::string localToplevel(initialTopLevel);
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(
+    std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
+    this->GetOutputExtension());
+  // all GROUP in one vs all COMPONENT in one
+  localToplevel += "/" + compInstDirName;
+
+  /* replace the TEMP DIRECTORY with the component one */
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
+  /* replace proposed CPACK_OUTPUT_FILE_NAME */
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
+  /* replace the TEMPORARY package file name */
+  this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                  packageFileName.c_str());
+
+  if (!compInstDirName.empty()) {
+    // Tell CPackRPM.cmake the path where the component is.
+    std::string component_path = "/";
+    component_path += compInstDirName;
+    this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
+                    component_path.c_str());
+  }
+
+  if (this->ReadListFile("CPackRPM.cmake")) {
+    AddGeneratedPackageNames();
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
+                    << std::endl);
+    retval = 0;
+  }
+
+  return retval;
+}
+
+int cmCPackRPMGenerator::PackageFiles()
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
+
+  /* Are we in the component packaging case */
+  if (WantsComponentInstallation()) {
+    // CASE 1 : COMPONENT ALL-IN-ONE package
+    // If ALL COMPONENTS in ONE package has been requested
+    // then the package file is unique and should be open here.
+    if (componentPackageMethod == ONE_PACKAGE) {
+      return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
+    }
+    // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
+    // There will be 1 package for each component group
+    // however one may require to ignore component group and
+    // in this case you'll get 1 package for each component.
+    return PackageComponents(componentPackageMethod ==
+                             ONE_PACKAGE_PER_COMPONENT);
+  }
+  // CASE 3 : NON COMPONENT package.
+  return PackageComponentsAllInOne("");
+}
+
+bool cmCPackRPMGenerator::SupportsComponentInstallation() const
+{
+  return IsOn("CPACK_RPM_COMPONENT_INSTALL");
+}
+
+std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
+    return componentName;
+  }
+
+  if (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));
+  }
+  return componentName;
+}
diff --git a/Source/CPack/cmCPackRPMGenerator.h b/Source/CPack/cmCPackRPMGenerator.h
new file mode 100644
index 0000000..27d3b63
--- /dev/null
+++ b/Source/CPack/cmCPackRPMGenerator.h
@@ -0,0 +1,72 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackRPMGenerator_h
+#define cmCPackRPMGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackGenerator.h"
+
+#include <string>
+
+/** \class cmCPackRPMGenerator
+ * \brief A generator for RPM packages
+ * The idea of the CPack RPM generator is to use
+ * as minimal C++ code as possible.
+ * Ideally the C++ part of the CPack RPM generator
+ * will only 'execute' (aka ->ReadListFile) several
+ * CMake macros files.
+ */
+class cmCPackRPMGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackRPMGenerator, cmCPackGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackRPMGenerator();
+  ~cmCPackRPMGenerator() override;
+
+  static bool CanGenerate()
+  {
+#ifdef __APPLE__
+    // on MacOS enable CPackRPM iff rpmbuild is found
+    std::vector<std::string> locations;
+    locations.push_back("/sw/bin");        // Fink
+    locations.push_back("/opt/local/bin"); // MacPorts
+    return cmSystemTools::FindProgram("rpmbuild") != "" ? true : false;
+#else
+    // legacy behavior on other systems
+    return true;
+#endif
+  }
+
+protected:
+  int InitializeInternal() override;
+  int PackageFiles() override;
+  /**
+   * This method factors out the work done in component packaging case.
+   */
+  int PackageOnePack(std::string const& initialToplevel,
+                     std::string const& packageName);
+  /**
+   * The method used to package files when component
+   * install is used. This will create one
+   * archive for each component group.
+   */
+  int PackageComponents(bool ignoreGroup);
+  /**
+   * Special case of component install where all
+   * components will be put in a single installer.
+   */
+  int PackageComponentsAllInOne(const std::string& compInstDirName);
+  const char* GetOutputExtension() override { return ".rpm"; }
+  bool SupportsComponentInstallation() const override;
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) override;
+
+  void AddGeneratedPackageNames();
+};
+
+#endif
diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx
new file mode 100644
index 0000000..3d7fd3c
--- /dev/null
+++ b/Source/CPack/cmCPackSTGZGenerator.cxx
@@ -0,0 +1,112 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackSTGZGenerator.h"
+
+#include "cmsys/FStream.hxx"
+#include <sstream>
+#include <stdio.h>
+#include <string>
+
+#include "cmCPackGenerator.h"
+#include "cmCPackLog.h"
+#include "cmSystemTools.h"
+#include "cm_sys_stat.h"
+
+cmCPackSTGZGenerator::cmCPackSTGZGenerator()
+{
+}
+
+cmCPackSTGZGenerator::~cmCPackSTGZGenerator()
+{
+}
+
+int cmCPackSTGZGenerator::InitializeInternal()
+{
+  this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
+
+  std::string inFile = this->FindTemplate("CPack.STGZ_Header.sh.in");
+  if (inFile.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find template file: " << inFile << std::endl);
+    return 0;
+  }
+  this->SetOptionIfNotSet("CPACK_STGZ_HEADER_FILE", inFile.c_str());
+  this->SetOptionIfNotSet("CPACK_AT_SIGN", "@");
+
+  return this->Superclass::InitializeInternal();
+}
+
+int cmCPackSTGZGenerator::PackageFiles()
+{
+  bool retval = true;
+  if (!this->Superclass::PackageFiles()) {
+    return 0;
+  }
+
+  /* TGZ generator (our Superclass) may
+   * have generated several packages (component packaging)
+   * so we must iterate over generated packages.
+   */
+  for (std::string const& pfn : packageFileNames) {
+    retval &= cmSystemTools::SetPermissions(pfn.c_str(),
+#if defined(_MSC_VER) || defined(__MINGW32__)
+                                            S_IREAD | S_IWRITE | S_IEXEC
+#else
+                                            S_IRUSR | S_IWUSR | S_IXUSR |
+                                              S_IRGRP | S_IWGRP | S_IXGRP |
+                                              S_IROTH | S_IWOTH | S_IXOTH
+#endif
+                                            );
+  }
+  return retval;
+}
+
+int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
+{
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Writing header" << std::endl);
+  std::ostringstream str;
+  int counter = 0;
+
+  std::string inLicFile = this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
+  std::string line;
+  cmsys::ifstream ilfs(inLicFile.c_str());
+  std::string licenseText;
+  while (cmSystemTools::GetLineFromStream(ilfs, line)) {
+    licenseText += line + "\n";
+  }
+  this->SetOptionIfNotSet("CPACK_RESOURCE_FILE_LICENSE_CONTENT",
+                          licenseText.c_str());
+
+  const char headerLengthTag[] = "###CPACK_HEADER_LENGTH###";
+
+  // Create the header
+  std::string inFile = this->GetOption("CPACK_STGZ_HEADER_FILE");
+  cmsys::ifstream ifs(inFile.c_str());
+  std::string packageHeaderText;
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
+    packageHeaderText += line + "\n";
+  }
+
+  // Configure in the values
+  std::string res;
+  this->ConfigureString(packageHeaderText, res);
+
+  // Count the lines
+  const char* ptr = res.c_str();
+  while (*ptr) {
+    if (*ptr == '\n') {
+      counter++;
+    }
+    ++ptr;
+  }
+  counter++;
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Number of lines: " << counter
+                                                           << std::endl);
+  char buffer[1024];
+  sprintf(buffer, "%d", counter);
+  cmSystemTools::ReplaceString(res, headerLengthTag, buffer);
+
+  // Write in file
+  *os << res;
+  return this->Superclass::GenerateHeader(os);
+}
diff --git a/Source/CPack/cmCPackSTGZGenerator.h b/Source/CPack/cmCPackSTGZGenerator.h
new file mode 100644
index 0000000..9cf184b
--- /dev/null
+++ b/Source/CPack/cmCPackSTGZGenerator.h
@@ -0,0 +1,35 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackSTGZGenerator_h
+#define cmCPackSTGZGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackGenerator.h"
+#include "cmCPackTGZGenerator.h"
+
+#include <iosfwd>
+
+/** \class cmCPackSTGZGenerator
+ * \brief A generator for Self extractable TGZ files
+ *
+ */
+class cmCPackSTGZGenerator : public cmCPackTGZGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackSTGZGenerator, cmCPackTGZGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackSTGZGenerator();
+  ~cmCPackSTGZGenerator() override;
+
+protected:
+  int PackageFiles() override;
+  int InitializeInternal() override;
+  int GenerateHeader(std::ostream* os) override;
+  const char* GetOutputExtension() override { return ".sh"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackTGZGenerator.cxx b/Source/CPack/cmCPackTGZGenerator.cxx
new file mode 100644
index 0000000..eaf8186
--- /dev/null
+++ b/Source/CPack/cmCPackTGZGenerator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackTGZGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPackTGZGenerator::cmCPackTGZGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressGZip, "paxr")
+{
+}
+
+cmCPackTGZGenerator::~cmCPackTGZGenerator()
+{
+}
diff --git a/Source/CPack/cmCPackTGZGenerator.h b/Source/CPack/cmCPackTGZGenerator.h
new file mode 100644
index 0000000..7be3d9d
--- /dev/null
+++ b/Source/CPack/cmCPackTGZGenerator.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackTGZGenerator_h
+#define cmCPackTGZGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackTGZGenerator
+ * \brief A generator for TGZ files
+ *
+ */
+class cmCPackTGZGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackTGZGenerator, cmCPackArchiveGenerator);
+  /**
+   * Construct generator
+   */
+  cmCPackTGZGenerator();
+  ~cmCPackTGZGenerator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".tar.gz"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackTXZGenerator.cxx b/Source/CPack/cmCPackTXZGenerator.cxx
new file mode 100644
index 0000000..e55e903
--- /dev/null
+++ b/Source/CPack/cmCPackTXZGenerator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackTXZGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPackTXZGenerator::cmCPackTXZGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ, "paxr")
+{
+}
+
+cmCPackTXZGenerator::~cmCPackTXZGenerator()
+{
+}
diff --git a/Source/CPack/cmCPackTXZGenerator.h b/Source/CPack/cmCPackTXZGenerator.h
new file mode 100644
index 0000000..4aa5973
--- /dev/null
+++ b/Source/CPack/cmCPackTXZGenerator.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackTXZGenerator_h
+#define cmCPackTXZGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackTXZGenerator
+ * \brief A generator for TXZ files
+ *
+ */
+class cmCPackTXZGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackTXZGenerator, cmCPackArchiveGenerator);
+  /**
+   * Construct generator
+   */
+  cmCPackTXZGenerator();
+  ~cmCPackTXZGenerator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".tar.xz"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackTarBZip2Generator.cxx b/Source/CPack/cmCPackTarBZip2Generator.cxx
new file mode 100644
index 0000000..c7a3dd4
--- /dev/null
+++ b/Source/CPack/cmCPackTarBZip2Generator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackTarBZip2Generator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPackTarBZip2Generator::cmCPackTarBZip2Generator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressBZip2, "paxr")
+{
+}
+
+cmCPackTarBZip2Generator::~cmCPackTarBZip2Generator()
+{
+}
diff --git a/Source/CPack/cmCPackTarBZip2Generator.h b/Source/CPack/cmCPackTarBZip2Generator.h
new file mode 100644
index 0000000..7975dda
--- /dev/null
+++ b/Source/CPack/cmCPackTarBZip2Generator.h
@@ -0,0 +1,28 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackTarBZip2Generator_h
+#define cmCPackTarBZip2Generator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackTarBZip2Generator
+ * \brief A generator for TarBZip2 files
+ */
+class cmCPackTarBZip2Generator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackTarBZip2Generator, cmCPackArchiveGenerator);
+  /**
+   * Construct generator
+   */
+  cmCPackTarBZip2Generator();
+  ~cmCPackTarBZip2Generator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".tar.bz2"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackTarCompressGenerator.cxx b/Source/CPack/cmCPackTarCompressGenerator.cxx
new file mode 100644
index 0000000..0a7cd97
--- /dev/null
+++ b/Source/CPack/cmCPackTarCompressGenerator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackTarCompressGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPackTarCompressGenerator::cmCPackTarCompressGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressCompress, "paxr")
+{
+}
+
+cmCPackTarCompressGenerator::~cmCPackTarCompressGenerator()
+{
+}
diff --git a/Source/CPack/cmCPackTarCompressGenerator.h b/Source/CPack/cmCPackTarCompressGenerator.h
new file mode 100644
index 0000000..37c7f48
--- /dev/null
+++ b/Source/CPack/cmCPackTarCompressGenerator.h
@@ -0,0 +1,28 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackTarCompressGenerator_h
+#define cmCPackTarCompressGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackTarCompressGenerator
+ * \brief A generator for TarCompress files
+ */
+class cmCPackTarCompressGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackTarCompressGenerator, cmCPackArchiveGenerator);
+  /**
+   * Construct generator
+   */
+  cmCPackTarCompressGenerator();
+  ~cmCPackTarCompressGenerator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".tar.Z"; }
+};
+
+#endif
diff --git a/Source/CPack/cmCPackZIPGenerator.cxx b/Source/CPack/cmCPackZIPGenerator.cxx
new file mode 100644
index 0000000..6b77c36
--- /dev/null
+++ b/Source/CPack/cmCPackZIPGenerator.cxx
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCPackZIPGenerator.h"
+
+#include "cmArchiveWrite.h"
+#include "cmCPackArchiveGenerator.h"
+
+cmCPackZIPGenerator::cmCPackZIPGenerator()
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressNone, "zip")
+{
+}
+
+cmCPackZIPGenerator::~cmCPackZIPGenerator()
+{
+}
diff --git a/Source/CPack/cmCPackZIPGenerator.h b/Source/CPack/cmCPackZIPGenerator.h
new file mode 100644
index 0000000..58ec79e
--- /dev/null
+++ b/Source/CPack/cmCPackZIPGenerator.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackZIPGenerator_h
+#define cmCPackZIPGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCPackArchiveGenerator.h"
+#include "cmCPackGenerator.h"
+
+/** \class cmCPackZIPGenerator
+ * \brief A generator for ZIP files
+ */
+class cmCPackZIPGenerator : public cmCPackArchiveGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackZIPGenerator, cmCPackArchiveGenerator);
+
+  /**
+   * Construct generator
+   */
+  cmCPackZIPGenerator();
+  ~cmCPackZIPGenerator() override;
+
+protected:
+  const char* GetOutputExtension() override { return ".zip"; }
+};
+
+#endif
diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx
new file mode 100644
index 0000000..2b2152c
--- /dev/null
+++ b/Source/CPack/cpack.cxx
@@ -0,0 +1,447 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmsys/CommandLineArguments.hxx"
+#include "cmsys/Encoding.hxx"
+#include <iostream>
+#include <map>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+#include <stddef.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
+#include "cmsys/ConsoleBuf.hxx"
+#endif
+
+#include "cmCPackGenerator.h"
+#include "cmCPackGeneratorFactory.h"
+#include "cmCPackLog.h"
+#include "cmDocumentation.h"
+#include "cmDocumentationEntry.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateSnapshot.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+static const char* cmDocumentationName[][2] = {
+  { nullptr, "  cpack - Packaging driver provided by CMake." },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationUsage[][2] = {
+  { nullptr, "  cpack -G <generator> [options]" },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationOptions[][2] = {
+  { "-G <generator>", "Use the specified generator to generate package." },
+  { "-C <Configuration>", "Specify the project configuration" },
+  { "-D <var>=<value>", "Set a CPack variable." },
+  { "--config <config file>", "Specify the config file." },
+  { "--verbose,-V", "enable verbose output" },
+  { "--trace", "Put underlying cmake scripts in trace mode." },
+  { "--trace-expand", "Put underlying cmake scripts in expanded trace mode." },
+  { "--debug", "enable debug output (for CPack developers)" },
+  { "-P <package name>", "override/define CPACK_PACKAGE_NAME" },
+  { "-R <package version>", "override/define CPACK_PACKAGE_VERSION" },
+  { "-B <package directory>", "override/define CPACK_PACKAGE_DIRECTORY" },
+  { "--vendor <vendor name>", "override/define CPACK_PACKAGE_VENDOR" },
+  { nullptr, nullptr }
+};
+
+int cpackUnknownArgument(const char* /*unused*/, void* /*unused*/)
+{
+  return 1;
+}
+
+struct cpackDefinitions
+{
+  typedef std::map<std::string, std::string> MapType;
+  MapType Map;
+  cmCPackLog* Log;
+};
+
+int cpackDefinitionArgument(const char* argument, const char* cValue,
+                            void* call_data)
+{
+  (void)argument;
+  cpackDefinitions* def = static_cast<cpackDefinitions*>(call_data);
+  std::string value = cValue;
+  size_t pos = value.find_first_of('=');
+  if (pos == std::string::npos) {
+    cmCPack_Log(def->Log, cmCPackLog::LOG_ERROR,
+                "Please specify CPack definitions as: KEY=VALUE" << std::endl);
+    return 0;
+  }
+  std::string key = value.substr(0, pos);
+  value = value.c_str() + pos + 1;
+  def->Map[key] = value;
+  cmCPack_Log(def->Log, cmCPackLog::LOG_DEBUG, "Set CPack variable: "
+                << key << " to \"" << value << "\"" << std::endl);
+  return 1;
+}
+
+// this is CPack.
+int main(int argc, char const* const* argv)
+{
+#if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
+  // Replace streambuf so we can output Unicode to console
+  cmsys::ConsoleBuf::Manager consoleOut(std::cout);
+  consoleOut.SetUTF8Pipes();
+  cmsys::ConsoleBuf::Manager consoleErr(std::cerr, true);
+  consoleErr.SetUTF8Pipes();
+#endif
+  cmsys::Encoding::CommandLineArguments args =
+    cmsys::Encoding::CommandLineArguments::Main(argc, argv);
+  argc = args.argc();
+  argv = args.argv();
+
+  cmSystemTools::EnableMSVCDebugHook();
+  cmSystemTools::InitializeLibUV();
+  cmSystemTools::FindCMakeResources(argv[0]);
+  cmCPackLog log;
+
+  log.SetErrorPrefix("CPack Error: ");
+  log.SetWarningPrefix("CPack Warning: ");
+  log.SetOutputPrefix("CPack: ");
+  log.SetVerbosePrefix("CPack Verbose: ");
+
+  if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
+    cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                "Current working directory cannot be established."
+                  << std::endl);
+    return 1;
+  }
+
+  std::string generator;
+  bool help = false;
+  bool helpVersion = false;
+  bool verbose = false;
+  bool trace = false;
+  bool traceExpand = false;
+  bool debug = false;
+  std::string helpFull;
+  std::string helpMAN;
+  std::string helpHTML;
+
+  std::string cpackProjectName;
+  std::string cpackProjectDirectory;
+  std::string cpackBuildConfig;
+  std::string cpackProjectVersion;
+  std::string cpackProjectPatch;
+  std::string cpackProjectVendor;
+  std::string cpackConfigFile;
+
+  cpackDefinitions definitions;
+  definitions.Log = &log;
+
+  cpackConfigFile.clear();
+
+  cmsys::CommandLineArguments arg;
+  arg.Initialize(argc, argv);
+  typedef cmsys::CommandLineArguments argT;
+  // Help arguments
+  arg.AddArgument("--help", argT::NO_ARGUMENT, &help, "CPack help");
+  arg.AddArgument("--help-full", argT::SPACE_ARGUMENT, &helpFull,
+                  "CPack help");
+  arg.AddArgument("--help-html", argT::SPACE_ARGUMENT, &helpHTML,
+                  "CPack help");
+  arg.AddArgument("--help-man", argT::SPACE_ARGUMENT, &helpMAN, "CPack help");
+  arg.AddArgument("--version", argT::NO_ARGUMENT, &helpVersion, "CPack help");
+
+  arg.AddArgument("-V", argT::NO_ARGUMENT, &verbose, "CPack verbose");
+  arg.AddArgument("--verbose", argT::NO_ARGUMENT, &verbose, "-V");
+  arg.AddArgument("--debug", argT::NO_ARGUMENT, &debug, "-V");
+  arg.AddArgument("--config", argT::SPACE_ARGUMENT, &cpackConfigFile,
+                  "CPack configuration file");
+  arg.AddArgument("--trace", argT::NO_ARGUMENT, &trace,
+                  "Put underlying cmake scripts in trace mode.");
+  arg.AddArgument("--trace-expand", argT::NO_ARGUMENT, &traceExpand,
+                  "Put underlying cmake scripts in expanded trace mode.");
+  arg.AddArgument("-C", argT::SPACE_ARGUMENT, &cpackBuildConfig,
+                  "CPack build configuration");
+  arg.AddArgument("-G", argT::SPACE_ARGUMENT, &generator, "CPack generator");
+  arg.AddArgument("-P", argT::SPACE_ARGUMENT, &cpackProjectName,
+                  "CPack project name");
+  arg.AddArgument("-R", argT::SPACE_ARGUMENT, &cpackProjectVersion,
+                  "CPack project version");
+  arg.AddArgument("-B", argT::SPACE_ARGUMENT, &cpackProjectDirectory,
+                  "CPack project directory");
+  arg.AddArgument("--patch", argT::SPACE_ARGUMENT, &cpackProjectPatch,
+                  "CPack project patch");
+  arg.AddArgument("--vendor", argT::SPACE_ARGUMENT, &cpackProjectVendor,
+                  "CPack project vendor");
+  arg.AddCallback("-D", argT::SPACE_ARGUMENT, cpackDefinitionArgument,
+                  &definitions, "CPack Definitions");
+  arg.SetUnknownArgumentCallback(cpackUnknownArgument);
+
+  // Parse command line
+  int parsed = arg.Parse();
+
+  // Setup logging
+  if (verbose) {
+    log.SetVerbose(verbose);
+    cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Verbose" << std::endl);
+  }
+  if (debug) {
+    log.SetDebug(debug);
+    cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Debug" << std::endl);
+  }
+
+  cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
+              "Read CPack config file: " << cpackConfigFile << std::endl);
+
+  cmake cminst(cmake::RoleScript);
+  cminst.SetHomeDirectory("");
+  cminst.SetHomeOutputDirectory("");
+  cminst.GetCurrentSnapshot().SetDefaultDefinitions();
+  cmGlobalGenerator cmgg(&cminst);
+  cmMakefile globalMF(&cmgg, cminst.GetCurrentSnapshot());
+#if defined(__CYGWIN__)
+  globalMF.AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");
+#endif
+
+  if (trace) {
+    cminst.SetTrace(true);
+  }
+  if (traceExpand) {
+    cminst.SetTrace(true);
+    cminst.SetTraceExpand(true);
+  }
+
+  bool cpackConfigFileSpecified = true;
+  if (cpackConfigFile.empty()) {
+    cpackConfigFile = cmSystemTools::GetCurrentWorkingDirectory();
+    cpackConfigFile += "/CPackConfig.cmake";
+    cpackConfigFileSpecified = false;
+  }
+
+  cmCPackGeneratorFactory generators;
+  generators.SetLogger(&log);
+  cmCPackGenerator* cpackGenerator = nullptr;
+
+  cmDocumentation doc;
+  doc.addCPackStandardDocSections();
+  /* Were we invoked to display doc or to do some work ?
+   * Unlike cmake launching cpack with zero argument
+   * should launch cpack using "cpackConfigFile" if it exists
+   * in the current directory.
+   */
+  help = doc.CheckOptions(argc, argv, "-G") && argc != 1;
+
+  // This part is used for cpack documentation lookup as well.
+  cminst.AddCMakePaths();
+
+  if (parsed && !help) {
+    // find out which system cpack is running on, so it can setup the search
+    // paths, so FIND_XXX() commands can be used in scripts
+    std::string systemFile =
+      globalMF.GetModulesFile("CMakeDetermineSystem.cmake");
+    if (!globalMF.ReadListFile(systemFile.c_str())) {
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                  "Error reading CMakeDetermineSystem.cmake" << std::endl);
+      return 1;
+    }
+
+    systemFile =
+      globalMF.GetModulesFile("CMakeSystemSpecificInformation.cmake");
+    if (!globalMF.ReadListFile(systemFile.c_str())) {
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                  "Error reading CMakeSystemSpecificInformation.cmake"
+                    << std::endl);
+      return 1;
+    }
+
+    if (!cpackBuildConfig.empty()) {
+      globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
+    }
+
+    if (cmSystemTools::FileExists(cpackConfigFile.c_str())) {
+      cpackConfigFile = cmSystemTools::CollapseFullPath(cpackConfigFile);
+      cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
+                  "Read CPack configuration file: " << cpackConfigFile
+                                                    << std::endl);
+      if (!globalMF.ReadListFile(cpackConfigFile.c_str())) {
+        cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                    "Problem reading CPack config file: \""
+                      << cpackConfigFile << "\"" << std::endl);
+        return 1;
+      }
+    } else if (cpackConfigFileSpecified) {
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                  "Cannot find CPack config file: \"" << cpackConfigFile
+                                                      << "\"" << std::endl);
+      return 1;
+    }
+
+    if (!generator.empty()) {
+      globalMF.AddDefinition("CPACK_GENERATOR", generator.c_str());
+    }
+    if (!cpackProjectName.empty()) {
+      globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str());
+    }
+    if (!cpackProjectVersion.empty()) {
+      globalMF.AddDefinition("CPACK_PACKAGE_VERSION",
+                             cpackProjectVersion.c_str());
+    }
+    if (!cpackProjectVendor.empty()) {
+      globalMF.AddDefinition("CPACK_PACKAGE_VENDOR",
+                             cpackProjectVendor.c_str());
+    }
+    // if this is not empty it has been set on the command line
+    // go for it. Command line override values set in config file.
+    if (!cpackProjectDirectory.empty()) {
+      globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY",
+                             cpackProjectDirectory.c_str());
+    }
+    // The value has not been set on the command line
+    else {
+      // get a default value (current working directory)
+      cpackProjectDirectory = cmsys::SystemTools::GetCurrentWorkingDirectory();
+      // use default value iff no value has been provided by the config file
+      if (!globalMF.IsSet("CPACK_PACKAGE_DIRECTORY")) {
+        globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY",
+                               cpackProjectDirectory.c_str());
+      }
+    }
+    for (auto const& cd : definitions.Map) {
+      globalMF.AddDefinition(cd.first, cd.second.c_str());
+    }
+
+    const char* cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH");
+    if (cpackModulesPath) {
+      globalMF.AddDefinition("CMAKE_MODULE_PATH", cpackModulesPath);
+    }
+    const char* genList = globalMF.GetDefinition("CPACK_GENERATOR");
+    if (!genList) {
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "CPack generator not specified"
+                    << std::endl);
+    } else {
+      std::vector<std::string> generatorsVector;
+      cmSystemTools::ExpandListArgument(genList, generatorsVector);
+      for (std::string const& gen : generatorsVector) {
+        cmMakefile::ScopePushPop raii(&globalMF);
+        cmMakefile* mf = &globalMF;
+        cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
+                    "Specified generator: " << gen << std::endl);
+        if (parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME")) {
+          cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                      "CPack project name not specified" << std::endl);
+          parsed = 0;
+        }
+        if (parsed &&
+            !(mf->GetDefinition("CPACK_PACKAGE_VERSION") ||
+              (mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR") &&
+               mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR") &&
+               mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH")))) {
+          cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                      "CPack project version not specified"
+                        << std::endl
+                        << "Specify CPACK_PACKAGE_VERSION, or "
+                           "CPACK_PACKAGE_VERSION_MAJOR, "
+                           "CPACK_PACKAGE_VERSION_MINOR, and "
+                           "CPACK_PACKAGE_VERSION_PATCH."
+                        << std::endl);
+          parsed = 0;
+        }
+        if (parsed) {
+          cpackGenerator = generators.NewGenerator(gen);
+          if (!cpackGenerator) {
+            cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                        "Cannot initialize CPack generator: " << gen
+                                                              << std::endl);
+            parsed = 0;
+          }
+
+          cpackGenerator->SetTrace(trace);
+          cpackGenerator->SetTraceExpand(traceExpand);
+
+          if (parsed && !cpackGenerator->Initialize(gen, mf)) {
+            cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                        "Cannot initialize the generator " << gen
+                                                           << std::endl);
+            parsed = 0;
+          }
+
+          if (!mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
+              !mf->GetDefinition("CPACK_INSTALL_SCRIPT") &&
+              !mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
+              !mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS")) {
+            cmCPack_Log(
+              &log, cmCPackLog::LOG_ERROR,
+              "Please specify build tree of the project that uses CMake "
+              "using CPACK_INSTALL_CMAKE_PROJECTS, specify "
+              "CPACK_INSTALL_COMMANDS, CPACK_INSTALL_SCRIPT, or "
+              "CPACK_INSTALLED_DIRECTORIES."
+                << std::endl);
+            parsed = 0;
+          }
+          if (parsed) {
+            const char* projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
+            cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE, "Use generator: "
+                          << cpackGenerator->GetNameOfClass() << std::endl);
+            cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
+                        "For project: " << projName << std::endl);
+
+            const char* projVersion =
+              mf->GetDefinition("CPACK_PACKAGE_VERSION");
+            if (!projVersion) {
+              const char* projVersionMajor =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
+              const char* projVersionMinor =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
+              const char* projVersionPatch =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
+              std::ostringstream ostr;
+              ostr << projVersionMajor << "." << projVersionMinor << "."
+                   << projVersionPatch;
+              mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str());
+            }
+
+            int res = cpackGenerator->DoPackage();
+            if (!res) {
+              cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+                          "Error when generating package: " << projName
+                                                            << std::endl);
+              return 1;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /* In this case we are building the documentation object
+   * instance in order to create appropriate structure
+   * in order to satisfy the appropriate --help-xxx request
+   */
+  if (help) {
+    // Construct and print requested documentation.
+
+    doc.SetName("cpack");
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    doc.PrependSection("Options", cmDocumentationOptions);
+
+    std::vector<cmDocumentationEntry> v;
+    for (auto const& g : generators.GetGeneratorsList()) {
+      cmDocumentationEntry e;
+      e.Name = g.first;
+      e.Brief = g.second;
+      v.push_back(e);
+    }
+    doc.SetSection("Generators", v);
+
+    return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
+  }
+
+  if (cmSystemTools::GetErrorOccuredFlag()) {
+    return 1;
+  }
+
+  return 0;
+}
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
new file mode 100644
index 0000000..0152200
--- /dev/null
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -0,0 +1,473 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestBZR.h"
+
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+
+#include "cm_expat.h"
+#include "cmsys/RegularExpression.hxx"
+#include <list>
+#include <map>
+#include <ostream>
+#include <stdlib.h>
+#include <vector>
+
+extern "C" int cmBZRXMLParserUnknownEncodingHandler(void* /*unused*/,
+                                                    const XML_Char* name,
+                                                    XML_Encoding* info)
+{
+  static const int latin1[] = {
+    0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+    0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011,
+    0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A,
+    0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020, 0x0021, 0x0022, 0x0023,
+    0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C,
+    0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
+    0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E,
+    0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
+    0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
+    0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0062,
+    0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
+    0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
+    0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D,
+    0x007E, 0x007F, 0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020,
+    0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC,
+    0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178, 0x00A0, 0x00A1,
+    0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA,
+    0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3,
+    0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC,
+    0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5,
+    0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE,
+    0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+    0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
+    0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
+    0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2,
+    0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB,
+    0x00FC, 0x00FD, 0x00FE, 0x00FF
+  };
+
+  // The BZR xml output plugin can use some encodings that are not
+  // recognized by expat.  This will lead to an error, e.g. "Error
+  // parsing bzr log xml: unknown encoding", the following is a
+  // workaround for these unknown encodings.
+  if (name == std::string("ascii") || name == std::string("cp1252") ||
+      name == std::string("ANSI_X3.4-1968")) {
+    for (unsigned int i = 0; i < 256; ++i) {
+      info->map[i] = latin1[i];
+    }
+    return 1;
+  }
+
+  return 0;
+}
+
+cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+  // Even though it is specified in the documentation, with bzr 1.13
+  // BZR_PROGRESS_BAR has no effect. In the future this bug might be fixed.
+  // Since it doesn't hurt, we specify this environment variable.
+  cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none");
+}
+
+cmCTestBZR::~cmCTestBZR()
+{
+}
+
+class cmCTestBZR::InfoParser : public cmCTestVC::LineParser
+{
+public:
+  InfoParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+    , CheckOutFound(false)
+  {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
+    this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
+  }
+
+private:
+  cmCTestBZR* BZR;
+  bool CheckOutFound;
+  cmsys::RegularExpression RegexCheckOut;
+  cmsys::RegularExpression RegexParent;
+  bool ProcessLine() override
+  {
+    if (this->RegexCheckOut.find(this->Line)) {
+      this->BZR->URL = this->RegexCheckOut.match(1);
+      CheckOutFound = true;
+    } else if (!CheckOutFound && this->RegexParent.find(this->Line)) {
+      this->BZR->URL = this->RegexParent.match(1);
+    }
+    return true;
+  }
+};
+
+class cmCTestBZR::RevnoParser : public cmCTestVC::LineParser
+{
+public:
+  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexRevno.compile("^([0-9]+)$");
+  }
+
+private:
+  std::string& Rev;
+  cmsys::RegularExpression RegexRevno;
+  bool ProcessLine() override
+  {
+    if (this->RegexRevno.find(this->Line)) {
+      this->Rev = this->RegexRevno.match(1);
+    }
+    return true;
+  }
+};
+
+std::string cmCTestBZR::LoadInfo()
+{
+  // Run "bzr info" to get the repository info from the work tree.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_info[] = { bzr, "info", nullptr };
+  InfoParser iout(this, "info-out> ");
+  OutputLogger ierr(this->Log, "info-err> ");
+  this->RunChild(bzr_info, &iout, &ierr);
+
+  // Run "bzr revno" to get the repository revision number from the work tree.
+  const char* bzr_revno[] = { bzr, "revno", nullptr };
+  std::string rev;
+  RevnoParser rout(this, "revno-out> ", rev);
+  OutputLogger rerr(this->Log, "revno-err> ");
+  this->RunChild(bzr_revno, &rout, &rerr);
+
+  return rev;
+}
+
+bool cmCTestBZR::NoteOldRevision()
+{
+  this->OldRevision = this->LoadInfo();
+  this->Log << "Revision before update: " << this->OldRevision << "\n";
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
+               << this->OldRevision << "\n");
+  this->PriorRev.Rev = this->OldRevision;
+  return true;
+}
+
+bool cmCTestBZR::NoteNewRevision()
+{
+  this->NewRevision = this->LoadInfo();
+  this->Log << "Revision after update: " << this->NewRevision << "\n";
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
+               << this->NewRevision << "\n");
+  this->Log << "URL = " << this->URL << "\n";
+  return true;
+}
+
+class cmCTestBZR::LogParser : public cmCTestVC::OutputLogger,
+                              private cmXMLParser
+{
+public:
+  LogParser(cmCTestBZR* bzr, const char* prefix)
+    : OutputLogger(bzr->Log, prefix)
+    , BZR(bzr)
+    , EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
+  {
+    this->InitializeParser();
+  }
+  ~LogParser() override { this->CleanupParser(); }
+
+  int InitializeParser() override
+  {
+    int res = cmXMLParser::InitializeParser();
+    if (res) {
+      XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
+                                    cmBZRXMLParserUnknownEncodingHandler,
+                                    nullptr);
+    }
+    return res;
+  }
+
+private:
+  cmCTestBZR* BZR;
+
+  typedef cmCTestBZR::Revision Revision;
+  typedef cmCTestBZR::Change Change;
+  Revision Rev;
+  std::vector<Change> Changes;
+  Change CurChange;
+  std::vector<char> CData;
+
+  cmsys::RegularExpression EmailRegex;
+
+  bool ProcessChunk(const char* data, int length) override
+  {
+    this->OutputLogger::ProcessChunk(data, length);
+    this->ParseChunk(data, length);
+    return true;
+  }
+
+  void StartElement(const std::string& name, const char** /*atts*/) override
+  {
+    this->CData.clear();
+    if (name == "log") {
+      this->Rev = Revision();
+      this->Changes.clear();
+    }
+    // affected-files can contain blocks of
+    // modified, unknown, renamed, kind-changed, removed, conflicts, added
+    else if (name == "modified" || name == "renamed" ||
+             name == "kind-changed") {
+      this->CurChange = Change();
+      this->CurChange.Action = 'M';
+    } else if (name == "added") {
+      this->CurChange = Change();
+      this->CurChange = 'A';
+    } else if (name == "removed") {
+      this->CurChange = Change();
+      this->CurChange = 'D';
+    } else if (name == "unknown" || name == "conflicts") {
+      // Should not happen here
+      this->CurChange = Change();
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
+
+  void EndElement(const std::string& name) override
+  {
+    if (name == "log") {
+      this->BZR->DoRevision(this->Rev, this->Changes);
+    } else if (!this->CData.empty() &&
+               (name == "file" || name == "directory")) {
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size());
+      cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
+      this->Changes.push_back(this->CurChange);
+    } else if (!this->CData.empty() && name == "symlink") {
+      // symlinks have an arobase at the end in the log
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size() - 1);
+      cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
+      this->Changes.push_back(this->CurChange);
+    } else if (!this->CData.empty() && name == "committer") {
+      this->Rev.Author.assign(&this->CData[0], this->CData.size());
+      if (this->EmailRegex.find(this->Rev.Author)) {
+        this->Rev.Author = this->EmailRegex.match(1);
+        this->Rev.EMail = this->EmailRegex.match(2);
+      }
+    } else if (!this->CData.empty() && name == "timestamp") {
+      this->Rev.Date.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "message") {
+      this->Rev.Log.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "revno") {
+      this->Rev.Rev.assign(&this->CData[0], this->CData.size());
+    }
+    this->CData.clear();
+  }
+
+  void ReportError(int /*line*/, int /*column*/, const char* msg) override
+  {
+    this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
+  }
+};
+
+class cmCTestBZR::UpdateParser : public cmCTestVC::LineParser
+{
+public:
+  UpdateParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
+  }
+
+private:
+  cmCTestBZR* BZR;
+  cmsys::RegularExpression RegexUpdate;
+
+  bool ProcessChunk(const char* first, int length) override
+  {
+    bool last_is_new_line = (*first == '\r' || *first == '\n');
+
+    const char* const last = first + length;
+    for (const char* c = first; c != last; ++c) {
+      if (*c == '\r' || *c == '\n') {
+        if (!last_is_new_line) {
+          // Log this line.
+          if (this->Log && this->Prefix) {
+            *this->Log << this->Prefix << this->Line << "\n";
+          }
+
+          // Hand this line to the subclass implementation.
+          if (!this->ProcessLine()) {
+            this->Line.clear();
+            return false;
+          }
+
+          this->Line.clear();
+          last_is_new_line = true;
+        }
+      } else {
+        // Append this character to the line under construction.
+        this->Line.append(1, *c);
+        last_is_new_line = false;
+      }
+    }
+    return true;
+  }
+
+  bool ProcessLine() override
+  {
+    if (this->RegexUpdate.find(this->Line)) {
+      this->DoPath(this->RegexUpdate.match(1)[0],
+                   this->RegexUpdate.match(2)[0],
+                   this->RegexUpdate.match(3)[0], this->RegexUpdate.match(4));
+    }
+    return true;
+  }
+
+  void DoPath(char c0, char c1, char c2, std::string path)
+  {
+    if (path.empty()) {
+      return;
+    }
+    cmSystemTools::ConvertToUnixSlashes(path);
+
+    const std::string dir = cmSystemTools::GetFilenamePath(path);
+    const std::string name = cmSystemTools::GetFilenameName(path);
+
+    if (c0 == 'C') {
+      this->BZR->Dirs[dir][name].Status = PathConflicting;
+      return;
+    }
+
+    if (c1 == 'M' || c1 == 'K' || c1 == 'N' || c1 == 'D' || c2 == '*') {
+      this->BZR->Dirs[dir][name].Status = PathUpdated;
+      return;
+    }
+  }
+};
+
+bool cmCTestBZR::UpdateImpl()
+{
+  // Get user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+
+  // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
+
+  // Use "bzr pull" to update the working tree.
+  std::vector<char const*> bzr_update;
+  bzr_update.push_back(this->CommandLineTool.c_str());
+  bzr_update.push_back("pull");
+
+  for (std::string const& arg : args) {
+    bzr_update.push_back(arg.c_str());
+  }
+
+  bzr_update.push_back(this->URL.c_str());
+
+  bzr_update.push_back(nullptr);
+
+  // For some reason bzr uses stderr to display the update status.
+  OutputLogger out(this->Log, "pull-out> ");
+  UpdateParser err(this, "pull-err> ");
+  return this->RunUpdateCommand(&bzr_update[0], &out, &err);
+}
+
+bool cmCTestBZR::LoadRevisions()
+{
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Gathering version information (one . per revision):\n"
+             "    "
+               << std::flush);
+
+  // We are interested in every revision included in the update.
+  this->Revisions.clear();
+  std::string revs;
+  if (atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str())) {
+    // DoRevision takes care of discarding the information about OldRevision
+    revs = this->OldRevision + ".." + this->NewRevision;
+  } else {
+    return true;
+  }
+
+  // Run "bzr log" to get all global revisions of interest.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_log[] = {
+    bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), nullptr
+  };
+  {
+    LogParser out(this, "log-out> ");
+    OutputLogger err(this->Log, "log-err> ");
+    this->RunChild(bzr_log, &out, &err);
+  }
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+  return true;
+}
+
+class cmCTestBZR::StatusParser : public cmCTestVC::LineParser
+{
+public:
+  StatusParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
+    this->SetLog(&bzr->Log, prefix);
+    this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
+  }
+
+private:
+  cmCTestBZR* BZR;
+  cmsys::RegularExpression RegexStatus;
+  bool ProcessLine() override
+  {
+    if (this->RegexStatus.find(this->Line)) {
+      this->DoPath(this->RegexStatus.match(1)[0],
+                   this->RegexStatus.match(2)[0],
+                   this->RegexStatus.match(3)[0], this->RegexStatus.match(4));
+    }
+    return true;
+  }
+
+  void DoPath(char c0, char c1, char c2, std::string path)
+  {
+    if (path.empty()) {
+      return;
+    }
+    cmSystemTools::ConvertToUnixSlashes(path);
+
+    if (c0 == 'C') {
+      this->BZR->DoModification(PathConflicting, path);
+      return;
+    }
+
+    if (c0 == '+' || c0 == 'R' || c0 == 'P' || c1 == 'M' || c1 == 'K' ||
+        c1 == 'N' || c1 == 'D' || c2 == '*') {
+      this->BZR->DoModification(PathModified, path);
+      return;
+    }
+  }
+};
+
+bool cmCTestBZR::LoadModifications()
+{
+  // Run "bzr status" which reports local modifications.
+  const char* bzr = this->CommandLineTool.c_str();
+  const char* bzr_status[] = { bzr, "status", "-SV", nullptr };
+  StatusParser out(this, "status-out> ");
+  OutputLogger err(this->Log, "status-err> ");
+  this->RunChild(bzr_status, &out, &err);
+  return true;
+}
diff --git a/Source/CTest/cmCTestBZR.h b/Source/CTest/cmCTestBZR.h
new file mode 100644
index 0000000..d5c78c7
--- /dev/null
+++ b/Source/CTest/cmCTestBZR.h
@@ -0,0 +1,54 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestBZR_h
+#define cmCTestBZR_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGlobalVC.h"
+
+#include <iosfwd>
+#include <string>
+
+class cmCTest;
+
+/** \class cmCTestBZR
+ * \brief Interaction with bzr command-line tool
+ *
+ */
+class cmCTestBZR : public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestBZR(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestBZR() override;
+
+private:
+  // Implement cmCTestVC internal API.
+  bool NoteOldRevision() override;
+  bool NoteNewRevision() override;
+  bool UpdateImpl() override;
+
+  // URL of repository directory checked out in the working tree.
+  std::string URL;
+
+  std::string LoadInfo();
+  bool LoadModifications() override;
+  bool LoadRevisions() override;
+
+  // Parsing helper classes.
+  class InfoParser;
+  class LogParser;
+  class RevnoParser;
+  class StatusParser;
+  class UpdateParser;
+
+  friend class InfoParser;
+  friend class LogParser;
+  friend class RevnoParser;
+  friend class UpdateParser;
+  friend class StatusParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
new file mode 100644
index 0000000..85d98d0
--- /dev/null
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -0,0 +1,445 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestBuildAndTestHandler.h"
+
+#include "cmCTest.h"
+#include "cmCTestTestHandler.h"
+#include "cmGlobalGenerator.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+#include "cmake.h"
+
+#include "cmsys/Process.h"
+#include <chrono>
+#include <ratio>
+#include <stdlib.h>
+
+cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
+{
+  this->BuildTwoConfig = false;
+  this->BuildNoClean = false;
+  this->BuildNoCMake = false;
+  this->Timeout = std::chrono::duration<double>::zero();
+}
+
+void cmCTestBuildAndTestHandler::Initialize()
+{
+  this->BuildTargets.clear();
+  this->Superclass::Initialize();
+}
+
+const char* cmCTestBuildAndTestHandler::GetOutput()
+{
+  return this->Output.c_str();
+}
+int cmCTestBuildAndTestHandler::ProcessHandler()
+{
+  this->Output.clear();
+  std::string output;
+  cmSystemTools::ResetErrorOccuredFlag();
+  int retv = this->RunCMakeAndTest(&this->Output);
+  cmSystemTools::ResetErrorOccuredFlag();
+  return retv;
+}
+
+int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
+                                         std::ostringstream& out,
+                                         std::string& cmakeOutString,
+                                         cmake* cm)
+{
+  std::vector<std::string> args;
+  args.push_back(cmSystemTools::GetCMakeCommand());
+  args.push_back(this->SourceDir);
+  if (!this->BuildGenerator.empty()) {
+    std::string generator = "-G";
+    generator += this->BuildGenerator;
+    args.push_back(generator);
+  }
+  if (!this->BuildGeneratorPlatform.empty()) {
+    std::string platform = "-A";
+    platform += this->BuildGeneratorPlatform;
+    args.push_back(platform);
+  }
+  if (!this->BuildGeneratorToolset.empty()) {
+    std::string toolset = "-T";
+    toolset += this->BuildGeneratorToolset;
+    args.push_back(toolset);
+  }
+
+  const char* config = nullptr;
+  if (!this->CTest->GetConfigType().empty()) {
+    config = this->CTest->GetConfigType().c_str();
+  }
+#ifdef CMAKE_INTDIR
+  if (!config) {
+    config = CMAKE_INTDIR;
+  }
+#endif
+
+  if (config) {
+    std::string btype = "-DCMAKE_BUILD_TYPE:STRING=" + std::string(config);
+    args.push_back(btype);
+  }
+
+  for (std::string const& opt : this->BuildOptions) {
+    args.push_back(opt);
+  }
+  if (cm->Run(args) != 0) {
+    out << "Error: cmake execution failed\n";
+    out << cmakeOutString << "\n";
+    if (outstring) {
+      *outstring = out.str();
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
+    }
+    return 1;
+  }
+  // do another config?
+  if (this->BuildTwoConfig) {
+    if (cm->Run(args) != 0) {
+      out << "Error: cmake execution failed\n";
+      out << cmakeOutString << "\n";
+      if (outstring) {
+        *outstring = out.str();
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
+      }
+      return 1;
+    }
+  }
+  out << "======== CMake output     ======\n";
+  out << cmakeOutString;
+  out << "======== End CMake output ======\n";
+  return 0;
+}
+
+void CMakeMessageCallback(const char* m, const char* /*unused*/,
+                          bool& /*unused*/, void* s)
+{
+  std::string* out = static_cast<std::string*>(s);
+  *out += m;
+  *out += "\n";
+}
+
+void CMakeProgressCallback(const char* msg, float /*unused*/, void* s)
+{
+  std::string* out = static_cast<std::string*>(s);
+  *out += msg;
+  *out += "\n";
+}
+
+void CMakeOutputCallback(const char* m, size_t len, void* s)
+{
+  std::string* out = static_cast<std::string*>(s);
+  out->append(m, len);
+}
+
+class cmCTestBuildAndTestCaptureRAII
+{
+  cmake& CM;
+
+public:
+  cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s)
+    : CM(cm)
+  {
+    cmSystemTools::SetMessageCallback(CMakeMessageCallback, &s);
+    cmSystemTools::SetStdoutCallback(CMakeOutputCallback, &s);
+    cmSystemTools::SetStderrCallback(CMakeOutputCallback, &s);
+    this->CM.SetProgressCallback(CMakeProgressCallback, &s);
+  }
+  ~cmCTestBuildAndTestCaptureRAII()
+  {
+    this->CM.SetProgressCallback(nullptr, nullptr);
+    cmSystemTools::SetStderrCallback(nullptr, nullptr);
+    cmSystemTools::SetStdoutCallback(nullptr, nullptr);
+    cmSystemTools::SetMessageCallback(nullptr, nullptr);
+  }
+};
+
+int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
+{
+  // if the generator and make program are not specified then it is an error
+  if (this->BuildGenerator.empty()) {
+    if (outstring) {
+      *outstring = "--build-and-test requires that the generator "
+                   "be provided using the --build-generator "
+                   "command line option. ";
+    }
+    return 1;
+  }
+
+  cmake cm(cmake::RoleProject);
+  cm.SetHomeDirectory("");
+  cm.SetHomeOutputDirectory("");
+  std::string cmakeOutString;
+  cmCTestBuildAndTestCaptureRAII captureRAII(cm, cmakeOutString);
+  static_cast<void>(captureRAII);
+  std::ostringstream out;
+
+  if (this->CTest->GetConfigType().empty() && !this->ConfigSample.empty()) {
+    // use the config sample to set the ConfigType
+    std::string fullPath;
+    std::string resultingConfig;
+    std::vector<std::string> extraPaths;
+    std::vector<std::string> failed;
+    fullPath = cmCTestTestHandler::FindExecutable(
+      this->CTest, this->ConfigSample.c_str(), resultingConfig, extraPaths,
+      failed);
+    if (!fullPath.empty() && !resultingConfig.empty()) {
+      this->CTest->SetConfigType(resultingConfig.c_str());
+    }
+    out << "Using config sample with results: " << fullPath << " and "
+        << resultingConfig << std::endl;
+  }
+
+  // we need to honor the timeout specified, the timeout include cmake, build
+  // and test time
+  auto clock_start = std::chrono::steady_clock::now();
+
+  // make sure the binary dir is there
+  out << "Internal cmake changing into directory: " << this->BinaryDir
+      << std::endl;
+  if (!cmSystemTools::FileIsDirectory(this->BinaryDir)) {
+    cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
+  }
+  cmWorkingDirectory workdir(this->BinaryDir);
+
+  if (this->BuildNoCMake) {
+    // Make the generator available for the Build call below.
+    cm.SetGlobalGenerator(cm.CreateGlobalGenerator(this->BuildGenerator));
+    cm.SetGeneratorPlatform(this->BuildGeneratorPlatform);
+    cm.SetGeneratorToolset(this->BuildGeneratorToolset);
+
+    // Load the cache to make CMAKE_MAKE_PROGRAM available.
+    cm.LoadCache(this->BinaryDir);
+  } else {
+    // do the cmake step, no timeout here since it is not a sub process
+    if (this->RunCMake(outstring, out, cmakeOutString, &cm)) {
+      return 1;
+    }
+  }
+
+  // do the build
+  if (this->BuildTargets.empty()) {
+    this->BuildTargets.push_back("");
+  }
+  for (std::string const& tar : this->BuildTargets) {
+    std::chrono::duration<double> remainingTime = std::chrono::seconds(0);
+    if (this->Timeout > std::chrono::duration<double>::zero()) {
+      remainingTime =
+        this->Timeout - (std::chrono::steady_clock::now() - clock_start);
+      if (remainingTime <= std::chrono::seconds(0)) {
+        if (outstring) {
+          *outstring = "--build-and-test timeout exceeded. ";
+        }
+        return 1;
+      }
+    }
+    std::string output;
+    const char* config = nullptr;
+    if (!this->CTest->GetConfigType().empty()) {
+      config = this->CTest->GetConfigType().c_str();
+    }
+#ifdef CMAKE_INTDIR
+    if (!config) {
+      config = CMAKE_INTDIR;
+    }
+#endif
+    if (!config) {
+      config = "Debug";
+    }
+    int retVal = cm.GetGlobalGenerator()->Build(
+      this->SourceDir, this->BinaryDir, this->BuildProject, tar, output,
+      this->BuildMakeProgram, config, !this->BuildNoClean, false, false,
+      remainingTime.count());
+    out << output;
+    // if the build failed then return
+    if (retVal) {
+      if (outstring) {
+        *outstring = out.str();
+      }
+      return 1;
+    }
+  }
+  if (outstring) {
+    *outstring = out.str();
+  }
+
+  // if no test was specified then we are done
+  if (this->TestCommand.empty()) {
+    return 0;
+  }
+
+  // now run the compiled test if we can find it
+  // store the final location in fullPath
+  std::string fullPath;
+  std::string resultingConfig;
+  std::vector<std::string> extraPaths;
+  // if this->ExecutableDirectory is set try that as well
+  if (!this->ExecutableDirectory.empty()) {
+    std::string tempPath = this->ExecutableDirectory;
+    tempPath += "/";
+    tempPath += this->TestCommand;
+    extraPaths.push_back(tempPath);
+  }
+  std::vector<std::string> failed;
+  fullPath =
+    cmCTestTestHandler::FindExecutable(this->CTest, this->TestCommand.c_str(),
+                                       resultingConfig, extraPaths, failed);
+
+  if (!cmSystemTools::FileExists(fullPath.c_str())) {
+    out << "Could not find path to executable, perhaps it was not built: "
+        << this->TestCommand << "\n";
+    out << "tried to find it in these places:\n";
+    out << fullPath << "\n";
+    for (std::string const& fail : failed) {
+      out << fail << "\n";
+    }
+    if (outstring) {
+      *outstring = out.str();
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
+    }
+    return 1;
+  }
+
+  std::vector<const char*> testCommand;
+  testCommand.push_back(fullPath.c_str());
+  for (std::string const& testCommandArg : this->TestCommandArgs) {
+    testCommand.push_back(testCommandArg.c_str());
+  }
+  testCommand.push_back(nullptr);
+  std::string outs;
+  int retval = 0;
+  // run the test from the this->BuildRunDir if set
+  if (!this->BuildRunDir.empty()) {
+    out << "Run test in directory: " << this->BuildRunDir << "\n";
+    cmSystemTools::ChangeDirectory(this->BuildRunDir);
+  }
+  out << "Running test command: \"" << fullPath << "\"";
+  for (std::string const& testCommandArg : this->TestCommandArgs) {
+    out << " \"" << testCommandArg << "\"";
+  }
+  out << "\n";
+
+  // how much time is remaining
+  std::chrono::duration<double> remainingTime = std::chrono::seconds(0);
+  if (this->Timeout > std::chrono::duration<double>::zero()) {
+    remainingTime =
+      this->Timeout - (std::chrono::steady_clock::now() - clock_start);
+    if (remainingTime <= std::chrono::seconds(0)) {
+      if (outstring) {
+        *outstring = "--build-and-test timeout exceeded. ";
+      }
+      return 1;
+    }
+  }
+
+  int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, nullptr,
+                                        remainingTime, nullptr);
+
+  if (runTestRes != cmsysProcess_State_Exited || retval != 0) {
+    out << "Test command failed: " << testCommand[0] << "\n";
+    retval = 1;
+  }
+
+  out << outs << "\n";
+  if (outstring) {
+    *outstring = out.str();
+  } else {
+    cmCTestLog(this->CTest, OUTPUT, out.str() << std::endl);
+  }
+  return retval;
+}
+
+int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
+  const std::string& currentArg, size_t& idx,
+  const std::vector<std::string>& allArgs)
+{
+  // --build-and-test options
+  if (currentArg.find("--build-and-test", 0) == 0 &&
+      idx < allArgs.size() - 1) {
+    if (idx + 2 < allArgs.size()) {
+      idx++;
+      this->SourceDir = allArgs[idx];
+      idx++;
+      this->BinaryDir = allArgs[idx];
+      // dir must exist before CollapseFullPath is called
+      cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
+      this->BinaryDir = cmSystemTools::CollapseFullPath(this->BinaryDir);
+      this->SourceDir = cmSystemTools::CollapseFullPath(this->SourceDir);
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "--build-and-test must have source and binary dir"
+                   << std::endl);
+      return 0;
+    }
+  }
+  if (currentArg.find("--build-target", 0) == 0 && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildTargets.push_back(allArgs[idx]);
+  }
+  if (currentArg.find("--build-nocmake", 0) == 0) {
+    this->BuildNoCMake = true;
+  }
+  if (currentArg.find("--build-run-dir", 0) == 0 && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildRunDir = allArgs[idx];
+  }
+  if (currentArg.find("--build-two-config", 0) == 0) {
+    this->BuildTwoConfig = true;
+  }
+  if (currentArg.find("--build-exe-dir", 0) == 0 && idx < allArgs.size() - 1) {
+    idx++;
+    this->ExecutableDirectory = allArgs[idx];
+  }
+  if (currentArg.find("--test-timeout", 0) == 0 && idx < allArgs.size() - 1) {
+    idx++;
+    this->Timeout = std::chrono::duration<double>(atof(allArgs[idx].c_str()));
+  }
+  if (currentArg == "--build-generator" && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildGenerator = allArgs[idx];
+  }
+  if (currentArg == "--build-generator-platform" && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildGeneratorPlatform = allArgs[idx];
+  }
+  if (currentArg == "--build-generator-toolset" && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildGeneratorToolset = allArgs[idx];
+  }
+  if (currentArg.find("--build-project", 0) == 0 && idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildProject = allArgs[idx];
+  }
+  if (currentArg.find("--build-makeprogram", 0) == 0 &&
+      idx < allArgs.size() - 1) {
+    idx++;
+    this->BuildMakeProgram = allArgs[idx];
+  }
+  if (currentArg.find("--build-config-sample", 0) == 0 &&
+      idx < allArgs.size() - 1) {
+    idx++;
+    this->ConfigSample = allArgs[idx];
+  }
+  if (currentArg.find("--build-noclean", 0) == 0) {
+    this->BuildNoClean = true;
+  }
+  if (currentArg.find("--build-options", 0) == 0) {
+    while (idx + 1 < allArgs.size() && allArgs[idx + 1] != "--build-target" &&
+           allArgs[idx + 1] != "--test-command") {
+      ++idx;
+      this->BuildOptions.push_back(allArgs[idx]);
+    }
+  }
+  if (currentArg.find("--test-command", 0) == 0 && idx < allArgs.size() - 1) {
+    ++idx;
+    this->TestCommand = allArgs[idx];
+    while (idx + 1 < allArgs.size()) {
+      ++idx;
+      this->TestCommandArgs.push_back(allArgs[idx]);
+    }
+  }
+  return 1;
+}
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.h b/Source/CTest/cmCTestBuildAndTestHandler.h
new file mode 100644
index 0000000..f8a9ed7
--- /dev/null
+++ b/Source/CTest/cmCTestBuildAndTestHandler.h
@@ -0,0 +1,74 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestBuildAndTestHandler_h
+#define cmCTestBuildAndTestHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include <chrono>
+#include <sstream>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+class cmake;
+
+/** \class cmCTestBuildAndTestHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestBuildAndTestHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  //! Set all the build and test arguments
+  int ProcessCommandLineArguments(
+    const std::string& currentArg, size_t& idx,
+    const std::vector<std::string>& allArgs) override;
+
+  /*
+   * Get the output variable
+   */
+  const char* GetOutput();
+
+  cmCTestBuildAndTestHandler();
+
+  void Initialize() override;
+
+protected:
+  ///! Run CMake and build a test and then run it as a single test.
+  int RunCMakeAndTest(std::string* output);
+  int RunCMake(std::string* outstring, std::ostringstream& out,
+               std::string& cmakeOutString, cmake* cm);
+
+  std::string Output;
+
+  std::string BuildGenerator;
+  std::string BuildGeneratorPlatform;
+  std::string BuildGeneratorToolset;
+  std::vector<std::string> BuildOptions;
+  bool BuildTwoConfig;
+  std::string BuildMakeProgram;
+  std::string ConfigSample;
+  std::string SourceDir;
+  std::string BinaryDir;
+  std::string BuildProject;
+  std::string TestCommand;
+  bool BuildNoClean;
+  std::string BuildRunDir;
+  std::string ExecutableDirectory;
+  std::vector<std::string> TestCommandArgs;
+  std::vector<std::string> BuildTargets;
+  bool BuildNoCMake;
+  std::chrono::duration<double> Timeout;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
new file mode 100644
index 0000000..ce27da1
--- /dev/null
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -0,0 +1,184 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestBuildCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestBuildHandler.h"
+#include "cmCTestGenericHandler.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <sstream>
+#include <string.h>
+
+class cmExecutionStatus;
+
+cmCTestBuildCommand::cmCTestBuildCommand()
+{
+  this->GlobalGenerator = nullptr;
+  this->Arguments[ctb_NUMBER_ERRORS] = "NUMBER_ERRORS";
+  this->Arguments[ctb_NUMBER_WARNINGS] = "NUMBER_WARNINGS";
+  this->Arguments[ctb_TARGET] = "TARGET";
+  this->Arguments[ctb_CONFIGURATION] = "CONFIGURATION";
+  this->Arguments[ctb_FLAGS] = "FLAGS";
+  this->Arguments[ctb_PROJECT_NAME] = "PROJECT_NAME";
+  this->Arguments[ctb_LAST] = nullptr;
+  this->Last = ctb_LAST;
+}
+
+cmCTestBuildCommand::~cmCTestBuildCommand()
+{
+  if (this->GlobalGenerator) {
+    delete this->GlobalGenerator;
+    this->GlobalGenerator = nullptr;
+  }
+}
+
+cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
+{
+  cmCTestGenericHandler* handler = this->CTest->GetInitializedHandler("build");
+  if (!handler) {
+    this->SetError("internal CTest error. Cannot instantiate build handler");
+    return nullptr;
+  }
+  this->Handler = static_cast<cmCTestBuildHandler*>(handler);
+
+  const char* ctestBuildCommand =
+    this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
+  if (ctestBuildCommand && *ctestBuildCommand) {
+    this->CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand,
+                                       this->Quiet);
+  } else {
+    const char* cmakeGeneratorName =
+      this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+    const char* cmakeProjectName =
+      (this->Values[ctb_PROJECT_NAME] && *this->Values[ctb_PROJECT_NAME])
+      ? this->Values[ctb_PROJECT_NAME]
+      : this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
+
+    // Build configuration is determined by: CONFIGURATION argument,
+    // or CTEST_BUILD_CONFIGURATION script variable, or
+    // CTEST_CONFIGURATION_TYPE script variable, or ctest -C command
+    // line argument... in that order.
+    //
+    const char* ctestBuildConfiguration =
+      this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
+    const char* cmakeBuildConfiguration =
+      (this->Values[ctb_CONFIGURATION] && *this->Values[ctb_CONFIGURATION])
+      ? this->Values[ctb_CONFIGURATION]
+      : ((ctestBuildConfiguration && *ctestBuildConfiguration)
+           ? ctestBuildConfiguration
+           : this->CTest->GetConfigType().c_str());
+
+    const char* cmakeBuildAdditionalFlags =
+      (this->Values[ctb_FLAGS] && *this->Values[ctb_FLAGS])
+      ? this->Values[ctb_FLAGS]
+      : this->Makefile->GetDefinition("CTEST_BUILD_FLAGS");
+    const char* cmakeBuildTarget =
+      (this->Values[ctb_TARGET] && *this->Values[ctb_TARGET])
+      ? this->Values[ctb_TARGET]
+      : this->Makefile->GetDefinition("CTEST_BUILD_TARGET");
+
+    if (cmakeGeneratorName && *cmakeGeneratorName && cmakeProjectName &&
+        *cmakeProjectName) {
+      if (!cmakeBuildConfiguration) {
+        cmakeBuildConfiguration = "Release";
+      }
+      if (this->GlobalGenerator) {
+        if (this->GlobalGenerator->GetName() != cmakeGeneratorName) {
+          delete this->GlobalGenerator;
+          this->GlobalGenerator = nullptr;
+        }
+      }
+      if (!this->GlobalGenerator) {
+        this->GlobalGenerator =
+          this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
+            cmakeGeneratorName);
+        if (!this->GlobalGenerator) {
+          std::string e = "could not create generator named \"";
+          e += cmakeGeneratorName;
+          e += "\"";
+          this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
+          cmSystemTools::SetFatalErrorOccured();
+          return nullptr;
+        }
+      }
+      if (strlen(cmakeBuildConfiguration) == 0) {
+        const char* config = nullptr;
+#ifdef CMAKE_INTDIR
+        config = CMAKE_INTDIR;
+#endif
+        if (!config) {
+          config = "Debug";
+        }
+        cmakeBuildConfiguration = config;
+      }
+
+      std::string dir = this->CTest->GetCTestConfiguration("BuildDirectory");
+      std::string buildCommand =
+        this->GlobalGenerator->GenerateCMakeBuildCommand(
+          cmakeBuildTarget ? cmakeBuildTarget : "", cmakeBuildConfiguration,
+          cmakeBuildAdditionalFlags ? cmakeBuildAdditionalFlags : "",
+          this->Makefile->IgnoreErrorsCMP0061());
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "SetMakeCommand:" << buildCommand << "\n",
+                         this->Quiet);
+      this->CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str(),
+                                         this->Quiet);
+    } else {
+      std::ostringstream ostr;
+      /* clang-format off */
+      ostr << "has no project to build. If this is a "
+        "\"built with CMake\" project, verify that CTEST_CMAKE_GENERATOR "
+        "and CTEST_PROJECT_NAME are set."
+        "\n"
+        "CTEST_PROJECT_NAME is usually set in CTestConfig.cmake. Verify "
+        "that CTestConfig.cmake exists, or CTEST_PROJECT_NAME "
+        "is set in the script, or PROJECT_NAME is passed as an argument "
+        "to ctest_build."
+        "\n"
+        "Alternatively, set CTEST_BUILD_COMMAND to build the project "
+        "with a custom command line.";
+      /* clang-format on */
+      this->SetError(ostr.str());
+      return nullptr;
+    }
+  }
+
+  if (const char* useLaunchers =
+        this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS")) {
+    this->CTest->SetCTestConfiguration("UseLaunchers", useLaunchers,
+                                       this->Quiet);
+  }
+
+  if (const char* labelsForSubprojects =
+        this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
+    this->CTest->SetCTestConfiguration("LabelsForSubprojects",
+                                       labelsForSubprojects, this->Quiet);
+  }
+
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
+
+bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus& status)
+{
+  bool ret = cmCTestHandlerCommand::InitialPass(args, status);
+  if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) {
+    std::ostringstream str;
+    str << this->Handler->GetTotalErrors();
+    this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS],
+                                  str.str().c_str());
+  }
+  if (this->Values[ctb_NUMBER_WARNINGS] &&
+      *this->Values[ctb_NUMBER_WARNINGS]) {
+    std::ostringstream str;
+    str << this->Handler->GetTotalWarnings();
+    this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS],
+                                  str.str().c_str());
+  }
+  return ret;
+}
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
new file mode 100644
index 0000000..77b0549
--- /dev/null
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -0,0 +1,68 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestBuildCommand_h
+#define cmCTestBuildCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestHandlerCommand.h"
+
+#include <string>
+#include <vector>
+
+class cmCTestBuildHandler;
+class cmCTestGenericHandler;
+class cmCommand;
+class cmExecutionStatus;
+class cmGlobalGenerator;
+
+/** \class cmCTestBuild
+ * \brief Run a ctest script
+ *
+ * cmCTestBuildCommand defineds the command to build the project.
+ */
+class cmCTestBuildCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestBuildCommand();
+  ~cmCTestBuildCommand() override;
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestBuildCommand* ni = new cmCTestBuildCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_build"; }
+
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  cmGlobalGenerator* GlobalGenerator;
+
+protected:
+  cmCTestBuildHandler* Handler;
+  enum
+  {
+    ctb_BUILD = ct_LAST,
+    ctb_NUMBER_ERRORS,
+    ctb_NUMBER_WARNINGS,
+    ctb_TARGET,
+    ctb_CONFIGURATION,
+    ctb_FLAGS,
+    ctb_PROJECT_NAME,
+    ctb_LAST
+  };
+
+  cmCTestGenericHandler* InitializeHandler() override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
new file mode 100644
index 0000000..ef4d3c6
--- /dev/null
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -0,0 +1,1152 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestBuildHandler.h"
+
+#include "cmAlgorithms.h"
+#include "cmCTest.h"
+#include "cmFileTimeComparison.h"
+#include "cmGeneratedFileStream.h"
+#include "cmMakefile.h"
+#include "cmProcessOutput.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include "cmsys/Process.h"
+#include <set>
+#include <stdlib.h>
+#include <string.h>
+
+static const char* cmCTestErrorMatches[] = {
+  "^[Bb]us [Ee]rror",
+  "^[Ss]egmentation [Vv]iolation",
+  "^[Ss]egmentation [Ff]ault",
+  ":.*[Pp]ermission [Dd]enied",
+  "([^ :]+):([0-9]+): ([^ \\t])",
+  "([^:]+): error[ \\t]*[0-9]+[ \\t]*:",
+  "^Error ([0-9]+):",
+  "^Fatal",
+  "^Error: ",
+  "^Error ",
+  "[0-9] ERROR: ",
+  "^\"[^\"]+\", line [0-9]+: [^Ww]",
+  "^cc[^C]*CC: ERROR File = ([^,]+), Line = ([0-9]+)",
+  "^ld([^:])*:([ \\t])*ERROR([^:])*:",
+  "^ild:([ \\t])*\\(undefined symbol\\)",
+  "([^ :]+) : (error|fatal error|catastrophic error)",
+  "([^:]+): (Error:|error|undefined reference|multiply defined)",
+  "([^:]+)\\(([^\\)]+)\\) ?: (error|fatal error|catastrophic error)",
+  "^fatal error C[0-9]+:",
+  ": syntax error ",
+  "^collect2: ld returned 1 exit status",
+  "ld terminated with signal",
+  "Unsatisfied symbol",
+  "^Unresolved:",
+  "Undefined symbol",
+  "^Undefined[ \\t]+first referenced",
+  "^CMake Error.*:",
+  ":[ \\t]cannot find",
+  ":[ \\t]can't find",
+  ": \\*\\*\\* No rule to make target [`'].*\\'.  Stop",
+  ": \\*\\*\\* No targets specified and no makefile found",
+  ": Invalid loader fixup for symbol",
+  ": Invalid fixups exist",
+  ": Can't find library for",
+  ": internal link edit command failed",
+  ": Unrecognized option [`'].*\\'",
+  "\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([^WI]\\)",
+  "ld: 0706-006 Cannot find or open library file: -l ",
+  "ild: \\(argument error\\) can't find library argument ::",
+  "^could not be found and will not be loaded.",
+  "s:616 string too big",
+  "make: Fatal error: ",
+  "ld: 0711-993 Error occurred while writing to the output file:",
+  "ld: fatal: ",
+  "final link failed:",
+  "make: \\*\\*\\*.*Error",
+  "make\\[.*\\]: \\*\\*\\*.*Error",
+  "\\*\\*\\* Error code",
+  "nternal error:",
+  "Makefile:[0-9]+: \\*\\*\\* .*  Stop\\.",
+  ": No such file or directory",
+  ": Invalid argument",
+  "^The project cannot be built\\.",
+  "^\\[ERROR\\]",
+  "^Command .* failed with exit code",
+  nullptr
+};
+
+static const char* cmCTestErrorExceptions[] = {
+  "instantiated from ",
+  "candidates are:",
+  ": warning",
+  ": \\(Warning\\)",
+  ": note",
+  "Note:",
+  "makefile:",
+  "Makefile:",
+  ":[ \\t]+Where:",
+  "([^ :]+):([0-9]+): Warning",
+  "------ Build started: .* ------",
+  nullptr
+};
+
+static const char* cmCTestWarningMatches[] = {
+  "([^ :]+):([0-9]+): warning:",
+  "([^ :]+):([0-9]+): note:",
+  "^cc[^C]*CC: WARNING File = ([^,]+), Line = ([0-9]+)",
+  "^ld([^:])*:([ \\t])*WARNING([^:])*:",
+  "([^:]+): warning ([0-9]+):",
+  "^\"[^\"]+\", line [0-9]+: [Ww](arning|arnung)",
+  "([^:]+): warning[ \\t]*[0-9]+[ \\t]*:",
+  "^(Warning|Warnung) ([0-9]+):",
+  "^(Warning|Warnung)[ :]",
+  "WARNING: ",
+  "([^ :]+) : warning",
+  "([^:]+): warning",
+  "\", line [0-9]+\\.[0-9]+: [0-9]+-[0-9]+ \\([WI]\\)",
+  "^cxx: Warning:",
+  ".*file: .* has no symbols",
+  "([^ :]+):([0-9]+): (Warning|Warnung)",
+  "\\([0-9]*\\): remark #[0-9]*",
+  "\".*\", line [0-9]+: remark\\([0-9]*\\):",
+  "cc-[0-9]* CC: REMARK File = .*, Line = [0-9]*",
+  "^CMake Warning.*:",
+  "^\\[WARNING\\]",
+  nullptr
+};
+
+static const char* cmCTestWarningExceptions[] = {
+  "/usr/.*/X11/Xlib\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
+  "/usr/.*/X11/Xutil\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
+  "/usr/.*/X11/XResource\\.h:[0-9]+: war.*: ANSI C\\+\\+ forbids declaration",
+  "WARNING 84 :",
+  "WARNING 47 :",
+  "makefile:",
+  "Makefile:",
+  "warning:  Clock skew detected.  Your build may be incomplete.",
+  "/usr/openwin/include/GL/[^:]+:",
+  "bind_at_load",
+  "XrmQGetResource",
+  "IceFlush",
+  "warning LNK4089: all references to [^ \\t]+ discarded by .OPT:REF",
+  "ld32: WARNING 85: definition of dataKey in",
+  "cc: warning 422: Unknown option \"\\+b",
+  "_with_warning_C",
+  nullptr
+};
+
+struct cmCTestBuildCompileErrorWarningRex
+{
+  const char* RegularExpressionString;
+  int FileIndex;
+  int LineIndex;
+};
+
+static cmCTestBuildCompileErrorWarningRex cmCTestWarningErrorFileLine[] = {
+  { "^Warning W[0-9]+ ([a-zA-Z.\\:/0-9_+ ~-]+) ([0-9]+):", 1, 2 },
+  { "^([a-zA-Z./0-9_+ ~-]+):([0-9]+):", 1, 2 },
+  { "^([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "^[0-9]+>([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 },
+  { "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 },
+  { nullptr, 0, 0 }
+};
+
+cmCTestBuildHandler::cmCTestBuildHandler()
+{
+  this->MaxPreContext = 10;
+  this->MaxPostContext = 10;
+
+  this->MaxErrors = 50;
+  this->MaxWarnings = 50;
+
+  this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
+
+  this->UseCTestLaunch = false;
+}
+
+void cmCTestBuildHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->StartBuild.clear();
+  this->EndBuild.clear();
+  this->CustomErrorMatches.clear();
+  this->CustomErrorExceptions.clear();
+  this->CustomWarningMatches.clear();
+  this->CustomWarningExceptions.clear();
+  this->ReallyCustomWarningMatches.clear();
+  this->ReallyCustomWarningExceptions.clear();
+  this->ErrorWarningFileLineRegex.clear();
+
+  this->ErrorMatchRegex.clear();
+  this->ErrorExceptionRegex.clear();
+  this->WarningMatchRegex.clear();
+  this->WarningExceptionRegex.clear();
+  this->BuildProcessingQueue.clear();
+  this->BuildProcessingErrorQueue.clear();
+  this->BuildOutputLogSize = 0;
+  this->CurrentProcessingLine.clear();
+
+  this->SimplifySourceDir.clear();
+  this->SimplifyBuildDir.clear();
+  this->OutputLineCounter = 0;
+  this->ErrorsAndWarnings.clear();
+  this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
+  this->PostContextCount = 0;
+  this->MaxPreContext = 10;
+  this->MaxPostContext = 10;
+  this->PreContext.clear();
+
+  this->TotalErrors = 0;
+  this->TotalWarnings = 0;
+  this->LastTickChar = 0;
+
+  this->ErrorQuotaReached = false;
+  this->WarningQuotaReached = false;
+
+  this->MaxErrors = 50;
+  this->MaxWarnings = 50;
+
+  this->UseCTestLaunch = false;
+}
+
+void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile* mf)
+{
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
+                                    this->CustomErrorMatches);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",
+                                    this->CustomErrorExceptions);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",
+                                    this->CustomWarningMatches);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",
+                                    this->CustomWarningExceptions);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS", this->MaxErrors);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS", this->MaxWarnings);
+
+  int n = -1;
+  this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_PRE_CONTEXT", n);
+  if (n != -1) {
+    this->MaxPreContext = static_cast<size_t>(n);
+  }
+
+  n = -1;
+  this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_POST_CONTEXT", n);
+  if (n != -1) {
+    this->MaxPostContext = static_cast<size_t>(n);
+  }
+
+  // Record the user-specified custom warning rules.
+  if (const char* customWarningMatchers =
+        mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH")) {
+    cmSystemTools::ExpandListArgument(customWarningMatchers,
+                                      this->ReallyCustomWarningMatches);
+  }
+  if (const char* customWarningExceptions =
+        mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION")) {
+    cmSystemTools::ExpandListArgument(customWarningExceptions,
+                                      this->ReallyCustomWarningExceptions);
+  }
+}
+
+std::string cmCTestBuildHandler::GetMakeCommand()
+{
+  std::string makeCommand = this->CTest->GetCTestConfiguration("MakeCommand");
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "MakeCommand:" << makeCommand << "\n", this->Quiet);
+
+  std::string configType = this->CTest->GetConfigType();
+  if (configType.empty()) {
+    configType =
+      this->CTest->GetCTestConfiguration("DefaultCTestConfigurationType");
+  }
+  if (configType.empty()) {
+    configType = "Release";
+  }
+
+  cmSystemTools::ReplaceString(makeCommand, "${CTEST_CONFIGURATION_TYPE}",
+                               configType.c_str());
+
+  return makeCommand;
+}
+
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
+int cmCTestBuildHandler::ProcessHandler()
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl,
+                     this->Quiet);
+
+  // do we have time for this
+  if (this->CTest->GetRemainingTimeAllowed() < std::chrono::minutes(2)) {
+    return 0;
+  }
+
+  int entry;
+  for (entry = 0; cmCTestWarningErrorFileLine[entry].RegularExpressionString;
+       ++entry) {
+    cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;
+    if (r.RegularExpression.compile(
+          cmCTestWarningErrorFileLine[entry].RegularExpressionString)) {
+      r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;
+      r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;
+      this->ErrorWarningFileLineRegex.push_back(r);
+    } else {
+      cmCTestLog(
+        this->CTest, ERROR_MESSAGE, "Problem Compiling regular expression: "
+          << cmCTestWarningErrorFileLine[entry].RegularExpressionString
+          << std::endl);
+    }
+  }
+
+  // Determine build command and build directory
+  std::string makeCommand = this->GetMakeCommand();
+  if (makeCommand.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find MakeCommand key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  const std::string& buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  std::string const& useLaunchers =
+    this->CTest->GetCTestConfiguration("UseLaunchers");
+  this->UseCTestLaunch = cmSystemTools::IsOn(useLaunchers.c_str());
+
+  // Create a last build log
+  cmGeneratedFileStream ofs;
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+  if (!this->StartLogFile("Build", ofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
+                 << std::endl);
+  }
+
+  // Create lists of regular expression strings for errors, error exceptions,
+  // warnings and warning exceptions.
+  std::vector<std::string>::size_type cc;
+  for (cc = 0; cmCTestErrorMatches[cc]; cc++) {
+    this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
+  }
+  for (cc = 0; cmCTestErrorExceptions[cc]; cc++) {
+    this->CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
+  }
+  for (cc = 0; cmCTestWarningMatches[cc]; cc++) {
+    this->CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
+  }
+
+  for (cc = 0; cmCTestWarningExceptions[cc]; cc++) {
+    this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
+  }
+
+// Pre-compile regular expressions objects for all regular expressions
+
+#define cmCTestBuildHandlerPopulateRegexVector(strings, regexes)              \
+  regexes.clear();                                                            \
+  cmCTestOptionalLog(this->CTest, DEBUG,                                      \
+                     this << "Add " #regexes << std::endl, this->Quiet);      \
+  for (std::string const& s : (strings)) {                                    \
+    cmCTestOptionalLog(this->CTest, DEBUG,                                    \
+                       "Add " #strings ": " << s << std::endl, this->Quiet);  \
+    (regexes).push_back(s.c_str());                                           \
+  }
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorMatches,
+                                         this->ErrorMatchRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorExceptions,
+                                         this->ErrorExceptionRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningMatches,
+                                         this->WarningMatchRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningExceptions,
+                                         this->WarningExceptionRegex);
+
+  // Determine source and binary tree substitutions to simplify the output.
+  this->SimplifySourceDir.clear();
+  this->SimplifyBuildDir.clear();
+  if (this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20) {
+    std::string srcdir =
+      this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
+    std::string srcdirrep;
+    for (cc = srcdir.size() - 2; cc > 0; cc--) {
+      if (srcdir[cc] == '/') {
+        srcdirrep = srcdir.c_str() + cc;
+        srcdirrep = "/..." + srcdirrep;
+        srcdir = srcdir.substr(0, cc + 1);
+        break;
+      }
+    }
+    this->SimplifySourceDir = srcdir;
+  }
+  if (this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20) {
+    std::string bindir =
+      this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
+    std::string bindirrep;
+    for (cc = bindir.size() - 2; cc > 0; cc--) {
+      if (bindir[cc] == '/') {
+        bindirrep = bindir.c_str() + cc;
+        bindirrep = "/..." + bindirrep;
+        bindir = bindir.substr(0, cc + 1);
+        break;
+      }
+    }
+    this->SimplifyBuildDir = bindir;
+  }
+
+  // Ok, let's do the build
+
+  // Remember start build time
+  this->StartBuild = this->CTest->CurrentTime();
+  this->StartBuildTime = std::chrono::system_clock::now();
+  int retVal = 0;
+  int res = cmsysProcess_State_Exited;
+  if (!this->CTest->GetShowOnly()) {
+    res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
+                               buildDirectory.c_str(), 0, ofs);
+  } else {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Build with command: " << makeCommand << std::endl,
+                       this->Quiet);
+  }
+
+  // Remember end build time and calculate elapsed time
+  this->EndBuild = this->CTest->CurrentTime();
+  this->EndBuildTime = std::chrono::system_clock::now();
+  auto elapsed_build_time =
+    std::chrono::steady_clock::now() - elapsed_time_start;
+
+  // Cleanups strings in the errors and warnings list.
+  if (!this->SimplifySourceDir.empty()) {
+    for (cmCTestBuildErrorWarning& evit : this->ErrorsAndWarnings) {
+      cmSystemTools::ReplaceString(evit.Text, this->SimplifySourceDir.c_str(),
+                                   "/.../");
+      cmSystemTools::ReplaceString(evit.PreContext,
+                                   this->SimplifySourceDir.c_str(), "/.../");
+      cmSystemTools::ReplaceString(evit.PostContext,
+                                   this->SimplifySourceDir.c_str(), "/.../");
+    }
+  }
+
+  if (!this->SimplifyBuildDir.empty()) {
+    for (cmCTestBuildErrorWarning& evit : this->ErrorsAndWarnings) {
+      cmSystemTools::ReplaceString(evit.Text, this->SimplifyBuildDir.c_str(),
+                                   "/.../");
+      cmSystemTools::ReplaceString(evit.PreContext,
+                                   this->SimplifyBuildDir.c_str(), "/.../");
+      cmSystemTools::ReplaceString(evit.PostContext,
+                                   this->SimplifyBuildDir.c_str(), "/.../");
+    }
+  }
+
+  // Generate XML output
+  cmGeneratedFileStream xofs;
+  if (!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
+                 << std::endl);
+    return -1;
+  }
+  cmXMLWriter xml(xofs);
+  this->GenerateXMLHeader(xml);
+  if (this->UseCTestLaunch) {
+    this->GenerateXMLLaunched(xml);
+  } else {
+    this->GenerateXMLLogScraped(xml);
+  }
+  this->GenerateXMLFooter(xml, elapsed_build_time);
+
+  if (res != cmsysProcess_State_Exited || retVal || this->TotalErrors > 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
+                 << std::endl);
+  }
+
+  // Display message about number of errors and warnings
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   "
+               << this->TotalErrors
+               << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
+               << " Compiler errors" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   "
+               << this->TotalWarnings
+               << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
+               << " Compiler warnings" << std::endl);
+
+  return retVal;
+}
+
+void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml)
+{
+  this->CTest->StartXML(xml, this->AppendXML);
+  this->CTest->GenerateSubprojectsOutput(xml);
+  xml.StartElement("Build");
+  xml.Element("StartDateTime", this->StartBuild);
+  xml.Element("StartBuildTime", this->StartBuildTime);
+  xml.Element("BuildCommand", this->GetMakeCommand());
+}
+
+class cmCTestBuildHandler::FragmentCompare
+{
+public:
+  FragmentCompare(cmFileTimeComparison* ftc)
+    : FTC(ftc)
+  {
+  }
+  FragmentCompare()
+    : FTC(nullptr)
+  {
+  }
+  bool operator()(std::string const& l, std::string const& r) const
+  {
+    // Order files by modification time.  Use lexicographic order
+    // among files with the same time.
+    int result;
+    if (this->FTC->FileTimeCompare(l.c_str(), r.c_str(), &result) &&
+        result != 0) {
+      return result < 0;
+    }
+    return l < r;
+  }
+
+private:
+  cmFileTimeComparison* FTC;
+};
+
+void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml)
+{
+  if (this->CTestLaunchDir.empty()) {
+    return;
+  }
+
+  // Sort XML fragments in chronological order.
+  cmFileTimeComparison ftc;
+  FragmentCompare fragmentCompare(&ftc);
+  typedef std::set<std::string, FragmentCompare> Fragments;
+  Fragments fragments(fragmentCompare);
+
+  // only report the first 50 warnings and first 50 errors
+  int numErrorsAllowed = this->MaxErrors;
+  int numWarningsAllowed = this->MaxWarnings;
+  // Identify fragments on disk.
+  cmsys::Directory launchDir;
+  launchDir.Load(this->CTestLaunchDir);
+  unsigned long n = launchDir.GetNumberOfFiles();
+  for (unsigned long i = 0; i < n; ++i) {
+    const char* fname = launchDir.GetFile(i);
+    if (this->IsLaunchedErrorFile(fname) && numErrorsAllowed) {
+      numErrorsAllowed--;
+      fragments.insert(this->CTestLaunchDir + "/" + fname);
+      ++this->TotalErrors;
+    } else if (this->IsLaunchedWarningFile(fname) && numWarningsAllowed) {
+      numWarningsAllowed--;
+      fragments.insert(this->CTestLaunchDir + "/" + fname);
+      ++this->TotalWarnings;
+    }
+  }
+
+  // Copy the fragments into the final XML file.
+  for (std::string const& f : fragments) {
+    xml.FragmentFile(f.c_str());
+  }
+}
+
+void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml)
+{
+  std::vector<cmCTestBuildErrorWarning>& ew = this->ErrorsAndWarnings;
+  std::vector<cmCTestBuildErrorWarning>::iterator it;
+
+  // only report the first 50 warnings and first 50 errors
+  int numErrorsAllowed = this->MaxErrors;
+  int numWarningsAllowed = this->MaxWarnings;
+  std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
+  // make sure the source dir is in the correct case on windows
+  // via a call to collapse full path.
+  srcdir = cmSystemTools::CollapseFullPath(srcdir);
+  srcdir += "/";
+  for (it = ew.begin();
+       it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++) {
+    cmCTestBuildErrorWarning* cm = &(*it);
+    if ((cm->Error && numErrorsAllowed) ||
+        (!cm->Error && numWarningsAllowed)) {
+      if (cm->Error) {
+        numErrorsAllowed--;
+      } else {
+        numWarningsAllowed--;
+      }
+      xml.StartElement(cm->Error ? "Error" : "Warning");
+      xml.Element("BuildLogLine", cm->LogLine);
+      xml.Element("Text", cm->Text);
+      for (cmCTestCompileErrorWarningRex& rit :
+           this->ErrorWarningFileLineRegex) {
+        cmsys::RegularExpression* re = &rit.RegularExpression;
+        if (re->find(cm->Text.c_str())) {
+          cm->SourceFile = re->match(rit.FileIndex);
+          // At this point we need to make this->SourceFile relative to
+          // the source root of the project, so cvs links will work
+          cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
+          if (cm->SourceFile.find("/.../") != std::string::npos) {
+            cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
+            std::string::size_type p = cm->SourceFile.find('/');
+            if (p != std::string::npos) {
+              cm->SourceFile =
+                cm->SourceFile.substr(p + 1, cm->SourceFile.size() - p);
+            }
+          } else {
+            // make sure it is a full path with the correct case
+            cm->SourceFile = cmSystemTools::CollapseFullPath(cm->SourceFile);
+            cmSystemTools::ReplaceString(cm->SourceFile, srcdir.c_str(), "");
+          }
+          cm->LineNumber = atoi(re->match(rit.LineIndex).c_str());
+          break;
+        }
+      }
+      if (!cm->SourceFile.empty() && cm->LineNumber >= 0) {
+        if (!cm->SourceFile.empty()) {
+          xml.Element("SourceFile", cm->SourceFile);
+        }
+        if (!cm->SourceFileTail.empty()) {
+          xml.Element("SourceFileTail", cm->SourceFileTail);
+        }
+        if (cm->LineNumber >= 0) {
+          xml.Element("SourceLineNumber", cm->LineNumber);
+        }
+      }
+      xml.Element("PreContext", cm->PreContext);
+      xml.StartElement("PostContext");
+      xml.Content(cm->PostContext);
+      // is this the last warning or error, if so notify
+      if ((cm->Error && !numErrorsAllowed) ||
+          (!cm->Error && !numWarningsAllowed)) {
+        xml.Content("\nThe maximum number of reported warnings or errors "
+                    "has been reached!!!\n");
+      }
+      xml.EndElement(); // PostContext
+      xml.Element("RepeatCount", "0");
+      xml.EndElement(); // "Error" / "Warning"
+    }
+  }
+}
+
+void cmCTestBuildHandler::GenerateXMLFooter(
+  cmXMLWriter& xml, std::chrono::duration<double> elapsed_build_time)
+{
+  xml.StartElement("Log");
+  xml.Attribute("Encoding", "base64");
+  xml.Attribute("Compression", "bin/gzip");
+  xml.EndElement(); // Log
+
+  xml.Element("EndDateTime", this->EndBuild);
+  xml.Element("EndBuildTime", this->EndBuildTime);
+  xml.Element(
+    "ElapsedMinutes",
+    std::chrono::duration_cast<std::chrono::minutes>(elapsed_build_time)
+      .count());
+  xml.EndElement(); // Build
+  this->CTest->EndXML(xml);
+}
+
+bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname)
+{
+  // error-{hash}.xml
+  return (cmHasLiteralPrefix(fname, "error-") &&
+          strcmp(fname + strlen(fname) - 4, ".xml") == 0);
+}
+
+bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname)
+{
+  // warning-{hash}.xml
+  return (cmHasLiteralPrefix(fname, "warning-") &&
+          strcmp(fname + strlen(fname) - 4, ".xml") == 0);
+}
+
+//######################################################################
+//######################################################################
+//######################################################################
+//######################################################################
+
+class cmCTestBuildHandler::LaunchHelper
+{
+public:
+  LaunchHelper(cmCTestBuildHandler* handler);
+  ~LaunchHelper();
+
+private:
+  cmCTestBuildHandler* Handler;
+  cmCTest* CTest;
+
+  void WriteLauncherConfig();
+  void WriteScrapeMatchers(const char* purpose,
+                           std::vector<std::string> const& matchers);
+};
+
+cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler)
+  : Handler(handler)
+  , CTest(handler->CTest)
+{
+  std::string tag = this->CTest->GetCurrentTag();
+  if (tag.empty()) {
+    // This is not for a dashboard submission, so there is no XML.
+    // Skip enabling the launchers.
+    this->Handler->UseCTestLaunch = false;
+  } else {
+    // Compute a directory in which to store launcher fragments.
+    std::string& launchDir = this->Handler->CTestLaunchDir;
+    launchDir = this->CTest->GetBinaryDir();
+    launchDir += "/Testing/";
+    launchDir += tag;
+    launchDir += "/Build";
+
+    // Clean out any existing launcher fragments.
+    cmSystemTools::RemoveADirectory(launchDir);
+
+    if (this->Handler->UseCTestLaunch) {
+      // Enable launcher fragments.
+      cmSystemTools::MakeDirectory(launchDir.c_str());
+      this->WriteLauncherConfig();
+      std::string launchEnv = "CTEST_LAUNCH_LOGS=";
+      launchEnv += launchDir;
+      cmSystemTools::PutEnv(launchEnv);
+    }
+  }
+
+  // If not using launchers, make sure they passthru.
+  if (!this->Handler->UseCTestLaunch) {
+    cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
+  }
+}
+
+cmCTestBuildHandler::LaunchHelper::~LaunchHelper()
+{
+  if (this->Handler->UseCTestLaunch) {
+    cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
+  }
+}
+
+void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
+{
+  this->WriteScrapeMatchers("Warning",
+                            this->Handler->ReallyCustomWarningMatches);
+  this->WriteScrapeMatchers("WarningSuppress",
+                            this->Handler->ReallyCustomWarningExceptions);
+
+  // Give some testing configuration information to the launcher.
+  std::string fname = this->Handler->CTestLaunchDir;
+  fname += "/CTestLaunchConfig.cmake";
+  cmGeneratedFileStream fout(fname.c_str());
+  std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
+  fout << "set(CTEST_SOURCE_DIRECTORY \"" << srcdir << "\")\n";
+}
+
+void cmCTestBuildHandler::LaunchHelper::WriteScrapeMatchers(
+  const char* purpose, std::vector<std::string> const& matchers)
+{
+  if (matchers.empty()) {
+    return;
+  }
+  std::string fname = this->Handler->CTestLaunchDir;
+  fname += "/Custom";
+  fname += purpose;
+  fname += ".txt";
+  cmGeneratedFileStream fout(fname.c_str());
+  for (std::string const& m : matchers) {
+    fout << m << "\n";
+  }
+}
+
+int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
+                                        const char* dir, int timeout,
+                                        std::ostream& ofs, Encoding encoding)
+{
+  // First generate the command and arguments
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
+
+  if (args.empty()) {
+    return false;
+  }
+
+  std::vector<const char*> argv;
+  argv.reserve(args.size() + 1);
+  for (std::string const& arg : args) {
+    argv.push_back(arg.c_str());
+  }
+  argv.push_back(nullptr);
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:",
+                     this->Quiet);
+  for (char const* arg : argv) {
+    if (!arg) {
+      break;
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " \"" << arg << "\"", this->Quiet);
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
+                     this->Quiet);
+
+  // Optionally use make rule launchers to record errors and warnings.
+  LaunchHelper launchHelper(this);
+  static_cast<void>(launchHelper);
+
+  // Now create process object
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*argv.begin());
+  cmsysProcess_SetWorkingDirectory(cp, dir);
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  cmsysProcess_SetTimeout(cp, timeout);
+  cmsysProcess_Execute(cp);
+
+  // Initialize tick's
+  std::string::size_type tick = 0;
+  const std::string::size_type tick_len = 1024;
+
+  char* data;
+  int length;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_PROGRESS_OUTPUT, "   Each symbol represents "
+      << tick_len << " bytes of output." << std::endl
+      << (this->UseCTestLaunch
+            ? ""
+            : "   '!' represents an error and '*' a warning.\n")
+      << "    " << std::flush,
+    this->Quiet);
+
+  // Initialize building structures
+  this->BuildProcessingQueue.clear();
+  this->OutputLineCounter = 0;
+  this->ErrorsAndWarnings.clear();
+  this->TotalErrors = 0;
+  this->TotalWarnings = 0;
+  this->BuildOutputLogSize = 0;
+  this->LastTickChar = '.';
+  this->WarningQuotaReached = false;
+  this->ErrorQuotaReached = false;
+
+  // For every chunk of data
+  int res;
+  while ((res = cmsysProcess_WaitForData(cp, &data, &length, nullptr))) {
+    // Replace '\0' with '\n', since '\0' does not really make sense. This is
+    // for Visual Studio output
+    for (int cc = 0; cc < length; ++cc) {
+      if (data[cc] == 0) {
+        data[cc] = '\n';
+      }
+    }
+
+    // Process the chunk of data
+    if (res == cmsysProcess_Pipe_STDERR) {
+      processOutput.DecodeText(data, length, strdata, 1);
+      this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len, ofs,
+                          &this->BuildProcessingErrorQueue);
+    } else {
+      processOutput.DecodeText(data, length, strdata, 2);
+      this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len, ofs,
+                          &this->BuildProcessingQueue);
+    }
+  }
+  processOutput.DecodeText(std::string(), strdata, 1);
+  if (!strdata.empty()) {
+    this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len, ofs,
+                        &this->BuildProcessingErrorQueue);
+  }
+  processOutput.DecodeText(std::string(), strdata, 2);
+  if (!strdata.empty()) {
+    this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len, ofs,
+                        &this->BuildProcessingQueue);
+  }
+
+  this->ProcessBuffer(nullptr, 0, tick, tick_len, ofs,
+                      &this->BuildProcessingQueue);
+  this->ProcessBuffer(nullptr, 0, tick, tick_len, ofs,
+                      &this->BuildProcessingErrorQueue);
+  cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, " Size of output: "
+                       << ((this->BuildOutputLogSize + 512) / 1024) << "K"
+                       << std::endl,
+                     this->Quiet);
+
+  // Properly handle output of the build command
+  cmsysProcess_WaitForExit(cp, nullptr);
+  int result = cmsysProcess_GetState(cp);
+
+  if (result == cmsysProcess_State_Exited) {
+    if (retVal) {
+      *retVal = cmsysProcess_GetExitValue(cp);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Command exited with the value: " << *retVal
+                                                           << std::endl,
+                         this->Quiet);
+      // if a non zero return value
+      if (*retVal) {
+        // If there was an error running command, report that on the
+        // dashboard.
+        cmCTestBuildErrorWarning errorwarning;
+        errorwarning.LogLine = 1;
+        errorwarning.Text =
+          "*** WARNING non-zero return value in ctest from: ";
+        errorwarning.Text += argv[0];
+        errorwarning.PreContext.clear();
+        errorwarning.PostContext.clear();
+        errorwarning.Error = false;
+        this->ErrorsAndWarnings.push_back(errorwarning);
+        this->TotalWarnings++;
+      }
+    }
+  } else if (result == cmsysProcess_State_Exception) {
+    if (retVal) {
+      *retVal = cmsysProcess_GetExitException(cp);
+      cmCTestOptionalLog(this->CTest, WARNING,
+                         "There was an exception: " << *retVal << std::endl,
+                         this->Quiet);
+    }
+  } else if (result == cmsysProcess_State_Expired) {
+    cmCTestOptionalLog(this->CTest, WARNING,
+                       "There was a timeout" << std::endl, this->Quiet);
+  } else if (result == cmsysProcess_State_Error) {
+    // If there was an error running command, report that on the dashboard.
+    cmCTestBuildErrorWarning errorwarning;
+    errorwarning.LogLine = 1;
+    errorwarning.Text = "*** ERROR executing: ";
+    errorwarning.Text += cmsysProcess_GetErrorString(cp);
+    errorwarning.PreContext.clear();
+    errorwarning.PostContext.clear();
+    errorwarning.Error = true;
+    this->ErrorsAndWarnings.push_back(errorwarning);
+    this->TotalErrors++;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
+  }
+
+  cmsysProcess_Delete(cp);
+  return result;
+}
+
+//######################################################################
+//######################################################################
+//######################################################################
+//######################################################################
+
+void cmCTestBuildHandler::ProcessBuffer(const char* data, size_t length,
+                                        size_t& tick, size_t tick_len,
+                                        std::ostream& ofs,
+                                        t_BuildProcessingQueueType* queue)
+{
+  const std::string::size_type tick_line_len = 50;
+  const char* ptr;
+  for (ptr = data; ptr < data + length; ptr++) {
+    queue->push_back(*ptr);
+  }
+  this->BuildOutputLogSize += length;
+
+  // until there are any lines left in the buffer
+  while (true) {
+    // Find the end of line
+    t_BuildProcessingQueueType::iterator it;
+    for (it = queue->begin(); it != queue->end(); ++it) {
+      if (*it == '\n') {
+        break;
+      }
+    }
+
+    // Once certain number of errors or warnings reached, ignore future errors
+    // or warnings.
+    if (this->TotalWarnings >= this->MaxWarnings) {
+      this->WarningQuotaReached = true;
+    }
+    if (this->TotalErrors >= this->MaxErrors) {
+      this->ErrorQuotaReached = true;
+    }
+
+    // If the end of line was found
+    if (it != queue->end()) {
+      // Create a contiguous array for the line
+      this->CurrentProcessingLine.clear();
+      this->CurrentProcessingLine.insert(this->CurrentProcessingLine.end(),
+                                         queue->begin(), it);
+      this->CurrentProcessingLine.push_back(0);
+      const char* line = &*this->CurrentProcessingLine.begin();
+
+      // Process the line
+      int lineType = this->ProcessSingleLine(line);
+
+      // Erase the line from the queue
+      queue->erase(queue->begin(), it + 1);
+
+      // Depending on the line type, produce error or warning, or nothing
+      cmCTestBuildErrorWarning errorwarning;
+      bool found = false;
+      switch (lineType) {
+        case b_WARNING_LINE:
+          this->LastTickChar = '*';
+          errorwarning.Error = false;
+          found = true;
+          this->TotalWarnings++;
+          break;
+        case b_ERROR_LINE:
+          this->LastTickChar = '!';
+          errorwarning.Error = true;
+          found = true;
+          this->TotalErrors++;
+          break;
+      }
+      if (found) {
+        // This is an error or warning, so generate report
+        errorwarning.LogLine = static_cast<int>(this->OutputLineCounter + 1);
+        errorwarning.Text = line;
+        errorwarning.PreContext.clear();
+        errorwarning.PostContext.clear();
+
+        // Copy pre-context to report
+        for (std::string const& pc : this->PreContext) {
+          errorwarning.PreContext += pc + "\n";
+        }
+        this->PreContext.clear();
+
+        // Store report
+        this->ErrorsAndWarnings.push_back(errorwarning);
+        this->LastErrorOrWarning = this->ErrorsAndWarnings.end() - 1;
+        this->PostContextCount = 0;
+      } else {
+        // This is not an error or warning.
+        // So, figure out if this is a post-context line
+        if (!this->ErrorsAndWarnings.empty() &&
+            this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
+            this->PostContextCount < this->MaxPostContext) {
+          this->PostContextCount++;
+          this->LastErrorOrWarning->PostContext += line;
+          if (this->PostContextCount < this->MaxPostContext) {
+            this->LastErrorOrWarning->PostContext += "\n";
+          }
+        } else {
+          // Otherwise store pre-context for the next error
+          this->PreContext.push_back(line);
+          if (this->PreContext.size() > this->MaxPreContext) {
+            this->PreContext.erase(this->PreContext.begin(),
+                                   this->PreContext.end() -
+                                     this->MaxPreContext);
+          }
+        }
+      }
+      this->OutputLineCounter++;
+    } else {
+      break;
+    }
+  }
+
+  // Now that the buffer is processed, display missing ticks
+  int tickDisplayed = false;
+  while (this->BuildOutputLogSize > (tick * tick_len)) {
+    tick++;
+    cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,
+                       this->LastTickChar, this->Quiet);
+    tickDisplayed = true;
+    if (tick % tick_line_len == 0 && tick > 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, "  Size: "
+                           << ((this->BuildOutputLogSize + 512) / 1024) << "K"
+                           << std::endl
+                           << "    ",
+                         this->Quiet);
+    }
+  }
+  if (tickDisplayed) {
+    this->LastTickChar = '.';
+  }
+
+  // And if this is verbose output, display the content of the chunk
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             cmCTestLogWrite(data, length));
+
+  // Always store the chunk to the file
+  ofs << cmCTestLogWrite(data, length);
+}
+
+int cmCTestBuildHandler::ProcessSingleLine(const char* data)
+{
+  if (this->UseCTestLaunch) {
+    // No log scraping when using launchers.
+    return b_REGULAR_LINE;
+  }
+
+  cmCTestOptionalLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl,
+                     this->Quiet);
+
+  int warningLine = 0;
+  int errorLine = 0;
+
+  // Check for regular expressions
+
+  if (!this->ErrorQuotaReached) {
+    // Errors
+    int wrxCnt = 0;
+    for (cmsys::RegularExpression& rx : this->ErrorMatchRegex) {
+      if (rx.find(data)) {
+        errorLine = 1;
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "  Error Line: " << data << " (matches: "
+                                            << this->CustomErrorMatches[wrxCnt]
+                                            << ")" << std::endl,
+                           this->Quiet);
+        break;
+      }
+      wrxCnt++;
+    }
+    // Error exceptions
+    wrxCnt = 0;
+    for (cmsys::RegularExpression& rx : this->ErrorExceptionRegex) {
+      if (rx.find(data)) {
+        errorLine = 0;
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Not an error Line: "
+                             << data << " (matches: "
+                             << this->CustomErrorExceptions[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
+        break;
+      }
+      wrxCnt++;
+    }
+  }
+  if (!this->WarningQuotaReached) {
+    // Warnings
+    int wrxCnt = 0;
+    for (cmsys::RegularExpression& rx : this->WarningMatchRegex) {
+      if (rx.find(data)) {
+        warningLine = 1;
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Warning Line: "
+                             << data << " (matches: "
+                             << this->CustomWarningMatches[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
+        break;
+      }
+      wrxCnt++;
+    }
+
+    wrxCnt = 0;
+    // Warning exceptions
+    for (cmsys::RegularExpression& rx : this->WarningExceptionRegex) {
+      if (rx.find(data)) {
+        warningLine = 0;
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Not a warning Line: "
+                             << data << " (matches: "
+                             << this->CustomWarningExceptions[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
+        break;
+      }
+      wrxCnt++;
+    }
+  }
+  if (errorLine) {
+    return b_ERROR_LINE;
+  }
+  if (warningLine) {
+    return b_WARNING_LINE;
+  }
+  return b_REGULAR_LINE;
+}
diff --git a/Source/CTest/cmCTestBuildHandler.h b/Source/CTest/cmCTestBuildHandler.h
new file mode 100644
index 0000000..d1b9b2e
--- /dev/null
+++ b/Source/CTest/cmCTestBuildHandler.h
@@ -0,0 +1,154 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestBuildHandler_h
+#define cmCTestBuildHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include "cmProcessOutput.h"
+#include "cmsys/RegularExpression.hxx"
+#include <chrono>
+#include <deque>
+#include <iosfwd>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+class cmMakefile;
+class cmXMLWriter;
+
+/** \class cmCTestBuildHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestBuildHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+  typedef cmProcessOutput::Encoding Encoding;
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  cmCTestBuildHandler();
+
+  void PopulateCustomVectors(cmMakefile* mf) override;
+
+  /**
+   * Initialize handler
+   */
+  void Initialize() override;
+
+  int GetTotalErrors() { return this->TotalErrors; }
+  int GetTotalWarnings() { return this->TotalWarnings; }
+
+private:
+  std::string GetMakeCommand();
+
+  //! Run command specialized for make and configure. Returns process status
+  // and retVal is return value or exception.
+  int RunMakeCommand(const char* command, int* retVal, const char* dir,
+                     int timeout, std::ostream& ofs,
+                     Encoding encoding = cmProcessOutput::Auto);
+
+  enum
+  {
+    b_REGULAR_LINE,
+    b_WARNING_LINE,
+    b_ERROR_LINE
+  };
+
+  class cmCTestCompileErrorWarningRex
+  {
+  public:
+    cmCTestCompileErrorWarningRex() {}
+    int FileIndex;
+    int LineIndex;
+    cmsys::RegularExpression RegularExpression;
+  };
+
+  struct cmCTestBuildErrorWarning
+  {
+    bool Error;
+    int LogLine;
+    std::string Text;
+    std::string SourceFile;
+    std::string SourceFileTail;
+    int LineNumber;
+    std::string PreContext;
+    std::string PostContext;
+  };
+
+  // generate the XML output
+  void GenerateXMLHeader(cmXMLWriter& xml);
+  void GenerateXMLLaunched(cmXMLWriter& xml);
+  void GenerateXMLLogScraped(cmXMLWriter& xml);
+  void GenerateXMLFooter(cmXMLWriter& xml,
+                         std::chrono::duration<double> elapsed_build_time);
+  bool IsLaunchedErrorFile(const char* fname);
+  bool IsLaunchedWarningFile(const char* fname);
+
+  std::string StartBuild;
+  std::string EndBuild;
+  std::chrono::system_clock::time_point StartBuildTime;
+  std::chrono::system_clock::time_point EndBuildTime;
+
+  std::vector<std::string> CustomErrorMatches;
+  std::vector<std::string> CustomErrorExceptions;
+  std::vector<std::string> CustomWarningMatches;
+  std::vector<std::string> CustomWarningExceptions;
+  std::vector<std::string> ReallyCustomWarningMatches;
+  std::vector<std::string> ReallyCustomWarningExceptions;
+  std::vector<cmCTestCompileErrorWarningRex> ErrorWarningFileLineRegex;
+
+  std::vector<cmsys::RegularExpression> ErrorMatchRegex;
+  std::vector<cmsys::RegularExpression> ErrorExceptionRegex;
+  std::vector<cmsys::RegularExpression> WarningMatchRegex;
+  std::vector<cmsys::RegularExpression> WarningExceptionRegex;
+
+  typedef std::deque<char> t_BuildProcessingQueueType;
+
+  void ProcessBuffer(const char* data, size_t length, size_t& tick,
+                     size_t tick_len, std::ostream& ofs,
+                     t_BuildProcessingQueueType* queue);
+  int ProcessSingleLine(const char* data);
+
+  t_BuildProcessingQueueType BuildProcessingQueue;
+  t_BuildProcessingQueueType BuildProcessingErrorQueue;
+  size_t BuildOutputLogSize;
+  std::vector<char> CurrentProcessingLine;
+
+  std::string SimplifySourceDir;
+  std::string SimplifyBuildDir;
+  size_t OutputLineCounter;
+  typedef std::vector<cmCTestBuildErrorWarning> t_ErrorsAndWarningsVector;
+  t_ErrorsAndWarningsVector ErrorsAndWarnings;
+  t_ErrorsAndWarningsVector::iterator LastErrorOrWarning;
+  size_t PostContextCount;
+  size_t MaxPreContext;
+  size_t MaxPostContext;
+  std::deque<std::string> PreContext;
+
+  int TotalErrors;
+  int TotalWarnings;
+  char LastTickChar;
+
+  bool ErrorQuotaReached;
+  bool WarningQuotaReached;
+
+  int MaxErrors;
+  int MaxWarnings;
+
+  bool UseCTestLaunch;
+  std::string CTestLaunchDir;
+  class LaunchHelper;
+
+  friend class LaunchHelper;
+  class FragmentCompare;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestCVS.cxx b/Source/CTest/cmCTestCVS.cxx
new file mode 100644
index 0000000..5779935
--- /dev/null
+++ b/Source/CTest/cmCTestCVS.cxx
@@ -0,0 +1,278 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestCVS.h"
+
+#include "cmCTest.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <utility>
+
+cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log)
+  : cmCTestVC(ct, log)
+{
+}
+
+cmCTestCVS::~cmCTestCVS()
+{
+}
+
+class cmCTestCVS::UpdateParser : public cmCTestVC::LineParser
+{
+public:
+  UpdateParser(cmCTestCVS* cvs, const char* prefix)
+    : CVS(cvs)
+  {
+    this->SetLog(&cvs->Log, prefix);
+    // See "man cvs", section "update output".
+    this->RegexFileUpdated.compile("^([UP])  *(.*)");
+    this->RegexFileModified.compile("^([MRA])  *(.*)");
+    this->RegexFileConflicting.compile("^([C])  *(.*)");
+    this->RegexFileRemoved1.compile(
+      "cvs[^ ]* update: `?([^']*)'? is no longer in the repository");
+    this->RegexFileRemoved2.compile(
+      "cvs[^ ]* update: "
+      "warning: `?([^']*)'? is not \\(any longer\\) pertinent");
+  }
+
+private:
+  cmCTestCVS* CVS;
+  cmsys::RegularExpression RegexFileUpdated;
+  cmsys::RegularExpression RegexFileModified;
+  cmsys::RegularExpression RegexFileConflicting;
+  cmsys::RegularExpression RegexFileRemoved1;
+  cmsys::RegularExpression RegexFileRemoved2;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexFileUpdated.find(this->Line)) {
+      this->DoFile(PathUpdated, this->RegexFileUpdated.match(2));
+    } else if (this->RegexFileModified.find(this->Line)) {
+      this->DoFile(PathModified, this->RegexFileModified.match(2));
+    } else if (this->RegexFileConflicting.find(this->Line)) {
+      this->DoFile(PathConflicting, this->RegexFileConflicting.match(2));
+    } else if (this->RegexFileRemoved1.find(this->Line)) {
+      this->DoFile(PathUpdated, this->RegexFileRemoved1.match(1));
+    } else if (this->RegexFileRemoved2.find(this->Line)) {
+      this->DoFile(PathUpdated, this->RegexFileRemoved2.match(1));
+    }
+    return true;
+  }
+
+  void DoFile(PathStatus status, std::string const& file)
+  {
+    std::string dir = cmSystemTools::GetFilenamePath(file);
+    std::string name = cmSystemTools::GetFilenameName(file);
+    this->CVS->Dirs[dir][name] = status;
+  }
+};
+
+bool cmCTestCVS::UpdateImpl()
+{
+  // Get user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("CVSUpdateOptions");
+    if (opts.empty()) {
+      opts = "-dP";
+    }
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+
+  // Specify the start time for nightly testing.
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
+    args.push_back("-D" + this->GetNightlyTime() + " UTC");
+  }
+
+  // Run "cvs update" to update the work tree.
+  std::vector<char const*> cvs_update;
+  cvs_update.push_back(this->CommandLineTool.c_str());
+  cvs_update.push_back("-z3");
+  cvs_update.push_back("update");
+  for (std::string const& arg : args) {
+    cvs_update.push_back(arg.c_str());
+  }
+  cvs_update.push_back(nullptr);
+
+  UpdateParser out(this, "up-out> ");
+  UpdateParser err(this, "up-err> ");
+  return this->RunUpdateCommand(&cvs_update[0], &out, &err);
+}
+
+class cmCTestCVS::LogParser : public cmCTestVC::LineParser
+{
+public:
+  typedef cmCTestCVS::Revision Revision;
+  LogParser(cmCTestCVS* cvs, const char* prefix, std::vector<Revision>& revs)
+    : CVS(cvs)
+    , Revisions(revs)
+    , Section(SectionHeader)
+  {
+    this->SetLog(&cvs->Log, prefix),
+      this->RegexRevision.compile("^revision +([^ ]*) *$");
+    this->RegexBranches.compile("^branches: .*$");
+    this->RegexPerson.compile("^date: +([^;]+); +author: +([^;]+);");
+  }
+
+private:
+  cmCTestCVS* CVS;
+  std::vector<Revision>& Revisions;
+  cmsys::RegularExpression RegexRevision;
+  cmsys::RegularExpression RegexBranches;
+  cmsys::RegularExpression RegexPerson;
+  enum SectionType
+  {
+    SectionHeader,
+    SectionRevisions,
+    SectionEnd
+  };
+  SectionType Section;
+  Revision Rev;
+
+  bool ProcessLine() override
+  {
+    if (this->Line == ("======================================="
+                       "======================================")) {
+      // This line ends the revision list.
+      if (this->Section == SectionRevisions) {
+        this->FinishRevision();
+      }
+      this->Section = SectionEnd;
+    } else if (this->Line == "----------------------------") {
+      // This line divides revisions from the header and each other.
+      if (this->Section == SectionHeader) {
+        this->Section = SectionRevisions;
+      } else if (this->Section == SectionRevisions) {
+        this->FinishRevision();
+      }
+    } else if (this->Section == SectionRevisions) {
+      if (!this->Rev.Log.empty()) {
+        // Continue the existing log.
+        this->Rev.Log += this->Line;
+        this->Rev.Log += "\n";
+      } else if (this->Rev.Rev.empty() &&
+                 this->RegexRevision.find(this->Line)) {
+        this->Rev.Rev = this->RegexRevision.match(1);
+      } else if (this->Rev.Date.empty() &&
+                 this->RegexPerson.find(this->Line)) {
+        this->Rev.Date = this->RegexPerson.match(1);
+        this->Rev.Author = this->RegexPerson.match(2);
+      } else if (!this->RegexBranches.find(this->Line)) {
+        // Start the log.
+        this->Rev.Log += this->Line;
+        this->Rev.Log += "\n";
+      }
+    }
+    return this->Section != SectionEnd;
+  }
+
+  void FinishRevision()
+  {
+    if (!this->Rev.Rev.empty()) {
+      // Record this revision.
+      /* clang-format off */
+      this->CVS->Log << "Found revision " << this->Rev.Rev << "\n"
+                     << "  author = " << this->Rev.Author << "\n"
+                     << "  date = " << this->Rev.Date << "\n";
+      /* clang-format on */
+      this->Revisions.push_back(this->Rev);
+
+      // We only need two revisions.
+      if (this->Revisions.size() >= 2) {
+        this->Section = SectionEnd;
+      }
+    }
+    this->Rev = Revision();
+  }
+};
+
+std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
+{
+  // Compute the tag file location for this directory.
+  std::string tagFile = this->SourceDirectory;
+  if (!dir.empty()) {
+    tagFile += "/";
+    tagFile += dir;
+  }
+  tagFile += "/CVS/Tag";
+
+  // Lookup the branch in the tag file, if any.
+  std::string tagLine;
+  cmsys::ifstream tagStream(tagFile.c_str());
+  if (tagStream && cmSystemTools::GetLineFromStream(tagStream, tagLine) &&
+      tagLine.size() > 1 && tagLine[0] == 'T') {
+    // Use the branch specified in the tag file.
+    std::string flag = "-r";
+    flag += tagLine.substr(1);
+    return flag;
+  }
+  // Use the default branch.
+  return "-b";
+}
+
+void cmCTestCVS::LoadRevisions(std::string const& file, const char* branchFlag,
+                               std::vector<Revision>& revisions)
+{
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
+
+  // Run "cvs log" to get revisions of this file on this branch.
+  const char* cvs = this->CommandLineTool.c_str();
+  const char* cvs_log[] = {
+    cvs, "log", "-N", branchFlag, file.c_str(), nullptr
+  };
+
+  LogParser out(this, "log-out> ", revisions);
+  OutputLogger err(this->Log, "log-err> ");
+  this->RunChild(cvs_log, &out, &err);
+}
+
+void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml, std::string const& path,
+                                   Directory const& dir)
+{
+  const char* slash = path.empty() ? "" : "/";
+  xml.StartElement("Directory");
+  xml.Element("Name", path);
+
+  // Lookup the branch checked out in the working tree.
+  std::string branchFlag = this->ComputeBranchFlag(path);
+
+  // Load revisions and write an entry for each file in this directory.
+  std::vector<Revision> revisions;
+  for (auto const& fi : dir) {
+    std::string full = path + slash + fi.first;
+
+    // Load two real or unknown revisions.
+    revisions.clear();
+    if (fi.second != PathUpdated) {
+      // For local modifications the current rev is unknown and the
+      // prior rev is the latest from cvs.
+      revisions.push_back(this->Unknown);
+    }
+    this->LoadRevisions(full, branchFlag.c_str(), revisions);
+    revisions.resize(2, this->Unknown);
+
+    // Write the entry for this file with these revisions.
+    File f(fi.second, &revisions[0], &revisions[1]);
+    this->WriteXMLEntry(xml, path, fi.first, full, f);
+  }
+  xml.EndElement(); // Directory
+}
+
+bool cmCTestCVS::WriteXMLUpdates(cmXMLWriter& xml)
+{
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Gathering version information (one . per updated file):\n"
+             "    "
+               << std::flush);
+
+  for (auto const& d : this->Dirs) {
+    this->WriteXMLDirectory(xml, d.first, d.second);
+  }
+
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+
+  return true;
+}
diff --git a/Source/CTest/cmCTestCVS.h b/Source/CTest/cmCTestCVS.h
new file mode 100644
index 0000000..77fc3cc
--- /dev/null
+++ b/Source/CTest/cmCTestCVS.h
@@ -0,0 +1,55 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestCVS_h
+#define cmCTestCVS_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestVC.h"
+
+#include <iosfwd>
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmXMLWriter;
+
+/** \class cmCTestCVS
+ * \brief Interaction with cvs command-line tool
+ *
+ */
+class cmCTestCVS : public cmCTestVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestCVS(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestCVS() override;
+
+private:
+  // Implement cmCTestVC internal API.
+  bool UpdateImpl() override;
+  bool WriteXMLUpdates(cmXMLWriter& xml) override;
+
+  // Update status for files in each directory.
+  class Directory : public std::map<std::string, PathStatus>
+  {
+  };
+  std::map<std::string, Directory> Dirs;
+
+  std::string ComputeBranchFlag(std::string const& dir);
+  void LoadRevisions(std::string const& file, const char* branchFlag,
+                     std::vector<Revision>& revisions);
+  void WriteXMLDirectory(cmXMLWriter& xml, std::string const& path,
+                         Directory const& dir);
+
+  // Parsing helper classes.
+  class LogParser;
+  class UpdateParser;
+
+  friend class LogParser;
+  friend class UpdateParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestCommand.h b/Source/CTest/cmCTestCommand.h
new file mode 100644
index 0000000..8efb419
--- /dev/null
+++ b/Source/CTest/cmCTestCommand.h
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestCommand_h
+#define cmCTestCommand_h
+
+#include "cmCommand.h"
+
+class cmCTest;
+class cmCTestScriptHandler;
+
+/** \class cmCTestCommand
+ * \brief A superclass for all commands added to the CTestScriptHandler
+ *
+ * cmCTestCommand is the superclass for all commands that will be added to
+ * the ctest script handlers parser.
+ *
+ */
+class cmCTestCommand : public cmCommand
+{
+public:
+  cmCTestCommand()
+  {
+    this->CTest = nullptr;
+    this->CTestScriptHandler = nullptr;
+  }
+
+  cmCTest* CTest;
+  cmCTestScriptHandler* CTestScriptHandler;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
new file mode 100644
index 0000000..c44b866
--- /dev/null
+++ b/Source/CTest/cmCTestConfigureCommand.cxx
@@ -0,0 +1,154 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestConfigureCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <sstream>
+#include <string.h>
+#include <vector>
+
+cmCTestConfigureCommand::cmCTestConfigureCommand()
+{
+  this->Arguments[ctc_OPTIONS] = "OPTIONS";
+  this->Arguments[ctc_LAST] = nullptr;
+  this->Last = ctc_LAST;
+}
+
+cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
+{
+  std::vector<std::string> options;
+
+  if (this->Values[ctc_OPTIONS]) {
+    cmSystemTools::ExpandListArgument(this->Values[ctc_OPTIONS], options);
+  }
+
+  if (this->CTest->GetCTestConfiguration("BuildDirectory").empty()) {
+    this->SetError(
+      "Build directory not specified. Either use BUILD "
+      "argument to CTEST_CONFIGURE command or set CTEST_BINARY_DIRECTORY "
+      "variable");
+    return nullptr;
+  }
+
+  const char* ctestConfigureCommand =
+    this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
+
+  if (ctestConfigureCommand && *ctestConfigureCommand) {
+    this->CTest->SetCTestConfiguration("ConfigureCommand",
+                                       ctestConfigureCommand, this->Quiet);
+  } else {
+    const char* cmakeGeneratorName =
+      this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+    if (cmakeGeneratorName && *cmakeGeneratorName) {
+      const std::string& source_dir =
+        this->CTest->GetCTestConfiguration("SourceDirectory");
+      if (source_dir.empty()) {
+        this->SetError(
+          "Source directory not specified. Either use SOURCE "
+          "argument to CTEST_CONFIGURE command or set CTEST_SOURCE_DIRECTORY "
+          "variable");
+        return nullptr;
+      }
+
+      const std::string cmakelists_file = source_dir + "/CMakeLists.txt";
+      if (!cmSystemTools::FileExists(cmakelists_file.c_str())) {
+        std::ostringstream e;
+        e << "CMakeLists.txt file does not exist [" << cmakelists_file << "]";
+        this->SetError(e.str());
+        return nullptr;
+      }
+
+      bool multiConfig = false;
+      bool cmakeBuildTypeInOptions = false;
+
+      cmGlobalGenerator* gg =
+        this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
+          cmakeGeneratorName);
+      if (gg) {
+        multiConfig = gg->IsMultiConfig();
+        delete gg;
+      }
+
+      std::string cmakeConfigureCommand = "\"";
+      cmakeConfigureCommand += cmSystemTools::GetCMakeCommand();
+      cmakeConfigureCommand += "\"";
+
+      for (std::string const& option : options) {
+        cmakeConfigureCommand += " \"";
+        cmakeConfigureCommand += option;
+        cmakeConfigureCommand += "\"";
+
+        if ((nullptr != strstr(option.c_str(), "CMAKE_BUILD_TYPE=")) ||
+            (nullptr != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING="))) {
+          cmakeBuildTypeInOptions = true;
+        }
+      }
+
+      if (!multiConfig && !cmakeBuildTypeInOptions &&
+          !this->CTest->GetConfigType().empty()) {
+        cmakeConfigureCommand += " \"-DCMAKE_BUILD_TYPE:STRING=";
+        cmakeConfigureCommand += this->CTest->GetConfigType();
+        cmakeConfigureCommand += "\"";
+      }
+
+      if (this->Makefile->IsOn("CTEST_USE_LAUNCHERS")) {
+        cmakeConfigureCommand += " \"-DCTEST_USE_LAUNCHERS:BOOL=TRUE\"";
+      }
+
+      cmakeConfigureCommand += " \"-G";
+      cmakeConfigureCommand += cmakeGeneratorName;
+      cmakeConfigureCommand += "\"";
+
+      const char* cmakeGeneratorPlatform =
+        this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_PLATFORM");
+      if (cmakeGeneratorPlatform && *cmakeGeneratorPlatform) {
+        cmakeConfigureCommand += " \"-A";
+        cmakeConfigureCommand += cmakeGeneratorPlatform;
+        cmakeConfigureCommand += "\"";
+      }
+
+      const char* cmakeGeneratorToolset =
+        this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_TOOLSET");
+      if (cmakeGeneratorToolset && *cmakeGeneratorToolset) {
+        cmakeConfigureCommand += " \"-T";
+        cmakeConfigureCommand += cmakeGeneratorToolset;
+        cmakeConfigureCommand += "\"";
+      }
+
+      cmakeConfigureCommand += " \"";
+      cmakeConfigureCommand += source_dir;
+      cmakeConfigureCommand += "\"";
+
+      this->CTest->SetCTestConfiguration(
+        "ConfigureCommand", cmakeConfigureCommand.c_str(), this->Quiet);
+    } else {
+      this->SetError(
+        "Configure command is not specified. If this is a "
+        "\"built with CMake\" project, set CTEST_CMAKE_GENERATOR. If not, "
+        "set CTEST_CONFIGURE_COMMAND.");
+      return nullptr;
+    }
+  }
+
+  if (const char* labelsForSubprojects =
+        this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
+    this->CTest->SetCTestConfiguration("LabelsForSubprojects",
+                                       labelsForSubprojects, this->Quiet);
+  }
+
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("configure");
+  if (!handler) {
+    this->SetError(
+      "internal CTest error. Cannot instantiate configure handler");
+    return nullptr;
+  }
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
new file mode 100644
index 0000000..0cbcbfa
--- /dev/null
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -0,0 +1,52 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestConfigureCommand_h
+#define cmCTestConfigureCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestHandlerCommand.h"
+
+#include <string>
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestConfigure
+ * \brief Run a ctest script
+ *
+ * cmCTestConfigureCommand defineds the command to configures the project.
+ */
+class cmCTestConfigureCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestConfigureCommand();
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_configure"; }
+
+protected:
+  cmCTestGenericHandler* InitializeHandler() override;
+
+  enum
+  {
+    ctc_FIRST = ct_LAST,
+    ctc_OPTIONS,
+    ctc_LAST
+  };
+};
+
+#endif
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
new file mode 100644
index 0000000..eb067e5
--- /dev/null
+++ b/Source/CTest/cmCTestConfigureHandler.cxx
@@ -0,0 +1,104 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestConfigureHandler.h"
+
+#include "cmCTest.h"
+#include "cmGeneratedFileStream.h"
+#include "cmXMLWriter.h"
+
+#include <chrono>
+#include <ostream>
+#include <string>
+
+cmCTestConfigureHandler::cmCTestConfigureHandler()
+{
+}
+
+void cmCTestConfigureHandler::Initialize()
+{
+  this->Superclass::Initialize();
+}
+
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
+int cmCTestConfigureHandler::ProcessHandler()
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "Configure project" << std::endl, this->Quiet);
+  std::string cCommand =
+    this->CTest->GetCTestConfiguration("ConfigureCommand");
+  if (cCommand.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find ConfigureCommand key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  std::string buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+  std::string output;
+  int retVal = 0;
+  int res = 0;
+  if (!this->CTest->GetShowOnly()) {
+    cmGeneratedFileStream os;
+    if (!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open configure file"
+                   << std::endl);
+      return 1;
+    }
+    std::string start_time = this->CTest->CurrentTime();
+    auto start_time_time = std::chrono::system_clock::now();
+
+    cmGeneratedFileStream ofs;
+    this->StartLogFile("Configure", ofs);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Configure with command: " << cCommand << std::endl,
+                       this->Quiet);
+    res = this->CTest->RunMakeCommand(
+      cCommand.c_str(), output, &retVal, buildDirectory.c_str(),
+      std::chrono::duration<double>::zero(), ofs);
+
+    if (ofs) {
+      ofs.close();
+    }
+
+    if (os) {
+      cmXMLWriter xml(os);
+      this->CTest->StartXML(xml, this->AppendXML);
+      this->CTest->GenerateSubprojectsOutput(xml);
+      xml.StartElement("Configure");
+      xml.Element("StartDateTime", start_time);
+      xml.Element("StartConfigureTime", start_time_time);
+      xml.Element("ConfigureCommand", cCommand);
+      cmCTestOptionalLog(this->CTest, DEBUG, "End" << std::endl, this->Quiet);
+      xml.Element("Log", output);
+      xml.Element("ConfigureStatus", retVal);
+      xml.Element("EndDateTime", this->CTest->CurrentTime());
+      xml.Element("EndConfigureTime", std::chrono::system_clock::now());
+      xml.Element("ElapsedMinutes",
+                  std::chrono::duration_cast<std::chrono::minutes>(
+                    std::chrono::steady_clock::now() - elapsed_time_start)
+                    .count());
+      xml.EndElement(); // Configure
+      this->CTest->EndXML(xml);
+    }
+  } else {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Configure with command: " << cCommand << std::endl,
+                       this->Quiet);
+  }
+  if (!res || retVal) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error(s) when configuring the project" << std::endl);
+    return -1;
+  }
+  return 0;
+}
diff --git a/Source/CTest/cmCTestConfigureHandler.h b/Source/CTest/cmCTestConfigureHandler.h
new file mode 100644
index 0000000..680401c
--- /dev/null
+++ b/Source/CTest/cmCTestConfigureHandler.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestConfigureHandler_h
+#define cmCTestConfigureHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+/** \class cmCTestConfigureHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestConfigureHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  cmCTestConfigureHandler();
+
+  void Initialize() override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx
new file mode 100644
index 0000000..d2003ba
--- /dev/null
+++ b/Source/CTest/cmCTestCoverageCommand.cxx
@@ -0,0 +1,61 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestCoverageCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+
+class cmCTestGenericHandler;
+
+cmCTestCoverageCommand::cmCTestCoverageCommand()
+{
+  this->LabelsMentioned = false;
+}
+
+cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
+{
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS",
+    this->Quiet);
+  cmCTestCoverageHandler* handler = static_cast<cmCTestCoverageHandler*>(
+    this->CTest->GetInitializedHandler("coverage"));
+  if (!handler) {
+    this->SetError("internal CTest error. Cannot instantiate test handler");
+    return nullptr;
+  }
+
+  // If a LABELS option was given, select only files with the labels.
+  if (this->LabelsMentioned) {
+    handler->SetLabelFilter(this->Labels);
+  }
+
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
+
+bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
+{
+  // Look for arguments specific to this command.
+  if (arg == "LABELS") {
+    this->ArgumentDoing = ArgumentDoingLabels;
+    this->LabelsMentioned = true;
+    return true;
+  }
+
+  // Look for other arguments.
+  return this->Superclass::CheckArgumentKeyword(arg);
+}
+
+bool cmCTestCoverageCommand::CheckArgumentValue(std::string const& arg)
+{
+  // Handle states specific to this command.
+  if (this->ArgumentDoing == ArgumentDoingLabels) {
+    this->Labels.insert(arg);
+    return true;
+  }
+
+  // Look for other arguments.
+  return this->Superclass::CheckArgumentValue(arg);
+}
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
new file mode 100644
index 0000000..1ae2d86
--- /dev/null
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -0,0 +1,60 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestCoverageCommand_h
+#define cmCTestCoverageCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestHandlerCommand.h"
+
+#include <set>
+#include <string>
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestCoverage
+ * \brief Run a ctest script
+ *
+ * cmCTestCoverageCommand defineds the command to test the project.
+ */
+class cmCTestCoverageCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestCoverageCommand();
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_coverage"; }
+
+  typedef cmCTestHandlerCommand Superclass;
+
+protected:
+  cmCTestGenericHandler* InitializeHandler() override;
+
+  bool CheckArgumentKeyword(std::string const& arg) override;
+  bool CheckArgumentValue(std::string const& arg) override;
+
+  enum
+  {
+    ArgumentDoingLabels = Superclass::ArgumentDoingLast1,
+    ArgumentDoingLast2
+  };
+
+  bool LabelsMentioned;
+  std::set<std::string> Labels;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
new file mode 100644
index 0000000..2a9fd72
--- /dev/null
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -0,0 +1,2336 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestCoverageHandler.h"
+
+#include "cmCTest.h"
+#include "cmGeneratedFileStream.h"
+#include "cmParseBlanketJSCoverage.h"
+#include "cmParseCacheCoverage.h"
+#include "cmParseCoberturaCoverage.h"
+#include "cmParseDelphiCoverage.h"
+#include "cmParseGTMCoverage.h"
+#include "cmParseJacocoCoverage.h"
+#include "cmParsePHPCoverage.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+#include "cmXMLWriter.h"
+#include "cmake.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include "cmsys/Process.h"
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <chrono>
+#include <iomanip>
+#include <iterator>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <utility>
+
+class cmMakefile;
+
+#define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0))
+
+class cmCTestRunProcess
+{
+public:
+  cmCTestRunProcess()
+  {
+    this->Process = cmsysProcess_New();
+    this->PipeState = -1;
+    this->TimeOut = std::chrono::duration<double>(-1);
+  }
+  ~cmCTestRunProcess()
+  {
+    if (!(this->PipeState == -1) &&
+        !(this->PipeState == cmsysProcess_Pipe_None) &&
+        !(this->PipeState == cmsysProcess_Pipe_Timeout)) {
+      this->WaitForExit();
+    }
+    cmsysProcess_Delete(this->Process);
+  }
+  void SetCommand(const char* command)
+  {
+    this->CommandLineStrings.clear();
+    this->CommandLineStrings.push_back(command);
+    ;
+  }
+  void AddArgument(const char* arg)
+  {
+    if (arg) {
+      this->CommandLineStrings.push_back(arg);
+    }
+  }
+  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir; }
+  void SetTimeout(std::chrono::duration<double> t) { this->TimeOut = t; }
+  bool StartProcess()
+  {
+    std::vector<const char*> args;
+    for (std::string const& cl : this->CommandLineStrings) {
+      args.push_back(cl.c_str());
+    }
+    args.push_back(nullptr); // null terminate
+    cmsysProcess_SetCommand(this->Process, &*args.begin());
+    if (!this->WorkingDirectory.empty()) {
+      cmsysProcess_SetWorkingDirectory(this->Process,
+                                       this->WorkingDirectory.c_str());
+    }
+
+    cmsysProcess_SetOption(this->Process, cmsysProcess_Option_HideWindow, 1);
+    if (this->TimeOut >= std::chrono::duration<double>::zero()) {
+      cmsysProcess_SetTimeout(this->Process, this->TimeOut.count());
+    }
+    cmsysProcess_Execute(this->Process);
+    this->PipeState = cmsysProcess_GetState(this->Process);
+    // if the process is running or exited return true
+    return this->PipeState == cmsysProcess_State_Executing ||
+      this->PipeState == cmsysProcess_State_Exited;
+  }
+  void SetStdoutFile(const char* fname)
+  {
+    cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDOUT, fname);
+  }
+  void SetStderrFile(const char* fname)
+  {
+    cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDERR, fname);
+  }
+  int WaitForExit(double* timeout = nullptr)
+  {
+    this->PipeState = cmsysProcess_WaitForExit(this->Process, timeout);
+    return this->PipeState;
+  }
+  int GetProcessState() { return this->PipeState; }
+
+private:
+  int PipeState;
+  cmsysProcess* Process;
+  std::vector<std::string> CommandLineStrings;
+  std::string WorkingDirectory;
+  std::chrono::duration<double> TimeOut;
+};
+
+cmCTestCoverageHandler::cmCTestCoverageHandler()
+{
+}
+
+void cmCTestCoverageHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->CustomCoverageExclude.clear();
+  this->SourceLabels.clear();
+  this->TargetDirs.clear();
+  this->LabelIdMap.clear();
+  this->Labels.clear();
+  this->LabelFilter.clear();
+}
+
+void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)
+{
+  std::string logGlob = this->CTest->GetCTestConfiguration("BuildDirectory");
+  logGlob += "/Testing/";
+  logGlob += this->CTest->GetCurrentTag();
+  logGlob += "/CoverageLog*";
+  cmsys::Glob gl;
+  gl.FindFiles(logGlob);
+  std::vector<std::string> const& files = gl.GetFiles();
+  for (std::string const& f : files) {
+    log << "Removing old coverage log: " << f << "\n";
+    cmSystemTools::RemoveFile(f);
+  }
+}
+
+bool cmCTestCoverageHandler::StartCoverageLogFile(
+  cmGeneratedFileStream& covLogFile, int logFileCount)
+{
+  char covLogFilename[1024];
+  sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Open file: " << covLogFilename << std::endl,
+                     this->Quiet);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, covLogFilename,
+                               covLogFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open log file: " << covLogFilename << std::endl);
+    return false;
+  }
+  return true;
+}
+
+void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
+                                                int logFileCount)
+{
+  char covLogFilename[1024];
+  sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Close file: " << covLogFilename << std::endl,
+                     this->Quiet);
+  ostr.Close();
+}
+
+void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml)
+{
+  this->CTest->StartXML(xml, this->AppendXML);
+  xml.StartElement("CoverageLog");
+  xml.Element("StartDateTime", this->CTest->CurrentTime());
+  xml.Element("StartTime", std::chrono::system_clock::now());
+}
+
+void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
+{
+  xml.Element("EndDateTime", this->CTest->CurrentTime());
+  xml.Element("EndTime", std::chrono::system_clock::now());
+  xml.EndElement(); // CoverageLog
+  this->CTest->EndXML(xml);
+}
+
+bool cmCTestCoverageHandler::ShouldIDoCoverage(std::string const& file,
+                                               std::string const& srcDir,
+                                               std::string const& binDir)
+{
+  if (this->IsFilteredOut(file)) {
+    return false;
+  }
+
+  for (cmsys::RegularExpression& rx : this->CustomCoverageExcludeRegex) {
+    if (rx.find(file)) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File "
+                           << file << " is excluded in CTestCustom.ctest"
+                           << std::endl;
+                         , this->Quiet);
+      return false;
+    }
+  }
+
+  std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir);
+  std::string fBinDir = cmSystemTools::CollapseFullPath(binDir);
+  std::string fFile = cmSystemTools::CollapseFullPath(file);
+  bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile, fSrcDir);
+  bool buildSubDir = cmSystemTools::IsSubDirectory(fFile, fBinDir);
+  // Always check parent directory of the file.
+  std::string fileDir = cmSystemTools::GetFilenamePath(fFile);
+  std::string checkDir;
+
+  // We also need to check the binary/source directory pair.
+  if (sourceSubDir && buildSubDir) {
+    if (fSrcDir.size() > fBinDir.size()) {
+      checkDir = fSrcDir;
+    } else {
+      checkDir = fBinDir;
+    }
+  } else if (sourceSubDir) {
+    checkDir = fSrcDir;
+  } else if (buildSubDir) {
+    checkDir = fBinDir;
+  }
+  std::string ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of " << file
+                                 << std::endl,
+                       this->Quiet);
+    return false;
+  }
+
+  // By now checkDir should be set to parent directory of the file.
+  // Get the relative path to the file an apply it to the opposite directory.
+  // If it is the same as fileDir, then ignore, otherwise check.
+  std::string relPath;
+  if (!checkDir.empty()) {
+    relPath = cmSystemTools::RelativePath(checkDir.c_str(), fFile.c_str());
+  } else {
+    relPath = fFile;
+  }
+  if (checkDir == fSrcDir) {
+    checkDir = fBinDir;
+  } else {
+    checkDir = fSrcDir;
+  }
+  fFile = checkDir + "/" + relPath;
+  fFile = cmSystemTools::GetFilenamePath(fFile);
+
+  if (fileDir == fFile) {
+    // This is in-source build, so we trust the previous check.
+    return true;
+  }
+
+  ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of: " << file
+                                 << std::endl,
+                       this->Quiet);
+    return false;
+  }
+  // Ok, nothing in source tree, nothing in binary tree
+  return true;
+}
+
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
+int cmCTestCoverageHandler::ProcessHandler()
+{
+  this->CTest->ClearSubmitFiles(cmCTest::PartCoverage);
+  int error = 0;
+  // do we have time for this
+  if (this->CTest->GetRemainingTimeAllowed() < std::chrono::minutes(2)) {
+    return error;
+  }
+
+  std::string coverage_start_time = this->CTest->CurrentTime();
+  auto coverage_start_time_time = std::chrono::system_clock::now();
+  std::string sourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
+
+  this->LoadLabels();
+
+  cmGeneratedFileStream ofs;
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+  if (!this->StartLogFile("Coverage", ofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create LastCoverage.log file" << std::endl);
+  }
+
+  ofs << "Performing coverage: "
+      << elapsed_time_start.time_since_epoch().count() << std::endl;
+  this->CleanCoverageLogFiles(ofs);
+
+  cmSystemTools::ConvertToUnixSlashes(sourceDir);
+  cmSystemTools::ConvertToUnixSlashes(binaryDir);
+
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "Performing coverage" << std::endl, this->Quiet);
+
+  cmCTestCoverageHandlerContainer cont;
+  cont.Error = error;
+  cont.SourceDir = sourceDir;
+  cont.BinaryDir = binaryDir;
+  cont.OFS = &ofs;
+  cont.Quiet = this->Quiet;
+
+  // setup the regex exclude stuff
+  this->CustomCoverageExcludeRegex.clear();
+  for (std::string const& rex : this->CustomCoverageExclude) {
+    this->CustomCoverageExcludeRegex.push_back(
+      cmsys::RegularExpression(rex.c_str()));
+  }
+
+  if (this->HandleBullseyeCoverage(&cont)) {
+    return cont.Error;
+  }
+  int file_count = 0;
+  file_count += this->HandleGCovCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+  file_count += this->HandleLCovCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+  file_count += this->HandleTracePyCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+  file_count += this->HandlePHPCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+  file_count += this->HandleCoberturaCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+
+  file_count += this->HandleMumpsCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+
+  file_count += this->HandleJacocoCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+
+  file_count += this->HandleBlanketJSCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+
+  file_count += this->HandleDelphiCoverage(&cont);
+  error = cont.Error;
+  if (file_count < 0) {
+    return error;
+  }
+  std::set<std::string> uncovered = this->FindUncoveredFiles(&cont);
+
+  if (file_count == 0 && this->ExtraCoverageGlobs.empty()) {
+    cmCTestOptionalLog(
+      this->CTest, WARNING,
+      " Cannot find any coverage files. Ignoring Coverage request."
+        << std::endl,
+      this->Quiet);
+    return error;
+  }
+  cmGeneratedFileStream covSumFile;
+  cmGeneratedFileStream covLogFile;
+  cmXMLWriter covSumXML(covSumFile);
+  cmXMLWriter covLogXML(covLogFile);
+
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
+    return -1;
+  }
+  covSumFile.setf(std::ios::fixed, std::ios::floatfield);
+  covSumFile.precision(2);
+
+  this->CTest->StartXML(covSumXML, this->AppendXML);
+  // Produce output xml files
+
+  covSumXML.StartElement("Coverage");
+  covSumXML.Element("StartDateTime", coverage_start_time);
+  covSumXML.Element("StartTime", coverage_start_time_time);
+  int logFileCount = 0;
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
+    return -1;
+  }
+  this->StartCoverageLogXML(covLogXML);
+  int cnt = 0;
+  long total_tested = 0;
+  long total_untested = 0;
+  // std::string fullSourceDir = sourceDir + "/";
+  // std::string fullBinaryDir = binaryDir + "/";
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
+    "   Accumulating results (each . represents one file):" << std::endl,
+    this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+
+  std::vector<std::string> errorsWhileAccumulating;
+
+  file_count = 0;
+  for (auto const& file : cont.TotalCoverage) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
+                       this->Quiet);
+    file_count++;
+    if (file_count % 50 == 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
+                           << file_count << " out of "
+                           << cont.TotalCoverage.size() << std::endl,
+                         this->Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+    }
+
+    const std::string fullFileName = file.first;
+    bool shouldIDoCoverage =
+      this->ShouldIDoCoverage(fullFileName, sourceDir, binaryDir);
+    if (!shouldIDoCoverage) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         ".NoDartCoverage found, so skip coverage check for: "
+                           << fullFileName << std::endl,
+                         this->Quiet);
+      continue;
+    }
+
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Process file: " << fullFileName << std::endl,
+                       this->Quiet);
+
+    if (!cmSystemTools::FileExists(fullFileName.c_str())) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot find file: " << fullFileName << std::endl);
+      continue;
+    }
+
+    if (++cnt % 100 == 0) {
+      this->EndCoverageLogXML(covLogXML);
+      this->EndCoverageLogFile(covLogFile, logFileCount);
+      logFileCount++;
+      if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
+        return -1;
+      }
+      this->StartCoverageLogXML(covLogXML);
+    }
+
+    const std::string fileName = cmSystemTools::GetFilenameName(fullFileName);
+    std::string shortFileName =
+      this->CTest->GetShortPathToFile(fullFileName.c_str());
+    const cmCTestCoverageHandlerContainer::SingleFileCoverageVector& fcov =
+      file.second;
+    covLogXML.StartElement("File");
+    covLogXML.Attribute("Name", fileName);
+    covLogXML.Attribute("FullPath", shortFileName);
+    covLogXML.StartElement("Report");
+
+    cmsys::ifstream ifs(fullFileName.c_str());
+    if (!ifs) {
+      std::ostringstream ostr;
+      ostr << "Cannot open source file: " << fullFileName;
+      errorsWhileAccumulating.push_back(ostr.str());
+      error++;
+      continue;
+    }
+
+    int tested = 0;
+    int untested = 0;
+
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector::size_type cc;
+    std::string line;
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Actually performing coverage for: " << fullFileName
+                                                            << std::endl,
+                       this->Quiet);
+    for (cc = 0; cc < fcov.size(); cc++) {
+      if (!cmSystemTools::GetLineFromStream(ifs, line) &&
+          cc != fcov.size() - 1) {
+        std::ostringstream ostr;
+        ostr << "Problem reading source file: " << fullFileName
+             << " line:" << cc << "  out total: " << fcov.size() - 1;
+        errorsWhileAccumulating.push_back(ostr.str());
+        error++;
+        break;
+      }
+      covLogXML.StartElement("Line");
+      covLogXML.Attribute("Number", cc);
+      covLogXML.Attribute("Count", fcov[cc]);
+      covLogXML.Content(line);
+      covLogXML.EndElement(); // Line
+      if (fcov[cc] == 0) {
+        untested++;
+      } else if (fcov[cc] > 0) {
+        tested++;
+      }
+    }
+    if (cmSystemTools::GetLineFromStream(ifs, line)) {
+      std::ostringstream ostr;
+      ostr << "Looks like there are more lines in the file: " << fullFileName;
+      errorsWhileAccumulating.push_back(ostr.str());
+    }
+    float cper = 0;
+    float cmet = 0;
+    if (tested + untested > 0) {
+      cper = (100 * SAFEDIV(static_cast<float>(tested),
+                            static_cast<float>(tested + untested)));
+      cmet = (SAFEDIV(static_cast<float>(tested + 10),
+                      static_cast<float>(tested + untested + 10)));
+    }
+    total_tested += tested;
+    total_untested += untested;
+    covLogXML.EndElement(); // Report
+    covLogXML.EndElement(); // File
+    covSumXML.StartElement("File");
+    covSumXML.Attribute("Name", fileName);
+    covSumXML.Attribute("FullPath",
+                        this->CTest->GetShortPathToFile(fullFileName.c_str()));
+    covSumXML.Attribute("Covered", tested + untested > 0 ? "true" : "false");
+    covSumXML.Element("LOCTested", tested);
+    covSumXML.Element("LOCUnTested", untested);
+    covSumXML.Element("PercentCoverage", cper);
+    covSumXML.Element("CoverageMetric", cmet);
+    this->WriteXMLLabels(covSumXML, shortFileName);
+    covSumXML.EndElement(); // File
+  }
+
+  // Handle all the files in the extra coverage globs that have no cov data
+  for (std::string const& u : uncovered) {
+    std::string fileName = cmSystemTools::GetFilenameName(u);
+    std::string fullPath = cont.SourceDir + "/" + u;
+
+    covLogXML.StartElement("File");
+    covLogXML.Attribute("Name", fileName);
+    covLogXML.Attribute("FullPath", u);
+    covLogXML.StartElement("Report");
+
+    cmsys::ifstream ifs(fullPath.c_str());
+    if (!ifs) {
+      std::ostringstream ostr;
+      ostr << "Cannot open source file: " << fullPath;
+      errorsWhileAccumulating.push_back(ostr.str());
+      error++;
+      covLogXML.EndElement(); // Report
+      covLogXML.EndElement(); // File
+      continue;
+    }
+    int untested = 0;
+    std::string line;
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Actually performing coverage for: " << u << std::endl,
+                       this->Quiet);
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      covLogXML.StartElement("Line");
+      covLogXML.Attribute("Number", untested);
+      covLogXML.Attribute("Count", 0);
+      covLogXML.Content(line);
+      covLogXML.EndElement(); // Line
+      untested++;
+    }
+    covLogXML.EndElement(); // Report
+    covLogXML.EndElement(); // File
+
+    total_untested += untested;
+    covSumXML.StartElement("File");
+    covSumXML.Attribute("Name", fileName);
+    covSumXML.Attribute("FullPath", u);
+    covSumXML.Attribute("Covered", "true");
+    covSumXML.Element("LOCTested", 0);
+    covSumXML.Element("LOCUnTested", untested);
+    covSumXML.Element("PercentCoverage", 0);
+    covSumXML.Element("CoverageMetric", 0);
+    this->WriteXMLLabels(covSumXML, u);
+    covSumXML.EndElement(); // File
+  }
+
+  this->EndCoverageLogXML(covLogXML);
+  this->EndCoverageLogFile(covLogFile, logFileCount);
+
+  if (!errorsWhileAccumulating.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error(s) while accumulating results:" << std::endl);
+    for (std::string const& er : errorsWhileAccumulating) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  " << er << std::endl);
+    }
+  }
+
+  long total_lines = total_tested + total_untested;
+  float percent_coverage = 100 *
+    SAFEDIV(static_cast<float>(total_tested), static_cast<float>(total_lines));
+  if (total_lines == 0) {
+    percent_coverage = 0;
+  }
+
+  std::string end_time = this->CTest->CurrentTime();
+
+  covSumXML.Element("LOCTested", total_tested);
+  covSumXML.Element("LOCUntested", total_untested);
+  covSumXML.Element("LOC", total_lines);
+  covSumXML.Element("PercentCoverage", percent_coverage);
+  covSumXML.Element("EndDateTime", end_time);
+  covSumXML.Element("EndTime", std::chrono::system_clock::now());
+  covSumXML.Element("ElapsedMinutes",
+                    std::chrono::duration_cast<std::chrono::minutes>(
+                      std::chrono::steady_clock::now() - elapsed_time_start)
+                      .count());
+  covSumXML.EndElement(); // Coverage
+  this->CTest->EndXML(covSumXML);
+
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, ""
+               << std::endl
+               << "\tCovered LOC:         " << total_tested << std::endl
+               << "\tNot covered LOC:     " << total_untested << std::endl
+               << "\tTotal LOC:           " << total_lines << std::endl
+               << "\tPercentage Coverage: "
+               << std::setiosflags(std::ios::fixed) << std::setprecision(2)
+               << (percent_coverage) << "%" << std::endl);
+
+  ofs << "\tCovered LOC:         " << total_tested << std::endl
+      << "\tNot covered LOC:     " << total_untested << std::endl
+      << "\tTotal LOC:           " << total_lines << std::endl
+      << "\tPercentage Coverage: " << std::setiosflags(std::ios::fixed)
+      << std::setprecision(2) << (percent_coverage) << "%" << std::endl;
+
+  if (error) {
+    return -1;
+  }
+  return 0;
+}
+
+void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile* mf)
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " Add coverage exclude regular expressions." << std::endl,
+                     this->Quiet);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
+                                    this->CustomCoverageExclude);
+  this->CTest->PopulateCustomVector(mf, "CTEST_EXTRA_COVERAGE_GLOB",
+                                    this->ExtraCoverageGlobs);
+  for (std::string const& cce : this->CustomCoverageExclude) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Add coverage exclude: " << cce << std::endl,
+                       this->Quiet);
+  }
+  for (std::string const& ecg : this->ExtraCoverageGlobs) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Add coverage glob: " << ecg << std::endl,
+                       this->Quiet);
+  }
+}
+
+// Fix for issue #4971 where the case of the drive letter component of
+// the filenames might be different when analyzing gcov output.
+//
+// Compare file names: fnc(fn1) == fnc(fn2) // fnc == file name compare
+//
+#ifdef _WIN32
+#define fnc(s) cmSystemTools::LowerCase(s)
+#else
+#define fnc(s) s
+#endif
+
+bool IsFileInDir(const std::string& infile, const std::string& indir)
+{
+  std::string file = cmSystemTools::CollapseFullPath(infile);
+  std::string dir = cmSystemTools::CollapseFullPath(indir);
+
+  return file.size() > dir.size() &&
+    fnc(file.substr(0, dir.size())) == fnc(dir) && file[dir.size()] == '/';
+}
+
+int cmCTestCoverageHandler::HandlePHPCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmParsePHPCoverage cov(*cont, this->CTest);
+  std::string coverageDir = this->CTest->GetBinaryDir() + "/xdebugCoverage";
+  if (cmSystemTools::FileIsDirectory(coverageDir)) {
+    cov.ReadPHPCoverageDirectory(coverageDir.c_str());
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+
+int cmCTestCoverageHandler::HandleCoberturaCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmParseCoberturaCoverage cov(*cont, this->CTest);
+
+  // Assume the coverage.xml is in the binary directory
+  // check for the COBERTURADIR environment variable,
+  // if it doesn't exist or is empty, assume the
+  // binary directory is used.
+  std::string coverageXMLFile;
+  if (!cmSystemTools::GetEnv("COBERTURADIR", coverageXMLFile) ||
+      coverageXMLFile.empty()) {
+    coverageXMLFile = this->CTest->GetBinaryDir();
+  }
+  // build the find file string with the directory from above
+  coverageXMLFile += "/coverage.xml";
+
+  if (cmSystemTools::FileExists(coverageXMLFile.c_str())) {
+    // If file exists, parse it
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Parsing Cobertura XML file: " << coverageXMLFile
+                                                      << std::endl,
+                       this->Quiet);
+    cov.ReadCoverageXML(coverageXMLFile.c_str());
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find Cobertura XML file: " << coverageXMLFile
+                                                           << std::endl,
+                       this->Quiet);
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+
+int cmCTestCoverageHandler::HandleMumpsCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  // try gtm coverage
+  cmParseGTMCoverage cov(*cont, this->CTest);
+  std::string coverageFile =
+    this->CTest->GetBinaryDir() + "/gtm_coverage.mcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
+    cov.ReadCoverageFile(coverageFile.c_str());
+    return static_cast<int>(cont->TotalCoverage.size());
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " Cannot find GTM coverage file: " << coverageFile
+                                                        << std::endl,
+                     this->Quiet);
+  cmParseCacheCoverage ccov(*cont, this->CTest);
+  coverageFile = this->CTest->GetBinaryDir() + "/cache_coverage.cmcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
+    ccov.ReadCoverageFile(coverageFile.c_str());
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find Cache coverage file: " << coverageFile
+                                                            << std::endl,
+                       this->Quiet);
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+
+struct cmCTestCoverageHandlerLocale
+{
+  cmCTestCoverageHandlerLocale()
+  {
+    std::string l;
+    if (cmSystemTools::GetEnv("LC_ALL", l)) {
+      lc_all = l;
+    }
+    if (lc_all != "C") {
+      cmSystemTools::PutEnv("LC_ALL=C");
+    }
+  }
+  ~cmCTestCoverageHandlerLocale()
+  {
+    if (!lc_all.empty()) {
+      cmSystemTools::PutEnv("LC_ALL=" + lc_all);
+    } else {
+      cmSystemTools::UnsetEnv("LC_ALL");
+    }
+  }
+  std::string lc_all;
+};
+
+int cmCTestCoverageHandler::HandleJacocoCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmParseJacocoCoverage cov = cmParseJacocoCoverage(*cont, this->CTest);
+
+  // Search in the source directory.
+  cmsys::Glob g1;
+  std::vector<std::string> files;
+  g1.SetRecurse(true);
+
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string coverageFile = SourceDir + "/*jacoco.xml";
+
+  g1.FindFiles(coverageFile);
+  files = g1.GetFiles();
+
+  // ...and in the binary directory.
+  cmsys::Glob g2;
+  std::vector<std::string> binFiles;
+  g2.SetRecurse(true);
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
+  std::string binCoverageFile = binaryDir + "/*jacoco.xml";
+  g2.FindFiles(binCoverageFile);
+  binFiles = g2.GetFiles();
+  if (!binFiles.empty()) {
+    files.insert(files.end(), binFiles.begin(), binFiles.end());
+  }
+
+  if (!files.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found Jacoco Files, Performing Coverage" << std::endl,
+                       this->Quiet);
+    cov.LoadCoverageData(files);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find Jacoco coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+
+int cmCTestCoverageHandler::HandleDelphiCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmParseDelphiCoverage cov = cmParseDelphiCoverage(*cont, this->CTest);
+  cmsys::Glob g;
+  std::vector<std::string> files;
+  g.SetRecurse(true);
+
+  std::string BinDir = this->CTest->GetBinaryDir();
+  std::string coverageFile = BinDir + "/*(*.pas).html";
+
+  g.FindFiles(coverageFile);
+  files = g.GetFiles();
+  if (!files.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found Delphi HTML Files, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
+    cov.LoadCoverageData(files);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find Delphi coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+
+static std::string joinCommandLine(const std::vector<std::string>& args)
+{
+  std::string ret;
+
+  for (std::string const& s : args) {
+    if (s.find(' ') == std::string::npos) {
+      ret += s + ' ';
+    } else {
+      ret += "\"" + s + "\" ";
+    }
+  }
+
+  // drop trailing whitespace
+  ret.erase(ret.size() - 1);
+
+  return ret;
+}
+
+int cmCTestCoverageHandler::HandleBlanketJSCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmParseBlanketJSCoverage cov = cmParseBlanketJSCoverage(*cont, this->CTest);
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+
+  // Look for something other than output.json, still JSON extension.
+  std::string coverageFile = SourceDir + "/*.json";
+  cmsys::Glob g;
+  std::vector<std::string> files;
+  std::vector<std::string> blanketFiles;
+  g.FindFiles(coverageFile);
+  files = g.GetFiles();
+  // Ensure that the JSON files found are the result of the
+  // Blanket.js output. Check for the "node-jscoverage"
+  // string on the second line
+  std::string line;
+  for (std::string const& fileEntry : files) {
+    cmsys::ifstream in(fileEntry.c_str());
+    cmSystemTools::GetLineFromStream(in, line);
+    cmSystemTools::GetLineFromStream(in, line);
+    if (line.find("node-jscoverage") != std::string::npos) {
+      blanketFiles.push_back(fileEntry);
+    }
+  }
+  //  Take all files with the node-jscoverage string and parse those
+  if (!blanketFiles.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found BlanketJS output JSON, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
+    cov.LoadCoverageData(files);
+  } else {
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      " Cannot find BlanketJS coverage files: " << coverageFile << std::endl,
+      this->Quiet);
+  }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
+int cmCTestCoverageHandler::HandleGCovCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  std::string gcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  if (gcovCommand.empty()) {
+    cmCTestLog(this->CTest, WARNING, "Could not find gcov." << std::endl);
+    return 0;
+  }
+  std::string gcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+
+  // Immediately skip to next coverage option since codecov is only for Intel
+  // compiler
+  if (gcovCommand == "codecov") {
+    return 0;
+  }
+
+  // Style 1
+  std::string st1gcovOutputRex1 =
+    "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
+  std::string st1gcovOutputRex2 = "^Creating (.*\\.gcov)\\.";
+  cmsys::RegularExpression st1re1(st1gcovOutputRex1.c_str());
+  cmsys::RegularExpression st1re2(st1gcovOutputRex2.c_str());
+
+  // Style 2
+  std::string st2gcovOutputRex1 = "^File *[`'](.*)'$";
+  std::string st2gcovOutputRex2 =
+    "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
+  std::string st2gcovOutputRex3 = "^(.*)reating [`'](.*\\.gcov)'";
+  std::string st2gcovOutputRex4 = "^(.*):unexpected EOF *$";
+  std::string st2gcovOutputRex5 = "^(.*):cannot open source file*$";
+  std::string st2gcovOutputRex6 =
+    "^(.*):source file is newer than graph file `(.*)'$";
+  cmsys::RegularExpression st2re1(st2gcovOutputRex1.c_str());
+  cmsys::RegularExpression st2re2(st2gcovOutputRex2.c_str());
+  cmsys::RegularExpression st2re3(st2gcovOutputRex3.c_str());
+  cmsys::RegularExpression st2re4(st2gcovOutputRex4.c_str());
+  cmsys::RegularExpression st2re5(st2gcovOutputRex5.c_str());
+  cmsys::RegularExpression st2re6(st2gcovOutputRex6.c_str());
+
+  std::vector<std::string> files;
+  this->FindGCovFiles(files);
+
+  if (files.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find any GCov coverage files." << std::endl,
+                       this->Quiet);
+    // No coverage files is a valid thing, so the exit code is 0
+    return 0;
+  }
+
+  std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
+  std::string tempDir = testingDir + "/CoverageInfo";
+  cmSystemTools::MakeDirectory(tempDir.c_str());
+  cmWorkingDirectory workdir(tempDir);
+
+  int gcovStyle = 0;
+
+  std::set<std::string> missingFiles;
+
+  std::string actualSourceFile;
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
+    "   Processing coverage (each . represents one file):" << std::endl,
+    this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+  int file_count = 0;
+
+  // make sure output from gcov is in English!
+  cmCTestCoverageHandlerLocale locale_C;
+  static_cast<void>(locale_C);
+
+  std::vector<std::string> basecovargs =
+    cmSystemTools::ParseArguments(gcovExtraFlags.c_str());
+  basecovargs.insert(basecovargs.begin(), gcovCommand);
+  basecovargs.push_back("-o");
+
+  // files is a list of *.da and *.gcda files with coverage data in them.
+  // These are binary files that you give as input to gcov so that it will
+  // give us text output we can analyze to summarize coverage.
+  //
+  for (std::string const& f : files) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
+                       this->Quiet);
+
+    // Call gcov to get coverage data for this *.gcda file:
+    //
+    std::string fileDir = cmSystemTools::GetFilenamePath(f);
+    std::vector<std::string> covargs = basecovargs;
+    covargs.push_back(fileDir);
+    covargs.push_back(f);
+    const std::string command = joinCommandLine(covargs);
+
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command << std::endl, this->Quiet);
+
+    std::string output;
+    std::string errors;
+    int retVal = 0;
+    *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
+    *cont->OFS << "  Command: " << command << std::endl;
+    int res = this->CTest->RunCommand(
+      covargs, &output, &errors, &retVal, tempDir.c_str(),
+      std::chrono::duration<double>::zero() /*this->TimeOut*/);
+
+    *cont->OFS << "  Output: " << output << std::endl;
+    *cont->OFS << "  Errors: " << errors << std::endl;
+    if (!res) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Problem running coverage on file: " << f << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
+      continue;
+    }
+    if (retVal != 0) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
+                   << retVal << " while processing: " << f << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      "--------------------------------------------------------------"
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
+
+    std::vector<std::string> lines;
+
+    cmSystemTools::Split(output.c_str(), lines);
+
+    for (std::string const& line : lines) {
+      std::string sourceFile;
+      std::string gcovFile;
+
+      cmCTestOptionalLog(this->CTest, DEBUG,
+                         "Line: [" << line << "]" << std::endl, this->Quiet);
+
+      if (line.empty()) {
+        // Ignore empty line; probably style 2
+      } else if (st1re1.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 1;
+        }
+        if (gcovStyle != 1) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e1"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        actualSourceFile.clear();
+        sourceFile = st1re1.match(2);
+      } else if (st1re2.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 1;
+        }
+        if (gcovStyle != 1) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e2"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        gcovFile = st1re2.match(1);
+      } else if (st2re1.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e3"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        actualSourceFile.clear();
+        sourceFile = st2re1.match(1);
+      } else if (st2re2.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e4"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+      } else if (st2re3.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e5"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        gcovFile = st2re3.match(2);
+      } else if (st2re4.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e6"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        cmCTestOptionalLog(this->CTest, WARNING,
+                           "Warning: " << st2re4.match(1)
+                                       << " had unexpected EOF" << std::endl,
+                           this->Quiet);
+      } else if (st2re5.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e7"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        cmCTestOptionalLog(this->CTest, WARNING, "Warning: Cannot open file: "
+                             << st2re5.match(1) << std::endl,
+                           this->Quiet);
+      } else if (st2re6.find(line.c_str())) {
+        if (gcovStyle == 0) {
+          gcovStyle = 2;
+        }
+        if (gcovStyle != 2) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e8"
+                       << std::endl);
+          cont->Error++;
+          break;
+        }
+
+        cmCTestOptionalLog(this->CTest, WARNING, "Warning: File: "
+                             << st2re6.match(1) << " is newer than "
+                             << st2re6.match(2) << std::endl,
+                           this->Quiet);
+      } else {
+        // gcov 4.7 can have output lines saying "No executable lines" and
+        // "Removing 'filename.gcov'"... Don't log those as "errors."
+        if (line != "No executable lines" &&
+            !cmSystemTools::StringStartsWith(line.c_str(), "Removing ")) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output line: ["
+                       << line << "]" << std::endl);
+          cont->Error++;
+          // abort();
+        }
+      }
+
+      // If the last line of gcov output gave us a valid value for gcovFile,
+      // and we have an actualSourceFile, then insert a (or add to existing)
+      // SingleFileCoverageVector for actualSourceFile:
+      //
+      if (!gcovFile.empty() && !actualSourceFile.empty()) {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+          cont->TotalCoverage[actualSourceFile];
+
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "   in gcovFile: " << gcovFile << std::endl,
+                           this->Quiet);
+
+        cmsys::ifstream ifile(gcovFile.c_str());
+        if (!ifile) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << gcovFile << std::endl);
+        } else {
+          long cnt = -1;
+          std::string nl;
+          while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+            cnt++;
+
+            // TODO: Handle gcov 3.0 non-coverage lines
+
+            // Skip empty lines
+            if (nl.empty()) {
+              continue;
+            }
+
+            // Skip unused lines
+            if (nl.size() < 12) {
+              continue;
+            }
+
+            // Read the coverage count from the beginning of the gcov output
+            // line
+            std::string prefix = nl.substr(0, 12);
+            int cov = atoi(prefix.c_str());
+
+            // Read the line number starting at the 10th character of the gcov
+            // output line
+            std::string lineNumber = nl.substr(10, 5);
+
+            int lineIdx = atoi(lineNumber.c_str()) - 1;
+            if (lineIdx >= 0) {
+              while (vec.size() <= static_cast<size_t>(lineIdx)) {
+                vec.push_back(-1);
+              }
+
+              // Initially all entries are -1 (not used). If we get coverage
+              // information, increment it to 0 first.
+              if (vec[lineIdx] < 0) {
+                if (cov > 0 || prefix.find('#') != std::string::npos) {
+                  vec[lineIdx] = 0;
+                }
+              }
+
+              vec[lineIdx] += cov;
+            }
+          }
+        }
+
+        actualSourceFile.clear();
+      }
+
+      if (!sourceFile.empty() && actualSourceFile.empty()) {
+        gcovFile.clear();
+
+        // Is it in the source dir or the binary dir?
+        //
+        if (IsFileInDir(sourceFile, cont->SourceDir)) {
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "   produced s: " << sourceFile << std::endl,
+                             this->Quiet);
+          *cont->OFS << "  produced in source dir: " << sourceFile
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        } else if (IsFileInDir(sourceFile, cont->BinaryDir)) {
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "   produced b: " << sourceFile << std::endl,
+                             this->Quiet);
+          *cont->OFS << "  produced in binary dir: " << sourceFile
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        }
+
+        if (actualSourceFile.empty()) {
+          if (missingFiles.find(sourceFile) == missingFiles.end()) {
+            cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                               "Something went wrong" << std::endl,
+                               this->Quiet);
+            cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                               "Cannot find file: [" << sourceFile << "]"
+                                                     << std::endl,
+                               this->Quiet);
+            cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                               " in source dir: [" << cont->SourceDir << "]"
+                                                   << std::endl,
+                               this->Quiet);
+            cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                               " or binary dir: [" << cont->BinaryDir.size()
+                                                   << "]" << std::endl,
+                               this->Quiet);
+            *cont->OFS << "  Something went wrong. Cannot find file: "
+                       << sourceFile << " in source dir: " << cont->SourceDir
+                       << " or binary dir: " << cont->BinaryDir << std::endl;
+
+            missingFiles.insert(sourceFile);
+          }
+        }
+      }
+    }
+
+    file_count++;
+
+    if (file_count % 50 == 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+    }
+  }
+
+  return file_count;
+}
+
+int cmCTestCoverageHandler::HandleLCovCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  std::string lcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  std::string lcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+  if (lcovCommand != "codecov") {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Not a valid Intel Coverage command." << std::endl,
+                       this->Quiet);
+    return 0;
+  }
+  // There is only percentage completed output from LCOV
+  std::string st2lcovOutputRex3 = "[0-9]+%";
+  cmsys::RegularExpression st2re3(st2lcovOutputRex3.c_str());
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " This is coverage command: " << lcovCommand << std::endl,
+                     this->Quiet);
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " These are coverage command flags: " << lcovExtraFlags
+                                                           << std::endl,
+                     this->Quiet);
+
+  std::vector<std::string> files;
+  if (!this->FindLCovFiles(files)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error while finding LCov files.\n");
+    return 0;
+  }
+
+  if (files.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find any LCov coverage files." << std::endl,
+                       this->Quiet);
+    // No coverage files is a valid thing, so the exit code is 0
+    return 0;
+  }
+  std::string testingDir = this->CTest->GetBinaryDir();
+
+  std::set<std::string> missingFiles;
+
+  std::string actualSourceFile;
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
+    "   Processing coverage (each . represents one file):" << std::endl,
+    this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+  int file_count = 0;
+
+  // make sure output from lcov is in English!
+  cmCTestCoverageHandlerLocale locale_C;
+  static_cast<void>(locale_C);
+
+  std::vector<std::string> covargs =
+    cmSystemTools::ParseArguments(lcovExtraFlags.c_str());
+  covargs.insert(covargs.begin(), lcovCommand);
+  const std::string command = joinCommandLine(covargs);
+
+  // In intel compiler we have to call codecov only once in each executable
+  // directory. It collects all *.dyn files to generate .dpi file.
+  for (std::string const& f : files) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
+                       this->Quiet);
+    std::string fileDir = cmSystemTools::GetFilenamePath(f);
+    cmWorkingDirectory workdir(fileDir);
+
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Current coverage dir: " << fileDir << std::endl,
+                       this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command << std::endl, this->Quiet);
+
+    std::string output;
+    std::string errors;
+    int retVal = 0;
+    *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
+    *cont->OFS << "  Command: " << command << std::endl;
+    int res = this->CTest->RunCommand(
+      covargs, &output, &errors, &retVal, fileDir.c_str(),
+      std::chrono::duration<double>::zero() /*this->TimeOut*/);
+
+    *cont->OFS << "  Output: " << output << std::endl;
+    *cont->OFS << "  Errors: " << errors << std::endl;
+    if (!res) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Problem running coverage on file: " << f << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
+      continue;
+    }
+    if (retVal != 0) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
+                   << retVal << " while processing: " << f << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      "--------------------------------------------------------------"
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
+
+    std::vector<std::string> lines;
+
+    cmSystemTools::Split(output.c_str(), lines);
+
+    for (std::string const& line : lines) {
+      std::string sourceFile;
+      std::string lcovFile;
+
+      if (line.empty()) {
+        // Ignore empty line
+      }
+      // Look for LCOV files in binary directory
+      // Intel Compiler creates a CodeCoverage dir for each subfolder and
+      // each subfolder has LCOV files
+      cmsys::Glob gl;
+      gl.RecurseOn();
+      gl.RecurseThroughSymlinksOff();
+      std::string dir;
+      std::vector<std::string> lcovFiles;
+      dir = this->CTest->GetBinaryDir();
+      std::string daGlob;
+      daGlob = dir;
+      daGlob += "/*.LCOV";
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_VERBOSE_OUTPUT,
+        "   looking for LCOV files in: " << daGlob << std::endl, this->Quiet);
+      gl.FindFiles(daGlob);
+      // Keep a list of all LCOV files
+      lcovFiles.insert(lcovFiles.end(), gl.GetFiles().begin(),
+                       gl.GetFiles().end());
+
+      for (std::string const& file : lcovFiles) {
+        lcovFile = file;
+        cmsys::ifstream srcead(lcovFile.c_str());
+        if (!srcead) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << lcovFile << std::endl);
+        }
+        std::string srcname;
+
+        int success = cmSystemTools::GetLineFromStream(srcead, srcname);
+        if (!success) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Error while parsing lcov file '"
+                       << lcovFile << "':"
+                       << " No source file name found!" << std::endl);
+          return 0;
+        }
+        srcname = srcname.substr(18);
+        // We can directly read found LCOV files to determine the source
+        // files
+        sourceFile = srcname;
+        actualSourceFile = srcname;
+
+        for (std::string const& t : lcovFiles) {
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "Found LCOV File: " << t << std::endl,
+                             this->Quiet);
+        }
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "SourceFile: " << sourceFile << std::endl,
+                           this->Quiet);
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "lCovFile: " << lcovFile << std::endl, this->Quiet);
+
+        // If we have some LCOV files to process
+        if (!lcovFile.empty() && !actualSourceFile.empty()) {
+          cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+            cont->TotalCoverage[actualSourceFile];
+
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "   in lcovFile: " << lcovFile << std::endl,
+                             this->Quiet);
+
+          cmsys::ifstream ifile(lcovFile.c_str());
+          if (!ifile) {
+            cmCTestLog(this->CTest, ERROR_MESSAGE,
+                       "Cannot open file: " << lcovFile << std::endl);
+          } else {
+            long cnt = -1;
+            std::string nl;
+
+            // Skip the first line
+            cmSystemTools::GetLineFromStream(ifile, nl);
+            cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                               "File is ready, start reading." << std::endl,
+                               this->Quiet);
+            while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+              cnt++;
+
+              // Skip empty lines
+              if (nl.empty()) {
+                continue;
+              }
+
+              // Skip unused lines
+              if (nl.size() < 12) {
+                continue;
+              }
+
+              // Read the coverage count from the beginning of the lcov
+              // output line
+              std::string prefix = nl.substr(0, 17);
+              int cov = atoi(prefix.c_str());
+
+              // Read the line number starting at the 17th character of the
+              // lcov output line
+              std::string lineNumber = nl.substr(17, 7);
+
+              int lineIdx = atoi(lineNumber.c_str()) - 1;
+              if (lineIdx >= 0) {
+                while (vec.size() <= static_cast<size_t>(lineIdx)) {
+                  vec.push_back(-1);
+                }
+
+                // Initially all entries are -1 (not used). If we get coverage
+                // information, increment it to 0 first.
+                if (vec[lineIdx] < 0) {
+                  if (cov > 0 || prefix.find('#') != std::string::npos) {
+                    vec[lineIdx] = 0;
+                  }
+                }
+
+                vec[lineIdx] += cov;
+              }
+            }
+          }
+
+          actualSourceFile.clear();
+        }
+      }
+    }
+
+    file_count++;
+
+    if (file_count % 50 == 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
+    }
+  }
+
+  return file_count;
+}
+
+void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
+{
+  cmsys::Glob gl;
+  gl.RecurseOn();
+  gl.RecurseThroughSymlinksOff();
+
+  for (auto const& lm : this->TargetDirs) {
+    // Skip targets containing no interesting labels.
+    if (!this->IntersectsFilter(lm.second)) {
+      continue;
+    }
+
+    // Coverage files appear next to their object files in the target
+    // support directory.
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      "   globbing for coverage in: " << lm.first << std::endl, this->Quiet);
+    std::string daGlob = lm.first;
+    daGlob += "/*.da";
+    gl.FindFiles(daGlob);
+    files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
+    daGlob = lm.first;
+    daGlob += "/*.gcda";
+    gl.FindFiles(daGlob);
+    files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
+  }
+}
+
+bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
+{
+  cmsys::Glob gl;
+  gl.RecurseOff(); // No need of recurse if -prof_dir${BUILD_DIR} flag is
+                   // used while compiling.
+  gl.RecurseThroughSymlinksOff();
+  std::string buildDir = this->CTest->GetCTestConfiguration("BuildDirectory");
+  cmWorkingDirectory workdir(buildDir);
+
+  // Run profmerge to merge all *.dyn files into dpi files
+  if (!cmSystemTools::RunSingleCommand("profmerge")) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error while running profmerge.\n");
+    return false;
+  }
+
+  // DPI file should appear in build directory
+  std::string daGlob;
+  daGlob = buildDir;
+  daGlob += "/*.dpi";
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "   looking for dpi files in: " << daGlob << std::endl,
+                     this->Quiet);
+  if (!gl.FindFiles(daGlob)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error while finding files matching " << daGlob << std::endl);
+    return false;
+  }
+  files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Now searching in: " << daGlob << std::endl, this->Quiet);
+  return true;
+}
+
+int cmCTestCoverageHandler::HandleTracePyCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  cmsys::Glob gl;
+  gl.RecurseOn();
+  gl.RecurseThroughSymlinksOff();
+  std::string daGlob = cont->BinaryDir + "/*.cover";
+  gl.FindFiles(daGlob);
+  std::vector<std::string> files = gl.GetFiles();
+
+  if (files.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " Cannot find any Python Trace.py coverage files."
+                         << std::endl,
+                       this->Quiet);
+    // No coverage files is a valid thing, so the exit code is 0
+    return 0;
+  }
+
+  std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
+  std::string tempDir = testingDir + "/CoverageInfo";
+  cmSystemTools::MakeDirectory(tempDir.c_str());
+
+  int file_count = 0;
+  for (std::string const& file : files) {
+    std::string fileName = this->FindFile(cont, file);
+    if (fileName.empty()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot find source Python file corresponding to: "
+                   << file << std::endl);
+      continue;
+    }
+
+    std::string actualSourceFile = cmSystemTools::CollapseFullPath(fileName);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "   Check coverage for file: " << actualSourceFile
+                                                      << std::endl,
+                       this->Quiet);
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector* vec =
+      &cont->TotalCoverage[actualSourceFile];
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "   in file: " << file << std::endl, this->Quiet);
+    cmsys::ifstream ifile(file.c_str());
+    if (!ifile) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot open file: " << file << std::endl);
+    } else {
+      long cnt = -1;
+      std::string nl;
+      while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+        cnt++;
+
+        // Skip empty lines
+        if (nl.empty()) {
+          continue;
+        }
+
+        // Skip unused lines
+        if (nl.size() < 12) {
+          continue;
+        }
+
+        // Read the coverage count from the beginning of the Trace.py output
+        // line
+        std::string prefix = nl.substr(0, 6);
+        if (prefix[5] != ' ' && prefix[5] != ':') {
+          // This is a hack. We should really do something more elaborate
+          prefix = nl.substr(0, 7);
+          if (prefix[6] != ' ' && prefix[6] != ':') {
+            prefix = nl.substr(0, 8);
+            if (prefix[7] != ' ' && prefix[7] != ':') {
+              cmCTestLog(this->CTest, ERROR_MESSAGE,
+                         "Currently the limit is maximum coverage of 999999"
+                           << std::endl);
+            }
+          }
+        }
+        int cov = atoi(prefix.c_str());
+        if (prefix[prefix.size() - 1] != ':') {
+          // This line does not have ':' so no coverage here. That said,
+          // Trace.py does not handle not covered lines versus comments etc.
+          // So, this will be set to 0.
+          cov = 0;
+        }
+        cmCTestOptionalLog(
+          this->CTest, DEBUG,
+          "Prefix: " << prefix << " cov: " << cov << std::endl, this->Quiet);
+        // Read the line number starting at the 10th character of the gcov
+        // output line
+        long lineIdx = cnt;
+        if (lineIdx >= 0) {
+          while (vec->size() <= static_cast<size_t>(lineIdx)) {
+            vec->push_back(-1);
+          }
+          // Initially all entries are -1 (not used). If we get coverage
+          // information, increment it to 0 first.
+          if ((*vec)[lineIdx] < 0) {
+            if (cov >= 0) {
+              (*vec)[lineIdx] = 0;
+            }
+          }
+          (*vec)[lineIdx] += cov;
+        }
+      }
+    }
+    ++file_count;
+  }
+  return file_count;
+}
+
+std::string cmCTestCoverageHandler::FindFile(
+  cmCTestCoverageHandlerContainer* cont, std::string const& fileName)
+{
+  std::string fileNameNoE =
+    cmSystemTools::GetFilenameWithoutLastExtension(fileName);
+  // First check in source and binary directory
+  std::string fullName = cont->SourceDir + "/" + fileNameNoE + ".py";
+  if (cmSystemTools::FileExists(fullName.c_str())) {
+    return fullName;
+  }
+  fullName = cont->BinaryDir + "/" + fileNameNoE + ".py";
+  if (cmSystemTools::FileExists(fullName.c_str())) {
+    return fullName;
+  }
+  return "";
+}
+
+// This is a header put on each marked up source file
+namespace {
+const char* bullseyeHelp[] = {
+  "    Coverage produced by bullseye covbr tool: ",
+  "      www.bullseye.com/help/ref_covbr.html",
+  "    * An arrow --> indicates incomplete coverage.",
+  "    * An X indicates a function that was invoked, a switch label that ",
+  "      was exercised, a try-block that finished, or an exception handler ",
+  "      that was invoked.",
+  "    * A T or F indicates a boolean decision that evaluated true or false,",
+  "      respectively.",
+  "    * A t or f indicates a boolean condition within a decision if the ",
+  "      condition evaluated true or false, respectively.",
+  "    * A k indicates a constant decision or condition.",
+  "    * The slash / means this probe is excluded from summary results. ",
+  nullptr
+};
+}
+
+int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
+  cmCTestCoverageHandlerContainer* cont,
+  std::set<std::string>& coveredFileNames, std::vector<std::string>& files,
+  std::vector<std::string>& filesFullPath)
+{
+  if (files.size() != filesFullPath.size()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Files and full path files not the same size?:\n");
+    return 0;
+  }
+  // create the output stream for the CoverageLog-N.xml file
+  cmGeneratedFileStream covLogFile;
+  cmXMLWriter covLogXML(covLogFile);
+  int logFileCount = 0;
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
+    return -1;
+  }
+  this->StartCoverageLogXML(covLogXML);
+  // for each file run covbr on that file to get the coverage
+  // information for that file
+  std::string outputFile;
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "run covbr: " << std::endl, this->Quiet);
+
+  if (!this->RunBullseyeCommand(cont, "covbr", nullptr, outputFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for."
+                 << "\n");
+    return -1;
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "covbr output in  " << outputFile << std::endl,
+                     this->Quiet);
+  // open the output file
+  cmsys::ifstream fin(outputFile.c_str());
+  if (!fin) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open coverage file: " << outputFile << std::endl);
+    return 0;
+  }
+  std::map<std::string, std::string> fileMap;
+  std::vector<std::string>::iterator fp = filesFullPath.begin();
+  for (std::vector<std::string>::iterator f = files.begin(); f != files.end();
+       ++f, ++fp) {
+    fileMap[*f] = *fp;
+  }
+
+  int count = 0; // keep count of the number of files
+  // Now parse each line from the bullseye cov log file
+  std::string lineIn;
+  bool valid = false; // are we in a valid output file
+  int line = 0;       // line of the current file
+  std::string file;
+  while (cmSystemTools::GetLineFromStream(fin, lineIn)) {
+    bool startFile = false;
+    if (lineIn.size() > 1 && lineIn[lineIn.size() - 1] == ':') {
+      file = lineIn.substr(0, lineIn.size() - 1);
+      if (coveredFileNames.find(file) != coveredFileNames.end()) {
+        startFile = true;
+      }
+    }
+    if (startFile) {
+      // if we are in a valid file close it because a new one started
+      if (valid) {
+        covLogXML.EndElement(); // Report
+        covLogXML.EndElement(); // File
+      }
+      // only allow 100 files in each log file
+      if (count != 0 && count % 100 == 0) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "start a new log file: " << count << std::endl,
+                           this->Quiet);
+        this->EndCoverageLogXML(covLogXML);
+        this->EndCoverageLogFile(covLogFile, logFileCount);
+        logFileCount++;
+        if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
+          return -1;
+        }
+        this->StartCoverageLogXML(covLogXML);
+        count++; // move on one
+      }
+      std::map<std::string, std::string>::iterator i = fileMap.find(file);
+      // if the file should be covered write out the header for that file
+      if (i != fileMap.end()) {
+        // we have a new file so count it in the output
+        count++;
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "Produce coverage for file: " << file << " "
+                                                         << count << std::endl,
+                           this->Quiet);
+        // start the file output
+        covLogXML.StartElement("File");
+        covLogXML.Attribute("Name", i->first);
+        covLogXML.Attribute(
+          "FullPath", this->CTest->GetShortPathToFile(i->second.c_str()));
+        covLogXML.StartElement("Report");
+        // write the bullseye header
+        line = 0;
+        for (int k = 0; bullseyeHelp[k] != nullptr; ++k) {
+          covLogXML.StartElement("Line");
+          covLogXML.Attribute("Number", line);
+          covLogXML.Attribute("Count", -1);
+          covLogXML.Content(bullseyeHelp[k]);
+          covLogXML.EndElement(); // Line
+          line++;
+        }
+        valid = true; // we are in a valid file section
+      } else {
+        // this is not a file that we want coverage for
+        valid = false;
+      }
+    }
+    // we are not at a start file, and we are in a valid file output the line
+    else if (valid) {
+      covLogXML.StartElement("Line");
+      covLogXML.Attribute("Number", line);
+      covLogXML.Attribute("Count", -1);
+      covLogXML.Content(lineIn);
+      covLogXML.EndElement(); // Line
+      line++;
+    }
+  }
+  // if we ran out of lines a valid file then close that file
+  if (valid) {
+    covLogXML.EndElement(); // Report
+    covLogXML.EndElement(); // File
+  }
+  this->EndCoverageLogXML(covLogXML);
+  this->EndCoverageLogFile(covLogFile, logFileCount);
+  return 1;
+}
+
+int cmCTestCoverageHandler::RunBullseyeCommand(
+  cmCTestCoverageHandlerContainer* cont, const char* cmd, const char* arg,
+  std::string& outputFile)
+{
+  std::string program = cmSystemTools::FindProgram(cmd);
+  if (program.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find :" << cmd << "\n");
+    return 0;
+  }
+  if (arg) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Run : " << program << " " << arg << "\n", this->Quiet);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Run : " << program << "\n", this->Quiet);
+  }
+  // create a process object and start it
+  cmCTestRunProcess runCoverageSrc;
+  runCoverageSrc.SetCommand(program.c_str());
+  runCoverageSrc.AddArgument(arg);
+  std::string stdoutFile = cont->BinaryDir + "/Testing/Temporary/";
+  stdoutFile += this->GetCTestInstance()->GetCurrentTag();
+  stdoutFile += "-";
+  stdoutFile += cmd;
+  std::string stderrFile = stdoutFile;
+  stdoutFile += ".stdout";
+  stderrFile += ".stderr";
+  runCoverageSrc.SetStdoutFile(stdoutFile.c_str());
+  runCoverageSrc.SetStderrFile(stderrFile.c_str());
+  if (!runCoverageSrc.StartProcess()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Could not run : " << program << " " << arg << "\n"
+                                  << "kwsys process state : "
+                                  << runCoverageSrc.GetProcessState());
+    return 0;
+  }
+  // since we set the output file names wait for it to end
+  runCoverageSrc.WaitForExit();
+  outputFile = stdoutFile;
+  return 1;
+}
+
+int cmCTestCoverageHandler::RunBullseyeSourceSummary(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  // Run the covsrc command and create a temp outputfile
+  std::string outputFile;
+  if (!this->RunBullseyeCommand(cont, "covsrc", "-c", outputFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covsrc:\n");
+    return 0;
+  }
+
+  std::ostream& tmpLog = *cont->OFS;
+  // copen the Coverage.xml file in the Testing directory
+  cmGeneratedFileStream covSumFile;
+  cmXMLWriter xml(covSumFile);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
+    return 0;
+  }
+  this->CTest->StartXML(xml, this->AppendXML);
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+  std::string coverage_start_time = this->CTest->CurrentTime();
+  xml.StartElement("Coverage");
+  xml.Element("StartDateTime", coverage_start_time);
+  xml.Element("StartTime", std::chrono::system_clock::now());
+  std::string stdline;
+  std::string errline;
+  // expected output:
+  // first line is:
+  // "Source","Function Coverage","out of","%","C/D Coverage","out of","%"
+  // after that data follows in that format
+  std::string sourceFile;
+  int functionsCalled = 0;
+  int totalFunctions = 0;
+  int percentFunction = 0;
+  int branchCovered = 0;
+  int totalBranches = 0;
+  int percentBranch = 0;
+  double total_tested = 0;
+  double total_untested = 0;
+  double total_functions = 0;
+  double percent_coverage = 0;
+  double number_files = 0;
+  std::vector<std::string> coveredFiles;
+  std::vector<std::string> coveredFilesFullPath;
+  // Read and parse the summary output file
+  cmsys::ifstream fin(outputFile.c_str());
+  if (!fin) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open coverage summary file: " << outputFile
+                                                     << std::endl);
+    return 0;
+  }
+  std::set<std::string> coveredFileNames;
+  while (cmSystemTools::GetLineFromStream(fin, stdline)) {
+    // if we have a line of output from stdout
+    if (!stdline.empty()) {
+      // parse the comma separated output
+      this->ParseBullsEyeCovsrcLine(
+        stdline, sourceFile, functionsCalled, totalFunctions, percentFunction,
+        branchCovered, totalBranches, percentBranch);
+      // The first line is the header
+      if (sourceFile == "Source" || sourceFile == "Total") {
+        continue;
+      }
+      std::string file = sourceFile;
+      coveredFileNames.insert(file);
+      if (!cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
+        // file will be relative to the binary dir
+        file = cont->BinaryDir;
+        file += "/";
+        file += sourceFile;
+      }
+      file = cmSystemTools::CollapseFullPath(file);
+      bool shouldIDoCoverage =
+        this->ShouldIDoCoverage(file, cont->SourceDir, cont->BinaryDir);
+      if (!shouldIDoCoverage) {
+        cmCTestOptionalLog(
+          this->CTest, HANDLER_VERBOSE_OUTPUT,
+          ".NoDartCoverage found, so skip coverage check for: " << file
+                                                                << std::endl,
+          this->Quiet);
+        continue;
+      }
+
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Doing coverage for: " << file << std::endl,
+                         this->Quiet);
+
+      coveredFiles.push_back(sourceFile);
+      coveredFilesFullPath.push_back(file);
+
+      number_files++;
+      total_functions += totalFunctions;
+      total_tested += functionsCalled;
+      total_untested += (totalFunctions - functionsCalled);
+
+      std::string fileName = cmSystemTools::GetFilenameName(file);
+      std::string shortFileName =
+        this->CTest->GetShortPathToFile(file.c_str());
+
+      float cper = static_cast<float>(percentBranch + percentFunction);
+      if (totalBranches > 0) {
+        cper /= 2.0f;
+      }
+      percent_coverage += static_cast<double>(cper);
+      float cmet = static_cast<float>(percentFunction + percentBranch);
+      if (totalBranches > 0) {
+        cmet /= 2.0f;
+      }
+      cmet /= 100.0f;
+      tmpLog << stdline << "\n";
+      tmpLog << fileName << "\n";
+      tmpLog << "functionsCalled: " << functionsCalled / 100 << "\n";
+      tmpLog << "totalFunctions: " << totalFunctions / 100 << "\n";
+      tmpLog << "percentFunction: " << percentFunction << "\n";
+      tmpLog << "branchCovered: " << branchCovered << "\n";
+      tmpLog << "totalBranches: " << totalBranches << "\n";
+      tmpLog << "percentBranch: " << percentBranch << "\n";
+      tmpLog << "percentCoverage: " << percent_coverage << "\n";
+      tmpLog << "coverage metric: " << cmet << "\n";
+      xml.StartElement("File");
+      xml.Attribute("Name", sourceFile);
+      xml.Attribute("FullPath", shortFileName);
+      xml.Attribute("Covered", cmet > 0 ? "true" : "false");
+      xml.Element("BranchesTested", branchCovered);
+      xml.Element("BranchesUnTested", totalBranches - branchCovered);
+      xml.Element("FunctionsTested", functionsCalled);
+      xml.Element("FunctionsUnTested", totalFunctions - functionsCalled);
+      // Hack for conversion of function to loc assume a function
+      // has 100 lines of code
+      xml.Element("LOCTested", functionsCalled * 100);
+      xml.Element("LOCUnTested", (totalFunctions - functionsCalled) * 100);
+      xml.Element("PercentCoverage", cper);
+      xml.Element("CoverageMetric", cmet);
+      this->WriteXMLLabels(xml, shortFileName);
+      xml.EndElement(); // File
+    }
+  }
+  std::string end_time = this->CTest->CurrentTime();
+  xml.Element("LOCTested", total_tested);
+  xml.Element("LOCUntested", total_untested);
+  xml.Element("LOC", total_functions);
+  xml.Element("PercentCoverage", SAFEDIV(percent_coverage, number_files));
+  xml.Element("EndDateTime", end_time);
+  xml.Element("EndTime", std::chrono::system_clock::now());
+  xml.Element("ElapsedMinutes",
+              std::chrono::duration_cast<std::chrono::minutes>(
+                std::chrono::steady_clock::now() - elapsed_time_start)
+                .count());
+  xml.EndElement(); // Coverage
+  this->CTest->EndXML(xml);
+
+  // Now create the coverage information for each file
+  return this->RunBullseyeCoverageBranch(cont, coveredFileNames, coveredFiles,
+                                         coveredFilesFullPath);
+}
+
+int cmCTestCoverageHandler::HandleBullseyeCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  std::string covfile;
+  if (!cmSystemTools::GetEnv("COVFILE", covfile) || covfile.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " COVFILE environment variable not found, not running "
+                       " bullseye\n",
+                       this->Quiet);
+    return 0;
+  }
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_VERBOSE_OUTPUT,
+    " run covsrc with COVFILE=[" << covfile << "]" << std::endl, this->Quiet);
+  if (!this->RunBullseyeSourceSummary(cont)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error running bullseye summary.\n");
+    return 0;
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "HandleBullseyeCoverage return 1 " << std::endl,
+                     this->Quiet);
+  return 1;
+}
+
+bool cmCTestCoverageHandler::GetNextInt(std::string const& inputLine,
+                                        std::string::size_type& pos,
+                                        int& value)
+{
+  std::string::size_type start = pos;
+  pos = inputLine.find(',', start);
+  value = atoi(inputLine.substr(start, pos).c_str());
+  if (pos == std::string::npos) {
+    return true;
+  }
+  pos++;
+  return true;
+}
+
+bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine(
+  std::string const& inputLine, std::string& sourceFile, int& functionsCalled,
+  int& totalFunctions, int& percentFunction, int& branchCovered,
+  int& totalBranches, int& percentBranch)
+{
+  // find the first comma
+  std::string::size_type pos = inputLine.find(',');
+  if (pos == std::string::npos) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing string : " << inputLine << "\n");
+    return false;
+  }
+  // the source file has "" around it so extract out the file name
+  sourceFile = inputLine.substr(1, pos - 2);
+  pos++;
+  if (!this->GetNextInt(inputLine, pos, functionsCalled)) {
+    return false;
+  }
+  if (!this->GetNextInt(inputLine, pos, totalFunctions)) {
+    return false;
+  }
+  if (!this->GetNextInt(inputLine, pos, percentFunction)) {
+    return false;
+  }
+  if (!this->GetNextInt(inputLine, pos, branchCovered)) {
+    return false;
+  }
+  if (!this->GetNextInt(inputLine, pos, totalBranches)) {
+    return false;
+  }
+  if (!this->GetNextInt(inputLine, pos, percentBranch)) {
+    return false;
+  }
+  // should be at the end now
+  if (pos != std::string::npos) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing input : "
+                 << inputLine << " last pos not npos =  " << pos << "\n");
+  }
+  return true;
+}
+
+int cmCTestCoverageHandler::GetLabelId(std::string const& label)
+{
+  LabelIdMapType::iterator i = this->LabelIdMap.find(label);
+  if (i == this->LabelIdMap.end()) {
+    int n = int(this->Labels.size());
+    this->Labels.push_back(label);
+    LabelIdMapType::value_type entry(label, n);
+    i = this->LabelIdMap.insert(entry).first;
+  }
+  return i->second;
+}
+
+void cmCTestCoverageHandler::LoadLabels()
+{
+  std::string fileList = this->CTest->GetBinaryDir();
+  fileList += cmake::GetCMakeFilesDirectory();
+  fileList += "/TargetDirectories.txt";
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " target directory list [" << fileList << "]\n",
+                     this->Quiet);
+  cmsys::ifstream finList(fileList.c_str());
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(finList, line)) {
+    this->LoadLabels(line.c_str());
+  }
+}
+
+void cmCTestCoverageHandler::LoadLabels(const char* dir)
+{
+  LabelSet& dirLabels = this->TargetDirs[dir];
+  std::string fname = dir;
+  fname += "/Labels.txt";
+  cmsys::ifstream fin(fname.c_str());
+  if (!fin) {
+    return;
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     " loading labels from [" << fname << "]\n", this->Quiet);
+  bool inTarget = true;
+  std::string source;
+  std::string line;
+  std::vector<int> targetLabels;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty() || line[0] == '#') {
+      // Ignore blank and comment lines.
+      continue;
+    }
+    if (line[0] == ' ') {
+      // Label lines appear indented by one space.
+      std::string label = line.substr(1);
+      int id = this->GetLabelId(label);
+      dirLabels.insert(id);
+      if (inTarget) {
+        targetLabels.push_back(id);
+      } else {
+        this->SourceLabels[source].insert(id);
+      }
+    } else {
+      // Non-indented lines specify a source file name.  The first one
+      // is the end of the target-wide labels.
+      inTarget = false;
+
+      source = this->CTest->GetShortPathToFile(line.c_str());
+
+      // Label the source with the target labels.
+      LabelSet& labelSet = this->SourceLabels[source];
+      labelSet.insert(targetLabels.begin(), targetLabels.end());
+    }
+  }
+}
+
+void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml,
+                                            std::string const& source)
+{
+  LabelMapType::const_iterator li = this->SourceLabels.find(source);
+  if (li != this->SourceLabels.end() && !li->second.empty()) {
+    xml.StartElement("Labels");
+    for (auto const& ls : li->second) {
+      xml.Element("Label", this->Labels[ls]);
+    }
+    xml.EndElement(); // Labels
+  }
+}
+
+void cmCTestCoverageHandler::SetLabelFilter(
+  std::set<std::string> const& labels)
+{
+  this->LabelFilter.clear();
+  for (std::string const& l : labels) {
+    this->LabelFilter.insert(this->GetLabelId(l));
+  }
+}
+
+bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels)
+{
+  // If there is no label filter then nothing is filtered out.
+  if (this->LabelFilter.empty()) {
+    return true;
+  }
+
+  std::vector<int> ids;
+  std::set_intersection(labels.begin(), labels.end(),
+                        this->LabelFilter.begin(), this->LabelFilter.end(),
+                        std::back_inserter(ids));
+  return !ids.empty();
+}
+
+bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source)
+{
+  // If there is no label filter then nothing is filtered out.
+  if (this->LabelFilter.empty()) {
+    return false;
+  }
+
+  // The source is filtered out if it does not have any labels in
+  // common with the filter set.
+  std::string shortSrc = this->CTest->GetShortPathToFile(source.c_str());
+  LabelMapType::const_iterator li = this->SourceLabels.find(shortSrc);
+  if (li != this->SourceLabels.end()) {
+    return !this->IntersectsFilter(li->second);
+  }
+  return true;
+}
+
+std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  std::set<std::string> extraMatches;
+
+  for (std::string const& ecg : this->ExtraCoverageGlobs) {
+    cmsys::Glob gl;
+    gl.RecurseOn();
+    gl.RecurseThroughSymlinksOff();
+    std::string glob = cont->SourceDir + "/" + ecg;
+    gl.FindFiles(glob);
+    std::vector<std::string> files = gl.GetFiles();
+    for (std::string const& f : files) {
+      if (this->ShouldIDoCoverage(f, cont->SourceDir, cont->BinaryDir)) {
+        extraMatches.insert(this->CTest->GetShortPathToFile(f.c_str()));
+      }
+    }
+  }
+
+  if (!extraMatches.empty()) {
+    for (auto const& i : cont->TotalCoverage) {
+      std::string shortPath = this->CTest->GetShortPathToFile(i.first.c_str());
+      extraMatches.erase(shortPath);
+    }
+  }
+  return extraMatches;
+}
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
new file mode 100644
index 0000000..6492fe9
--- /dev/null
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -0,0 +1,152 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestCoverageHandler_h
+#define cmCTestCoverageHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmGeneratedFileStream;
+class cmMakefile;
+class cmXMLWriter;
+
+class cmCTestCoverageHandlerContainer
+{
+public:
+  int Error;
+  std::string SourceDir;
+  std::string BinaryDir;
+  typedef std::vector<int> SingleFileCoverageVector;
+  typedef std::map<std::string, SingleFileCoverageVector> TotalCoverageMap;
+  TotalCoverageMap TotalCoverage;
+  std::ostream* OFS;
+  bool Quiet;
+};
+/** \class cmCTestCoverageHandler
+ * \brief A class that handles coverage computation for ctest
+ *
+ */
+class cmCTestCoverageHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  cmCTestCoverageHandler();
+
+  void Initialize() override;
+
+  /**
+   * This method is called when reading CTest custom file
+   */
+  void PopulateCustomVectors(cmMakefile* mf) override;
+
+  /** Report coverage only for sources with these labels.  */
+  void SetLabelFilter(std::set<std::string> const& labels);
+
+private:
+  bool ShouldIDoCoverage(std::string const& file, std::string const& srcDir,
+                         std::string const& binDir);
+  void CleanCoverageLogFiles(std::ostream& log);
+  bool StartCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
+  void EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
+
+  void StartCoverageLogXML(cmXMLWriter& xml);
+  void EndCoverageLogXML(cmXMLWriter& xml);
+
+  //! Handle coverage using GCC's GCov
+  int HandleGCovCoverage(cmCTestCoverageHandlerContainer* cont);
+  void FindGCovFiles(std::vector<std::string>& files);
+
+  //! Handle coverage using Intel's LCov
+  int HandleLCovCoverage(cmCTestCoverageHandlerContainer* cont);
+  bool FindLCovFiles(std::vector<std::string>& files);
+
+  //! Handle coverage using xdebug php coverage
+  int HandlePHPCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage for Python with coverage.py
+  int HandleCoberturaCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage for mumps
+  int HandleMumpsCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage for Jacoco
+  int HandleJacocoCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage for Delphi (Pascal)
+  int HandleDelphiCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage for Jacoco
+  int HandleBlanketJSCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  //! Handle coverage using Bullseye
+  int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
+  int RunBullseyeSourceSummary(cmCTestCoverageHandlerContainer* cont);
+  int RunBullseyeCoverageBranch(cmCTestCoverageHandlerContainer* cont,
+                                std::set<std::string>& coveredFileNames,
+                                std::vector<std::string>& files,
+                                std::vector<std::string>& filesFullPath);
+
+  int RunBullseyeCommand(cmCTestCoverageHandlerContainer* cont,
+                         const char* cmd, const char* arg,
+                         std::string& outputFile);
+  bool ParseBullsEyeCovsrcLine(std::string const& inputLine,
+                               std::string& sourceFile, int& functionsCalled,
+                               int& totalFunctions, int& percentFunction,
+                               int& branchCovered, int& totalBranches,
+                               int& percentBranch);
+  bool GetNextInt(std::string const& inputLine, std::string::size_type& pos,
+                  int& value);
+  //! Handle Python coverage using Python's Trace.py
+  int HandleTracePyCoverage(cmCTestCoverageHandlerContainer* cont);
+
+  // Find the source file based on the source and build tree. This is used for
+  // Trace.py mode, since that one does not tell us where the source file is.
+  std::string FindFile(cmCTestCoverageHandlerContainer* cont,
+                       std::string const& fileName);
+
+  std::set<std::string> FindUncoveredFiles(
+    cmCTestCoverageHandlerContainer* cont);
+  std::vector<std::string> CustomCoverageExclude;
+  std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
+  std::vector<std::string> ExtraCoverageGlobs;
+
+  // Map from source file to label ids.
+  class LabelSet : public std::set<int>
+  {
+  };
+  typedef std::map<std::string, LabelSet> LabelMapType;
+  LabelMapType SourceLabels;
+  LabelMapType TargetDirs;
+
+  // Map from label name to label id.
+  typedef std::map<std::string, int> LabelIdMapType;
+  LabelIdMapType LabelIdMap;
+  std::vector<std::string> Labels;
+  int GetLabelId(std::string const& label);
+
+  // Label reading and writing methods.
+  void LoadLabels();
+  void LoadLabels(const char* dir);
+  void WriteXMLLabels(cmXMLWriter& xml, std::string const& source);
+
+  // Label-based filtering.
+  std::set<int> LabelFilter;
+  bool IntersectsFilter(LabelSet const& labels);
+  bool IsFilteredOut(std::string const& source);
+};
+
+#endif
diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx
new file mode 100644
index 0000000..7b5ea60
--- /dev/null
+++ b/Source/CTest/cmCTestCurl.cxx
@@ -0,0 +1,271 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestCurl.h"
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+
+#include <ostream>
+#include <stdio.h>
+
+cmCTestCurl::cmCTestCurl(cmCTest* ctest)
+{
+  this->CTest = ctest;
+  this->SetProxyType();
+  this->UseHttp10 = false;
+  // In windows, this will init the winsock stuff
+  ::curl_global_init(CURL_GLOBAL_ALL);
+  // default is to verify https
+  this->VerifyPeerOff = false;
+  this->VerifyHostOff = false;
+  this->Quiet = false;
+  this->TimeOutSeconds = 0;
+  this->Curl = curl_easy_init();
+}
+
+cmCTestCurl::~cmCTestCurl()
+{
+  ::curl_easy_cleanup(this->Curl);
+  ::curl_global_cleanup();
+}
+
+std::string cmCTestCurl::Escape(std::string const& source)
+{
+  char* data1 = curl_easy_escape(this->Curl, source.c_str(), 0);
+  std::string ret = data1;
+  curl_free(data1);
+  return ret;
+}
+
+namespace {
+size_t curlWriteMemoryCallback(void* ptr, size_t size, size_t nmemb,
+                               void* data)
+{
+  int realsize = static_cast<int>(size * nmemb);
+
+  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  vec->insert(vec->end(), chPtr, chPtr + realsize);
+  return realsize;
+}
+
+size_t curlDebugCallback(CURL* /*unused*/, curl_infotype /*unused*/,
+                         char* chPtr, size_t size, void* data)
+{
+  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
+  vec->insert(vec->end(), chPtr, chPtr + size);
+
+  return size;
+}
+}
+
+void cmCTestCurl::SetCurlOptions(std::vector<std::string> const& args)
+{
+  for (std::string const& arg : args) {
+    if (arg == "CURLOPT_SSL_VERIFYPEER_OFF") {
+      this->VerifyPeerOff = true;
+    }
+    if (arg == "CURLOPT_SSL_VERIFYHOST_OFF") {
+      this->VerifyHostOff = true;
+    }
+  }
+}
+
+bool cmCTestCurl::InitCurl()
+{
+  if (!this->Curl) {
+    return false;
+  }
+  if (this->VerifyPeerOff) {
+    curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYPEER, 0);
+  }
+  if (this->VerifyHostOff) {
+    curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYHOST, 0);
+  }
+  if (!this->HTTPProxy.empty()) {
+    curl_easy_setopt(this->Curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
+    curl_easy_setopt(this->Curl, CURLOPT_PROXYTYPE, this->HTTPProxyType);
+    if (!this->HTTPProxyAuth.empty()) {
+      curl_easy_setopt(this->Curl, CURLOPT_PROXYUSERPWD,
+                       this->HTTPProxyAuth.c_str());
+    }
+  }
+  if (this->UseHttp10) {
+    curl_easy_setopt(this->Curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
+  }
+  // enable HTTP ERROR parsing
+  curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
+
+  // if there is little to no activity for too long stop submitting
+  if (this->TimeOutSeconds) {
+    curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_LIMIT, 1);
+    curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_TIME, this->TimeOutSeconds);
+  }
+
+  return true;
+}
+
+bool cmCTestCurl::UploadFile(std::string const& local_file,
+                             std::string const& url, std::string const& fields,
+                             std::string& response)
+{
+  response.clear();
+  if (!this->InitCurl()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
+    return false;
+  }
+  /* enable uploading */
+  curl_easy_setopt(this->Curl, CURLOPT_UPLOAD, 1);
+
+  /* HTTP PUT please */
+  ::curl_easy_setopt(this->Curl, CURLOPT_PUT, 1);
+  ::curl_easy_setopt(this->Curl, CURLOPT_VERBOSE, 1);
+
+  FILE* ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
+  if (!ftpfile) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Could not open file for upload: " << local_file << "\n");
+    return false;
+  }
+  // set the url
+  std::string upload_url = url;
+  upload_url += "?";
+  upload_url += fields;
+  ::curl_easy_setopt(this->Curl, CURLOPT_URL, upload_url.c_str());
+  // now specify which file to upload
+  ::curl_easy_setopt(this->Curl, CURLOPT_INFILE, ftpfile);
+  unsigned long filelen = cmSystemTools::FileLength(local_file);
+  // and give the size of the upload (optional)
+  ::curl_easy_setopt(this->Curl, CURLOPT_INFILESIZE,
+                     static_cast<long>(filelen));
+  ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
+                     curlWriteMemoryCallback);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
+  // Set Content-Type to satisfy fussy modsecurity rules.
+  struct curl_slist* headers =
+    ::curl_slist_append(nullptr, "Content-Type: text/xml");
+  // Add any additional headers that the user specified.
+  for (std::string const& h : this->HttpHeaders) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Add HTTP Header: \"" << h << "\"" << std::endl,
+                       this->Quiet);
+    headers = ::curl_slist_append(headers, h.c_str());
+  }
+  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
+  std::vector<char> responseData;
+  std::vector<char> debugData;
+  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, &responseData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, &debugData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
+  // Now run off and do what you've been told!
+  ::curl_easy_perform(this->Curl);
+  ::fclose(ftpfile);
+  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, NULL);
+  ::curl_slist_free_all(headers);
+
+  if (!responseData.empty()) {
+    response = std::string(responseData.begin(), responseData.end());
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Curl response: [" << response << "]\n", this->Quiet);
+  }
+  std::string curlDebug;
+  if (!debugData.empty()) {
+    curlDebug = std::string(debugData.begin(), debugData.end());
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Curl debug: [" << curlDebug << "]\n", this->Quiet);
+  }
+  if (response.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n"
+                 << curlDebug);
+    return false;
+  }
+  return true;
+}
+
+bool cmCTestCurl::HttpRequest(std::string const& url,
+                              std::string const& fields, std::string& response)
+{
+  response.clear();
+  cmCTestOptionalLog(this->CTest, DEBUG, "HttpRequest\n"
+                       << "url: " << url << "\n"
+                       << "fields " << fields << "\n",
+                     this->Quiet);
+  if (!this->InitCurl()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
+    return false;
+  }
+  curl_easy_setopt(this->Curl, CURLOPT_POST, 1);
+  curl_easy_setopt(this->Curl, CURLOPT_POSTFIELDS, fields.c_str());
+  ::curl_easy_setopt(this->Curl, CURLOPT_URL, url.c_str());
+  ::curl_easy_setopt(this->Curl, CURLOPT_FOLLOWLOCATION, 1);
+  // set response options
+  ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
+                     curlWriteMemoryCallback);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
+  std::vector<char> responseData;
+  std::vector<char> debugData;
+  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, &responseData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, &debugData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
+
+  // Add headers if any were specified.
+  struct curl_slist* headers = nullptr;
+  if (!this->HttpHeaders.empty()) {
+    for (std::string const& h : this->HttpHeaders) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Add HTTP Header: \"" << h << "\"" << std::endl,
+                         this->Quiet);
+      headers = ::curl_slist_append(headers, h.c_str());
+    }
+  }
+
+  ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
+  CURLcode res = ::curl_easy_perform(this->Curl);
+  ::curl_slist_free_all(headers);
+
+  if (!responseData.empty()) {
+    response = std::string(responseData.begin(), responseData.end());
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Curl response: [" << response << "]\n", this->Quiet);
+  }
+  if (!debugData.empty()) {
+    std::string curlDebug = std::string(debugData.begin(), debugData.end());
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Curl debug: [" << curlDebug << "]\n", this->Quiet);
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG, "Curl res: " << res << "\n",
+                     this->Quiet);
+  return (res == 0);
+}
+
+void cmCTestCurl::SetProxyType()
+{
+  this->HTTPProxy.clear();
+  // this is the default
+  this->HTTPProxyType = CURLPROXY_HTTP;
+  this->HTTPProxyAuth.clear();
+  if (cmSystemTools::GetEnv("HTTP_PROXY", this->HTTPProxy)) {
+    std::string port;
+    if (cmSystemTools::GetEnv("HTTP_PROXY_PORT", port)) {
+      this->HTTPProxy += ":";
+      this->HTTPProxy += port;
+    }
+    std::string type;
+    if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE", type)) {
+      // HTTP/SOCKS4/SOCKS5
+      if (type == "HTTP") {
+        this->HTTPProxyType = CURLPROXY_HTTP;
+      } else if (type == "SOCKS4") {
+        this->HTTPProxyType = CURLPROXY_SOCKS4;
+      } else if (type == "SOCKS5") {
+        this->HTTPProxyType = CURLPROXY_SOCKS5;
+      }
+    }
+    cmSystemTools::GetEnv("HTTP_PROXY_USER", this->HTTPProxyAuth);
+    std::string passwd;
+    if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD", passwd)) {
+      this->HTTPProxyAuth += ":";
+      this->HTTPProxyAuth += passwd;
+    }
+  }
+}
diff --git a/Source/CTest/cmCTestCurl.h b/Source/CTest/cmCTestCurl.h
new file mode 100644
index 0000000..427a392
--- /dev/null
+++ b/Source/CTest/cmCTestCurl.h
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestCurl_h
+#define cmCTestCurl_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cm_curl.h"
+#include <string>
+#include <vector>
+
+class cmCTest;
+
+class cmCTestCurl
+{
+public:
+  cmCTestCurl(cmCTest*);
+  ~cmCTestCurl();
+  bool UploadFile(std::string const& url, std::string const& file,
+                  std::string const& fields, std::string& response);
+  bool HttpRequest(std::string const& url, std::string const& fields,
+                   std::string& response);
+  // currently only supports CURLOPT_SSL_VERIFYPEER_OFF
+  // and CURLOPT_SSL_VERIFYHOST_OFF
+  void SetCurlOptions(std::vector<std::string> const& args);
+  void SetHttpHeaders(std::vector<std::string> const& v)
+  {
+    this->HttpHeaders = v;
+  }
+  void SetUseHttp10On() { this->UseHttp10 = true; }
+  void SetTimeOutSeconds(int s) { this->TimeOutSeconds = s; }
+  void SetQuiet(bool b) { this->Quiet = b; }
+  std::string Escape(std::string const& source);
+
+protected:
+  void SetProxyType();
+  bool InitCurl();
+
+private:
+  cmCTest* CTest;
+  CURL* Curl;
+  std::vector<std::string> HttpHeaders;
+  std::string HTTPProxyAuth;
+  std::string HTTPProxy;
+  curl_proxytype HTTPProxyType;
+  bool VerifyHostOff;
+  bool VerifyPeerOff;
+  bool UseHttp10;
+  bool Quiet;
+  int TimeOutSeconds;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
new file mode 100644
index 0000000..f4531a1
--- /dev/null
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
@@ -0,0 +1,27 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestEmptyBinaryDirectoryCommand.h"
+
+#include "cmCTestScriptHandler.h"
+
+#include <sstream>
+
+class cmExecutionStatus;
+
+bool cmCTestEmptyBinaryDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
+{
+  if (args.size() != 1) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  if (!cmCTestScriptHandler::EmptyBinaryDirectory(args[0].c_str())) {
+    std::ostringstream ostr;
+    ostr << "problem removing the binary directory: " << args[0];
+    this->SetError(ostr.str());
+    return false;
+  }
+
+  return true;
+}
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
new file mode 100644
index 0000000..9425ece
--- /dev/null
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -0,0 +1,47 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestEmptyBinaryDirectoryCommand_h
+#define cmCTestEmptyBinaryDirectoryCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <string>
+#include <vector>
+
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestEmptyBinaryDirectory
+ * \brief Run a ctest script
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmCTestEmptyBinaryDirectoryCommand : public cmCTestCommand
+{
+public:
+  cmCTestEmptyBinaryDirectoryCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestEmptyBinaryDirectoryCommand* ni =
+      new cmCTestEmptyBinaryDirectoryCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx
new file mode 100644
index 0000000..8cb795e
--- /dev/null
+++ b/Source/CTest/cmCTestGIT.cxx
@@ -0,0 +1,661 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestGIT.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Process.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <vector>
+
+#include "cmAlgorithms.h"
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmProcessOutput.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+
+static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
+                                      unsigned int minor, unsigned int fix)
+{
+  // 1.6.5.0 maps to 10605000
+  return fix + minor * 1000 + major * 100000 + epic * 10000000;
+}
+
+cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+  this->CurrentGitVersion = 0;
+}
+
+cmCTestGIT::~cmCTestGIT()
+{
+}
+
+class cmCTestGIT::OneLineParser : public cmCTestVC::LineParser
+{
+public:
+  OneLineParser(cmCTestGIT* git, const char* prefix, std::string& l)
+    : Line1(l)
+  {
+    this->SetLog(&git->Log, prefix);
+  }
+
+private:
+  std::string& Line1;
+  bool ProcessLine() override
+  {
+    // Only the first line is of interest.
+    this->Line1 = this->Line;
+    return false;
+  }
+};
+
+std::string cmCTestGIT::GetWorkingRevision()
+{
+  // Run plumbing "git rev-list" to get work tree revision.
+  const char* git = this->CommandLineTool.c_str();
+  const char* git_rev_list[] = { git,    "rev-list", "-n",   "1",
+                                 "HEAD", "--",       nullptr };
+  std::string rev;
+  OneLineParser out(this, "rl-out> ", rev);
+  OutputLogger err(this->Log, "rl-err> ");
+  this->RunChild(git_rev_list, &out, &err);
+  return rev;
+}
+
+bool cmCTestGIT::NoteOldRevision()
+{
+  this->OldRevision = this->GetWorkingRevision();
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
+               << this->OldRevision << "\n");
+  this->PriorRev.Rev = this->OldRevision;
+  return true;
+}
+
+bool cmCTestGIT::NoteNewRevision()
+{
+  this->NewRevision = this->GetWorkingRevision();
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
+               << this->NewRevision << "\n");
+  return true;
+}
+
+std::string cmCTestGIT::FindGitDir()
+{
+  std::string git_dir;
+
+  // Run "git rev-parse --git-dir" to locate the real .git directory.
+  const char* git = this->CommandLineTool.c_str();
+  char const* git_rev_parse[] = { git, "rev-parse", "--git-dir", nullptr };
+  std::string git_dir_line;
+  OneLineParser rev_parse_out(this, "rev-parse-out> ", git_dir_line);
+  OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
+  if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err, nullptr,
+                     cmProcessOutput::UTF8)) {
+    git_dir = git_dir_line;
+  }
+  if (git_dir.empty()) {
+    git_dir = ".git";
+  }
+
+  // Git reports a relative path only when the .git directory is in
+  // the current directory.
+  if (git_dir[0] == '.') {
+    git_dir = this->SourceDirectory + "/" + git_dir;
+  }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  else if (git_dir[0] == '/') {
+    // Cygwin Git reports a full path that Cygwin understands, but we
+    // are a Windows application.  Run "cygpath" to get Windows path.
+    std::string cygpath_exe = cmSystemTools::GetFilenamePath(git);
+    cygpath_exe += "/cygpath.exe";
+    if (cmSystemTools::FileExists(cygpath_exe.c_str())) {
+      char const* cygpath[] = { cygpath_exe.c_str(), "-w", git_dir.c_str(),
+                                0 };
+      OneLineParser cygpath_out(this, "cygpath-out> ", git_dir_line);
+      OutputLogger cygpath_err(this->Log, "cygpath-err> ");
+      if (this->RunChild(cygpath, &cygpath_out, &cygpath_err, nullptr,
+                         cmProcessOutput::UTF8)) {
+        git_dir = git_dir_line;
+      }
+    }
+  }
+#endif
+  return git_dir;
+}
+
+std::string cmCTestGIT::FindTopDir()
+{
+  std::string top_dir = this->SourceDirectory;
+
+  // Run "git rev-parse --show-cdup" to locate the top of the tree.
+  const char* git = this->CommandLineTool.c_str();
+  char const* git_rev_parse[] = { git, "rev-parse", "--show-cdup", nullptr };
+  std::string cdup;
+  OneLineParser rev_parse_out(this, "rev-parse-out> ", cdup);
+  OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
+  if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err, nullptr,
+                     cmProcessOutput::UTF8) &&
+      !cdup.empty()) {
+    top_dir += "/";
+    top_dir += cdup;
+    top_dir = cmSystemTools::CollapseFullPath(top_dir);
+  }
+  return top_dir;
+}
+
+bool cmCTestGIT::UpdateByFetchAndReset()
+{
+  const char* git = this->CommandLineTool.c_str();
+
+  // Use "git fetch" to get remote commits.
+  std::vector<char const*> git_fetch;
+  git_fetch.push_back(git);
+  git_fetch.push_back("fetch");
+
+  // Add user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("GITUpdateOptions");
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+  for (std::string const& arg : args) {
+    git_fetch.push_back(arg.c_str());
+  }
+
+  // Sentinel argument.
+  git_fetch.push_back(nullptr);
+
+  // Fetch upstream refs.
+  OutputLogger fetch_out(this->Log, "fetch-out> ");
+  OutputLogger fetch_err(this->Log, "fetch-err> ");
+  if (!this->RunUpdateCommand(&git_fetch[0], &fetch_out, &fetch_err)) {
+    return false;
+  }
+
+  // Identify the merge head that would be used by "git pull".
+  std::string sha1;
+  {
+    std::string fetch_head = this->FindGitDir() + "/FETCH_HEAD";
+    cmsys::ifstream fin(fetch_head.c_str(), std::ios::in | std::ios::binary);
+    if (!fin) {
+      this->Log << "Unable to open " << fetch_head << "\n";
+      return false;
+    }
+    std::string line;
+    while (sha1.empty() && cmSystemTools::GetLineFromStream(fin, line)) {
+      this->Log << "FETCH_HEAD> " << line << "\n";
+      if (line.find("\tnot-for-merge\t") == std::string::npos) {
+        std::string::size_type pos = line.find('\t');
+        if (pos != std::string::npos) {
+          sha1 = line.substr(0, pos);
+        }
+      }
+    }
+    if (sha1.empty()) {
+      this->Log << "FETCH_HEAD has no upstream branch candidate!\n";
+      return false;
+    }
+  }
+
+  // Reset the local branch to point at that tracked from upstream.
+  char const* git_reset[] = { git, "reset", "--hard", sha1.c_str(), nullptr };
+  OutputLogger reset_out(this->Log, "reset-out> ");
+  OutputLogger reset_err(this->Log, "reset-err> ");
+  return this->RunChild(&git_reset[0], &reset_out, &reset_err);
+}
+
+bool cmCTestGIT::UpdateByCustom(std::string const& custom)
+{
+  std::vector<std::string> git_custom_command;
+  cmSystemTools::ExpandListArgument(custom, git_custom_command, true);
+  std::vector<char const*> git_custom;
+  git_custom.reserve(git_custom_command.size() + 1);
+  for (std::string const& i : git_custom_command) {
+    git_custom.push_back(i.c_str());
+  }
+  git_custom.push_back(nullptr);
+
+  OutputLogger custom_out(this->Log, "custom-out> ");
+  OutputLogger custom_err(this->Log, "custom-err> ");
+  return this->RunUpdateCommand(&git_custom[0], &custom_out, &custom_err);
+}
+
+bool cmCTestGIT::UpdateInternal()
+{
+  std::string custom = this->CTest->GetCTestConfiguration("GITUpdateCustom");
+  if (!custom.empty()) {
+    return this->UpdateByCustom(custom);
+  }
+  return this->UpdateByFetchAndReset();
+}
+
+bool cmCTestGIT::UpdateImpl()
+{
+  if (!this->UpdateInternal()) {
+    return false;
+  }
+
+  std::string top_dir = this->FindTopDir();
+  const char* git = this->CommandLineTool.c_str();
+  const char* recursive = "--recursive";
+  const char* sync_recursive = "--recursive";
+
+  // Git < 1.6.5 did not support submodule --recursive
+  if (this->GetGitVersion() < cmCTestGITVersion(1, 6, 5, 0)) {
+    recursive = nullptr;
+    // No need to require >= 1.6.5 if there are no submodules.
+    if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
+      this->Log << "Git < 1.6.5 cannot update submodules recursively\n";
+    }
+  }
+
+  // Git < 1.8.1 did not support sync --recursive
+  if (this->GetGitVersion() < cmCTestGITVersion(1, 8, 1, 0)) {
+    sync_recursive = nullptr;
+    // No need to require >= 1.8.1 if there are no submodules.
+    if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
+      this->Log << "Git < 1.8.1 cannot synchronize submodules recursively\n";
+    }
+  }
+
+  OutputLogger submodule_out(this->Log, "submodule-out> ");
+  OutputLogger submodule_err(this->Log, "submodule-err> ");
+
+  bool ret;
+
+  std::string init_submodules =
+    this->CTest->GetCTestConfiguration("GITInitSubmodules");
+  if (cmSystemTools::IsOn(init_submodules.c_str())) {
+    char const* git_submodule_init[] = { git, "submodule", "init", nullptr };
+    ret = this->RunChild(git_submodule_init, &submodule_out, &submodule_err,
+                         top_dir.c_str());
+
+    if (!ret) {
+      return false;
+    }
+  }
+
+  char const* git_submodule_sync[] = { git, "submodule", "sync",
+                                       sync_recursive, nullptr };
+  ret = this->RunChild(git_submodule_sync, &submodule_out, &submodule_err,
+                       top_dir.c_str());
+
+  if (!ret) {
+    return false;
+  }
+
+  char const* git_submodule[] = { git, "submodule", "update", recursive,
+                                  nullptr };
+  return this->RunChild(git_submodule, &submodule_out, &submodule_err,
+                        top_dir.c_str());
+}
+
+unsigned int cmCTestGIT::GetGitVersion()
+{
+  if (!this->CurrentGitVersion) {
+    const char* git = this->CommandLineTool.c_str();
+    char const* git_version[] = { git, "--version", nullptr };
+    std::string version;
+    OneLineParser version_out(this, "version-out> ", version);
+    OutputLogger version_err(this->Log, "version-err> ");
+    unsigned int v[4] = { 0, 0, 0, 0 };
+    if (this->RunChild(git_version, &version_out, &version_err) &&
+        sscanf(version.c_str(), "git version %u.%u.%u.%u", &v[0], &v[1], &v[2],
+               &v[3]) >= 3) {
+      this->CurrentGitVersion = cmCTestGITVersion(v[0], v[1], v[2], v[3]);
+    }
+  }
+  return this->CurrentGitVersion;
+}
+
+/* Diff format:
+
+   :src-mode dst-mode src-sha1 dst-sha1 status\0
+   src-path\0
+   [dst-path\0]
+
+   The format is repeated for every file changed.  The [dst-path\0]
+   line appears only for lines with status 'C' or 'R'.  See 'git help
+   diff-tree' for details.
+*/
+class cmCTestGIT::DiffParser : public cmCTestVC::LineParser
+{
+public:
+  DiffParser(cmCTestGIT* git, const char* prefix)
+    : LineParser('\0', false)
+    , GIT(git)
+    , DiffField(DiffFieldNone)
+  {
+    this->SetLog(&git->Log, prefix);
+  }
+
+  typedef cmCTestGIT::Change Change;
+  std::vector<Change> Changes;
+
+protected:
+  cmCTestGIT* GIT;
+  enum DiffFieldType
+  {
+    DiffFieldNone,
+    DiffFieldChange,
+    DiffFieldSrc,
+    DiffFieldDst
+  };
+  DiffFieldType DiffField;
+  Change CurChange;
+
+  void DiffReset()
+  {
+    this->DiffField = DiffFieldNone;
+    this->Changes.clear();
+  }
+
+  bool ProcessLine() override
+  {
+    if (this->Line[0] == ':') {
+      this->DiffField = DiffFieldChange;
+      this->CurChange = Change();
+    }
+    if (this->DiffField == DiffFieldChange) {
+      // :src-mode dst-mode src-sha1 dst-sha1 status
+      if (this->Line[0] != ':') {
+        this->DiffField = DiffFieldNone;
+        return true;
+      }
+      const char* src_mode_first = this->Line.c_str() + 1;
+      const char* src_mode_last = this->ConsumeField(src_mode_first);
+      const char* dst_mode_first = this->ConsumeSpace(src_mode_last);
+      const char* dst_mode_last = this->ConsumeField(dst_mode_first);
+      const char* src_sha1_first = this->ConsumeSpace(dst_mode_last);
+      const char* src_sha1_last = this->ConsumeField(src_sha1_first);
+      const char* dst_sha1_first = this->ConsumeSpace(src_sha1_last);
+      const char* dst_sha1_last = this->ConsumeField(dst_sha1_first);
+      const char* status_first = this->ConsumeSpace(dst_sha1_last);
+      const char* status_last = this->ConsumeField(status_first);
+      if (status_first != status_last) {
+        this->CurChange.Action = *status_first;
+        this->DiffField = DiffFieldSrc;
+      } else {
+        this->DiffField = DiffFieldNone;
+      }
+    } else if (this->DiffField == DiffFieldSrc) {
+      // src-path
+      if (this->CurChange.Action == 'C') {
+        // Convert copy to addition of destination.
+        this->CurChange.Action = 'A';
+        this->DiffField = DiffFieldDst;
+      } else if (this->CurChange.Action == 'R') {
+        // Convert rename to deletion of source and addition of destination.
+        this->CurChange.Action = 'D';
+        this->CurChange.Path = this->Line;
+        this->Changes.push_back(this->CurChange);
+
+        this->CurChange = Change('A');
+        this->DiffField = DiffFieldDst;
+      } else {
+        this->CurChange.Path = this->Line;
+        this->Changes.push_back(this->CurChange);
+        this->DiffField = this->DiffFieldNone;
+      }
+    } else if (this->DiffField == DiffFieldDst) {
+      // dst-path
+      this->CurChange.Path = this->Line;
+      this->Changes.push_back(this->CurChange);
+      this->DiffField = this->DiffFieldNone;
+    }
+    return true;
+  }
+
+  const char* ConsumeSpace(const char* c)
+  {
+    while (*c && isspace(*c)) {
+      ++c;
+    }
+    return c;
+  }
+  const char* ConsumeField(const char* c)
+  {
+    while (*c && !isspace(*c)) {
+      ++c;
+    }
+    return c;
+  }
+};
+
+/* Commit format:
+
+   commit ...\n
+   tree ...\n
+   parent ...\n
+   author ...\n
+   committer ...\n
+   \n
+       Log message indented by (4) spaces\n
+       (even blank lines have the spaces)\n
+ [[
+   \n
+   [Diff format]
+ OR
+   \0
+ ]]
+
+   The header may have more fields.  See 'git help diff-tree'.
+*/
+class cmCTestGIT::CommitParser : public cmCTestGIT::DiffParser
+{
+public:
+  CommitParser(cmCTestGIT* git, const char* prefix)
+    : DiffParser(git, prefix)
+    , Section(SectionHeader)
+  {
+    this->Separator = SectionSep[this->Section];
+  }
+
+private:
+  typedef cmCTestGIT::Revision Revision;
+  enum SectionType
+  {
+    SectionHeader,
+    SectionBody,
+    SectionDiff,
+    SectionCount
+  };
+  static char const SectionSep[SectionCount];
+  SectionType Section;
+  Revision Rev;
+
+  struct Person
+  {
+    std::string Name;
+    std::string EMail;
+    unsigned long Time;
+    long TimeZone;
+    Person()
+      : Name()
+      , EMail()
+      , Time(0)
+      , TimeZone(0)
+    {
+    }
+  };
+
+  void ParsePerson(const char* str, Person& person)
+  {
+    // Person Name <person@domain.com> 1234567890 +0000
+    const char* c = str;
+    while (*c && isspace(*c)) {
+      ++c;
+    }
+
+    const char* name_first = c;
+    while (*c && *c != '<') {
+      ++c;
+    }
+    const char* name_last = c;
+    while (name_last != name_first && isspace(*(name_last - 1))) {
+      --name_last;
+    }
+    person.Name.assign(name_first, name_last - name_first);
+
+    const char* email_first = *c ? ++c : c;
+    while (*c && *c != '>') {
+      ++c;
+    }
+    const char* email_last = *c ? c++ : c;
+    person.EMail.assign(email_first, email_last - email_first);
+
+    person.Time = strtoul(c, const_cast<char**>(&c), 10);
+    person.TimeZone = strtol(c, const_cast<char**>(&c), 10);
+  }
+
+  bool ProcessLine() override
+  {
+    if (this->Line.empty()) {
+      if (this->Section == SectionBody && this->LineEnd == '\0') {
+        // Skip SectionDiff
+        this->NextSection();
+      }
+      this->NextSection();
+    } else {
+      switch (this->Section) {
+        case SectionHeader:
+          this->DoHeaderLine();
+          break;
+        case SectionBody:
+          this->DoBodyLine();
+          break;
+        case SectionDiff:
+          this->DiffParser::ProcessLine();
+          break;
+        case SectionCount:
+          break; // never happens
+      }
+    }
+    return true;
+  }
+
+  void NextSection()
+  {
+    this->Section = SectionType((this->Section + 1) % SectionCount);
+    this->Separator = SectionSep[this->Section];
+    if (this->Section == SectionHeader) {
+      this->GIT->DoRevision(this->Rev, this->Changes);
+      this->Rev = Revision();
+      this->DiffReset();
+    }
+  }
+
+  void DoHeaderLine()
+  {
+    // Look for header fields that we need.
+    if (cmHasLiteralPrefix(this->Line.c_str(), "commit ")) {
+      this->Rev.Rev = this->Line.c_str() + 7;
+    } else if (cmHasLiteralPrefix(this->Line.c_str(), "author ")) {
+      Person author;
+      this->ParsePerson(this->Line.c_str() + 7, author);
+      this->Rev.Author = author.Name;
+      this->Rev.EMail = author.EMail;
+      this->Rev.Date = this->FormatDateTime(author);
+    } else if (cmHasLiteralPrefix(this->Line.c_str(), "committer ")) {
+      Person committer;
+      this->ParsePerson(this->Line.c_str() + 10, committer);
+      this->Rev.Committer = committer.Name;
+      this->Rev.CommitterEMail = committer.EMail;
+      this->Rev.CommitDate = this->FormatDateTime(committer);
+    }
+  }
+
+  void DoBodyLine()
+  {
+    // Commit log lines are indented by 4 spaces.
+    if (this->Line.size() >= 4) {
+      this->Rev.Log += this->Line.substr(4);
+    }
+    this->Rev.Log += "\n";
+  }
+
+  std::string FormatDateTime(Person const& person)
+  {
+    // Convert the time to a human-readable format that is also easy
+    // to machine-parse: "CCYY-MM-DD hh:mm:ss".
+    time_t seconds = static_cast<time_t>(person.Time);
+    struct tm* t = gmtime(&seconds);
+    char dt[1024];
+    sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900,
+            t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+    std::string out = dt;
+
+    // Add the time-zone field "+zone" or "-zone".
+    char tz[32];
+    if (person.TimeZone >= 0) {
+      sprintf(tz, " +%04ld", person.TimeZone);
+    } else {
+      sprintf(tz, " -%04ld", -person.TimeZone);
+    }
+    out += tz;
+    return out;
+  }
+};
+
+char const cmCTestGIT::CommitParser::SectionSep[SectionCount] = { '\n', '\n',
+                                                                  '\0' };
+
+bool cmCTestGIT::LoadRevisions()
+{
+  // Use 'git rev-list ... | git diff-tree ...' to get revisions.
+  std::string range = this->OldRevision + ".." + this->NewRevision;
+  const char* git = this->CommandLineTool.c_str();
+  const char* git_rev_list[] = { git,           "rev-list", "--reverse",
+                                 range.c_str(), "--",       nullptr };
+  const char* git_diff_tree[] = {
+    git,  "diff-tree",    "--stdin",          "--always", "-z",
+    "-r", "--pretty=raw", "--encoding=utf-8", nullptr
+  };
+  this->Log << this->ComputeCommandLine(git_rev_list) << " | "
+            << this->ComputeCommandLine(git_diff_tree) << "\n";
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_AddCommand(cp, git_rev_list);
+  cmsysProcess_AddCommand(cp, git_diff_tree);
+  cmsysProcess_SetWorkingDirectory(cp, this->SourceDirectory.c_str());
+
+  CommitParser out(this, "dt-out> ");
+  OutputLogger err(this->Log, "dt-err> ");
+  this->RunProcess(cp, &out, &err, cmProcessOutput::UTF8);
+
+  // Send one extra zero-byte to terminate the last record.
+  out.Process("", 1);
+
+  cmsysProcess_Delete(cp);
+  return true;
+}
+
+bool cmCTestGIT::LoadModifications()
+{
+  const char* git = this->CommandLineTool.c_str();
+
+  // Use 'git update-index' to refresh the index w.r.t. the work tree.
+  const char* git_update_index[] = { git, "update-index", "--refresh",
+                                     nullptr };
+  OutputLogger ui_out(this->Log, "ui-out> ");
+  OutputLogger ui_err(this->Log, "ui-err> ");
+  this->RunChild(git_update_index, &ui_out, &ui_err, nullptr,
+                 cmProcessOutput::UTF8);
+
+  // Use 'git diff-index' to get modified files.
+  const char* git_diff_index[] = { git,    "diff-index", "-z",
+                                   "HEAD", "--",         nullptr };
+  DiffParser out(this, "di-out> ");
+  OutputLogger err(this->Log, "di-err> ");
+  this->RunChild(git_diff_index, &out, &err, nullptr, cmProcessOutput::UTF8);
+
+  for (Change const& c : out.Changes) {
+    this->DoModification(PathModified, c.Path);
+  }
+  return true;
+}
diff --git a/Source/CTest/cmCTestGIT.h b/Source/CTest/cmCTestGIT.h
new file mode 100644
index 0000000..ade430f
--- /dev/null
+++ b/Source/CTest/cmCTestGIT.h
@@ -0,0 +1,57 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestGIT_h
+#define cmCTestGIT_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGlobalVC.h"
+
+#include <iosfwd>
+#include <string>
+
+class cmCTest;
+
+/** \class cmCTestGIT
+ * \brief Interaction with git command-line tool
+ *
+ */
+class cmCTestGIT : public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestGIT(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestGIT() override;
+
+private:
+  unsigned int CurrentGitVersion;
+  unsigned int GetGitVersion();
+  std::string GetWorkingRevision();
+  bool NoteOldRevision() override;
+  bool NoteNewRevision() override;
+  bool UpdateImpl() override;
+
+  std::string FindGitDir();
+  std::string FindTopDir();
+
+  bool UpdateByFetchAndReset();
+  bool UpdateByCustom(std::string const& custom);
+  bool UpdateInternal();
+
+  bool LoadRevisions() override;
+  bool LoadModifications() override;
+
+  // "public" needed by older Sun compilers
+public:
+  // Parsing helper classes.
+  class CommitParser;
+  class DiffParser;
+  class OneLineParser;
+
+  friend class CommitParser;
+  friend class DiffParser;
+  friend class OneLineParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx
new file mode 100644
index 0000000..ce8f709
--- /dev/null
+++ b/Source/CTest/cmCTestGenericHandler.cxx
@@ -0,0 +1,135 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestGenericHandler.h"
+
+#include <sstream>
+#include <utility>
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+
+cmCTestGenericHandler::cmCTestGenericHandler()
+{
+  this->HandlerVerbose = cmSystemTools::OUTPUT_NONE;
+  this->CTest = nullptr;
+  this->SubmitIndex = 0;
+  this->AppendXML = false;
+  this->Quiet = false;
+  this->TestLoad = 0;
+}
+
+cmCTestGenericHandler::~cmCTestGenericHandler()
+{
+}
+
+void cmCTestGenericHandler::SetOption(const std::string& op, const char* value)
+{
+  if (!value) {
+    cmCTestGenericHandler::t_StringToString::iterator remit =
+      this->Options.find(op);
+    if (remit != this->Options.end()) {
+      this->Options.erase(remit);
+    }
+    return;
+  }
+
+  this->Options[op] = value;
+}
+
+void cmCTestGenericHandler::SetPersistentOption(const std::string& op,
+                                                const char* value)
+{
+  this->SetOption(op, value);
+  if (!value) {
+    cmCTestGenericHandler::t_StringToString::iterator remit =
+      this->PersistentOptions.find(op);
+    if (remit != this->PersistentOptions.end()) {
+      this->PersistentOptions.erase(remit);
+    }
+    return;
+  }
+
+  this->PersistentOptions[op] = value;
+}
+
+void cmCTestGenericHandler::Initialize()
+{
+  this->AppendXML = false;
+  this->TestLoad = 0;
+  this->Options.clear();
+  for (auto const& po : this->PersistentOptions) {
+    this->Options[po.first] = po.second;
+  }
+}
+
+const char* cmCTestGenericHandler::GetOption(const std::string& op)
+{
+  cmCTestGenericHandler::t_StringToString::iterator remit =
+    this->Options.find(op);
+  if (remit == this->Options.end()) {
+    return nullptr;
+  }
+  return remit->second.c_str();
+}
+
+bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
+                                              const char* name,
+                                              cmGeneratedFileStream& xofs)
+{
+  if (!name) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create resulting XML file without providing the name"
+                 << std::endl;);
+    return false;
+  }
+  std::ostringstream ostr;
+  ostr << name;
+  if (this->SubmitIndex > 0) {
+    ostr << "_" << this->SubmitIndex;
+  }
+  ostr << ".xml";
+  if (this->CTest->GetCurrentTag().empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Current Tag empty, this may mean NightlyStartTime / "
+               "CTEST_NIGHTLY_START_TIME was not set correctly. Or "
+               "maybe you forgot to call ctest_start() before calling "
+               "ctest_configure()."
+                 << std::endl);
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+  }
+  if (!this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(), ostr.str(),
+                                   xofs, true)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create resulting XML file: "
+                 << ostr.str() << std::endl);
+    return false;
+  }
+  this->CTest->AddSubmitFile(part, ostr.str().c_str());
+  return true;
+}
+
+bool cmCTestGenericHandler::StartLogFile(const char* name,
+                                         cmGeneratedFileStream& xofs)
+{
+  if (!name) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create log file without providing the name"
+                 << std::endl;);
+    return false;
+  }
+  std::ostringstream ostr;
+  ostr << "Last" << name;
+  if (this->SubmitIndex > 0) {
+    ostr << "_" << this->SubmitIndex;
+  }
+  if (!this->CTest->GetCurrentTag().empty()) {
+    ostr << "_" << this->CTest->GetCurrentTag();
+  }
+  ostr << ".log";
+  if (!this->CTest->OpenOutputFile("Temporary", ostr.str(), xofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create log file: " << ostr.str() << std::endl);
+    return false;
+  }
+  return true;
+}
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
new file mode 100644
index 0000000..e881252
--- /dev/null
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -0,0 +1,108 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestGenericHandler_h
+#define cmCTestGenericHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+
+class cmCTestCommand;
+class cmGeneratedFileStream;
+class cmMakefile;
+
+/** \class cmCTestGenericHandler
+ * \brief A superclass of all CTest Handlers
+ *
+ */
+class cmCTestGenericHandler
+{
+public:
+  /**
+   * If verbose then more informaiton is printed out
+   */
+  void SetVerbose(bool val)
+  {
+    this->HandlerVerbose =
+      val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE;
+  }
+
+  /**
+   * Populate internals from CTest custom scripts
+   */
+  virtual void PopulateCustomVectors(cmMakefile*) {}
+
+  /**
+   * Do the actual processing. Subclass has to override it.
+   * Return < 0 if error.
+   */
+  virtual int ProcessHandler() = 0;
+
+  /**
+   * Process command line arguments that are applicable for the handler
+   */
+  virtual int ProcessCommandLineArguments(
+    const std::string& /*currentArg*/, size_t& /*idx*/,
+    const std::vector<std::string>& /*allArgs*/)
+  {
+    return 1;
+  }
+
+  /**
+   * Initialize handler
+   */
+  virtual void Initialize();
+
+  /**
+   * Set the CTest instance
+   */
+  void SetCTestInstance(cmCTest* ctest) { this->CTest = ctest; }
+  cmCTest* GetCTestInstance() { return this->CTest; }
+
+  /**
+   * Construct handler
+   */
+  cmCTestGenericHandler();
+  virtual ~cmCTestGenericHandler();
+
+  typedef std::map<std::string, std::string> t_StringToString;
+
+  void SetPersistentOption(const std::string& op, const char* value);
+  void SetOption(const std::string& op, const char* value);
+  const char* GetOption(const std::string& op);
+
+  void SetCommand(cmCTestCommand* command) { this->Command = command; }
+
+  void SetSubmitIndex(int idx) { this->SubmitIndex = idx; }
+  int GetSubmitIndex() { return this->SubmitIndex; }
+
+  void SetAppendXML(bool b) { this->AppendXML = b; }
+  void SetQuiet(bool b) { this->Quiet = b; }
+  bool GetQuiet() { return this->Quiet; }
+  void SetTestLoad(unsigned long load) { this->TestLoad = load; }
+  unsigned long GetTestLoad() const { return this->TestLoad; }
+
+protected:
+  bool StartResultingXML(cmCTest::Part part, const char* name,
+                         cmGeneratedFileStream& xofs);
+  bool StartLogFile(const char* name, cmGeneratedFileStream& xofs);
+
+  bool AppendXML;
+  bool Quiet;
+  unsigned long TestLoad;
+  cmSystemTools::OutputOption HandlerVerbose;
+  cmCTest* CTest;
+  t_StringToString Options;
+  t_StringToString PersistentOptions;
+
+  cmCTestCommand* Command;
+  int SubmitIndex;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestGlobalVC.cxx b/Source/CTest/cmCTestGlobalVC.cxx
new file mode 100644
index 0000000..d2714d90
--- /dev/null
+++ b/Source/CTest/cmCTestGlobalVC.cxx
@@ -0,0 +1,121 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestGlobalVC.h"
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+#include <ostream>
+#include <utility>
+
+cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log)
+  : cmCTestVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+}
+
+cmCTestGlobalVC::~cmCTestGlobalVC()
+{
+}
+
+const char* cmCTestGlobalVC::LocalPath(std::string const& path)
+{
+  return path.c_str();
+}
+
+void cmCTestGlobalVC::DoRevision(Revision const& revision,
+                                 std::vector<Change> const& changes)
+{
+  // Ignore changes in the old revision.
+  if (revision.Rev == this->OldRevision) {
+    this->PriorRev = revision;
+    return;
+  }
+
+  // Indicate we found a revision.
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
+
+  // Store the revision.
+  this->Revisions.push_back(revision);
+
+  // Report this revision.
+  Revision const& rev = this->Revisions.back();
+  /* clang-format off */
+  this->Log << "Found revision " << rev.Rev << "\n"
+            << "  author = " << rev.Author << "\n"
+            << "  date = " << rev.Date << "\n";
+  /* clang-format on */
+
+  // Update information about revisions of the changed files.
+  for (Change const& c : changes) {
+    if (const char* local = this->LocalPath(c.Path)) {
+      std::string dir = cmSystemTools::GetFilenamePath(local);
+      std::string name = cmSystemTools::GetFilenameName(local);
+      File& file = this->Dirs[dir][name];
+      file.PriorRev = file.Rev ? file.Rev : &this->PriorRev;
+      file.Rev = &rev;
+      this->Log << "  " << c.Action << " " << local << " "
+                << "\n";
+    }
+  }
+}
+
+void cmCTestGlobalVC::DoModification(PathStatus status,
+                                     std::string const& path)
+{
+  std::string dir = cmSystemTools::GetFilenamePath(path);
+  std::string name = cmSystemTools::GetFilenameName(path);
+  File& file = this->Dirs[dir][name];
+  file.Status = status;
+  // For local modifications the current rev is unknown and the
+  // prior rev is the latest from svn.
+  if (!file.Rev && !file.PriorRev) {
+    file.PriorRev = &this->PriorRev;
+  }
+}
+
+void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml,
+                                        std::string const& path,
+                                        Directory const& dir)
+{
+  const char* slash = path.empty() ? "" : "/";
+  xml.StartElement("Directory");
+  xml.Element("Name", path);
+  for (auto const& f : dir) {
+    std::string const full = path + slash + f.first;
+    this->WriteXMLEntry(xml, path, f.first, full, f.second);
+  }
+  xml.EndElement(); // Directory
+}
+
+void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml)
+{
+  if (!this->NewRevision.empty()) {
+    xml.Element("Revision", this->NewRevision);
+  }
+  if (!this->OldRevision.empty() && this->OldRevision != this->NewRevision) {
+    xml.Element("PriorRevision", this->OldRevision);
+  }
+}
+
+bool cmCTestGlobalVC::WriteXMLUpdates(cmXMLWriter& xml)
+{
+  bool result = true;
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Gathering version information (one . per revision):\n"
+             "    "
+               << std::flush);
+  result = this->LoadRevisions() && result;
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+
+  result = this->LoadModifications() && result;
+
+  this->WriteXMLGlobal(xml);
+
+  for (auto const& d : this->Dirs) {
+    this->WriteXMLDirectory(xml, d.first, d.second);
+  }
+
+  return result;
+}
diff --git a/Source/CTest/cmCTestGlobalVC.h b/Source/CTest/cmCTestGlobalVC.h
new file mode 100644
index 0000000..76377ed
--- /dev/null
+++ b/Source/CTest/cmCTestGlobalVC.h
@@ -0,0 +1,75 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestGlobalVC_h
+#define cmCTestGlobalVC_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestVC.h"
+
+#include <iosfwd>
+#include <list>
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmXMLWriter;
+
+/** \class cmCTestGlobalVC
+ * \brief Base class for handling globally-versioned trees
+ *
+ */
+class cmCTestGlobalVC : public cmCTestVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestGlobalVC(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestGlobalVC() override;
+
+protected:
+  // Implement cmCTestVC internal API.
+  bool WriteXMLUpdates(cmXMLWriter& xml) override;
+
+  /** Represent a vcs-reported action for one path in a revision.  */
+  struct Change
+  {
+    char Action;
+    std::string Path;
+    Change(char a = '?')
+      : Action(a)
+    {
+    }
+  };
+
+  // Update status for files in each directory.
+  class Directory : public std::map<std::string, File>
+  {
+  };
+  std::map<std::string, Directory> Dirs;
+
+  // Old and new repository revisions.
+  std::string OldRevision;
+  std::string NewRevision;
+
+  // Information known about old revision.
+  Revision PriorRev;
+
+  // Information about revisions from a svn log.
+  std::list<Revision> Revisions;
+
+  virtual const char* LocalPath(std::string const& path);
+
+  virtual void DoRevision(Revision const& revision,
+                          std::vector<Change> const& changes);
+  virtual void DoModification(PathStatus status, std::string const& path);
+  virtual bool LoadModifications() = 0;
+  virtual bool LoadRevisions() = 0;
+
+  virtual void WriteXMLGlobal(cmXMLWriter& xml);
+  void WriteXMLDirectory(cmXMLWriter& xml, std::string const& path,
+                         Directory const& dir);
+};
+
+#endif
diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx
new file mode 100644
index 0000000..525dacc
--- /dev/null
+++ b/Source/CTest/cmCTestHG.cxx
@@ -0,0 +1,309 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestHG.h"
+
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <ostream>
+#include <vector>
+
+cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+}
+
+cmCTestHG::~cmCTestHG()
+{
+}
+
+class cmCTestHG::IdentifyParser : public cmCTestVC::LineParser
+{
+public:
+  IdentifyParser(cmCTestHG* hg, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
+    this->SetLog(&hg->Log, prefix);
+    this->RegexIdentify.compile("^([0-9a-f]+)");
+  }
+
+private:
+  std::string& Rev;
+  cmsys::RegularExpression RegexIdentify;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexIdentify.find(this->Line)) {
+      this->Rev = this->RegexIdentify.match(1);
+      return false;
+    }
+    return true;
+  }
+};
+
+class cmCTestHG::StatusParser : public cmCTestVC::LineParser
+{
+public:
+  StatusParser(cmCTestHG* hg, const char* prefix)
+    : HG(hg)
+  {
+    this->SetLog(&hg->Log, prefix);
+    this->RegexStatus.compile("([MARC!?I]) (.*)");
+  }
+
+private:
+  cmCTestHG* HG;
+  cmsys::RegularExpression RegexStatus;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexStatus.find(this->Line)) {
+      this->DoPath(this->RegexStatus.match(1)[0], this->RegexStatus.match(2));
+    }
+    return true;
+  }
+
+  void DoPath(char status, std::string const& path)
+  {
+    if (path.empty()) {
+      return;
+    }
+
+    // See "hg help status".  Note that there is no 'conflict' status.
+    switch (status) {
+      case 'M':
+      case 'A':
+      case '!':
+      case 'R':
+        this->HG->DoModification(PathModified, path);
+        break;
+      case 'I':
+      case '?':
+      case 'C':
+      case ' ':
+      default:
+        break;
+    }
+  }
+};
+
+std::string cmCTestHG::GetWorkingRevision()
+{
+  // Run plumbing "hg identify" to get work tree revision.
+  const char* hg = this->CommandLineTool.c_str();
+  const char* hg_identify[] = { hg, "identify", "-i", nullptr };
+  std::string rev;
+  IdentifyParser out(this, "rev-out> ", rev);
+  OutputLogger err(this->Log, "rev-err> ");
+  this->RunChild(hg_identify, &out, &err);
+  return rev;
+}
+
+bool cmCTestHG::NoteOldRevision()
+{
+  this->OldRevision = this->GetWorkingRevision();
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
+               << this->OldRevision << "\n");
+  this->PriorRev.Rev = this->OldRevision;
+  return true;
+}
+
+bool cmCTestHG::NoteNewRevision()
+{
+  this->NewRevision = this->GetWorkingRevision();
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
+               << this->NewRevision << "\n");
+  return true;
+}
+
+bool cmCTestHG::UpdateImpl()
+{
+  // Use "hg pull" followed by "hg update" to update the working tree.
+  {
+    const char* hg = this->CommandLineTool.c_str();
+    const char* hg_pull[] = { hg, "pull", "-v", nullptr };
+    OutputLogger out(this->Log, "pull-out> ");
+    OutputLogger err(this->Log, "pull-err> ");
+    this->RunChild(&hg_pull[0], &out, &err);
+  }
+
+  // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
+
+  std::vector<char const*> hg_update;
+  hg_update.push_back(this->CommandLineTool.c_str());
+  hg_update.push_back("update");
+  hg_update.push_back("-v");
+
+  // Add user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("HGUpdateOptions");
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+  for (std::string const& arg : args) {
+    hg_update.push_back(arg.c_str());
+  }
+
+  // Sentinel argument.
+  hg_update.push_back(nullptr);
+
+  OutputLogger out(this->Log, "update-out> ");
+  OutputLogger err(this->Log, "update-err> ");
+  return this->RunUpdateCommand(&hg_update[0], &out, &err);
+}
+
+class cmCTestHG::LogParser : public cmCTestVC::OutputLogger,
+                             private cmXMLParser
+{
+public:
+  LogParser(cmCTestHG* hg, const char* prefix)
+    : OutputLogger(hg->Log, prefix)
+    , HG(hg)
+  {
+    this->InitializeParser();
+  }
+  ~LogParser() override { this->CleanupParser(); }
+private:
+  cmCTestHG* HG;
+
+  typedef cmCTestHG::Revision Revision;
+  typedef cmCTestHG::Change Change;
+  Revision Rev;
+  std::vector<Change> Changes;
+  Change CurChange;
+  std::vector<char> CData;
+
+  bool ProcessChunk(const char* data, int length) override
+  {
+    this->OutputLogger::ProcessChunk(data, length);
+    this->ParseChunk(data, length);
+    return true;
+  }
+
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    this->CData.clear();
+    if (name == "logentry") {
+      this->Rev = Revision();
+      if (const char* rev = this->FindAttribute(atts, "revision")) {
+        this->Rev.Rev = rev;
+      }
+      this->Changes.clear();
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
+
+  void EndElement(const std::string& name) override
+  {
+    if (name == "logentry") {
+      this->HG->DoRevision(this->Rev, this->Changes);
+    } else if (!this->CData.empty() && name == "author") {
+      this->Rev.Author.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "email") {
+      this->Rev.EMail.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "date") {
+      this->Rev.Date.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "msg") {
+      this->Rev.Log.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "files") {
+      std::vector<std::string> paths = this->SplitCData();
+      for (std::string const& path : paths) {
+        // Updated by default, will be modified using file_adds and
+        // file_dels.
+        this->CurChange = Change('U');
+        this->CurChange.Path = path;
+        this->Changes.push_back(this->CurChange);
+      }
+    } else if (!this->CData.empty() && name == "file_adds") {
+      std::string added_paths(this->CData.begin(), this->CData.end());
+      for (Change& change : this->Changes) {
+        if (added_paths.find(change.Path) != std::string::npos) {
+          change.Action = 'A';
+        }
+      }
+    } else if (!this->CData.empty() && name == "file_dels") {
+      std::string added_paths(this->CData.begin(), this->CData.end());
+      for (Change& change : this->Changes) {
+        if (added_paths.find(change.Path) != std::string::npos) {
+          change.Action = 'D';
+        }
+      }
+    }
+    this->CData.clear();
+  }
+
+  std::vector<std::string> SplitCData()
+  {
+    std::vector<std::string> output;
+    std::string currPath;
+    for (char i : this->CData) {
+      if (i != ' ') {
+        currPath += i;
+      } else {
+        output.push_back(currPath);
+        currPath.clear();
+      }
+    }
+    output.push_back(currPath);
+    return output;
+  }
+
+  void ReportError(int /*line*/, int /*column*/, const char* msg) override
+  {
+    this->HG->Log << "Error parsing hg log xml: " << msg << "\n";
+  }
+};
+
+bool cmCTestHG::LoadRevisions()
+{
+  // Use 'hg log' to get revisions in a xml format.
+  //
+  // TODO: This should use plumbing or python code to be more precise.
+  // The "list of strings" templates like {files} will not work when
+  // the project has spaces in the path.  Also, they may not have
+  // proper XML escapes.
+  std::string range = this->OldRevision + ":" + this->NewRevision;
+  const char* hg = this->CommandLineTool.c_str();
+  const char* hgXMLTemplate = "<logentry\n"
+                              "   revision=\"{node|short}\">\n"
+                              "  <author>{author|person}</author>\n"
+                              "  <email>{author|email}</email>\n"
+                              "  <date>{date|isodate}</date>\n"
+                              "  <msg>{desc}</msg>\n"
+                              "  <files>{files}</files>\n"
+                              "  <file_adds>{file_adds}</file_adds>\n"
+                              "  <file_dels>{file_dels}</file_dels>\n"
+                              "</logentry>\n";
+  const char* hg_log[] = {
+    hg,           "log",         "--removed", "-r", range.c_str(),
+    "--template", hgXMLTemplate, nullptr
+  };
+
+  LogParser out(this, "log-out> ");
+  out.Process("<?xml version=\"1.0\"?>\n"
+              "<log>\n");
+  OutputLogger err(this->Log, "log-err> ");
+  this->RunChild(hg_log, &out, &err);
+  out.Process("</log>\n");
+  return true;
+}
+
+bool cmCTestHG::LoadModifications()
+{
+  // Use 'hg status' to get modified files.
+  const char* hg = this->CommandLineTool.c_str();
+  const char* hg_status[] = { hg, "status", nullptr };
+  StatusParser out(this, "status-out> ");
+  OutputLogger err(this->Log, "status-err> ");
+  this->RunChild(hg_status, &out, &err);
+  return true;
+}
diff --git a/Source/CTest/cmCTestHG.h b/Source/CTest/cmCTestHG.h
new file mode 100644
index 0000000..c12d618
--- /dev/null
+++ b/Source/CTest/cmCTestHG.h
@@ -0,0 +1,46 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestHG_h
+#define cmCTestHG_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGlobalVC.h"
+
+#include <iosfwd>
+#include <string>
+
+class cmCTest;
+
+/** \class cmCTestHG
+ * \brief Interaction with Mercurial command-line tool
+ *
+ */
+class cmCTestHG : public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestHG(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestHG() override;
+
+private:
+  std::string GetWorkingRevision();
+  bool NoteOldRevision() override;
+  bool NoteNewRevision() override;
+  bool UpdateImpl() override;
+
+  bool LoadRevisions() override;
+  bool LoadModifications() override;
+
+  // Parsing helper classes.
+  class IdentifyParser;
+  class LogParser;
+  class StatusParser;
+
+  friend class IdentifyParser;
+  friend class LogParser;
+  friend class StatusParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
new file mode 100644
index 0000000..5a7baf5
--- /dev/null
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -0,0 +1,295 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestHandlerCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+#include "cmake.h"
+
+#include <sstream>
+#include <stdlib.h>
+
+class cmExecutionStatus;
+
+cmCTestHandlerCommand::cmCTestHandlerCommand()
+{
+  const size_t INIT_SIZE = 100;
+  size_t cc;
+  this->Arguments.reserve(INIT_SIZE);
+  for (cc = 0; cc < INIT_SIZE; ++cc) {
+    this->Arguments.push_back(nullptr);
+  }
+  this->Arguments[ct_RETURN_VALUE] = "RETURN_VALUE";
+  this->Arguments[ct_CAPTURE_CMAKE_ERROR] = "CAPTURE_CMAKE_ERROR";
+  this->Arguments[ct_SOURCE] = "SOURCE";
+  this->Arguments[ct_BUILD] = "BUILD";
+  this->Arguments[ct_SUBMIT_INDEX] = "SUBMIT_INDEX";
+  this->Last = ct_LAST;
+  this->AppendXML = false;
+  this->Quiet = false;
+}
+
+namespace {
+// class to save and restore the error state for ctest_* commands
+// if a ctest_* command has a CAPTURE_CMAKE_ERROR then put the error
+// state into there and restore the system wide error to what
+// it was before the command ran
+class SaveRestoreErrorState
+{
+public:
+  SaveRestoreErrorState()
+  {
+    this->InitialErrorState = cmSystemTools::GetErrorOccuredFlag();
+    cmSystemTools::ResetErrorOccuredFlag(); // rest the error state
+    this->CaptureCMakeErrorValue = false;
+  }
+  // if the function has a CAPTURE_CMAKE_ERROR then we should restore
+  // the error state to what it was before the function was run
+  // if not then let the error state be what it is
+  void CaptureCMakeError() { this->CaptureCMakeErrorValue = true; }
+  ~SaveRestoreErrorState()
+  {
+    // if we are not saving the return value then make sure
+    // if it was in error it goes back to being in error
+    // otherwise leave it be what it is
+    if (!this->CaptureCMakeErrorValue) {
+      if (this->InitialErrorState) {
+        cmSystemTools::SetErrorOccured();
+      }
+      return;
+    }
+    // if we have saved the error in a return variable
+    // then put things back exactly like they were
+    bool currentState = cmSystemTools::GetErrorOccuredFlag();
+    // if the state changed during this command we need
+    // to handle it, if not then nothing needs to be done
+    if (currentState != this->InitialErrorState) {
+      // restore the initial error state
+      if (this->InitialErrorState) {
+        cmSystemTools::SetErrorOccured();
+      } else {
+        cmSystemTools::ResetErrorOccuredFlag();
+      }
+    }
+  }
+
+private:
+  bool InitialErrorState;
+  bool CaptureCMakeErrorValue;
+};
+}
+
+bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
+                                        cmExecutionStatus& /*unused*/)
+{
+  // save error state and restore it if needed
+  SaveRestoreErrorState errorState;
+  // Allocate space for argument values.
+  this->Values.clear();
+  this->Values.resize(this->Last, nullptr);
+
+  // Process input arguments.
+  this->ArgumentDoing = ArgumentDoingNone;
+  // look at all arguments and do not short circuit on the first
+  // bad one so that CAPTURE_CMAKE_ERROR can override setting the
+  // global error state
+  bool foundBadArgument = false;
+  for (std::string const& arg : args) {
+    // Check this argument.
+    if (!this->CheckArgumentKeyword(arg) && !this->CheckArgumentValue(arg)) {
+      std::ostringstream e;
+      e << "called with unknown argument \"" << arg << "\".";
+      this->SetError(e.str());
+      foundBadArgument = true;
+    }
+    // note bad argument
+    if (this->ArgumentDoing == ArgumentDoingError) {
+      foundBadArgument = true;
+    }
+  }
+  bool capureCMakeError = (this->Values[ct_CAPTURE_CMAKE_ERROR] &&
+                           *this->Values[ct_CAPTURE_CMAKE_ERROR]);
+  // now that arguments are parsed check to see if there is a
+  // CAPTURE_CMAKE_ERROR specified let the errorState object know.
+  if (capureCMakeError) {
+    errorState.CaptureCMakeError();
+  }
+  // if we found a bad argument then exit before running command
+  if (foundBadArgument) {
+    // store the cmake error
+    if (capureCMakeError) {
+      this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR],
+                                    "-1");
+      std::string const err = this->GetName() + " " + this->GetError();
+      if (!cmSystemTools::FindLastString(err.c_str(), "unknown error.")) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, err << " error from command\n");
+      }
+      // return success because failure is recorded in CAPTURE_CMAKE_ERROR
+      return true;
+    }
+    // return failure because of bad argument
+    return false;
+  }
+
+  // Set the config type of this ctest to the current value of the
+  // CTEST_CONFIGURATION_TYPE script variable if it is defined.
+  // The current script value trumps the -C argument on the command
+  // line.
+  const char* ctestConfigType =
+    this->Makefile->GetDefinition("CTEST_CONFIGURATION_TYPE");
+  if (ctestConfigType) {
+    this->CTest->SetConfigType(ctestConfigType);
+  }
+
+  if (this->Values[ct_BUILD]) {
+    this->CTest->SetCTestConfiguration(
+      "BuildDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_BUILD]).c_str(),
+      this->Quiet);
+  } else {
+    const char* bdir =
+      this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
+    if (bdir) {
+      this->CTest->SetCTestConfiguration(
+        "BuildDirectory", cmSystemTools::CollapseFullPath(bdir).c_str(),
+        this->Quiet);
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "CTEST_BINARY_DIRECTORY not set"
+                   << std::endl;);
+    }
+  }
+  if (this->Values[ct_SOURCE]) {
+    cmCTestLog(this->CTest, DEBUG, "Set source directory to: "
+                 << this->Values[ct_SOURCE] << std::endl);
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_SOURCE]).c_str(),
+      this->Quiet);
+  } else {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(
+        this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY"))
+        .c_str(),
+      this->Quiet);
+  }
+
+  if (const char* changeId =
+        this->Makefile->GetDefinition("CTEST_CHANGE_ID")) {
+    this->CTest->SetCTestConfiguration("ChangeId", changeId, this->Quiet);
+  }
+
+  cmCTestLog(this->CTest, DEBUG, "Initialize handler" << std::endl;);
+  cmCTestGenericHandler* handler = this->InitializeHandler();
+  if (!handler) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot instantiate test handler "
+                 << this->GetName() << std::endl);
+    if (capureCMakeError) {
+      this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR],
+                                    "-1");
+      const char* err = this->GetError();
+      if (err && !cmSystemTools::FindLastString(err, "unknown error.")) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, err << " error from command\n");
+      }
+      return true;
+    }
+    return false;
+  }
+
+  handler->SetAppendXML(this->AppendXML);
+
+  handler->PopulateCustomVectors(this->Makefile);
+  if (this->Values[ct_SUBMIT_INDEX]) {
+    if (!this->CTest->GetDropSiteCDash() &&
+        this->CTest->GetDartVersion() <= 1) {
+      cmCTestLog(
+        this->CTest, ERROR_MESSAGE,
+        "Dart before version 2.0 does not support collecting submissions."
+          << std::endl
+          << "Please upgrade the server to Dart 2 or higher, or do not use "
+             "SUBMIT_INDEX."
+          << std::endl);
+    } else {
+      handler->SetSubmitIndex(atoi(this->Values[ct_SUBMIT_INDEX]));
+    }
+  }
+  cmWorkingDirectory workdir(
+    this->CTest->GetCTestConfiguration("BuildDirectory"));
+  int res = handler->ProcessHandler();
+  if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) {
+    std::ostringstream str;
+    str << res;
+    this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE],
+                                  str.str().c_str());
+  }
+  this->ProcessAdditionalValues(handler);
+  // log the error message if there was an error
+  if (capureCMakeError) {
+    const char* returnString = "0";
+    if (cmSystemTools::GetErrorOccuredFlag()) {
+      returnString = "-1";
+      const char* err = this->GetError();
+      // print out the error if it is not "unknown error" which means
+      // there was no message
+      if (err && !cmSystemTools::FindLastString(err, "unknown error.")) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, err);
+      }
+    }
+    // store the captured cmake error state 0 or -1
+    this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR],
+                                  returnString);
+  }
+  return true;
+}
+
+void cmCTestHandlerCommand::ProcessAdditionalValues(cmCTestGenericHandler*)
+{
+}
+
+bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg)
+{
+  // Look for non-value arguments common to all commands.
+  if (arg == "APPEND") {
+    this->ArgumentDoing = ArgumentDoingNone;
+    this->AppendXML = true;
+    return true;
+  }
+  if (arg == "QUIET") {
+    this->ArgumentDoing = ArgumentDoingNone;
+    this->Quiet = true;
+    return true;
+  }
+
+  // Check for a keyword in our argument/value table.
+  for (unsigned int k = 0; k < this->Arguments.size(); ++k) {
+    if (this->Arguments[k] && arg == this->Arguments[k]) {
+      this->ArgumentDoing = ArgumentDoingKeyword;
+      this->ArgumentIndex = k;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool cmCTestHandlerCommand::CheckArgumentValue(std::string const& arg)
+{
+  if (this->ArgumentDoing == ArgumentDoingKeyword) {
+    this->ArgumentDoing = ArgumentDoingNone;
+    unsigned int k = this->ArgumentIndex;
+    if (this->Values[k]) {
+      std::ostringstream e;
+      e << "Called with more than one value for " << this->Arguments[k];
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      this->ArgumentDoing = ArgumentDoingError;
+      return true;
+    }
+    this->Values[k] = arg.c_str();
+    cmCTestLog(this->CTest, DEBUG, "Set " << this->Arguments[k] << " to "
+                                          << arg << "\n");
+    return true;
+  }
+  return false;
+}
diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h
new file mode 100644
index 0000000..79d61f3
--- /dev/null
+++ b/Source/CTest/cmCTestHandlerCommand.h
@@ -0,0 +1,82 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestHandlerCommand_h
+#define cmCTestHandlerCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+class cmCTestGenericHandler;
+class cmExecutionStatus;
+
+/** \class cmCTestHandler
+ * \brief Run a ctest script
+ *
+ * cmCTestHandlerCommand defineds the command to test the project.
+ */
+class cmCTestHandlerCommand : public cmCTestCommand
+{
+public:
+  cmCTestHandlerCommand();
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual std::string GetName() const = 0;
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  enum
+  {
+    ct_NONE,
+    ct_RETURN_VALUE,
+    ct_CAPTURE_CMAKE_ERROR,
+    ct_BUILD,
+    ct_SOURCE,
+    ct_SUBMIT_INDEX,
+    ct_LAST
+  };
+
+protected:
+  virtual cmCTestGenericHandler* InitializeHandler() = 0;
+
+  virtual void ProcessAdditionalValues(cmCTestGenericHandler* handler);
+
+  // Command argument handling.
+  virtual bool CheckArgumentKeyword(std::string const& arg);
+  virtual bool CheckArgumentValue(std::string const& arg);
+  enum
+  {
+    ArgumentDoingNone,
+    ArgumentDoingError,
+    ArgumentDoingKeyword,
+    ArgumentDoingLast1
+  };
+  int ArgumentDoing;
+  unsigned int ArgumentIndex;
+
+  bool AppendXML;
+  bool Quiet;
+
+  std::string ReturnVariable;
+  std::vector<const char*> Arguments;
+  std::vector<const char*> Values;
+  size_t Last;
+};
+
+#define CTEST_COMMAND_APPEND_OPTION_DOCS                                      \
+  "The APPEND option marks results for append to those previously "           \
+  "submitted to a dashboard server since the last ctest_start.  "             \
+  "Append semantics are defined by the dashboard server in use."
+
+#endif
diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx
new file mode 100644
index 0000000..a1249f5
--- /dev/null
+++ b/Source/CTest/cmCTestLaunch.cxx
@@ -0,0 +1,637 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestLaunch.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Process.h"
+#include "cmsys/RegularExpression.hxx"
+#include <iostream>
+#include <memory> // IWYU pragma: keep
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmCryptoHash.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmProcessOutput.h"
+#include "cmStateSnapshot.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+#include "cmake.h"
+
+#ifdef _WIN32
+#include <fcntl.h> // for _O_BINARY
+#include <io.h>    // for _setmode
+#include <stdio.h> // for std{out,err} and fileno
+#endif
+
+cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
+{
+  this->Passthru = true;
+  this->Process = nullptr;
+  this->ExitCode = 1;
+  this->CWD = cmSystemTools::GetCurrentWorkingDirectory();
+
+  if (!this->ParseArguments(argc, argv)) {
+    return;
+  }
+
+  this->ComputeFileNames();
+
+  this->ScrapeRulesLoaded = false;
+  this->HaveOut = false;
+  this->HaveErr = false;
+  this->Process = cmsysProcess_New();
+}
+
+cmCTestLaunch::~cmCTestLaunch()
+{
+  cmsysProcess_Delete(this->Process);
+  if (!this->Passthru) {
+    cmSystemTools::RemoveFile(this->LogOut);
+    cmSystemTools::RemoveFile(this->LogErr);
+  }
+}
+
+bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
+{
+  // Launcher options occur first and are separated from the real
+  // command line by a '--' option.
+  enum Doing
+  {
+    DoingNone,
+    DoingOutput,
+    DoingSource,
+    DoingLanguage,
+    DoingTargetName,
+    DoingTargetType,
+    DoingBuildDir,
+    DoingCount,
+    DoingFilterPrefix
+  };
+  Doing doing = DoingNone;
+  int arg0 = 0;
+  for (int i = 1; !arg0 && i < argc; ++i) {
+    const char* arg = argv[i];
+    if (strcmp(arg, "--") == 0) {
+      arg0 = i + 1;
+    } else if (strcmp(arg, "--output") == 0) {
+      doing = DoingOutput;
+    } else if (strcmp(arg, "--source") == 0) {
+      doing = DoingSource;
+    } else if (strcmp(arg, "--language") == 0) {
+      doing = DoingLanguage;
+    } else if (strcmp(arg, "--target-name") == 0) {
+      doing = DoingTargetName;
+    } else if (strcmp(arg, "--target-type") == 0) {
+      doing = DoingTargetType;
+    } else if (strcmp(arg, "--build-dir") == 0) {
+      doing = DoingBuildDir;
+    } else if (strcmp(arg, "--filter-prefix") == 0) {
+      doing = DoingFilterPrefix;
+    } else if (doing == DoingOutput) {
+      this->OptionOutput = arg;
+      doing = DoingNone;
+    } else if (doing == DoingSource) {
+      this->OptionSource = arg;
+      doing = DoingNone;
+    } else if (doing == DoingLanguage) {
+      this->OptionLanguage = arg;
+      if (this->OptionLanguage == "CXX") {
+        this->OptionLanguage = "C++";
+      }
+      doing = DoingNone;
+    } else if (doing == DoingTargetName) {
+      this->OptionTargetName = arg;
+      doing = DoingNone;
+    } else if (doing == DoingTargetType) {
+      this->OptionTargetType = arg;
+      doing = DoingNone;
+    } else if (doing == DoingBuildDir) {
+      this->OptionBuildDir = arg;
+      doing = DoingNone;
+    } else if (doing == DoingFilterPrefix) {
+      this->OptionFilterPrefix = arg;
+      doing = DoingNone;
+    }
+  }
+
+  // Extract the real command line.
+  if (arg0) {
+    this->RealArgC = argc - arg0;
+    this->RealArgV = argv + arg0;
+    for (int i = 0; i < this->RealArgC; ++i) {
+      this->HandleRealArg(this->RealArgV[i]);
+    }
+    return true;
+  }
+  this->RealArgC = 0;
+  this->RealArgV = nullptr;
+  std::cerr << "No launch/command separator ('--') found!\n";
+  return false;
+}
+
+void cmCTestLaunch::HandleRealArg(const char* arg)
+{
+#ifdef _WIN32
+  // Expand response file arguments.
+  if (arg[0] == '@' && cmSystemTools::FileExists(arg + 1)) {
+    cmsys::ifstream fin(arg + 1);
+    std::string line;
+    while (cmSystemTools::GetLineFromStream(fin, line)) {
+      cmSystemTools::ParseWindowsCommandLine(line.c_str(), this->RealArgs);
+    }
+    return;
+  }
+#endif
+  this->RealArgs.push_back(arg);
+}
+
+void cmCTestLaunch::ComputeFileNames()
+{
+  // We just passthru the behavior of the real command unless the
+  // CTEST_LAUNCH_LOGS environment variable is set.
+  const char* d = getenv("CTEST_LAUNCH_LOGS");
+  if (!(d && *d)) {
+    return;
+  }
+  this->Passthru = false;
+
+  // The environment variable specifies the directory into which we
+  // generate build logs.
+  this->LogDir = d;
+  cmSystemTools::ConvertToUnixSlashes(this->LogDir);
+  this->LogDir += "/";
+
+  // We hash the input command working dir and command line to obtain
+  // a repeatable and (probably) unique name for log files.
+  cmCryptoHash md5(cmCryptoHash::AlgoMD5);
+  md5.Initialize();
+  md5.Append(this->CWD);
+  for (std::string const& realArg : this->RealArgs) {
+    md5.Append(realArg);
+  }
+  this->LogHash = md5.FinalizeHex();
+
+  // We store stdout and stderr in temporary log files.
+  this->LogOut = this->LogDir;
+  this->LogOut += "launch-";
+  this->LogOut += this->LogHash;
+  this->LogOut += "-out.txt";
+  this->LogErr = this->LogDir;
+  this->LogErr += "launch-";
+  this->LogErr += this->LogHash;
+  this->LogErr += "-err.txt";
+}
+
+void cmCTestLaunch::RunChild()
+{
+  // Ignore noopt make rules
+  if (this->RealArgs.empty() || this->RealArgs[0] == ":") {
+    this->ExitCode = 0;
+    return;
+  }
+
+  // Prepare to run the real command.
+  cmsysProcess* cp = this->Process;
+  cmsysProcess_SetCommand(cp, this->RealArgV);
+
+  cmsys::ofstream fout;
+  cmsys::ofstream ferr;
+  if (this->Passthru) {
+    // In passthru mode we just share the output pipes.
+    cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1);
+    cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1);
+  } else {
+    // In full mode we record the child output pipes to log files.
+    fout.open(this->LogOut.c_str(), std::ios::out | std::ios::binary);
+    ferr.open(this->LogErr.c_str(), std::ios::out | std::ios::binary);
+  }
+
+#ifdef _WIN32
+  // Do this so that newline transformation is not done when writing to cout
+  // and cerr below.
+  _setmode(fileno(stdout), _O_BINARY);
+  _setmode(fileno(stderr), _O_BINARY);
+#endif
+
+  // Run the real command.
+  cmsysProcess_Execute(cp);
+
+  // Record child stdout and stderr if necessary.
+  if (!this->Passthru) {
+    char* data = nullptr;
+    int length = 0;
+    cmProcessOutput processOutput;
+    std::string strdata;
+    while (int p = cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
+      if (p == cmsysProcess_Pipe_STDOUT) {
+        processOutput.DecodeText(data, length, strdata, 1);
+        fout.write(strdata.c_str(), strdata.size());
+        std::cout.write(strdata.c_str(), strdata.size());
+        this->HaveOut = true;
+      } else if (p == cmsysProcess_Pipe_STDERR) {
+        processOutput.DecodeText(data, length, strdata, 2);
+        ferr.write(strdata.c_str(), strdata.size());
+        std::cerr.write(strdata.c_str(), strdata.size());
+        this->HaveErr = true;
+      }
+    }
+    processOutput.DecodeText(std::string(), strdata, 1);
+    if (!strdata.empty()) {
+      fout.write(strdata.c_str(), strdata.size());
+      std::cout.write(strdata.c_str(), strdata.size());
+    }
+    processOutput.DecodeText(std::string(), strdata, 2);
+    if (!strdata.empty()) {
+      ferr.write(strdata.c_str(), strdata.size());
+      std::cerr.write(strdata.c_str(), strdata.size());
+    }
+  }
+
+  // Wait for the real command to finish.
+  cmsysProcess_WaitForExit(cp, nullptr);
+  this->ExitCode = cmsysProcess_GetExitValue(cp);
+}
+
+int cmCTestLaunch::Run()
+{
+  if (!this->Process) {
+    std::cerr << "Could not allocate cmsysProcess instance!\n";
+    return -1;
+  }
+
+  this->RunChild();
+
+  if (this->CheckResults()) {
+    return this->ExitCode;
+  }
+
+  this->LoadConfig();
+  this->WriteXML();
+
+  return this->ExitCode;
+}
+
+void cmCTestLaunch::LoadLabels()
+{
+  if (this->OptionBuildDir.empty() || this->OptionTargetName.empty()) {
+    return;
+  }
+
+  // Labels are listed in per-target files.
+  std::string fname = this->OptionBuildDir;
+  fname += cmake::GetCMakeFilesDirectory();
+  fname += "/";
+  fname += this->OptionTargetName;
+  fname += ".dir/Labels.txt";
+
+  // We are interested in per-target labels for this source file.
+  std::string source = this->OptionSource;
+  cmSystemTools::ConvertToUnixSlashes(source);
+
+  // Load the labels file.
+  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
+  if (!fin) {
+    return;
+  }
+  bool inTarget = true;
+  bool inSource = false;
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty() || line[0] == '#') {
+      // Ignore blank and comment lines.
+      continue;
+    }
+    if (line[0] == ' ') {
+      // Label lines appear indented by one space.
+      if (inTarget || inSource) {
+        this->Labels.insert(line.c_str() + 1);
+      }
+    } else if (!this->OptionSource.empty() && !inSource) {
+      // Non-indented lines specify a source file name.  The first one
+      // is the end of the target-wide labels.  Use labels following a
+      // matching source.
+      inTarget = false;
+      inSource = this->SourceMatches(line, source);
+    } else {
+      return;
+    }
+  }
+}
+
+bool cmCTestLaunch::SourceMatches(std::string const& lhs,
+                                  std::string const& rhs)
+{
+  // TODO: Case sensitivity, UseRelativePaths, etc.  Note that both
+  // paths in the comparison get generated by CMake.  This is done for
+  // every source in the target, so it should be efficient (cannot use
+  // cmSystemTools::IsSameFile).
+  return lhs == rhs;
+}
+
+bool cmCTestLaunch::IsError() const
+{
+  return this->ExitCode != 0;
+}
+
+void cmCTestLaunch::WriteXML()
+{
+  // Name the xml file.
+  std::string logXML = this->LogDir;
+  logXML += this->IsError() ? "error-" : "warning-";
+  logXML += this->LogHash;
+  logXML += ".xml";
+
+  // Use cmGeneratedFileStream to atomically create the report file.
+  cmGeneratedFileStream fxml(logXML.c_str());
+  cmXMLWriter xml(fxml, 2);
+  xml.StartElement("Failure");
+  xml.Attribute("type", this->IsError() ? "Error" : "Warning");
+  this->WriteXMLAction(xml);
+  this->WriteXMLCommand(xml);
+  this->WriteXMLResult(xml);
+  this->WriteXMLLabels(xml);
+  xml.EndElement(); // Failure
+}
+
+void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
+{
+  xml.Comment("Meta-information about the build action");
+  xml.StartElement("Action");
+
+  // TargetName
+  if (!this->OptionTargetName.empty()) {
+    xml.Element("TargetName", this->OptionTargetName);
+  }
+
+  // Language
+  if (!this->OptionLanguage.empty()) {
+    xml.Element("Language", this->OptionLanguage);
+  }
+
+  // SourceFile
+  if (!this->OptionSource.empty()) {
+    std::string source = this->OptionSource;
+    cmSystemTools::ConvertToUnixSlashes(source);
+
+    // If file is in source tree use its relative location.
+    if (cmSystemTools::FileIsFullPath(this->SourceDir.c_str()) &&
+        cmSystemTools::FileIsFullPath(source.c_str()) &&
+        cmSystemTools::IsSubDirectory(source, this->SourceDir)) {
+      source =
+        cmSystemTools::RelativePath(this->SourceDir.c_str(), source.c_str());
+    }
+
+    xml.Element("SourceFile", source);
+  }
+
+  // OutputFile
+  if (!this->OptionOutput.empty()) {
+    xml.Element("OutputFile", this->OptionOutput);
+  }
+
+  // OutputType
+  const char* outputType = nullptr;
+  if (!this->OptionTargetType.empty()) {
+    if (this->OptionTargetType == "EXECUTABLE") {
+      outputType = "executable";
+    } else if (this->OptionTargetType == "SHARED_LIBRARY") {
+      outputType = "shared library";
+    } else if (this->OptionTargetType == "MODULE_LIBRARY") {
+      outputType = "module library";
+    } else if (this->OptionTargetType == "STATIC_LIBRARY") {
+      outputType = "static library";
+    }
+  } else if (!this->OptionSource.empty()) {
+    outputType = "object file";
+  }
+  if (outputType) {
+    xml.Element("OutputType", outputType);
+  }
+
+  xml.EndElement(); // Action
+}
+
+void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml)
+{
+  xml.Comment("Details of command");
+  xml.StartElement("Command");
+  if (!this->CWD.empty()) {
+    xml.Element("WorkingDirectory", this->CWD);
+  }
+  for (std::string const& realArg : this->RealArgs) {
+    xml.Element("Argument", realArg);
+  }
+  xml.EndElement(); // Command
+}
+
+void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
+{
+  xml.Comment("Result of command");
+  xml.StartElement("Result");
+
+  // StdOut
+  xml.StartElement("StdOut");
+  this->DumpFileToXML(xml, this->LogOut);
+  xml.EndElement(); // StdOut
+
+  // StdErr
+  xml.StartElement("StdErr");
+  this->DumpFileToXML(xml, this->LogErr);
+  xml.EndElement(); // StdErr
+
+  // ExitCondition
+  xml.StartElement("ExitCondition");
+  cmsysProcess* cp = this->Process;
+  switch (cmsysProcess_GetState(cp)) {
+    case cmsysProcess_State_Starting:
+      xml.Content("No process has been executed");
+      break;
+    case cmsysProcess_State_Executing:
+      xml.Content("The process is still executing");
+      break;
+    case cmsysProcess_State_Disowned:
+      xml.Content("Disowned");
+      break;
+    case cmsysProcess_State_Killed:
+      xml.Content("Killed by parent");
+      break;
+
+    case cmsysProcess_State_Expired:
+      xml.Content("Killed when timeout expired");
+      break;
+    case cmsysProcess_State_Exited:
+      xml.Content(this->ExitCode);
+      break;
+    case cmsysProcess_State_Exception:
+      xml.Content("Terminated abnormally: ");
+      xml.Content(cmsysProcess_GetExceptionString(cp));
+      break;
+    case cmsysProcess_State_Error:
+      xml.Content("Error administrating child process: ");
+      xml.Content(cmsysProcess_GetErrorString(cp));
+      break;
+  };
+  xml.EndElement(); // ExitCondition
+
+  xml.EndElement(); // Result
+}
+
+void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml)
+{
+  this->LoadLabels();
+  if (!this->Labels.empty()) {
+    xml.Comment("Interested parties");
+    xml.StartElement("Labels");
+    for (std::string const& label : this->Labels) {
+      xml.Element("Label", label);
+    }
+    xml.EndElement(); // Labels
+  }
+}
+
+void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, std::string const& fname)
+{
+  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
+
+  std::string line;
+  const char* sep = "";
+
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (MatchesFilterPrefix(line)) {
+      continue;
+    }
+    if (this->Match(line, this->RegexWarningSuppress)) {
+      line = "[CTest: warning suppressed] " + line;
+    } else if (this->Match(line, this->RegexWarning)) {
+      line = "[CTest: warning matched] " + line;
+    }
+    xml.Content(sep);
+    xml.Content(line);
+    sep = "\n";
+  }
+}
+
+bool cmCTestLaunch::CheckResults()
+{
+  // Skip XML in passthru mode.
+  if (this->Passthru) {
+    return true;
+  }
+
+  // We always report failure for error conditions.
+  if (this->IsError()) {
+    return false;
+  }
+
+  // Scrape the output logs to look for warnings.
+  if ((this->HaveErr && this->ScrapeLog(this->LogErr)) ||
+      (this->HaveOut && this->ScrapeLog(this->LogOut))) {
+    return false;
+  }
+  return true;
+}
+
+void cmCTestLaunch::LoadScrapeRules()
+{
+  if (this->ScrapeRulesLoaded) {
+    return;
+  }
+  this->ScrapeRulesLoaded = true;
+
+  // Common compiler warning formats.  These are much simpler than the
+  // full log-scraping expressions because we do not need to extract
+  // file and line information.
+  this->RegexWarning.push_back("(^|[ :])[Ww][Aa][Rr][Nn][Ii][Nn][Gg]");
+  this->RegexWarning.push_back("(^|[ :])[Rr][Ee][Mm][Aa][Rr][Kk]");
+  this->RegexWarning.push_back("(^|[ :])[Nn][Oo][Tt][Ee]");
+
+  // Load custom match rules given to us by CTest.
+  this->LoadScrapeRules("Warning", this->RegexWarning);
+  this->LoadScrapeRules("WarningSuppress", this->RegexWarningSuppress);
+}
+
+void cmCTestLaunch::LoadScrapeRules(
+  const char* purpose, std::vector<cmsys::RegularExpression>& regexps)
+{
+  std::string fname = this->LogDir;
+  fname += "Custom";
+  fname += purpose;
+  fname += ".txt";
+  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
+  std::string line;
+  cmsys::RegularExpression rex;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (rex.compile(line.c_str())) {
+      regexps.push_back(rex);
+    }
+  }
+}
+
+bool cmCTestLaunch::ScrapeLog(std::string const& fname)
+{
+  this->LoadScrapeRules();
+
+  // Look for log file lines matching warning expressions but not
+  // suppression expressions.
+  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (MatchesFilterPrefix(line)) {
+      continue;
+    }
+
+    if (this->Match(line, this->RegexWarning) &&
+        !this->Match(line, this->RegexWarningSuppress)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool cmCTestLaunch::Match(std::string const& line,
+                          std::vector<cmsys::RegularExpression>& regexps)
+{
+  for (cmsys::RegularExpression& r : regexps) {
+    if (r.find(line.c_str())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const
+{
+  return !this->OptionFilterPrefix.empty() &&
+    cmSystemTools::StringStartsWith(line, this->OptionFilterPrefix.c_str());
+}
+
+int cmCTestLaunch::Main(int argc, const char* const argv[])
+{
+  if (argc == 2) {
+    std::cerr << "ctest --launch: this mode is for internal CTest use only"
+              << std::endl;
+    return 1;
+  }
+  cmCTestLaunch self(argc, argv);
+  return self.Run();
+}
+
+void cmCTestLaunch::LoadConfig()
+{
+  cmake cm(cmake::RoleScript);
+  cm.SetHomeDirectory("");
+  cm.SetHomeOutputDirectory("");
+  cm.GetCurrentSnapshot().SetDefaultDefinitions();
+  cmGlobalGenerator gg(&cm);
+  cmMakefile mf(&gg, cm.GetCurrentSnapshot());
+  std::string fname = this->LogDir;
+  fname += "CTestLaunchConfig.cmake";
+  if (cmSystemTools::FileExists(fname.c_str()) &&
+      mf.ReadListFile(fname.c_str())) {
+    this->SourceDir = mf.GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
+    cmSystemTools::ConvertToUnixSlashes(this->SourceDir);
+  }
+}
diff --git a/Source/CTest/cmCTestLaunch.h b/Source/CTest/cmCTestLaunch.h
new file mode 100644
index 0000000..29986ff
--- /dev/null
+++ b/Source/CTest/cmCTestLaunch.h
@@ -0,0 +1,103 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestLaunch_h
+#define cmCTestLaunch_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/RegularExpression.hxx"
+#include <set>
+#include <string>
+#include <vector>
+
+class cmXMLWriter;
+
+/** \class cmCTestLaunch
+ * \brief Launcher for make rules to report results for ctest
+ *
+ * This implements the 'ctest --launch' tool.
+ */
+class cmCTestLaunch
+{
+public:
+  /** Entry point from ctest executable main().  */
+  static int Main(int argc, const char* const argv[]);
+
+private:
+  // Initialize the launcher from its command line.
+  cmCTestLaunch(int argc, const char* const* argv);
+  ~cmCTestLaunch();
+
+  // Run the real command.
+  int Run();
+  void RunChild();
+
+  // Methods to check the result of the real command.
+  bool IsError() const;
+  bool CheckResults();
+
+  // Launcher options specified before the real command.
+  std::string OptionOutput;
+  std::string OptionSource;
+  std::string OptionLanguage;
+  std::string OptionTargetName;
+  std::string OptionTargetType;
+  std::string OptionBuildDir;
+  std::string OptionFilterPrefix;
+  bool ParseArguments(int argc, const char* const* argv);
+
+  // The real command line appearing after launcher arguments.
+  int RealArgC;
+  const char* const* RealArgV;
+  std::string CWD;
+
+  // The real command line after response file expansion.
+  std::vector<std::string> RealArgs;
+  void HandleRealArg(const char* arg);
+
+  // A hash of the real command line is unique and unlikely to collide.
+  std::string LogHash;
+  void ComputeFileNames();
+
+  bool Passthru;
+  struct cmsysProcess_s* Process;
+  int ExitCode;
+
+  // Temporary log files for stdout and stderr of real command.
+  std::string LogDir;
+  std::string LogOut;
+  std::string LogErr;
+  bool HaveOut;
+  bool HaveErr;
+
+  // Labels associated with the build rule.
+  std::set<std::string> Labels;
+  void LoadLabels();
+  bool SourceMatches(std::string const& lhs, std::string const& rhs);
+
+  // Regular expressions to match warnings and their exceptions.
+  bool ScrapeRulesLoaded;
+  std::vector<cmsys::RegularExpression> RegexWarning;
+  std::vector<cmsys::RegularExpression> RegexWarningSuppress;
+  void LoadScrapeRules();
+  void LoadScrapeRules(const char* purpose,
+                       std::vector<cmsys::RegularExpression>& regexps);
+  bool ScrapeLog(std::string const& fname);
+  bool Match(std::string const& line,
+             std::vector<cmsys::RegularExpression>& regexps);
+  bool MatchesFilterPrefix(std::string const& line) const;
+
+  // Methods to generate the xml fragment.
+  void WriteXML();
+  void WriteXMLAction(cmXMLWriter& xml);
+  void WriteXMLCommand(cmXMLWriter& xml);
+  void WriteXMLResult(cmXMLWriter& xml);
+  void WriteXMLLabels(cmXMLWriter& xml);
+  void DumpFileToXML(cmXMLWriter& xml, std::string const& fname);
+
+  // Configuration
+  void LoadConfig();
+  std::string SourceDir;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx
new file mode 100644
index 0000000..a5d5995
--- /dev/null
+++ b/Source/CTest/cmCTestMemCheckCommand.cxx
@@ -0,0 +1,54 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestMemCheckCommand.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmCTestMemCheckHandler.h"
+#include "cmMakefile.h"
+
+cmCTestMemCheckCommand::cmCTestMemCheckCommand()
+{
+  this->Arguments[ctm_DEFECT_COUNT] = "DEFECT_COUNT";
+  this->Arguments[ctm_LAST] = nullptr;
+  this->Last = ctm_LAST;
+}
+
+cmCTestGenericHandler* cmCTestMemCheckCommand::InitializeActualHandler()
+{
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("memcheck");
+
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckType", "CTEST_MEMORYCHECK_TYPE", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckSanitizerOptions",
+    "CTEST_MEMORYCHECK_SANITIZER_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckCommandOptions",
+    "CTEST_MEMORYCHECK_COMMAND_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckSuppressionFile",
+    "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE", this->Quiet);
+
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
+
+void cmCTestMemCheckCommand::ProcessAdditionalValues(
+  cmCTestGenericHandler* handler)
+{
+  if (this->Values[ctm_DEFECT_COUNT] && *this->Values[ctm_DEFECT_COUNT]) {
+    std::ostringstream str;
+    str << static_cast<cmCTestMemCheckHandler*>(handler)->GetDefectCount();
+    this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT],
+                                  str.str().c_str());
+  }
+}
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
new file mode 100644
index 0000000..b6b3c40
--- /dev/null
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -0,0 +1,46 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestMemCheckCommand_h
+#define cmCTestMemCheckCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestTestCommand.h"
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestMemCheck
+ * \brief Run a ctest script
+ *
+ * cmCTestMemCheckCommand defineds the command to test the project.
+ */
+class cmCTestMemCheckCommand : public cmCTestTestCommand
+{
+public:
+  cmCTestMemCheckCommand();
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+protected:
+  cmCTestGenericHandler* InitializeActualHandler() override;
+
+  void ProcessAdditionalValues(cmCTestGenericHandler* handler) override;
+
+  enum
+  {
+    ctm_DEFECT_COUNT = ctt_LAST,
+    ctm_LAST
+  };
+};
+
+#endif
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx
new file mode 100644
index 0000000..6b6c337
--- /dev/null
+++ b/Source/CTest/cmCTestMemCheckHandler.cxx
@@ -0,0 +1,1102 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestMemCheckHandler.h"
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+#include "cmXMLWriter.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include "cmsys/RegularExpression.hxx"
+#include <chrono>
+#include <iostream>
+#include <sstream>
+#include <string.h>
+
+struct CatToErrorType
+{
+  const char* ErrorCategory;
+  int ErrorCode;
+};
+
+static CatToErrorType cmCTestMemCheckBoundsChecker[] = {
+  // Error tags
+  { "Write Overrun", cmCTestMemCheckHandler::ABW },
+  { "Read Overrun", cmCTestMemCheckHandler::ABR },
+  { "Memory Overrun", cmCTestMemCheckHandler::ABW },
+  { "Allocation Conflict", cmCTestMemCheckHandler::FMM },
+  { "Bad Pointer Use", cmCTestMemCheckHandler::FMW },
+  { "Dangling Pointer", cmCTestMemCheckHandler::FMR },
+  { nullptr, 0 }
+};
+
+static void xmlReportError(int line, const char* msg, void* data)
+{
+  cmCTest* ctest = static_cast<cmCTest*>(data);
+  cmCTestLog(ctest, ERROR_MESSAGE, "Error parsing XML in stream at line "
+               << line << ": " << msg << std::endl);
+}
+
+// parse the xml file containing the results of last BoundsChecker run
+class cmBoundsCheckerParser : public cmXMLParser
+{
+public:
+  cmBoundsCheckerParser(cmCTest* c)
+  {
+    this->CTest = c;
+    this->SetErrorCallback(xmlReportError, c);
+  }
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    if (name == "MemoryLeak" || name == "ResourceLeak") {
+      this->Errors.push_back(cmCTestMemCheckHandler::MLK);
+    } else if (name == "Error" || name == "Dangling Pointer") {
+      this->ParseError(atts);
+    }
+    // Create the log
+    std::ostringstream ostr;
+    ostr << name << ":\n";
+    int i = 0;
+    for (; atts[i] != nullptr; i += 2) {
+      ostr << "   " << atts[i] << " - " << atts[i + 1] << "\n";
+    }
+    ostr << "\n";
+    this->Log += ostr.str();
+  }
+  void EndElement(const std::string& /*name*/) override {}
+
+  const char* GetAttribute(const char* name, const char** atts)
+  {
+    int i = 0;
+    for (; atts[i] != nullptr; ++i) {
+      if (strcmp(name, atts[i]) == 0) {
+        return atts[i + 1];
+      }
+    }
+    return nullptr;
+  }
+  void ParseError(const char** atts)
+  {
+    CatToErrorType* ptr = cmCTestMemCheckBoundsChecker;
+    const char* cat = this->GetAttribute("ErrorCategory", atts);
+    if (!cat) {
+      this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "No Category found in Bounds checker XML\n");
+      return;
+    }
+    while (ptr->ErrorCategory && cat) {
+      if (strcmp(ptr->ErrorCategory, cat) == 0) {
+        this->Errors.push_back(ptr->ErrorCode);
+        return; // found it we are done
+      }
+      ptr++;
+    }
+    if (ptr->ErrorCategory) {
+      this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Found unknown Bounds Checker error " << ptr->ErrorCategory
+                                                       << std::endl);
+    }
+  }
+  cmCTest* CTest;
+  std::vector<int> Errors;
+  std::string Log;
+};
+
+#define BOUNDS_CHECKER_MARKER                                                 \
+  "******######*****Begin BOUNDS CHECKER XML******######******"
+
+cmCTestMemCheckHandler::cmCTestMemCheckHandler()
+{
+  this->MemCheck = true;
+  this->CustomMaximumPassedTestOutputSize = 0;
+  this->CustomMaximumFailedTestOutputSize = 0;
+  this->LogWithPID = false;
+}
+
+void cmCTestMemCheckHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->LogWithPID = false;
+  this->CustomMaximumPassedTestOutputSize = 0;
+  this->CustomMaximumFailedTestOutputSize = 0;
+  this->MemoryTester.clear();
+  this->MemoryTesterDynamicOptions.clear();
+  this->MemoryTesterOptions.clear();
+  this->MemoryTesterStyle = UNKNOWN;
+  this->MemoryTesterOutputFile.clear();
+  this->DefectCount = 0;
+}
+
+int cmCTestMemCheckHandler::PreProcessHandler()
+{
+  if (!this->InitializeMemoryChecking()) {
+    return 0;
+  }
+
+  if (!this->ExecuteCommands(this->CustomPreMemCheck)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Problem executing pre-memcheck command(s)." << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+int cmCTestMemCheckHandler::PostProcessHandler()
+{
+  if (!this->ExecuteCommands(this->CustomPostMemCheck)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Problem executing post-memcheck command(s)." << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+void cmCTestMemCheckHandler::GenerateTestCommand(
+  std::vector<std::string>& args, int test)
+{
+  std::string index;
+  std::ostringstream stream;
+  std::string memcheckcommand =
+    cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
+  stream << test;
+  index = stream.str();
+  for (std::string arg : this->MemoryTesterDynamicOptions) {
+    std::string::size_type pos = arg.find("??");
+    if (pos != std::string::npos) {
+      arg.replace(pos, 2, index);
+    }
+    args.push_back(arg);
+    memcheckcommand += " \"";
+    memcheckcommand += arg;
+    memcheckcommand += "\"";
+  }
+  // Create a copy of the memory tester environment variable.
+  // This is used for memory testing programs that pass options
+  // via environment variables.
+  std::string memTesterEnvironmentVariable =
+    this->MemoryTesterEnvironmentVariable;
+  for (std::string const& arg : this->MemoryTesterOptions) {
+    if (!memTesterEnvironmentVariable.empty()) {
+      // If we are using env to pass options, append all the options to
+      // this string with space separation.
+      memTesterEnvironmentVariable += " " + arg;
+    }
+    // for regular options just add them to args and memcheckcommand
+    // which is just used for display
+    else {
+      args.push_back(arg);
+      memcheckcommand += " \"";
+      memcheckcommand += arg;
+      memcheckcommand += "\"";
+    }
+  }
+  // if this is an env option type, then add the env string as a single
+  // argument.
+  if (!memTesterEnvironmentVariable.empty()) {
+    std::string::size_type pos = memTesterEnvironmentVariable.find("??");
+    if (pos != std::string::npos) {
+      memTesterEnvironmentVariable.replace(pos, 2, index);
+    }
+    memcheckcommand += " " + memTesterEnvironmentVariable;
+    args.push_back(memTesterEnvironmentVariable);
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Memory check command: " << memcheckcommand << std::endl,
+                     this->Quiet);
+}
+
+void cmCTestMemCheckHandler::InitializeResultsVectors()
+{
+  // fill these members
+  //  cmsys::vector<std::string> ResultStrings;
+  //  cmsys::vector<std::string> ResultStringsLong;
+  //  cmsys::vector<int>         GlobalResults;
+  this->ResultStringsLong.clear();
+  this->ResultStrings.clear();
+  this->GlobalResults.clear();
+  // If we are working with style checkers that dynamically fill
+  // the results strings then return.
+  if (this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER) {
+    return;
+  }
+
+  // define the standard set of errors
+  //----------------------------------------------------------------------
+  static const char* cmCTestMemCheckResultStrings[] = {
+    "ABR", "ABW", "ABWL", "COR", "EXU", "FFM", "FIM",  "FMM",
+    "FMR", "FMW", "FUM",  "IPR", "IPW", "MAF", "MLK",  "MPK",
+    "NPR", "ODS", "PAR",  "PLK", "UMC", "UMR", nullptr
+  };
+  static const char* cmCTestMemCheckResultLongStrings[] = {
+    "Threading Problem",
+    "ABW",
+    "ABWL",
+    "COR",
+    "EXU",
+    "FFM",
+    "FIM",
+    "Mismatched deallocation",
+    "FMR",
+    "FMW",
+    "FUM",
+    "IPR",
+    "IPW",
+    "MAF",
+    "Memory Leak",
+    "Potential Memory Leak",
+    "NPR",
+    "ODS",
+    "Invalid syscall param",
+    "PLK",
+    "Uninitialized Memory Conditional",
+    "Uninitialized Memory Read",
+    nullptr
+  };
+  this->GlobalResults.clear();
+  for (int i = 0; cmCTestMemCheckResultStrings[i] != nullptr; ++i) {
+    this->ResultStrings.push_back(cmCTestMemCheckResultStrings[i]);
+    this->ResultStringsLong.push_back(cmCTestMemCheckResultLongStrings[i]);
+    this->GlobalResults.push_back(0);
+  }
+}
+
+void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile* mf)
+{
+  this->cmCTestTestHandler::PopulateCustomVectors(mf);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK",
+                                    this->CustomPreMemCheck);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK",
+                                    this->CustomPostMemCheck);
+
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_MEMCHECK_IGNORE",
+                                    this->CustomTestsIgnore);
+  std::string cmake = cmSystemTools::GetCMakeCommand();
+  this->CTest->SetCTestConfiguration("CMakeCommand", cmake.c_str(),
+                                     this->Quiet);
+}
+
+int cmCTestMemCheckHandler::GetDefectCount()
+{
+  return this->DefectCount;
+}
+
+void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
+{
+  if (!this->CTest->GetProduceXML()) {
+    return;
+  }
+  this->CTest->StartXML(xml, this->AppendXML);
+  this->CTest->GenerateSubprojectsOutput(xml);
+  xml.StartElement("DynamicAnalysis");
+  switch (this->MemoryTesterStyle) {
+    case cmCTestMemCheckHandler::VALGRIND:
+      xml.Attribute("Checker", "Valgrind");
+      break;
+    case cmCTestMemCheckHandler::PURIFY:
+      xml.Attribute("Checker", "Purify");
+      break;
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
+      xml.Attribute("Checker", "BoundsChecker");
+      break;
+    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
+      xml.Attribute("Checker", "AddressSanitizer");
+      break;
+    case cmCTestMemCheckHandler::LEAK_SANITIZER:
+      xml.Attribute("Checker", "LeakSanitizer");
+      break;
+    case cmCTestMemCheckHandler::THREAD_SANITIZER:
+      xml.Attribute("Checker", "ThreadSanitizer");
+      break;
+    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
+      xml.Attribute("Checker", "MemorySanitizer");
+      break;
+    case cmCTestMemCheckHandler::UB_SANITIZER:
+      xml.Attribute("Checker", "UndefinedBehaviorSanitizer");
+      break;
+    default:
+      xml.Attribute("Checker", "Unknown");
+  }
+
+  xml.Element("StartDateTime", this->StartTest);
+  xml.Element("StartTestTime", this->StartTestTime);
+  xml.StartElement("TestList");
+  cmCTestMemCheckHandler::TestResultsVector::size_type cc;
+  for (cmCTestTestResult const& result : this->TestResults) {
+    std::string testPath = result.Path + "/" + result.Name;
+    xml.Element("Test", this->CTest->GetShortPathToFile(testPath.c_str()));
+  }
+  xml.EndElement(); // TestList
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "-- Processing memory checking output:\n", this->Quiet);
+  size_t total = this->TestResults.size();
+  for (cc = 0; cc < this->TestResults.size(); cc++) {
+    cmCTestTestResult const& result = this->TestResults[cc];
+    std::string memcheckstr;
+    std::vector<int> memcheckresults(this->ResultStrings.size(), 0);
+    bool res =
+      this->ProcessMemCheckOutput(result.Output, memcheckstr, memcheckresults);
+    if (res && result.Status == cmCTestMemCheckHandler::COMPLETED) {
+      continue;
+    }
+    this->CleanTestOutput(
+      memcheckstr,
+      static_cast<size_t>(this->CustomMaximumFailedTestOutputSize));
+    this->WriteTestResultHeader(xml, result);
+    xml.StartElement("Results");
+    int memoryErrors = 0;
+    for (std::vector<int>::size_type kk = 0; kk < memcheckresults.size();
+         ++kk) {
+      if (memcheckresults[kk]) {
+        xml.StartElement("Defect");
+        xml.Attribute("type", this->ResultStringsLong[kk]);
+        xml.Content(memcheckresults[kk]);
+        memoryErrors += memcheckresults[kk];
+        xml.EndElement(); // Defect
+      }
+      this->GlobalResults[kk] += memcheckresults[kk];
+    }
+    xml.EndElement(); // Results
+    if (memoryErrors > 0) {
+      const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
+      std::string outname = result.Name + " ";
+      outname.resize(maxTestNameWidth + 4, '.');
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, cc + 1
+                           << "/" << total << " MemCheck: #"
+                           << result.TestCount << ": " << outname
+                           << "   Defects: " << memoryErrors << std::endl,
+                         this->Quiet);
+    }
+    xml.StartElement("Log");
+    if (this->CTest->ShouldCompressTestOutput()) {
+      this->CTest->CompressString(memcheckstr);
+      xml.Attribute("compression", "gzip");
+      xml.Attribute("encoding", "base64");
+    }
+    xml.Content(memcheckstr);
+    xml.EndElement(); // Log
+
+    this->WriteTestResultFooter(xml, result);
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "MemCheck log files can be found here: "
+                     "( * corresponds to test number)"
+                       << std::endl,
+                     this->Quiet);
+  std::string output = this->MemoryTesterOutputFile;
+  cmSystemTools::ReplaceString(output, "??", "*");
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, output << std::endl,
+                     this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "Memory checking results:" << std::endl, this->Quiet);
+  xml.StartElement("DefectList");
+  for (cc = 0; cc < this->GlobalResults.size(); cc++) {
+    if (this->GlobalResults[cc]) {
+      std::cerr.width(35);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         this->ResultStringsLong[cc]
+                           << " - " << this->GlobalResults[cc] << std::endl,
+                         this->Quiet);
+      xml.StartElement("Defect");
+      xml.Attribute("Type", this->ResultStringsLong[cc]);
+      xml.EndElement();
+    }
+  }
+  xml.EndElement(); // DefectList
+
+  xml.Element("EndDateTime", this->EndTest);
+  xml.Element("EndTestTime", this->EndTestTime);
+  xml.Element(
+    "ElapsedMinutes",
+    std::chrono::duration_cast<std::chrono::minutes>(this->ElapsedTestingTime)
+      .count());
+
+  xml.EndElement(); // DynamicAnalysis
+  this->CTest->EndXML(xml);
+}
+
+bool cmCTestMemCheckHandler::InitializeMemoryChecking()
+{
+  this->MemoryTesterEnvironmentVariable.clear();
+  this->MemoryTester.clear();
+  // Setup the command
+  if (cmSystemTools::FileExists(
+        this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("MemoryCheckCommand");
+    std::string testerName =
+      cmSystemTools::GetFilenameName(this->MemoryTester);
+    // determine the checker type
+    if (testerName.find("valgrind") != std::string::npos ||
+        this->CTest->GetCTestConfiguration("MemoryCheckType") == "Valgrind") {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+    } else if (testerName.find("purify") != std::string::npos) {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
+    } else if (testerName.find("BC") != std::string::npos) {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
+    } else {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::UNKNOWN;
+    }
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("PurifyCommand").c_str())) {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("PurifyCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("ValgrindCommand")
+                 .c_str())) {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("ValgrindCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("BoundsCheckerCommand")
+                 .c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("BoundsCheckerCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "AddressSanitizer") {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("CMakeCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::ADDRESS_SANITIZER;
+    this->LogWithPID = true; // even if we give the log file the pid is added
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "LeakSanitizer") {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("CMakeCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::LEAK_SANITIZER;
+    this->LogWithPID = true; // even if we give the log file the pid is added
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "ThreadSanitizer") {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("CMakeCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::THREAD_SANITIZER;
+    this->LogWithPID = true; // even if we give the log file the pid is added
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "MemorySanitizer") {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("CMakeCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::MEMORY_SANITIZER;
+    this->LogWithPID = true; // even if we give the log file the pid is added
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "UndefinedBehaviorSanitizer") {
+    this->MemoryTester = this->CTest->GetCTestConfiguration("CMakeCommand");
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::UB_SANITIZER;
+    this->LogWithPID = true; // even if we give the log file the pid is added
+  }
+  // Check the MemoryCheckType
+  if (this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN) {
+    std::string checkType =
+      this->CTest->GetCTestConfiguration("MemoryCheckType");
+    if (checkType == "Purify") {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
+    } else if (checkType == "BoundsChecker") {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
+    } else if (checkType == "Valgrind") {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+    }
+  }
+  if (this->MemoryTester.empty()) {
+    cmCTestOptionalLog(this->CTest, WARNING,
+                       "Memory checker (MemoryCheckCommand) "
+                       "not set, or cannot find the specified program."
+                         << std::endl,
+                       this->Quiet);
+    return false;
+  }
+
+  // Setup the options
+  std::string memoryTesterOptions;
+  if (!this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions")
+         .empty()) {
+    memoryTesterOptions =
+      this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions");
+  } else if (!this->CTest->GetCTestConfiguration("ValgrindCommandOptions")
+                .empty()) {
+    memoryTesterOptions =
+      this->CTest->GetCTestConfiguration("ValgrindCommandOptions");
+  }
+  this->MemoryTesterOptions =
+    cmSystemTools::ParseArguments(memoryTesterOptions.c_str());
+
+  this->MemoryTesterOutputFile =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.??.log";
+
+  switch (this->MemoryTesterStyle) {
+    case cmCTestMemCheckHandler::VALGRIND: {
+      if (this->MemoryTesterOptions.empty()) {
+        this->MemoryTesterOptions.push_back("-q");
+        this->MemoryTesterOptions.push_back("--tool=memcheck");
+        this->MemoryTesterOptions.push_back("--leak-check=yes");
+        this->MemoryTesterOptions.push_back("--show-reachable=yes");
+        this->MemoryTesterOptions.push_back("--num-callers=50");
+      }
+      if (!this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+             .empty()) {
+        if (!cmSystemTools::FileExists(
+              this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                .c_str())) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot find memory checker suppression file: "
+                       << this->CTest->GetCTestConfiguration(
+                            "MemoryCheckSuppressionFile")
+                       << std::endl);
+          return false;
+        }
+        std::string suppressions = "--suppressions=" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(suppressions);
+      }
+      std::string outputFile = "--log-file=" + this->MemoryTesterOutputFile;
+      this->MemoryTesterDynamicOptions.push_back(outputFile);
+      break;
+    }
+    case cmCTestMemCheckHandler::PURIFY: {
+      std::string outputFile;
+#ifdef _WIN32
+      if (this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+            .size()) {
+        if (!cmSystemTools::FileExists(
+              this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                .c_str())) {
+          cmCTestLog(
+            this->CTest, ERROR_MESSAGE,
+            "Cannot find memory checker suppression file: "
+              << this->CTest
+                   ->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                   .c_str()
+              << std::endl);
+          return false;
+        }
+        std::string filterFiles = "/FilterFiles=" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(filterFiles);
+      }
+      outputFile = "/SAVETEXTDATA=";
+#else
+      outputFile = "-log-file=";
+#endif
+      outputFile += this->MemoryTesterOutputFile;
+      this->MemoryTesterDynamicOptions.push_back(outputFile);
+      break;
+    }
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER: {
+      this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile;
+      std::string dpbdFile = this->CTest->GetBinaryDir() +
+        "/Testing/Temporary/MemoryChecker.??.DPbd";
+      this->BoundsCheckerDPBDFile = dpbdFile;
+      this->MemoryTesterDynamicOptions.push_back("/B");
+      this->MemoryTesterDynamicOptions.push_back(dpbdFile);
+      this->MemoryTesterDynamicOptions.push_back("/X");
+      this->MemoryTesterDynamicOptions.push_back(this->MemoryTesterOutputFile);
+      this->MemoryTesterOptions.push_back("/M");
+      break;
+    }
+    // these are almost the same but the env var used is different
+    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
+    case cmCTestMemCheckHandler::LEAK_SANITIZER:
+    case cmCTestMemCheckHandler::THREAD_SANITIZER:
+    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
+    case cmCTestMemCheckHandler::UB_SANITIZER: {
+      // To pass arguments to ThreadSanitizer the environment variable
+      // TSAN_OPTIONS is used. This is done with the cmake -E env command.
+      // The MemoryTesterDynamicOptions is setup with the -E env
+      // Then the MemoryTesterEnvironmentVariable gets the
+      // TSAN_OPTIONS string with the log_path in it.
+      this->MemoryTesterDynamicOptions.push_back("-E");
+      this->MemoryTesterDynamicOptions.push_back("env");
+      std::string envVar;
+      std::string extraOptions;
+      std::string suppressionsOption;
+      if (!this->CTest->GetCTestConfiguration("MemoryCheckSanitizerOptions")
+             .empty()) {
+        extraOptions = ":" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSanitizerOptions");
+      }
+      if (!this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+             .empty()) {
+        suppressionsOption = ":suppressions=" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+      }
+      if (this->MemoryTesterStyle ==
+          cmCTestMemCheckHandler::ADDRESS_SANITIZER) {
+        envVar = "ASAN_OPTIONS";
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::LEAK_SANITIZER) {
+        envVar = "LSAN_OPTIONS";
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::THREAD_SANITIZER) {
+        envVar = "TSAN_OPTIONS";
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::MEMORY_SANITIZER) {
+        envVar = "MSAN_OPTIONS";
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::UB_SANITIZER) {
+        envVar = "UBSAN_OPTIONS";
+      }
+      // Quote log_path with single quotes; see
+      // https://bugs.chromium.org/p/chromium/issues/detail?id=467936
+      std::string outputFile =
+        envVar + "=log_path='" + this->MemoryTesterOutputFile + "'";
+      this->MemoryTesterEnvironmentVariable =
+        outputFile + suppressionsOption + extraOptions;
+      break;
+    }
+    default:
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Do not understand memory checker: " << this->MemoryTester
+                                                      << std::endl);
+      return false;
+  }
+
+  this->InitializeResultsVectors();
+  // std::vector<std::string>::size_type cc;
+  // for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
+  //   {
+  //   this->MemoryTesterGlobalResults[cc] = 0;
+  //   }
+  return true;
+}
+
+bool cmCTestMemCheckHandler::ProcessMemCheckOutput(const std::string& str,
+                                                   std::string& log,
+                                                   std::vector<int>& results)
+{
+  switch (this->MemoryTesterStyle) {
+    case cmCTestMemCheckHandler::VALGRIND:
+      return this->ProcessMemCheckValgrindOutput(str, log, results);
+    case cmCTestMemCheckHandler::PURIFY:
+      return this->ProcessMemCheckPurifyOutput(str, log, results);
+    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
+    case cmCTestMemCheckHandler::LEAK_SANITIZER:
+    case cmCTestMemCheckHandler::THREAD_SANITIZER:
+    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
+    case cmCTestMemCheckHandler::UB_SANITIZER:
+      return this->ProcessMemCheckSanitizerOutput(str, log, results);
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
+      return this->ProcessMemCheckBoundsCheckerOutput(str, log, results);
+    default:
+      log.append("\nMemory checking style used was: ");
+      log.append("None that I know");
+      log = str;
+      return true;
+  }
+}
+
+std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning(
+  const std::string& warning)
+{
+  for (std::vector<std::string>::size_type i = 0;
+       i < this->ResultStrings.size(); ++i) {
+    if (this->ResultStrings[i] == warning) {
+      return i;
+    }
+  }
+  this->GlobalResults.push_back(0); // this must stay the same size
+  this->ResultStrings.push_back(warning);
+  this->ResultStringsLong.push_back(warning);
+  return this->ResultStrings.size() - 1;
+}
+bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
+  const std::string& str, std::string& log, std::vector<int>& result)
+{
+  std::string regex;
+  switch (this->MemoryTesterStyle) {
+    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
+      regex = "ERROR: AddressSanitizer: (.*) on.*";
+      break;
+    case cmCTestMemCheckHandler::LEAK_SANITIZER:
+      // use leakWarning regex
+      break;
+    case cmCTestMemCheckHandler::THREAD_SANITIZER:
+      regex = "WARNING: ThreadSanitizer: (.*) \\(pid=.*\\)";
+      break;
+    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
+      regex = "WARNING: MemorySanitizer: (.*)";
+      break;
+    case cmCTestMemCheckHandler::UB_SANITIZER:
+      regex = "runtime error: (.*)";
+      break;
+    default:
+      break;
+  }
+  cmsys::RegularExpression sanitizerWarning(regex);
+  cmsys::RegularExpression leakWarning("(Direct|Indirect) leak of .*");
+  int defects = 0;
+  std::vector<std::string> lines;
+  cmSystemTools::Split(str.c_str(), lines);
+  std::ostringstream ostr;
+  log.clear();
+  for (std::string const& l : lines) {
+    std::string resultFound;
+    if (leakWarning.find(l)) {
+      resultFound = leakWarning.match(1) + " leak";
+    } else if (sanitizerWarning.find(l)) {
+      resultFound = sanitizerWarning.match(1);
+    }
+    if (!resultFound.empty()) {
+      std::vector<int>::size_type idx = this->FindOrAddWarning(resultFound);
+      if (result.empty() || idx > result.size() - 1) {
+        result.push_back(1);
+      } else {
+        result[idx]++;
+      }
+      defects++;
+      ostr << "<b>" << this->ResultStrings[idx] << "</b> ";
+    }
+    ostr << l << std::endl;
+  }
+  log = ostr.str();
+  this->DefectCount += defects;
+  return defects == 0;
+}
+bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
+  const std::string& str, std::string& log, std::vector<int>& results)
+{
+  std::vector<std::string> lines;
+  cmSystemTools::Split(str.c_str(), lines);
+  std::ostringstream ostr;
+  log.clear();
+
+  cmsys::RegularExpression pfW("^\\[[WEI]\\] ([A-Z][A-Z][A-Z][A-Z]*): ");
+
+  int defects = 0;
+
+  for (std::string const& l : lines) {
+    std::vector<int>::size_type failure = this->ResultStrings.size();
+    if (pfW.find(l)) {
+      std::vector<int>::size_type cc;
+      for (cc = 0; cc < this->ResultStrings.size(); cc++) {
+        if (pfW.match(1) == this->ResultStrings[cc]) {
+          failure = cc;
+          break;
+        }
+      }
+      if (cc == this->ResultStrings.size()) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
+                     << pfW.match(1) << std::endl);
+        ostr << "*** Unknown Purify memory fault: " << pfW.match(1)
+             << std::endl;
+      }
+    }
+    if (failure != this->ResultStrings.size()) {
+      ostr << "<b>" << this->ResultStrings[failure] << "</b> ";
+      results[failure]++;
+      defects++;
+    }
+    ostr << l << std::endl;
+  }
+
+  log = ostr.str();
+  this->DefectCount += defects;
+  return defects == 0;
+}
+
+bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
+  const std::string& str, std::string& log, std::vector<int>& results)
+{
+  std::vector<std::string> lines;
+  cmSystemTools::Split(str.c_str(), lines);
+  bool unlimitedOutput = false;
+  if (str.find("CTEST_FULL_OUTPUT") != std::string::npos ||
+      this->CustomMaximumFailedTestOutputSize == 0) {
+    unlimitedOutput = true;
+  }
+
+  std::string::size_type cc;
+
+  std::ostringstream ostr;
+  log.clear();
+
+  int defects = 0;
+
+  cmsys::RegularExpression valgrindLine("^==[0-9][0-9]*==");
+
+  cmsys::RegularExpression vgFIM(
+    "== .*Invalid free\\(\\) / delete / delete\\[\\]");
+  cmsys::RegularExpression vgFMM(
+    "== .*Mismatched free\\(\\) / delete / delete \\[\\]");
+  cmsys::RegularExpression vgMLK1(
+    "== .*[0-9,]+ bytes in [0-9,]+ blocks are definitely lost"
+    " in loss record [0-9,]+ of [0-9,]+");
+  cmsys::RegularExpression vgMLK2(
+    "== .*[0-9,]+ \\([0-9,]+ direct, [0-9,]+ indirect\\)"
+    " bytes in [0-9,]+ blocks are definitely lost"
+    " in loss record [0-9,]+ of [0-9,]+");
+  cmsys::RegularExpression vgPAR(
+    "== .*Syscall param .* (contains|points to) unaddressable byte\\(s\\)");
+  cmsys::RegularExpression vgMPK1(
+    "== .*[0-9,]+ bytes in [0-9,]+ blocks are possibly lost in"
+    " loss record [0-9,]+ of [0-9,]+");
+  cmsys::RegularExpression vgMPK2(
+    "== .*[0-9,]+ bytes in [0-9,]+ blocks are still reachable"
+    " in loss record [0-9,]+ of [0-9,]+");
+  cmsys::RegularExpression vgUMC(
+    "== .*Conditional jump or move depends on uninitialised value\\(s\\)");
+  cmsys::RegularExpression vgUMR1(
+    "== .*Use of uninitialised value of size [0-9,]+");
+  cmsys::RegularExpression vgUMR2("== .*Invalid read of size [0-9,]+");
+  cmsys::RegularExpression vgUMR3("== .*Jump to the invalid address ");
+  cmsys::RegularExpression vgUMR4(
+    "== .*Syscall param .* contains "
+    "uninitialised or unaddressable byte\\(s\\)");
+  cmsys::RegularExpression vgUMR5("== .*Syscall param .* uninitialised");
+  cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9,]+");
+  cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is "
+                                 "locked by a different thread");
+  std::vector<std::string::size_type> nonValGrindOutput;
+  auto sttime = std::chrono::steady_clock::now();
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Start test: " << lines.size() << std::endl, this->Quiet);
+  std::string::size_type totalOutputSize = 0;
+  for (cc = 0; cc < lines.size(); cc++) {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "test line " << lines[cc] << std::endl, this->Quiet);
+
+    if (valgrindLine.find(lines[cc])) {
+      cmCTestOptionalLog(this->CTest, DEBUG,
+                         "valgrind  line " << lines[cc] << std::endl,
+                         this->Quiet);
+      int failure = cmCTestMemCheckHandler::NO_MEMORY_FAULT;
+      if (vgFIM.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::FIM;
+      } else if (vgFMM.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::FMM;
+      } else if (vgMLK1.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::MLK;
+      } else if (vgMLK2.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::MLK;
+      } else if (vgPAR.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::PAR;
+      } else if (vgMPK1.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::MPK;
+      } else if (vgMPK2.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::MPK;
+      } else if (vgUMC.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMC;
+      } else if (vgUMR1.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMR;
+      } else if (vgUMR2.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMR;
+      } else if (vgUMR3.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMR;
+      } else if (vgUMR4.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMR;
+      } else if (vgUMR5.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::UMR;
+      } else if (vgIPW.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::IPW;
+      } else if (vgABR.find(lines[cc])) {
+        failure = cmCTestMemCheckHandler::ABR;
+      }
+
+      if (failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT) {
+        ostr << "<b>" << this->ResultStrings[failure] << "</b> ";
+        results[failure]++;
+        defects++;
+      }
+      totalOutputSize += lines[cc].size();
+      ostr << lines[cc] << std::endl;
+    } else {
+      nonValGrindOutput.push_back(cc);
+    }
+  }
+  // Now put all all the non valgrind output into the test output
+  // This should be last in case it gets truncated by the output
+  // limiting code
+  for (std::string::size_type i : nonValGrindOutput) {
+    totalOutputSize += lines[i].size();
+    ostr << lines[i] << std::endl;
+    if (!unlimitedOutput &&
+        totalOutputSize >
+          static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) {
+      ostr << "....\n";
+      ostr << "Test Output for this test has been truncated see testing"
+              " machine logs for full output,\n";
+      ostr << "or put CTEST_FULL_OUTPUT in the output of "
+              "this test program.\n";
+      break; // stop the copy of output if we are full
+    }
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: "
+                       << std::chrono::duration_cast<std::chrono::seconds>(
+                            std::chrono::steady_clock::now() - sttime)
+                            .count()
+                       << "s)" << std::endl,
+                     this->Quiet);
+  log = ostr.str();
+  this->DefectCount += defects;
+  return defects == 0;
+}
+
+bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
+  const std::string& str, std::string& log, std::vector<int>& results)
+{
+  log.clear();
+  auto sttime = std::chrono::steady_clock::now();
+  std::vector<std::string> lines;
+  cmSystemTools::Split(str.c_str(), lines);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Start test: " << lines.size() << std::endl, this->Quiet);
+  std::vector<std::string>::size_type cc;
+  for (cc = 0; cc < lines.size(); cc++) {
+    if (lines[cc] == BOUNDS_CHECKER_MARKER) {
+      break;
+    }
+  }
+  cmBoundsCheckerParser parser(this->CTest);
+  parser.InitializeParser();
+  if (cc < lines.size()) {
+    for (cc++; cc < lines.size(); ++cc) {
+      std::string& theLine = lines[cc];
+      // check for command line arguments that are not escaped
+      // correctly by BC
+      if (theLine.find("TargetArgs=") != std::string::npos) {
+        // skip this because BC gets it wrong and we can't parse it
+      } else if (!parser.ParseChunk(theLine.c_str(), theLine.size())) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Error in ParseChunk: " << theLine << std::endl);
+      }
+    }
+  }
+  int defects = 0;
+  for (int err : parser.Errors) {
+    results[err]++;
+    defects++;
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: "
+                       << std::chrono::duration_cast<std::chrono::seconds>(
+                            std::chrono::steady_clock::now() - sttime)
+                            .count()
+                       << "s)" << std::endl,
+                     this->Quiet);
+  if (defects) {
+    // only put the output of Bounds Checker if there were
+    // errors or leaks detected
+    log = parser.Log;
+  }
+  this->DefectCount += defects;
+  return defects == 0;
+}
+
+// PostProcessTest memcheck results
+void cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res, int test)
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "PostProcessTest memcheck results for : " << res.Name
+                                                               << std::endl,
+                     this->Quiet);
+  if (this->MemoryTesterStyle == cmCTestMemCheckHandler::BOUNDS_CHECKER) {
+    this->PostProcessBoundsCheckerTest(res, test);
+  } else {
+    std::vector<std::string> files;
+    this->TestOutputFileNames(test, files);
+    for (std::string const& f : files) {
+      this->AppendMemTesterOutput(res, f);
+    }
+  }
+}
+
+// This method puts the bounds checker output file into the output
+// for the test
+void cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(
+  cmCTestTestResult& res, int test)
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "PostProcessBoundsCheckerTest for : " << res.Name
+                                                           << std::endl,
+                     this->Quiet);
+  std::vector<std::string> files;
+  this->TestOutputFileNames(test, files);
+  if (files.empty()) {
+    return;
+  }
+  std::string ofile = files[0];
+  if (ofile.empty()) {
+    return;
+  }
+  // put a scope around this to close ifs so the file can be removed
+  {
+    cmsys::ifstream ifs(ofile.c_str());
+    if (!ifs) {
+      std::string log = "Cannot read memory tester output file: " + ofile;
+      cmCTestLog(this->CTest, ERROR_MESSAGE, log << std::endl);
+      return;
+    }
+    res.Output += BOUNDS_CHECKER_MARKER;
+    res.Output += "\n";
+    std::string line;
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      res.Output += line;
+      res.Output += "\n";
+    }
+  }
+  cmSystemTools::Delay(1000);
+  cmSystemTools::RemoveFile(this->BoundsCheckerDPBDFile);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Remove: " << this->BoundsCheckerDPBDFile << std::endl,
+                     this->Quiet);
+  cmSystemTools::RemoveFile(this->BoundsCheckerXMLFile);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Remove: " << this->BoundsCheckerXMLFile << std::endl,
+                     this->Quiet);
+}
+
+void cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res,
+                                                   std::string const& ofile)
+{
+  if (ofile.empty()) {
+    return;
+  }
+  // put ifs in scope so file can be deleted if needed
+  {
+    cmsys::ifstream ifs(ofile.c_str());
+    if (!ifs) {
+      std::string log = "Cannot read memory tester output file: " + ofile;
+      cmCTestLog(this->CTest, ERROR_MESSAGE, log << std::endl);
+      return;
+    }
+    std::string line;
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      res.Output += line;
+      res.Output += "\n";
+    }
+  }
+  if (this->LogWithPID) {
+    cmSystemTools::RemoveFile(ofile);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Remove: " << ofile << "\n", this->Quiet);
+  }
+}
+
+void cmCTestMemCheckHandler::TestOutputFileNames(
+  int test, std::vector<std::string>& files)
+{
+  std::string index;
+  std::ostringstream stream;
+  stream << test;
+  index = stream.str();
+  std::string ofile = this->MemoryTesterOutputFile;
+  std::string::size_type pos = ofile.find("??");
+  ofile.replace(pos, 2, index);
+  if (this->LogWithPID) {
+    ofile += ".*";
+    cmsys::Glob g;
+    g.FindFiles(ofile);
+    if (g.GetFiles().empty()) {
+      std::string log = "Cannot find memory tester output file: " + ofile;
+      cmCTestLog(this->CTest, ERROR_MESSAGE, log << std::endl);
+      ofile.clear();
+    } else {
+      files = g.GetFiles();
+      return;
+    }
+  } else if (!cmSystemTools::FileExists(ofile.c_str())) {
+    std::string log = "Cannot find memory tester output file: " + ofile;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, log << std::endl);
+    ofile.clear();
+  }
+  files.push_back(ofile);
+}
diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h
new file mode 100644
index 0000000..9218294
--- /dev/null
+++ b/Source/CTest/cmCTestMemCheckHandler.h
@@ -0,0 +1,154 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestMemCheckHandler_h
+#define cmCTestMemCheckHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestTestHandler.h"
+
+#include <string>
+#include <vector>
+
+class cmMakefile;
+class cmXMLWriter;
+
+/** \class cmCTestMemCheckHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestMemCheckHandler : public cmCTestTestHandler
+{
+  friend class cmCTestRunTest;
+
+public:
+  typedef cmCTestTestHandler Superclass;
+
+  void PopulateCustomVectors(cmMakefile* mf) override;
+
+  cmCTestMemCheckHandler();
+
+  void Initialize() override;
+
+  int GetDefectCount();
+
+protected:
+  int PreProcessHandler() override;
+  int PostProcessHandler() override;
+  void GenerateTestCommand(std::vector<std::string>& args, int test) override;
+
+private:
+  enum
+  { // Memory checkers
+    UNKNOWN = 0,
+    VALGRIND,
+    PURIFY,
+    BOUNDS_CHECKER,
+    // checkers after here do not use the standard error list
+    ADDRESS_SANITIZER,
+    LEAK_SANITIZER,
+    THREAD_SANITIZER,
+    MEMORY_SANITIZER,
+    UB_SANITIZER
+  };
+
+public:
+  enum
+  { // Memory faults
+    ABR = 0,
+    ABW,
+    ABWL,
+    COR,
+    EXU,
+    FFM,
+    FIM,
+    FMM,
+    FMR,
+    FMW,
+    FUM,
+    IPR,
+    IPW,
+    MAF,
+    MLK,
+    MPK,
+    NPR,
+    ODS,
+    PAR,
+    PLK,
+    UMC,
+    UMR,
+    NO_MEMORY_FAULT
+  };
+
+private:
+  enum
+  { // Program statuses
+    NOT_RUN = 0,
+    TIMEOUT,
+    SEGFAULT,
+    ILLEGAL,
+    INTERRUPT,
+    NUMERICAL,
+    OTHER_FAULT,
+    FAILED,
+    BAD_COMMAND,
+    COMPLETED
+  };
+  std::string BoundsCheckerDPBDFile;
+  std::string BoundsCheckerXMLFile;
+  std::string MemoryTester;
+  std::vector<std::string> MemoryTesterDynamicOptions;
+  std::vector<std::string> MemoryTesterOptions;
+  int MemoryTesterStyle;
+  std::string MemoryTesterOutputFile;
+  std::string MemoryTesterEnvironmentVariable;
+  // these are used to store the types of errors that can show up
+  std::vector<std::string> ResultStrings;
+  std::vector<std::string> ResultStringsLong;
+  std::vector<int> GlobalResults;
+  bool LogWithPID; // does log file add pid
+  int DefectCount;
+
+  std::vector<int>::size_type FindOrAddWarning(const std::string& warning);
+  // initialize the ResultStrings and ResultStringsLong for
+  // this type of checker
+  void InitializeResultsVectors();
+
+  ///! Initialize memory checking subsystem.
+  bool InitializeMemoryChecking();
+
+  /**
+   * Generate the Dart compatible output
+   */
+  void GenerateDartOutput(cmXMLWriter& xml) override;
+
+  std::vector<std::string> CustomPreMemCheck;
+  std::vector<std::string> CustomPostMemCheck;
+
+  //! Parse Valgrind/Purify/Bounds Checker result out of the output
+  // string. After running, log holds the output and results hold the
+  // different memmory errors.
+  bool ProcessMemCheckOutput(const std::string& str, std::string& log,
+                             std::vector<int>& results);
+  bool ProcessMemCheckValgrindOutput(const std::string& str, std::string& log,
+                                     std::vector<int>& results);
+  bool ProcessMemCheckPurifyOutput(const std::string& str, std::string& log,
+                                   std::vector<int>& results);
+  bool ProcessMemCheckSanitizerOutput(const std::string& str, std::string& log,
+                                      std::vector<int>& results);
+  bool ProcessMemCheckBoundsCheckerOutput(const std::string& str,
+                                          std::string& log,
+                                          std::vector<int>& results);
+
+  void PostProcessTest(cmCTestTestResult& res, int test);
+  void PostProcessBoundsCheckerTest(cmCTestTestResult& res, int test);
+
+  ///! append MemoryTesterOutputFile to the test log
+  void AppendMemTesterOutput(cmCTestTestHandler::cmCTestTestResult& res,
+                             std::string const& filename);
+
+  ///! generate the output filename for the given test index
+  void TestOutputFileNames(int test, std::vector<std::string>& files);
+};
+
+#endif
diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx
new file mode 100644
index 0000000..53c47a2
--- /dev/null
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -0,0 +1,855 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestMultiProcessHandler.h"
+
+#include "cmCTest.h"
+#include "cmCTestRunTest.h"
+#include "cmCTestScriptHandler.h"
+#include "cmCTestTestHandler.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+
+#include "cm_uv.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/String.hxx"
+#include "cmsys/SystemInformation.hxx"
+
+#include <algorithm>
+#include <chrono>
+#include <iomanip>
+#include <list>
+#include <math.h>
+#include <sstream>
+#include <stack>
+#include <stdlib.h>
+#include <utility>
+
+#if defined(CMAKE_USE_SYSTEM_LIBUV) && !defined(_WIN32) &&                    \
+  UV_VERSION_MAJOR == 1 && UV_VERSION_MINOR < 19
+#define CMAKE_UV_SIGNAL_HACK
+/*
+   libuv does not use SA_RESTART on its signal handler, but C++ streams
+   depend on it for reliable i/o operations.  This RAII helper convinces
+   libuv to install its handler, and then revises the handler to add the
+   SA_RESTART flag.  We use a distinct uv loop that never runs to avoid
+   ever really getting a callback.  libuv may fill the hack loop's signal
+   pipe and then stop writing, but that won't break any real loops.
+ */
+class cmUVSignalHackRAII
+{
+  uv_loop_t HackLoop;
+  cm::uv_signal_ptr HackSignal;
+  static void HackCB(uv_signal_t*, int) {}
+public:
+  cmUVSignalHackRAII()
+  {
+    uv_loop_init(&this->HackLoop);
+    this->HackSignal.init(this->HackLoop);
+    this->HackSignal.start(HackCB, SIGCHLD);
+    struct sigaction hack_sa;
+    sigaction(SIGCHLD, NULL, &hack_sa);
+    if (!(hack_sa.sa_flags & SA_RESTART)) {
+      hack_sa.sa_flags |= SA_RESTART;
+      sigaction(SIGCHLD, &hack_sa, NULL);
+    }
+  }
+  ~cmUVSignalHackRAII()
+  {
+    this->HackSignal.stop();
+    uv_loop_close(&this->HackLoop);
+  }
+};
+#endif
+
+class TestComparator
+{
+public:
+  TestComparator(cmCTestMultiProcessHandler* handler)
+    : Handler(handler)
+  {
+  }
+  ~TestComparator() {}
+
+  // Sorts tests in descending order of cost
+  bool operator()(int index1, int index2) const
+  {
+    return Handler->Properties[index1]->Cost >
+      Handler->Properties[index2]->Cost;
+  }
+
+private:
+  cmCTestMultiProcessHandler* Handler;
+};
+
+cmCTestMultiProcessHandler::cmCTestMultiProcessHandler()
+{
+  this->ParallelLevel = 1;
+  this->TestLoad = 0;
+  this->Completed = 0;
+  this->RunningCount = 0;
+  this->StopTimePassed = false;
+  this->HasCycles = false;
+  this->SerialTestRunning = false;
+}
+
+cmCTestMultiProcessHandler::~cmCTestMultiProcessHandler()
+{
+}
+
+// Set the tests
+void cmCTestMultiProcessHandler::SetTests(TestMap& tests,
+                                          PropertiesMap& properties)
+{
+  this->Tests = tests;
+  this->Properties = properties;
+  this->Total = this->Tests.size();
+  // set test run map to false for all
+  for (auto const& t : this->Tests) {
+    this->TestRunningMap[t.first] = false;
+    this->TestFinishMap[t.first] = false;
+  }
+  if (!this->CTest->GetShowOnly()) {
+    this->ReadCostData();
+    this->HasCycles = !this->CheckCycles();
+    if (this->HasCycles) {
+      return;
+    }
+    this->CreateTestCostList();
+  }
+}
+
+// Set the max number of tests that can be run at the same time.
+void cmCTestMultiProcessHandler::SetParallelLevel(size_t level)
+{
+  this->ParallelLevel = level < 1 ? 1 : level;
+}
+
+void cmCTestMultiProcessHandler::SetTestLoad(unsigned long load)
+{
+  this->TestLoad = load;
+}
+
+void cmCTestMultiProcessHandler::RunTests()
+{
+  this->CheckResume();
+  if (this->HasCycles) {
+    return;
+  }
+#ifdef CMAKE_UV_SIGNAL_HACK
+  cmUVSignalHackRAII hackRAII;
+#endif
+  this->TestHandler->SetMaxIndex(this->FindMaxIndex());
+
+  uv_loop_init(&this->Loop);
+  this->StartNextTests();
+  uv_run(&this->Loop, UV_RUN_DEFAULT);
+  uv_loop_close(&this->Loop);
+
+  this->MarkFinished();
+  this->UpdateCostData();
+}
+
+bool cmCTestMultiProcessHandler::StartTestProcess(int test)
+{
+  std::chrono::system_clock::time_point stop_time = this->CTest->GetStopTime();
+  if (stop_time != std::chrono::system_clock::time_point() &&
+      stop_time <= std::chrono::system_clock::now()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "The stop time has been passed. "
+                                           "Stopping all tests."
+                 << std::endl);
+    this->StopTimePassed = true;
+    return false;
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "test " << test << "\n", this->Quiet);
+  this->TestRunningMap[test] = true; // mark the test as running
+  // now remove the test itself
+  this->EraseTest(test);
+  this->RunningCount += GetProcessorsUsed(test);
+
+  cmCTestRunTest* testRun = new cmCTestRunTest(*this);
+  if (this->CTest->GetRepeatUntilFail()) {
+    testRun->SetRunUntilFailOn();
+    testRun->SetNumberOfRuns(this->CTest->GetTestRepeat());
+  }
+  testRun->SetIndex(test);
+  testRun->SetTestProperties(this->Properties[test]);
+
+  // Find any failed dependencies for this test. We assume the more common
+  // scenario has no failed tests, so make it the outer loop.
+  for (std::string const& f : *this->Failed) {
+    if (this->Properties[test]->RequireSuccessDepends.find(f) !=
+        this->Properties[test]->RequireSuccessDepends.end()) {
+      testRun->AddFailedDependency(f);
+    }
+  }
+
+  cmWorkingDirectory workdir(this->Properties[test]->Directory);
+
+  // Lock the resources we'll be using
+  this->LockResources(test);
+
+  if (testRun->StartTest(this->Total)) {
+    return true;
+  }
+
+  this->FinishTestProcess(testRun, false);
+  return false;
+}
+
+void cmCTestMultiProcessHandler::LockResources(int index)
+{
+  this->LockedResources.insert(
+    this->Properties[index]->LockedResources.begin(),
+    this->Properties[index]->LockedResources.end());
+
+  if (this->Properties[index]->RunSerial) {
+    this->SerialTestRunning = true;
+  }
+}
+
+void cmCTestMultiProcessHandler::UnlockResources(int index)
+{
+  for (std::string const& i : this->Properties[index]->LockedResources) {
+    this->LockedResources.erase(i);
+  }
+  if (this->Properties[index]->RunSerial) {
+    this->SerialTestRunning = false;
+  }
+}
+
+void cmCTestMultiProcessHandler::EraseTest(int test)
+{
+  this->Tests.erase(test);
+  this->SortedTests.erase(
+    std::find(this->SortedTests.begin(), this->SortedTests.end(), test));
+}
+
+inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test)
+{
+  size_t processors = static_cast<int>(this->Properties[test]->Processors);
+  // If processors setting is set higher than the -j
+  // setting, we default to using all of the process slots.
+  if (processors > this->ParallelLevel) {
+    processors = this->ParallelLevel;
+  }
+  return processors;
+}
+
+std::string cmCTestMultiProcessHandler::GetName(int test)
+{
+  return this->Properties[test]->Name;
+}
+
+bool cmCTestMultiProcessHandler::StartTest(int test)
+{
+  // Check for locked resources
+  for (std::string const& i : this->Properties[test]->LockedResources) {
+    if (this->LockedResources.find(i) != this->LockedResources.end()) {
+      return false;
+    }
+  }
+
+  // if there are no depends left then run this test
+  if (this->Tests[test].empty()) {
+    return this->StartTestProcess(test);
+  }
+  // This test was not able to start because it is waiting
+  // on depends to run
+  return false;
+}
+
+void cmCTestMultiProcessHandler::StartNextTests()
+{
+  size_t numToStart = 0;
+
+  if (this->Tests.empty()) {
+    return;
+  }
+
+  if (this->RunningCount < this->ParallelLevel) {
+    numToStart = this->ParallelLevel - this->RunningCount;
+  }
+
+  if (numToStart == 0) {
+    return;
+  }
+
+  // Don't start any new tests if one with the RUN_SERIAL property
+  // is already running.
+  if (this->SerialTestRunning) {
+    return;
+  }
+
+  bool allTestsFailedTestLoadCheck = false;
+  bool usedFakeLoadForTesting = false;
+  size_t minProcessorsRequired = this->ParallelLevel;
+  std::string testWithMinProcessors;
+
+  cmsys::SystemInformation info;
+
+  unsigned long systemLoad = 0;
+  size_t spareLoad = 0;
+  if (this->TestLoad > 0) {
+    // Activate possible wait.
+    allTestsFailedTestLoadCheck = true;
+
+    // Check for a fake load average value used in testing.
+    std::string fake_load_value;
+    if (cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING",
+                              fake_load_value)) {
+      usedFakeLoadForTesting = true;
+      if (!cmSystemTools::StringToULong(fake_load_value.c_str(),
+                                        &systemLoad)) {
+        cmSystemTools::Error("Failed to parse fake load value: ",
+                             fake_load_value.c_str());
+      }
+    }
+    // If it's not set, look up the true load average.
+    else {
+      systemLoad = static_cast<unsigned long>(ceil(info.GetLoadAverage()));
+    }
+    spareLoad =
+      (this->TestLoad > systemLoad ? this->TestLoad - systemLoad : 0);
+
+    // Don't start more tests than the spare load can support.
+    if (numToStart > spareLoad) {
+      numToStart = spareLoad;
+    }
+  }
+
+  TestList copy = this->SortedTests;
+  for (auto const& test : copy) {
+    // Take a nap if we're currently performing a RUN_SERIAL test.
+    if (this->SerialTestRunning) {
+      break;
+    }
+    // We can only start a RUN_SERIAL test if no other tests are also running.
+    if (this->Properties[test]->RunSerial && this->RunningCount > 0) {
+      continue;
+    }
+
+    size_t processors = GetProcessorsUsed(test);
+    bool testLoadOk = true;
+    if (this->TestLoad > 0) {
+      if (processors <= spareLoad) {
+        cmCTestLog(this->CTest, DEBUG, "OK to run "
+                     << GetName(test) << ", it requires " << processors
+                     << " procs & system load is: " << systemLoad
+                     << std::endl);
+        allTestsFailedTestLoadCheck = false;
+      } else {
+        testLoadOk = false;
+      }
+    }
+
+    if (processors <= minProcessorsRequired) {
+      minProcessorsRequired = processors;
+      testWithMinProcessors = GetName(test);
+    }
+
+    if (testLoadOk && processors <= numToStart && this->StartTest(test)) {
+      if (this->StopTimePassed) {
+        return;
+      }
+
+      numToStart -= processors;
+    } else if (numToStart == 0) {
+      break;
+    }
+  }
+
+  if (allTestsFailedTestLoadCheck) {
+    // Find out whether there are any non RUN_SERIAL tests left, so that the
+    // correct warning may be displayed.
+    bool onlyRunSerialTestsLeft = true;
+    for (auto const& test : copy) {
+      if (!this->Properties[test]->RunSerial) {
+        onlyRunSerialTestsLeft = false;
+      }
+    }
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "***** WAITING, ");
+
+    if (this->SerialTestRunning) {
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "Waiting for RUN_SERIAL test to finish.");
+    } else if (onlyRunSerialTestsLeft) {
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "Only RUN_SERIAL tests remain, awaiting available slot.");
+    } else {
+      /* clang-format off */
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "System Load: " << systemLoad << ", "
+                 "Max Allowed Load: " << this->TestLoad << ", "
+                 "Smallest test " << testWithMinProcessors <<
+                 " requires " << minProcessorsRequired);
+      /* clang-format on */
+    }
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "*****" << std::endl);
+
+    if (usedFakeLoadForTesting) {
+      // Break out of the infinite loop of waiting for our fake load
+      // to come down.
+      this->StopTimePassed = true;
+    } else {
+      // Wait between 1 and 5 seconds before trying again.
+      cmCTestScriptHandler::SleepInSeconds(cmSystemTools::RandomSeed() % 5 +
+                                           1);
+    }
+  }
+}
+
+void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner,
+                                                   bool started)
+{
+  this->Completed++;
+
+  int test = runner->GetIndex();
+  auto properties = runner->GetTestProperties();
+
+  bool testResult = runner->EndTest(this->Completed, this->Total, started);
+  if (started) {
+    if (runner->StartAgain()) {
+      this->Completed--; // remove the completed test because run again
+      return;
+    }
+  }
+
+  if (testResult) {
+    this->Passed->push_back(properties->Name);
+  } else if (!properties->Disabled) {
+    this->Failed->push_back(properties->Name);
+  }
+
+  for (auto& t : this->Tests) {
+    t.second.erase(test);
+  }
+
+  this->TestFinishMap[test] = true;
+  this->TestRunningMap[test] = false;
+  this->WriteCheckpoint(test);
+  this->UnlockResources(test);
+  this->RunningCount -= GetProcessorsUsed(test);
+
+  delete runner;
+  if (started) {
+    this->StartNextTests();
+  }
+}
+
+void cmCTestMultiProcessHandler::UpdateCostData()
+{
+  std::string fname = this->CTest->GetCostDataFile();
+  std::string tmpout = fname + ".tmp";
+  cmsys::ofstream fout;
+  fout.open(tmpout.c_str());
+
+  PropertiesMap temp = this->Properties;
+
+  if (cmSystemTools::FileExists(fname.c_str())) {
+    cmsys::ifstream fin;
+    fin.open(fname.c_str());
+
+    std::string line;
+    while (std::getline(fin, line)) {
+      if (line == "---") {
+        break;
+      }
+      std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
+      // Format: <name> <previous_runs> <avg_cost>
+      if (parts.size() < 3) {
+        break;
+      }
+
+      std::string name = parts[0];
+      int prev = atoi(parts[1].c_str());
+      float cost = static_cast<float>(atof(parts[2].c_str()));
+
+      int index = this->SearchByName(name);
+      if (index == -1) {
+        // This test is not in memory. We just rewrite the entry
+        fout << name << " " << prev << " " << cost << "\n";
+      } else {
+        // Update with our new average cost
+        fout << name << " " << this->Properties[index]->PreviousRuns << " "
+             << this->Properties[index]->Cost << "\n";
+        temp.erase(index);
+      }
+    }
+    fin.close();
+    cmSystemTools::RemoveFile(fname);
+  }
+
+  // Add all tests not previously listed in the file
+  for (auto const& i : temp) {
+    fout << i.second->Name << " " << i.second->PreviousRuns << " "
+         << i.second->Cost << "\n";
+  }
+
+  // Write list of failed tests
+  fout << "---\n";
+  for (std::string const& f : *this->Failed) {
+    fout << f << "\n";
+  }
+  fout.close();
+  cmSystemTools::RenameFile(tmpout.c_str(), fname.c_str());
+}
+
+void cmCTestMultiProcessHandler::ReadCostData()
+{
+  std::string fname = this->CTest->GetCostDataFile();
+
+  if (cmSystemTools::FileExists(fname.c_str(), true)) {
+    cmsys::ifstream fin;
+    fin.open(fname.c_str());
+    std::string line;
+    while (std::getline(fin, line)) {
+      if (line == "---") {
+        break;
+      }
+
+      std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
+
+      // Probably an older version of the file, will be fixed next run
+      if (parts.size() < 3) {
+        fin.close();
+        return;
+      }
+
+      std::string name = parts[0];
+      int prev = atoi(parts[1].c_str());
+      float cost = static_cast<float>(atof(parts[2].c_str()));
+
+      int index = this->SearchByName(name);
+      if (index == -1) {
+        continue;
+      }
+
+      this->Properties[index]->PreviousRuns = prev;
+      // When not running in parallel mode, don't use cost data
+      if (this->ParallelLevel > 1 && this->Properties[index] &&
+          this->Properties[index]->Cost == 0) {
+        this->Properties[index]->Cost = cost;
+      }
+    }
+    // Next part of the file is the failed tests
+    while (std::getline(fin, line)) {
+      if (!line.empty()) {
+        this->LastTestsFailed.push_back(line);
+      }
+    }
+    fin.close();
+  }
+}
+
+int cmCTestMultiProcessHandler::SearchByName(std::string const& name)
+{
+  int index = -1;
+
+  for (auto const& p : this->Properties) {
+    if (p.second->Name == name) {
+      index = p.first;
+    }
+  }
+  return index;
+}
+
+void cmCTestMultiProcessHandler::CreateTestCostList()
+{
+  if (this->ParallelLevel > 1) {
+    CreateParallelTestCostList();
+  } else {
+    CreateSerialTestCostList();
+  }
+}
+
+void cmCTestMultiProcessHandler::CreateParallelTestCostList()
+{
+  TestSet alreadySortedTests;
+
+  std::list<TestSet> priorityStack;
+  priorityStack.push_back(TestSet());
+  TestSet& topLevel = priorityStack.back();
+
+  // In parallel test runs add previously failed tests to the front
+  // of the cost list and queue other tests for further sorting
+  for (auto const& t : this->Tests) {
+    if (std::find(this->LastTestsFailed.begin(), this->LastTestsFailed.end(),
+                  this->Properties[t.first]->Name) !=
+        this->LastTestsFailed.end()) {
+      // If the test failed last time, it should be run first.
+      this->SortedTests.push_back(t.first);
+      alreadySortedTests.insert(t.first);
+    } else {
+      topLevel.insert(t.first);
+    }
+  }
+
+  // In parallel test runs repeatedly move dependencies of the tests on
+  // the current dependency level to the next level until no
+  // further dependencies exist.
+  while (!priorityStack.back().empty()) {
+    TestSet& previousSet = priorityStack.back();
+    priorityStack.push_back(TestSet());
+    TestSet& currentSet = priorityStack.back();
+
+    for (auto const& i : previousSet) {
+      TestSet const& dependencies = this->Tests[i];
+      currentSet.insert(dependencies.begin(), dependencies.end());
+    }
+
+    for (auto const& i : currentSet) {
+      previousSet.erase(i);
+    }
+  }
+
+  // Remove the empty dependency level
+  priorityStack.pop_back();
+
+  // Reverse iterate over the different dependency levels (deepest first).
+  // Sort tests within each level by COST and append them to the cost list.
+  for (std::list<TestSet>::reverse_iterator i = priorityStack.rbegin();
+       i != priorityStack.rend(); ++i) {
+    TestSet const& currentSet = *i;
+    TestComparator comp(this);
+
+    TestList sortedCopy;
+
+    sortedCopy.insert(sortedCopy.end(), currentSet.begin(), currentSet.end());
+
+    std::stable_sort(sortedCopy.begin(), sortedCopy.end(), comp);
+
+    for (auto const& j : sortedCopy) {
+      if (alreadySortedTests.find(j) == alreadySortedTests.end()) {
+        this->SortedTests.push_back(j);
+        alreadySortedTests.insert(j);
+      }
+    }
+  }
+}
+
+void cmCTestMultiProcessHandler::GetAllTestDependencies(int test,
+                                                        TestList& dependencies)
+{
+  TestSet const& dependencySet = this->Tests[test];
+  for (int i : dependencySet) {
+    GetAllTestDependencies(i, dependencies);
+    dependencies.push_back(i);
+  }
+}
+
+void cmCTestMultiProcessHandler::CreateSerialTestCostList()
+{
+  TestList presortedList;
+
+  for (auto const& i : this->Tests) {
+    presortedList.push_back(i.first);
+  }
+
+  TestComparator comp(this);
+  std::stable_sort(presortedList.begin(), presortedList.end(), comp);
+
+  TestSet alreadySortedTests;
+
+  for (int test : presortedList) {
+    if (alreadySortedTests.find(test) != alreadySortedTests.end()) {
+      continue;
+    }
+
+    TestList dependencies;
+    GetAllTestDependencies(test, dependencies);
+
+    for (int testDependency : dependencies) {
+      if (alreadySortedTests.find(testDependency) ==
+          alreadySortedTests.end()) {
+        alreadySortedTests.insert(testDependency);
+        this->SortedTests.push_back(testDependency);
+      }
+    }
+
+    alreadySortedTests.insert(test);
+    this->SortedTests.push_back(test);
+  }
+}
+
+void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
+{
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
+  cmsys::ofstream fout;
+  fout.open(fname.c_str(), std::ios::app);
+  fout << index << "\n";
+  fout.close();
+}
+
+void cmCTestMultiProcessHandler::MarkFinished()
+{
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
+  cmSystemTools::RemoveFile(fname);
+}
+
+// For ShowOnly mode
+void cmCTestMultiProcessHandler::PrintTestList()
+{
+  this->TestHandler->SetMaxIndex(this->FindMaxIndex());
+  int count = 0;
+
+  for (auto& it : this->Properties) {
+    count++;
+    cmCTestTestHandler::cmCTestTestProperties& p = *it.second;
+
+    cmWorkingDirectory workdir(p.Directory);
+
+    cmCTestRunTest testRun(*this);
+    testRun.SetIndex(p.Index);
+    testRun.SetTestProperties(&p);
+    testRun.ComputeArguments(); // logs the command in verbose mode
+
+    if (!p.Labels.empty()) // print the labels
+    {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:",
+                         this->Quiet);
+    }
+    for (std::string const& label : p.Labels) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << label,
+                         this->Quiet);
+    }
+    if (!p.Labels.empty()) // print the labels
+    {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
+                         this->Quiet);
+    }
+
+    if (this->TestHandler->MemCheck) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "  Memory Check",
+                         this->Quiet);
+    } else {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "  Test", this->Quiet);
+    }
+    std::ostringstream indexStr;
+    indexStr << " #" << p.Index << ":";
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_OUTPUT,
+      std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
+        << indexStr.str(),
+      this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " " << p.Name,
+                       this->Quiet);
+    if (p.Disabled) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " (Disabled)",
+                         this->Quiet);
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl
+                       << "Total Tests: " << this->Total << std::endl,
+                     this->Quiet);
+}
+
+void cmCTestMultiProcessHandler::PrintLabels()
+{
+  std::set<std::string> allLabels;
+  for (auto& it : this->Properties) {
+    cmCTestTestHandler::cmCTestTestProperties& p = *it.second;
+    allLabels.insert(p.Labels.begin(), p.Labels.end());
+  }
+
+  if (!allLabels.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "All Labels:" << std::endl,
+                       this->Quiet);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "No Labels Exist" << std::endl, this->Quiet);
+  }
+  for (std::string const& label : allLabels) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "  " << label << std::endl,
+                       this->Quiet);
+  }
+}
+
+void cmCTestMultiProcessHandler::CheckResume()
+{
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
+  if (this->CTest->GetFailover()) {
+    if (cmSystemTools::FileExists(fname.c_str(), true)) {
+      *this->TestHandler->LogFile
+        << "Resuming previously interrupted test set" << std::endl
+        << "----------------------------------------------------------"
+        << std::endl;
+
+      cmsys::ifstream fin;
+      fin.open(fname.c_str());
+      std::string line;
+      while (std::getline(fin, line)) {
+        int index = atoi(line.c_str());
+        this->RemoveTest(index);
+      }
+      fin.close();
+    }
+  } else if (cmSystemTools::FileExists(fname.c_str(), true)) {
+    cmSystemTools::RemoveFile(fname);
+  }
+}
+
+void cmCTestMultiProcessHandler::RemoveTest(int index)
+{
+  this->EraseTest(index);
+  this->Properties.erase(index);
+  this->TestRunningMap[index] = false;
+  this->TestFinishMap[index] = true;
+  this->Completed++;
+}
+
+int cmCTestMultiProcessHandler::FindMaxIndex()
+{
+  int max = 0;
+  for (auto const& i : this->Tests) {
+    if (i.first > max) {
+      max = i.first;
+    }
+  }
+  return max;
+}
+
+// Returns true if no cycles exist in the dependency graph
+bool cmCTestMultiProcessHandler::CheckCycles()
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Checking test dependency graph..." << std::endl,
+                     this->Quiet);
+  for (auto const& it : this->Tests) {
+    // DFS from each element to itself
+    int root = it.first;
+    std::set<int> visited;
+    std::stack<int> s;
+    s.push(root);
+    while (!s.empty()) {
+      int test = s.top();
+      s.pop();
+      if (visited.insert(test).second) {
+        for (auto const& d : this->Tests[test]) {
+          if (d == root) {
+            // cycle exists
+            cmCTestLog(
+              this->CTest, ERROR_MESSAGE,
+              "Error: a cycle exists in the test dependency graph "
+              "for the test \""
+                << this->Properties[root]->Name
+                << "\".\nPlease fix the cycle and run ctest again.\n");
+            return false;
+          }
+          s.push(d);
+        }
+      }
+    }
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Checking test dependency graph end" << std::endl,
+                     this->Quiet);
+  return true;
+}
diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h
new file mode 100644
index 0000000..7837ff9
--- /dev/null
+++ b/Source/CTest/cmCTestMultiProcessHandler.h
@@ -0,0 +1,143 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestMultiProcessHandler_h
+#define cmCTestMultiProcessHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestTestHandler.h"
+#include <map>
+#include <set>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "cm_uv.h"
+
+class cmCTest;
+class cmCTestRunTest;
+
+/** \class cmCTestMultiProcessHandler
+ * \brief run parallel ctest
+ *
+ * cmCTestMultiProcessHandler
+ */
+class cmCTestMultiProcessHandler
+{
+  friend class TestComparator;
+  friend class cmCTestRunTest;
+
+public:
+  struct TestSet : public std::set<int>
+  {
+  };
+  struct TestMap : public std::map<int, TestSet>
+  {
+  };
+  struct TestList : public std::vector<int>
+  {
+  };
+  struct PropertiesMap
+    : public std::map<int, cmCTestTestHandler::cmCTestTestProperties*>
+  {
+  };
+
+  cmCTestMultiProcessHandler();
+  virtual ~cmCTestMultiProcessHandler();
+  // Set the tests
+  void SetTests(TestMap& tests, PropertiesMap& properties);
+  // Set the max number of tests that can be run at the same time.
+  void SetParallelLevel(size_t);
+  void SetTestLoad(unsigned long load);
+  virtual void RunTests();
+  void PrintTestList();
+  void PrintLabels();
+
+  void SetPassFailVectors(std::vector<std::string>* passed,
+                          std::vector<std::string>* failed)
+  {
+    this->Passed = passed;
+    this->Failed = failed;
+  }
+  void SetTestResults(std::vector<cmCTestTestHandler::cmCTestTestResult>* r)
+  {
+    this->TestResults = r;
+  }
+
+  void SetCTest(cmCTest* ctest) { this->CTest = ctest; }
+
+  void SetTestHandler(cmCTestTestHandler* handler)
+  {
+    this->TestHandler = handler;
+  }
+
+  cmCTestTestHandler* GetTestHandler() { return this->TestHandler; }
+
+  void SetQuiet(bool b) { this->Quiet = b; }
+protected:
+  // Start the next test or tests as many as are allowed by
+  // ParallelLevel
+  void StartNextTests();
+  bool StartTestProcess(int test);
+  bool StartTest(int test);
+  // Mark the checkpoint for the given test
+  void WriteCheckpoint(int index);
+
+  void UpdateCostData();
+  void ReadCostData();
+  // Return index of a test based on its name
+  int SearchByName(std::string const& name);
+
+  void CreateTestCostList();
+
+  void GetAllTestDependencies(int test, TestList& dependencies);
+  void CreateSerialTestCostList();
+
+  void CreateParallelTestCostList();
+
+  // Removes the checkpoint file
+  void MarkFinished();
+  void EraseTest(int index);
+  void FinishTestProcess(cmCTestRunTest* runner, bool started);
+
+  void RemoveTest(int index);
+  // Check if we need to resume an interrupted test set
+  void CheckResume();
+  // Check if there are any circular dependencies
+  bool CheckCycles();
+  int FindMaxIndex();
+  inline size_t GetProcessorsUsed(int index);
+  std::string GetName(int index);
+
+  void LockResources(int index);
+  void UnlockResources(int index);
+  // map from test number to set of depend tests
+  TestMap Tests;
+  TestList SortedTests;
+  // Total number of tests we'll be running
+  size_t Total;
+  // Number of tests that are complete
+  size_t Completed;
+  size_t RunningCount;
+  bool StopTimePassed;
+  // list of test properties (indices concurrent to the test map)
+  PropertiesMap Properties;
+  std::map<int, bool> TestRunningMap;
+  std::map<int, bool> TestFinishMap;
+  std::map<int, std::string> TestOutput;
+  std::vector<std::string>* Passed;
+  std::vector<std::string>* Failed;
+  std::vector<std::string> LastTestsFailed;
+  std::set<std::string> LockedResources;
+  std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;
+  size_t ParallelLevel; // max number of process that can be run at once
+  unsigned long TestLoad;
+  uv_loop_t Loop;
+  cmCTestTestHandler* TestHandler;
+  cmCTest* CTest;
+  bool HasCycles;
+  bool Quiet;
+  bool SerialTestRunning;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx
new file mode 100644
index 0000000..fdf8932
--- /dev/null
+++ b/Source/CTest/cmCTestP4.cxx
@@ -0,0 +1,527 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestP4.h"
+
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <ostream>
+#include <time.h>
+#include <utility>
+
+cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+}
+
+cmCTestP4::~cmCTestP4()
+{
+}
+
+class cmCTestP4::IdentifyParser : public cmCTestVC::LineParser
+{
+public:
+  IdentifyParser(cmCTestP4* p4, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
+    this->SetLog(&p4->Log, prefix);
+    this->RegexIdentify.compile("^Change ([0-9]+) on");
+  }
+
+private:
+  std::string& Rev;
+  cmsys::RegularExpression RegexIdentify;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexIdentify.find(this->Line)) {
+      this->Rev = this->RegexIdentify.match(1);
+      return false;
+    }
+    return true;
+  }
+};
+
+class cmCTestP4::ChangesParser : public cmCTestVC::LineParser
+{
+public:
+  ChangesParser(cmCTestP4* p4, const char* prefix)
+    : P4(p4)
+  {
+    this->SetLog(&P4->Log, prefix);
+    this->RegexIdentify.compile("^Change ([0-9]+) on");
+  }
+
+private:
+  cmsys::RegularExpression RegexIdentify;
+  cmCTestP4* P4;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexIdentify.find(this->Line)) {
+      P4->ChangeLists.push_back(this->RegexIdentify.match(1));
+    }
+    return true;
+  }
+};
+
+class cmCTestP4::UserParser : public cmCTestVC::LineParser
+{
+public:
+  UserParser(cmCTestP4* p4, const char* prefix)
+    : P4(p4)
+  {
+    this->SetLog(&P4->Log, prefix);
+    this->RegexUser.compile("^(.+) <(.*)> \\((.*)\\) accessed (.*)$");
+  }
+
+private:
+  cmsys::RegularExpression RegexUser;
+  cmCTestP4* P4;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexUser.find(this->Line)) {
+      User NewUser;
+
+      NewUser.UserName = this->RegexUser.match(1);
+      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;
+
+      return false;
+    }
+    return true;
+  }
+};
+
+/* Diff format:
+==== //depot/file#rev - /absolute/path/to/file ====
+(diff data)
+==== //depot/file2#rev - /absolute/path/to/file2 ====
+(diff data)
+==== //depot/file3#rev - /absolute/path/to/file3 ====
+==== //depot/file4#rev - /absolute/path/to/file4 ====
+(diff data)
+*/
+class cmCTestP4::DiffParser : public cmCTestVC::LineParser
+{
+public:
+  DiffParser(cmCTestP4* p4, const char* prefix)
+    : P4(p4)
+    , AlreadyNotified(false)
+  {
+    this->SetLog(&P4->Log, prefix);
+    this->RegexDiff.compile("^==== (.*)#[0-9]+ - (.*)");
+  }
+
+private:
+  cmCTestP4* P4;
+  bool AlreadyNotified;
+  std::string CurrentPath;
+  cmsys::RegularExpression RegexDiff;
+
+  bool ProcessLine() override
+  {
+    if (!this->Line.empty() && this->Line[0] == '=' &&
+        this->RegexDiff.find(this->Line)) {
+      CurrentPath = this->RegexDiff.match(1);
+      AlreadyNotified = false;
+    } else {
+      if (!AlreadyNotified) {
+        P4->DoModification(PathModified, CurrentPath);
+        AlreadyNotified = true;
+      }
+    }
+    return true;
+  }
+};
+
+cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
+{
+  std::map<std::string, cmCTestP4::User>::const_iterator it =
+    Users.find(username);
+
+  if (it == Users.end()) {
+    std::vector<char const*> p4_users;
+    SetP4Options(p4_users);
+    p4_users.push_back("users");
+    p4_users.push_back("-m");
+    p4_users.push_back("1");
+    p4_users.push_back(username.c_str());
+    p4_users.push_back(nullptr);
+
+    UserParser out(this, "users-out> ");
+    OutputLogger err(this->Log, "users-err> ");
+    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()) {
+      return cmCTestP4::User();
+    }
+  }
+
+  return it->second;
+}
+
+/* Commit format:
+
+Change 1111111 by user@client on 2013/09/26 11:50:36
+
+        text
+        text
+
+Affected files ...
+
+... //path/to/file#rev edit
+... //path/to/file#rev add
+... //path/to/file#rev delete
+... //path/to/file#rev integrate
+*/
+class cmCTestP4::DescribeParser : public cmCTestVC::LineParser
+{
+public:
+  DescribeParser(cmCTestP4* p4, const char* prefix)
+    : LineParser('\n', false)
+    , P4(p4)
+    , Section(SectionHeader)
+  {
+    this->SetLog(&P4->Log, prefix);
+    this->RegexHeader.compile("^Change ([0-9]+) by (.+)@(.+) on (.*)$");
+    this->RegexDiff.compile("^\\.\\.\\. (.*)#[0-9]+ ([^ ]+)$");
+  }
+
+private:
+  cmsys::RegularExpression RegexHeader;
+  cmsys::RegularExpression RegexDiff;
+  cmCTestP4* P4;
+
+  typedef cmCTestP4::Revision Revision;
+  typedef cmCTestP4::Change Change;
+  std::vector<Change> Changes;
+  enum SectionType
+  {
+    SectionHeader,
+    SectionBody,
+    SectionDiffHeader,
+    SectionDiff,
+    SectionCount
+  };
+  SectionType Section;
+  Revision Rev;
+
+  bool ProcessLine() override
+  {
+    if (this->Line.empty()) {
+      this->NextSection();
+    } else {
+      switch (this->Section) {
+        case SectionHeader:
+          this->DoHeaderLine();
+          break;
+        case SectionBody:
+          this->DoBodyLine();
+          break;
+        case SectionDiffHeader:
+          break; // nothing to do
+        case SectionDiff:
+          this->DoDiffLine();
+          break;
+        case SectionCount:
+          break; // never happens
+      }
+    }
+    return true;
+  }
+
+  void NextSection()
+  {
+    if (this->Section == SectionDiff) {
+      this->P4->DoRevision(this->Rev, this->Changes);
+      this->Rev = Revision();
+    }
+
+    this->Section = SectionType((this->Section + 1) % SectionCount);
+  }
+
+  void DoHeaderLine()
+  {
+    if (this->RegexHeader.find(this->Line)) {
+      this->Rev.Rev = this->RegexHeader.match(1);
+      this->Rev.Date = this->RegexHeader.match(4);
+
+      cmCTestP4::User user = P4->GetUserData(this->RegexHeader.match(2));
+      this->Rev.Author = user.Name;
+      this->Rev.EMail = user.EMail;
+
+      this->Rev.Committer = this->Rev.Author;
+      this->Rev.CommitterEMail = this->Rev.EMail;
+      this->Rev.CommitDate = this->Rev.Date;
+    }
+  }
+
+  void DoBodyLine()
+  {
+    if (this->Line[0] == '\t') {
+      this->Rev.Log += this->Line.substr(1);
+    }
+    this->Rev.Log += "\n";
+  }
+
+  void DoDiffLine()
+  {
+    if (this->RegexDiff.find(this->Line)) {
+      Change change;
+      std::string Path = this->RegexDiff.match(1);
+      if (Path.length() > 2 && Path[0] == '/' && Path[1] == '/') {
+        size_t found = Path.find('/', 2);
+        if (found != std::string::npos) {
+          Path = Path.substr(found + 1);
+        }
+      }
+
+      change.Path = Path;
+      std::string action = this->RegexDiff.match(2);
+
+      if (action == "add") {
+        change.Action = 'A';
+      } else if (action == "delete") {
+        change.Action = 'D';
+      } else if (action == "edit" || action == "integrate") {
+        change.Action = 'M';
+      }
+
+      Changes.push_back(change);
+    }
+  }
+};
+
+void cmCTestP4::SetP4Options(std::vector<char const*>& CommandOptions)
+{
+  if (P4Options.empty()) {
+    const char* p4 = this->CommandLineTool.c_str();
+    P4Options.push_back(p4);
+
+    // The CTEST_P4_CLIENT variable sets the P4 client used when issuing
+    // Perforce commands, if it's different from the default one.
+    std::string client = this->CTest->GetCTestConfiguration("P4Client");
+    if (!client.empty()) {
+      P4Options.push_back("-c");
+      P4Options.push_back(client);
+    }
+
+    // Set the message language to be English, in case the P4 admin
+    // has localized them
+    P4Options.push_back("-L");
+    P4Options.push_back("en");
+
+    // The CTEST_P4_OPTIONS variable adds additional Perforce command line
+    // options before the main command
+    std::string opts = this->CTest->GetCTestConfiguration("P4Options");
+    std::vector<std::string> args =
+      cmSystemTools::ParseArguments(opts.c_str());
+
+    P4Options.insert(P4Options.end(), args.begin(), args.end());
+  }
+
+  CommandOptions.clear();
+  for (std::string const& o : P4Options) {
+    CommandOptions.push_back(o.c_str());
+  }
+}
+
+std::string cmCTestP4::GetWorkingRevision()
+{
+  std::vector<char const*> p4_identify;
+  SetP4Options(p4_identify);
+
+  p4_identify.push_back("changes");
+  p4_identify.push_back("-m");
+  p4_identify.push_back("1");
+  p4_identify.push_back("-t");
+
+  std::string source = this->SourceDirectory + "/...#have";
+  p4_identify.push_back(source.c_str());
+  p4_identify.push_back(nullptr);
+
+  std::string rev;
+  IdentifyParser out(this, "p4_changes-out> ", rev);
+  OutputLogger err(this->Log, "p4_changes-err> ");
+
+  bool result = RunChild(&p4_identify[0], &out, &err);
+
+  // If there was a problem contacting the server return "<unknown>"
+  if (!result) {
+    return "<unknown>";
+  }
+
+  if (rev.empty()) {
+    return "0";
+  }
+  return rev;
+}
+
+bool cmCTestP4::NoteOldRevision()
+{
+  this->OldRevision = this->GetWorkingRevision();
+
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
+               << this->OldRevision << "\n");
+  this->PriorRev.Rev = this->OldRevision;
+  return true;
+}
+
+bool cmCTestP4::NoteNewRevision()
+{
+  this->NewRevision = this->GetWorkingRevision();
+
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
+               << this->NewRevision << "\n");
+  return true;
+}
+
+bool cmCTestP4::LoadRevisions()
+{
+  std::vector<char const*> p4_changes;
+  SetP4Options(p4_changes);
+
+  // Use 'p4 changes ...@old,new' to get a list of changelists
+  std::string range = this->SourceDirectory + "/...";
+
+  // If any revision is unknown it means we couldn't contact the server.
+  // Do not process updates
+  if (this->OldRevision == "<unknown>" || this->NewRevision == "<unknown>") {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   At least one of the revisions "
+                 << "is unknown. No repository changes will be reported.\n");
+    return false;
+  }
+
+  range.append("@")
+    .append(this->OldRevision)
+    .append(",")
+    .append(this->NewRevision);
+
+  p4_changes.push_back("changes");
+  p4_changes.push_back(range.c_str());
+  p4_changes.push_back(nullptr);
+
+  ChangesParser out(this, "p4_changes-out> ");
+  OutputLogger err(this->Log, "p4_changes-err> ");
+
+  ChangeLists.clear();
+  this->RunChild(&p4_changes[0], &out, &err);
+
+  if (ChangeLists.empty()) {
+    return true;
+  }
+
+  // p4 describe -s ...@1111111,2222222
+  std::vector<char const*> p4_describe;
+  for (std::vector<std::string>::reverse_iterator i = ChangeLists.rbegin();
+       i != ChangeLists.rend(); ++i) {
+    SetP4Options(p4_describe);
+    p4_describe.push_back("describe");
+    p4_describe.push_back("-s");
+    p4_describe.push_back(i->c_str());
+    p4_describe.push_back(nullptr);
+
+    DescribeParser outDescribe(this, "p4_describe-out> ");
+    OutputLogger errDescribe(this->Log, "p4_describe-err> ");
+    this->RunChild(&p4_describe[0], &outDescribe, &errDescribe);
+  }
+  return true;
+}
+
+bool cmCTestP4::LoadModifications()
+{
+  std::vector<char const*> p4_diff;
+  SetP4Options(p4_diff);
+
+  p4_diff.push_back("diff");
+
+  // Ideally we would use -Od but not all clients support it
+  p4_diff.push_back("-dn");
+  std::string source = this->SourceDirectory + "/...";
+  p4_diff.push_back(source.c_str());
+  p4_diff.push_back(nullptr);
+
+  DiffParser out(this, "p4_diff-out> ");
+  OutputLogger err(this->Log, "p4_diff-err> ");
+  this->RunChild(&p4_diff[0], &out, &err);
+  return true;
+}
+
+bool cmCTestP4::UpdateCustom(const std::string& custom)
+{
+  std::vector<std::string> p4_custom_command;
+  cmSystemTools::ExpandListArgument(custom, p4_custom_command, true);
+
+  std::vector<char const*> p4_custom;
+  p4_custom.reserve(p4_custom_command.size() + 1);
+  for (std::string const& i : p4_custom_command) {
+    p4_custom.push_back(i.c_str());
+  }
+  p4_custom.push_back(nullptr);
+
+  OutputLogger custom_out(this->Log, "p4_customsync-out> ");
+  OutputLogger custom_err(this->Log, "p4_customsync-err> ");
+
+  return this->RunUpdateCommand(&p4_custom[0], &custom_out, &custom_err);
+}
+
+bool cmCTestP4::UpdateImpl()
+{
+  std::string custom = this->CTest->GetCTestConfiguration("P4UpdateCustom");
+  if (!custom.empty()) {
+    return this->UpdateCustom(custom);
+  }
+
+  // If we couldn't get a revision number before updating, abort.
+  if (this->OldRevision == "<unknown>") {
+    this->UpdateCommandLine = "Unknown current revision";
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown current revision\n");
+    return false;
+  }
+
+  std::vector<char const*> p4_sync;
+  SetP4Options(p4_sync);
+
+  p4_sync.push_back("sync");
+
+  // Get user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("P4UpdateOptions");
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+  for (std::string const& arg : args) {
+    p4_sync.push_back(arg.c_str());
+  }
+
+  std::string source = this->SourceDirectory + "/...";
+
+  // Specify the start time for nightly testing.
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
+    std::string date = this->GetNightlyTime();
+    // CTest reports the date as YYYY-MM-DD, Perforce needs it as YYYY/MM/DD
+    std::replace(date.begin(), date.end(), '-', '/');
+
+    // Revision specification: /...@"YYYY/MM/DD HH:MM:SS"
+    source.append("@\"").append(date).append("\"");
+  }
+
+  p4_sync.push_back(source.c_str());
+  p4_sync.push_back(nullptr);
+
+  OutputLogger out(this->Log, "p4_sync-out> ");
+  OutputLogger err(this->Log, "p4_sync-err> ");
+
+  return this->RunUpdateCommand(&p4_sync[0], &out, &err);
+}
diff --git a/Source/CTest/cmCTestP4.h b/Source/CTest/cmCTestP4.h
new file mode 100644
index 0000000..b14edf7
--- /dev/null
+++ b/Source/CTest/cmCTestP4.h
@@ -0,0 +1,76 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestP4_h
+#define cmCTestP4_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGlobalVC.h"
+
+#include <iosfwd>
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCTest;
+
+/** \class cmCTestP4
+ * \brief Interaction with the Perforce command-line tool
+ *
+ */
+class cmCTestP4 : public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestP4(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestP4() override;
+
+private:
+  std::vector<std::string> ChangeLists;
+
+  struct User
+  {
+    std::string UserName;
+    std::string Name;
+    std::string EMail;
+    std::string AccessTime;
+
+    User()
+      : UserName()
+      , Name()
+      , EMail()
+      , AccessTime()
+    {
+    }
+  };
+  std::map<std::string, User> Users;
+  std::vector<std::string> P4Options;
+
+  User GetUserData(const std::string& username);
+  void SetP4Options(std::vector<char const*>& options);
+
+  std::string GetWorkingRevision();
+  bool NoteOldRevision() override;
+  bool NoteNewRevision() override;
+  bool UpdateImpl() override;
+  bool UpdateCustom(const std::string& custom);
+
+  bool LoadRevisions() override;
+  bool LoadModifications() override;
+
+  class ChangesParser;
+  class DescribeParser;
+  class DiffParser;
+  // Parsing helper classes.
+  class IdentifyParser;
+  class UserParser;
+
+  friend class IdentifyParser;
+  friend class ChangesParser;
+  friend class UserParser;
+  friend class DescribeParser;
+  friend class DiffParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.cxx b/Source/CTest/cmCTestReadCustomFilesCommand.cxx
new file mode 100644
index 0000000..ed14d06
--- /dev/null
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.cxx
@@ -0,0 +1,22 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestReadCustomFilesCommand.h"
+
+#include "cmCTest.h"
+
+class cmExecutionStatus;
+
+bool cmCTestReadCustomFilesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  for (std::string const& arg : args) {
+    this->CTest->ReadCustomConfigurationFileTree(arg.c_str(), this->Makefile);
+  }
+
+  return true;
+}
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h
new file mode 100644
index 0000000..ba25c51
--- /dev/null
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.h
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestReadCustomFilesCommand_h
+#define cmCTestReadCustomFilesCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <string>
+#include <vector>
+
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestReadCustomFiles
+ * \brief Run a ctest script
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmCTestReadCustomFilesCommand : public cmCTestCommand
+{
+public:
+  cmCTestReadCustomFilesCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestReadCustomFilesCommand* ni = new cmCTestReadCustomFilesCommand;
+    ni->CTest = this->CTest;
+    return ni;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestRunScriptCommand.cxx b/Source/CTest/cmCTestRunScriptCommand.cxx
new file mode 100644
index 0000000..238284a
--- /dev/null
+++ b/Source/CTest/cmCTestRunScriptCommand.cxx
@@ -0,0 +1,49 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestRunScriptCommand.h"
+
+#include "cmCTestScriptHandler.h"
+#include "cmMakefile.h"
+
+#include <sstream>
+
+class cmExecutionStatus;
+
+bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->CTestScriptHandler->RunCurrentScript();
+    return true;
+  }
+
+  bool np = false;
+  unsigned int i = 0;
+  if (args[i] == "NEW_PROCESS") {
+    np = true;
+    i++;
+  }
+  int start = i;
+  // run each script
+  std::string returnVariable;
+  for (i = start; i < args.size(); ++i) {
+    if (args[i] == "RETURN_VALUE") {
+      ++i;
+      if (i < args.size()) {
+        returnVariable = args[i];
+      }
+    }
+  }
+  for (i = start; i < args.size(); ++i) {
+    if (args[i] == "RETURN_VALUE") {
+      ++i;
+    } else {
+      int ret;
+      cmCTestScriptHandler::RunScript(this->CTest, args[i].c_str(), !np, &ret);
+      std::ostringstream str;
+      str << ret;
+      this->Makefile->AddDefinition(returnVariable, str.str().c_str());
+    }
+  }
+  return true;
+}
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
new file mode 100644
index 0000000..9d8b4b5
--- /dev/null
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -0,0 +1,46 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestRunScriptCommand_h
+#define cmCTestRunScriptCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <string>
+#include <vector>
+
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestRunScript
+ * \brief Run a ctest script
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmCTestRunScriptCommand : public cmCTestCommand
+{
+public:
+  cmCTestRunScriptCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
new file mode 100644
index 0000000..baf894e
--- /dev/null
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -0,0 +1,727 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestRunTest.h"
+
+#include "cmCTest.h"
+#include "cmCTestMemCheckHandler.h"
+#include "cmCTestMultiProcessHandler.h"
+#include "cmProcess.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+
+#include "cm_zlib.h"
+#include "cmsys/Base64.h"
+#include "cmsys/RegularExpression.hxx"
+#include <chrono>
+#include <cmAlgorithms.h>
+#include <iomanip>
+#include <ratio>
+#include <sstream>
+#include <stdio.h>
+#include <utility>
+
+cmCTestRunTest::cmCTestRunTest(cmCTestMultiProcessHandler& multiHandler)
+  : MultiTestHandler(multiHandler)
+{
+  this->CTest = multiHandler.CTest;
+  this->TestHandler = multiHandler.TestHandler;
+  this->TestResult.ExecutionTime = std::chrono::duration<double>::zero();
+  this->TestResult.ReturnValue = 0;
+  this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+  this->TestResult.TestCount = 0;
+  this->TestResult.Properties = nullptr;
+  this->ProcessOutput.clear();
+  this->CompressedOutput.clear();
+  this->CompressionRatio = 2;
+  this->NumberOfRunsLeft = 1; // default to 1 run of the test
+  this->RunUntilFail = false; // default to run the test once
+  this->RunAgain = false;     // default to not having to run again
+}
+
+void cmCTestRunTest::CheckOutput(std::string const& line)
+{
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+               << ": " << line << std::endl);
+  this->ProcessOutput += line;
+  this->ProcessOutput += "\n";
+
+  // Check for TIMEOUT_AFTER_MATCH property.
+  if (!this->TestProperties->TimeoutRegularExpressions.empty()) {
+    for (auto& reg : this->TestProperties->TimeoutRegularExpressions) {
+      if (reg.first.find(this->ProcessOutput.c_str())) {
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+                     << ": "
+                     << "Test timeout changed to "
+                     << std::chrono::duration_cast<std::chrono::seconds>(
+                          this->TestProperties->AlternateTimeout)
+                          .count()
+                     << std::endl);
+        this->TestProcess->ResetStartTime();
+        this->TestProcess->ChangeTimeout(
+          this->TestProperties->AlternateTimeout);
+        this->TestProperties->TimeoutRegularExpressions.clear();
+        break;
+      }
+    }
+  }
+}
+
+// Streamed compression of test output.  The compressed data
+// is appended to this->CompressedOutput
+void cmCTestRunTest::CompressOutput()
+{
+  int ret;
+  z_stream strm;
+
+  unsigned char* in = reinterpret_cast<unsigned char*>(
+    const_cast<char*>(this->ProcessOutput.c_str()));
+  // zlib makes the guarantee that this is the maximum output size
+  int outSize = static_cast<int>(
+    static_cast<double>(this->ProcessOutput.size()) * 1.001 + 13.0);
+  unsigned char* out = new unsigned char[outSize];
+
+  strm.zalloc = Z_NULL;
+  strm.zfree = Z_NULL;
+  strm.opaque = Z_NULL;
+  ret = deflateInit(&strm, -1); // default compression level
+  if (ret != Z_OK) {
+    delete[] out;
+    return;
+  }
+
+  strm.avail_in = static_cast<uInt>(this->ProcessOutput.size());
+  strm.next_in = in;
+  strm.avail_out = outSize;
+  strm.next_out = out;
+  ret = deflate(&strm, Z_FINISH);
+
+  if (ret != Z_STREAM_END) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error during output compression. Sending uncompressed output."
+                 << std::endl);
+    delete[] out;
+    return;
+  }
+
+  (void)deflateEnd(&strm);
+
+  unsigned char* encoded_buffer =
+    new unsigned char[static_cast<int>(outSize * 1.5)];
+
+  size_t rlen = cmsysBase64_Encode(out, strm.total_out, encoded_buffer, 1);
+
+  this->CompressedOutput.clear();
+  for (size_t i = 0; i < rlen; i++) {
+    this->CompressedOutput += encoded_buffer[i];
+  }
+
+  if (strm.total_in) {
+    this->CompressionRatio =
+      static_cast<double>(strm.total_out) / static_cast<double>(strm.total_in);
+  }
+
+  delete[] encoded_buffer;
+  delete[] out;
+}
+
+bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
+{
+  if ((!this->TestHandler->MemCheck &&
+       this->CTest->ShouldCompressTestOutput()) ||
+      (this->TestHandler->MemCheck &&
+       this->CTest->ShouldCompressTestOutput())) {
+    this->CompressOutput();
+  }
+
+  this->WriteLogOutputTop(completed, total);
+  std::string reason;
+  bool passed = true;
+  cmProcess::State res =
+    started ? this->TestProcess->GetProcessStatus() : cmProcess::State::Error;
+  int retVal = this->TestProcess->GetExitValue();
+  bool forceFail = false;
+  bool skipped = false;
+  bool outputTestErrorsToConsole = false;
+  if (!this->TestProperties->RequiredRegularExpressions.empty() &&
+      this->FailedDependencies.empty()) {
+    bool found = false;
+    for (auto& pass : this->TestProperties->RequiredRegularExpressions) {
+      if (pass.first.find(this->ProcessOutput.c_str())) {
+        found = true;
+        reason = "Required regular expression found.";
+        break;
+      }
+    }
+    if (!found) {
+      reason = "Required regular expression not found.";
+      forceFail = true;
+    }
+    reason += "Regex=[";
+    for (auto& pass : this->TestProperties->RequiredRegularExpressions) {
+      reason += pass.second;
+      reason += "\n";
+    }
+    reason += "]";
+  }
+  if (!this->TestProperties->ErrorRegularExpressions.empty() &&
+      this->FailedDependencies.empty()) {
+    for (auto& pass : this->TestProperties->ErrorRegularExpressions) {
+      if (pass.first.find(this->ProcessOutput.c_str())) {
+        reason = "Error regular expression found in output.";
+        reason += " Regex=[";
+        reason += pass.second;
+        reason += "]";
+        forceFail = true;
+        break;
+      }
+    }
+  }
+  if (res == cmProcess::State::Exited) {
+    bool success = !forceFail &&
+      (retVal == 0 ||
+       !this->TestProperties->RequiredRegularExpressions.empty());
+    if (this->TestProperties->SkipReturnCode >= 0 &&
+        this->TestProperties->SkipReturnCode == retVal) {
+      this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+      std::ostringstream s;
+      s << "SKIP_RETURN_CODE=" << this->TestProperties->SkipReturnCode;
+      this->TestResult.CompletionStatus = s.str();
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Skipped ");
+      skipped = true;
+    } else if ((success && !this->TestProperties->WillFail) ||
+               (!success && this->TestProperties->WillFail)) {
+      this->TestResult.Status = cmCTestTestHandler::COMPLETED;
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Passed  ");
+    } else {
+      this->TestResult.Status = cmCTestTestHandler::FAILED;
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed  " << reason);
+      outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
+    }
+  } else if (res == cmProcess::State::Expired) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout ");
+    this->TestResult.Status = cmCTestTestHandler::TIMEOUT;
+    outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
+  } else if (res == cmProcess::State::Exception) {
+    outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
+    this->TestResult.ExceptionStatus =
+      this->TestProcess->GetExitExceptionString();
+    switch (this->TestProcess->GetExitException()) {
+      case cmProcess::Exception::Fault:
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
+        this->TestResult.Status = cmCTestTestHandler::SEGFAULT;
+        break;
+      case cmProcess::Exception::Illegal:
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "Illegal");
+        this->TestResult.Status = cmCTestTestHandler::ILLEGAL;
+        break;
+      case cmProcess::Exception::Interrupt:
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "Interrupt");
+        this->TestResult.Status = cmCTestTestHandler::INTERRUPT;
+        break;
+      case cmProcess::Exception::Numerical:
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "Numerical");
+        this->TestResult.Status = cmCTestTestHandler::NUMERICAL;
+        break;
+      default:
+        cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                   this->TestResult.ExceptionStatus);
+        this->TestResult.Status = cmCTestTestHandler::OTHER_FAULT;
+    }
+  } else if ("Disabled" == this->TestResult.CompletionStatus) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Not Run (Disabled) ");
+  } else // cmProcess::State::Error
+  {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Not Run ");
+  }
+
+  passed = this->TestResult.Status == cmCTestTestHandler::COMPLETED;
+  char buf[1024];
+  sprintf(buf, "%6.2f sec", this->TestProcess->GetTotalTime().count());
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, buf << "\n");
+
+  if (outputTestErrorsToConsole) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, this->ProcessOutput << std::endl);
+  }
+
+  if (this->TestHandler->LogFile) {
+    *this->TestHandler->LogFile << "Test time = " << buf << std::endl;
+  }
+
+  // Set the working directory to the tests directory to process Dart files.
+  {
+    cmWorkingDirectory workdir(this->TestProperties->Directory);
+    this->DartProcessing();
+  }
+
+  // if this is doing MemCheck then all the output needs to be put into
+  // Output since that is what is parsed by cmCTestMemCheckHandler
+  if (!this->TestHandler->MemCheck && started) {
+    this->TestHandler->CleanTestOutput(
+      this->ProcessOutput,
+      static_cast<size_t>(
+        this->TestResult.Status == cmCTestTestHandler::COMPLETED
+          ? this->TestHandler->CustomMaximumPassedTestOutputSize
+          : this->TestHandler->CustomMaximumFailedTestOutputSize));
+  }
+  this->TestResult.Reason = reason;
+  if (this->TestHandler->LogFile) {
+    bool pass = true;
+    const char* reasonType = "Test Pass Reason";
+    if (this->TestResult.Status != cmCTestTestHandler::COMPLETED &&
+        this->TestResult.Status != cmCTestTestHandler::NOT_RUN) {
+      reasonType = "Test Fail Reason";
+      pass = false;
+    }
+    auto ttime = this->TestProcess->GetTotalTime();
+    auto hours = std::chrono::duration_cast<std::chrono::hours>(ttime);
+    ttime -= hours;
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(ttime);
+    ttime -= minutes;
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(ttime);
+    char buffer[100];
+    sprintf(buffer, "%02d:%02d:%02d", static_cast<unsigned>(hours.count()),
+            static_cast<unsigned>(minutes.count()),
+            static_cast<unsigned>(seconds.count()));
+    *this->TestHandler->LogFile
+      << "----------------------------------------------------------"
+      << std::endl;
+    if (!this->TestResult.Reason.empty()) {
+      *this->TestHandler->LogFile << reasonType << ":\n"
+                                  << this->TestResult.Reason << "\n";
+    } else {
+      if (pass) {
+        *this->TestHandler->LogFile << "Test Passed.\n";
+      } else {
+        *this->TestHandler->LogFile << "Test Failed.\n";
+      }
+    }
+    *this->TestHandler->LogFile
+      << "\"" << this->TestProperties->Name
+      << "\" end time: " << this->CTest->CurrentTime() << std::endl
+      << "\"" << this->TestProperties->Name << "\" time elapsed: " << buffer
+      << std::endl
+      << "----------------------------------------------------------"
+      << std::endl
+      << std::endl;
+  }
+  // if the test actually started and ran
+  // record the results in TestResult
+  if (started) {
+    bool compress = !this->TestHandler->MemCheck &&
+      this->CompressionRatio < 1 && this->CTest->ShouldCompressTestOutput();
+    this->TestResult.Output =
+      compress ? this->CompressedOutput : this->ProcessOutput;
+    this->TestResult.CompressOutput = compress;
+    this->TestResult.ReturnValue = this->TestProcess->GetExitValue();
+    if (!skipped) {
+      this->TestResult.CompletionStatus = "Completed";
+    }
+    this->TestResult.ExecutionTime = this->TestProcess->GetTotalTime();
+    this->MemCheckPostProcess();
+    this->ComputeWeightedCost();
+  }
+  // If the test does not need to rerun push the current TestResult onto the
+  // TestHandler vector
+  if (!this->NeedsToRerun()) {
+    this->TestHandler->TestResults.push_back(this->TestResult);
+  }
+  this->TestProcess.reset();
+  return passed || skipped;
+}
+
+bool cmCTestRunTest::StartAgain()
+{
+  if (!this->RunAgain) {
+    return false;
+  }
+  this->RunAgain = false; // reset
+  // change to tests directory
+  cmWorkingDirectory workdir(this->TestProperties->Directory);
+  this->StartTest(this->TotalNumberOfTests);
+  return true;
+}
+
+bool cmCTestRunTest::NeedsToRerun()
+{
+  this->NumberOfRunsLeft--;
+  if (this->NumberOfRunsLeft == 0) {
+    return false;
+  }
+  // if number of runs left is not 0, and we are running until
+  // we find a failed test, then return true so the test can be
+  // restarted
+  if (this->RunUntilFail &&
+      this->TestResult.Status == cmCTestTestHandler::COMPLETED) {
+    this->RunAgain = true;
+    return true;
+  }
+  return false;
+}
+void cmCTestRunTest::ComputeWeightedCost()
+{
+  double prev = static_cast<double>(this->TestProperties->PreviousRuns);
+  double avgcost = static_cast<double>(this->TestProperties->Cost);
+  double current = this->TestResult.ExecutionTime.count();
+
+  if (this->TestResult.Status == cmCTestTestHandler::COMPLETED) {
+    this->TestProperties->Cost =
+      static_cast<float>(((prev * avgcost) + current) / (prev + 1.0));
+    this->TestProperties->PreviousRuns++;
+  }
+}
+
+void cmCTestRunTest::MemCheckPostProcess()
+{
+  if (!this->TestHandler->MemCheck) {
+    return;
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
+                       << ": process test output now: "
+                       << this->TestProperties->Name << " "
+                       << this->TestResult.Name << std::endl,
+                     this->TestHandler->GetQuiet());
+  cmCTestMemCheckHandler* handler =
+    static_cast<cmCTestMemCheckHandler*>(this->TestHandler);
+  handler->PostProcessTest(this->TestResult, this->Index);
+}
+
+// Starts the execution of a test.  Returns once it has started
+bool cmCTestRunTest::StartTest(size_t total)
+{
+  this->TotalNumberOfTests = total; // save for rerun case
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(2 * getNumWidth(total) + 8)
+               << "Start "
+               << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
+               << this->TestProperties->Index << ": "
+               << this->TestProperties->Name << std::endl);
+  this->ProcessOutput.clear();
+
+  // Return immediately if test is disabled
+  if (this->TestProperties->Disabled) {
+    this->TestResult.Properties = this->TestProperties;
+    this->TestResult.ExecutionTime = std::chrono::duration<double>::zero();
+    this->TestResult.CompressOutput = false;
+    this->TestResult.ReturnValue = -1;
+    this->TestResult.CompletionStatus = "Disabled";
+    this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+    this->TestResult.TestCount = this->TestProperties->Index;
+    this->TestResult.Name = this->TestProperties->Name;
+    this->TestResult.Path = this->TestProperties->Directory;
+    this->TestProcess = cm::make_unique<cmProcess>(*this);
+    this->TestResult.Output = "Disabled";
+    this->TestResult.FullCommandLine.clear();
+    return false;
+  }
+
+  this->TestResult.Properties = this->TestProperties;
+  this->TestResult.ExecutionTime = std::chrono::duration<double>::zero();
+  this->TestResult.CompressOutput = false;
+  this->TestResult.ReturnValue = -1;
+  this->TestResult.CompletionStatus = "Failed to start";
+  this->TestResult.Status = cmCTestTestHandler::BAD_COMMAND;
+  this->TestResult.TestCount = this->TestProperties->Index;
+  this->TestResult.Name = this->TestProperties->Name;
+  this->TestResult.Path = this->TestProperties->Directory;
+
+  // Check for failed fixture dependencies before we even look at the command
+  // arguments because if we are not going to run the test, the command and
+  // its arguments are irrelevant. This matters for the case where a fixture
+  // dependency might be creating the executable we want to run.
+  if (!this->FailedDependencies.empty()) {
+    this->TestProcess = cm::make_unique<cmProcess>(*this);
+    std::string msg = "Failed test dependencies:";
+    for (std::string const& failedDep : this->FailedDependencies) {
+      msg += " " + failedDep;
+    }
+    *this->TestHandler->LogFile << msg << std::endl;
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, msg << std::endl);
+    this->TestResult.Output = msg;
+    this->TestResult.FullCommandLine.clear();
+    this->TestResult.CompletionStatus = "Fixture dependency failed";
+    this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+    return false;
+  }
+
+  this->ComputeArguments();
+  std::vector<std::string>& args = this->TestProperties->Args;
+  if (args.size() >= 2 && args[1] == "NOT_AVAILABLE") {
+    this->TestProcess = cm::make_unique<cmProcess>(*this);
+    std::string msg;
+    if (this->CTest->GetConfigType().empty()) {
+      msg = "Test not available without configuration.";
+      msg += "  (Missing \"-C <config>\"?)";
+    } else {
+      msg = "Test not available in configuration \"";
+      msg += this->CTest->GetConfigType();
+      msg += "\".";
+    }
+    *this->TestHandler->LogFile << msg << std::endl;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, msg << std::endl);
+    this->TestResult.Output = msg;
+    this->TestResult.FullCommandLine.clear();
+    this->TestResult.CompletionStatus = "Missing Configuration";
+    this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+    return false;
+  }
+
+  // Check if all required files exist
+  for (std::string const& file : this->TestProperties->RequiredFiles) {
+    if (!cmSystemTools::FileExists(file.c_str())) {
+      // Required file was not found
+      this->TestProcess = cm::make_unique<cmProcess>(*this);
+      *this->TestHandler->LogFile << "Unable to find required file: " << file
+                                  << std::endl;
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Unable to find required file: " << file << std::endl);
+      this->TestResult.Output = "Unable to find required file: " + file;
+      this->TestResult.FullCommandLine.clear();
+      this->TestResult.CompletionStatus = "Required Files Missing";
+      this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+      return false;
+    }
+  }
+  // log and return if we did not find the executable
+  if (this->ActualCommand.empty()) {
+    // if the command was not found create a TestResult object
+    // that has that information
+    this->TestProcess = cm::make_unique<cmProcess>(*this);
+    *this->TestHandler->LogFile << "Unable to find executable: " << args[1]
+                                << std::endl;
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Unable to find executable: " << args[1] << std::endl);
+    this->TestResult.Output = "Unable to find executable: " + args[1];
+    this->TestResult.FullCommandLine.clear();
+    this->TestResult.CompletionStatus = "Unable to find executable";
+    this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
+    return false;
+  }
+  this->StartTime = this->CTest->CurrentTime();
+
+  auto timeout = this->TestProperties->Timeout;
+
+  std::chrono::system_clock::time_point stop_time = this->CTest->GetStopTime();
+  if (stop_time != std::chrono::system_clock::time_point()) {
+    std::chrono::duration<double> stop_timeout =
+      (stop_time - std::chrono::system_clock::now()) % std::chrono::hours(24);
+
+    if (stop_timeout <= std::chrono::duration<double>::zero()) {
+      stop_timeout = std::chrono::duration<double>::zero();
+    }
+    if (timeout == std::chrono::duration<double>::zero() ||
+        stop_timeout < timeout) {
+      timeout = stop_timeout;
+    }
+  }
+
+  return this->ForkProcess(timeout, this->TestProperties->ExplicitTimeout,
+                           &this->TestProperties->Environment);
+}
+
+void cmCTestRunTest::ComputeArguments()
+{
+  this->Arguments.clear(); // reset becaue this might be a rerun
+  std::vector<std::string>::const_iterator j =
+    this->TestProperties->Args.begin();
+  ++j; // skip test name
+  // find the test executable
+  if (this->TestHandler->MemCheck) {
+    cmCTestMemCheckHandler* handler =
+      static_cast<cmCTestMemCheckHandler*>(this->TestHandler);
+    this->ActualCommand = handler->MemoryTester;
+    this->TestProperties->Args[1] = this->TestHandler->FindTheExecutable(
+      this->TestProperties->Args[1].c_str());
+  } else {
+    this->ActualCommand = this->TestHandler->FindTheExecutable(
+      this->TestProperties->Args[1].c_str());
+    ++j; // skip the executable (it will be actualCommand)
+  }
+  std::string testCommand =
+    cmSystemTools::ConvertToOutputPath(this->ActualCommand.c_str());
+
+  // Prepends memcheck args to our command string
+  this->TestHandler->GenerateTestCommand(this->Arguments, this->Index);
+  for (std::string const& arg : this->Arguments) {
+    testCommand += " \"";
+    testCommand += arg;
+    testCommand += "\"";
+  }
+
+  for (; j != this->TestProperties->Args.end(); ++j) {
+    testCommand += " \"";
+    testCommand += *j;
+    testCommand += "\"";
+    this->Arguments.push_back(*j);
+  }
+  this->TestResult.FullCommandLine = testCommand;
+
+  // Print the test command in verbose mode
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+               << this->Index << ": "
+               << (this->TestHandler->MemCheck ? "MemCheck" : "Test")
+               << " command: " << testCommand << std::endl);
+
+  // Print any test-specific env vars in verbose mode
+  if (!this->TestProperties->Environment.empty()) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
+                 << ": "
+                 << "Environment variables: " << std::endl);
+  }
+  for (std::string const& env : this->TestProperties->Environment) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ":  " << env
+                                                                << std::endl);
+  }
+}
+
+void cmCTestRunTest::DartProcessing()
+{
+  if (!this->ProcessOutput.empty() &&
+      this->ProcessOutput.find("<DartMeasurement") != std::string::npos) {
+    if (this->TestHandler->DartStuff.find(this->ProcessOutput.c_str())) {
+      this->TestResult.DartString = this->TestHandler->DartStuff.match(1);
+      // keep searching and replacing until none are left
+      while (this->TestHandler->DartStuff1.find(this->ProcessOutput.c_str())) {
+        // replace the exact match for the string
+        cmSystemTools::ReplaceString(
+          this->ProcessOutput, this->TestHandler->DartStuff1.match(1).c_str(),
+          "");
+      }
+    }
+  }
+}
+
+bool cmCTestRunTest::ForkProcess(std::chrono::duration<double> testTimeOut,
+                                 bool explicitTimeout,
+                                 std::vector<std::string>* environment)
+{
+  this->TestProcess = cm::make_unique<cmProcess>(*this);
+  this->TestProcess->SetId(this->Index);
+  this->TestProcess->SetWorkingDirectory(
+    this->TestProperties->Directory.c_str());
+  this->TestProcess->SetCommand(this->ActualCommand.c_str());
+  this->TestProcess->SetCommandArguments(this->Arguments);
+
+  // determine how much time we have
+  std::chrono::duration<double> timeout =
+    this->CTest->GetRemainingTimeAllowed();
+  if (timeout != cmCTest::MaxDuration()) {
+    timeout -= std::chrono::minutes(2);
+  }
+  if (this->CTest->GetTimeOut() > std::chrono::duration<double>::zero() &&
+      this->CTest->GetTimeOut() < timeout) {
+    timeout = this->CTest->GetTimeOut();
+  }
+  if (testTimeOut > std::chrono::duration<double>::zero() &&
+      testTimeOut < this->CTest->GetRemainingTimeAllowed()) {
+    timeout = testTimeOut;
+  }
+  // always have at least 1 second if we got to here
+  if (timeout <= std::chrono::duration<double>::zero()) {
+    timeout = std::chrono::seconds(1);
+  }
+  // handle timeout explicitly set to 0
+  if (testTimeOut == std::chrono::duration<double>::zero() &&
+      explicitTimeout) {
+    timeout = std::chrono::duration<double>::zero();
+  }
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
+      << ": "
+      << "Test timeout computed to be: "
+      << (timeout == cmCTest::MaxDuration()
+            ? std::string("infinite")
+            : std::to_string(
+                std::chrono::duration_cast<std::chrono::seconds>(timeout)
+                  .count()))
+      << "\n",
+    this->TestHandler->GetQuiet());
+
+  this->TestProcess->SetTimeout(timeout);
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  cmSystemTools::SaveRestoreEnvironment sre;
+#endif
+
+  if (environment && !environment->empty()) {
+    cmSystemTools::AppendEnv(*environment);
+  }
+
+  return this->TestProcess->StartProcess(this->MultiTestHandler.Loop);
+}
+
+void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
+{
+  // if this is the last or only run of this test
+  // then print out completed / total
+  // Only issue is if a test fails and we are running until fail
+  // then it will never print out the completed / total, same would
+  // got for run until pass.  Trick is when this is called we don't
+  // yet know if we are passing or failing.
+  if (this->NumberOfRunsLeft == 1) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
+                 << completed << "/");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
+                 << total << " ");
+  }
+  // if this is one of several runs of a test just print blank space
+  // to keep things neat
+  else {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
+                 << " "
+                 << " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
+                 << " "
+                 << " ");
+  }
+
+  if (this->TestHandler->MemCheck) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "MemCheck");
+  } else {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "Test");
+  }
+
+  std::ostringstream indexStr;
+  indexStr << " #" << this->Index << ":";
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
+               << indexStr.str());
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
+  const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
+  std::string outname = this->TestProperties->Name + " ";
+  outname.resize(maxTestNameWidth + 4, '.');
+
+  *this->TestHandler->LogFile << this->TestProperties->Index << "/"
+                              << this->TestHandler->TotalNumberOfTests
+                              << " Testing: " << this->TestProperties->Name
+                              << std::endl;
+  *this->TestHandler->LogFile << this->TestProperties->Index << "/"
+                              << this->TestHandler->TotalNumberOfTests
+                              << " Test: " << this->TestProperties->Name
+                              << std::endl;
+  *this->TestHandler->LogFile << "Command: \"" << this->ActualCommand << "\"";
+
+  for (std::string const& arg : this->Arguments) {
+    *this->TestHandler->LogFile << " \"" << arg << "\"";
+  }
+  *this->TestHandler->LogFile
+    << std::endl
+    << "Directory: " << this->TestProperties->Directory << std::endl
+    << "\"" << this->TestProperties->Name
+    << "\" start time: " << this->StartTime << std::endl;
+
+  *this->TestHandler->LogFile
+    << "Output:" << std::endl
+    << "----------------------------------------------------------"
+    << std::endl;
+  *this->TestHandler->LogFile << this->ProcessOutput << "<end of output>"
+                              << std::endl;
+
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
+  cmCTestLog(this->CTest, DEBUG, "Testing " << this->TestProperties->Name
+                                            << " ... ");
+}
+
+void cmCTestRunTest::FinalizeTest()
+{
+  this->MultiTestHandler.FinishTestProcess(this, true);
+}
diff --git a/Source/CTest/cmCTestRunTest.h b/Source/CTest/cmCTestRunTest.h
new file mode 100644
index 0000000..fbc202f
--- /dev/null
+++ b/Source/CTest/cmCTestRunTest.h
@@ -0,0 +1,126 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestRunTest_h
+#define cmCTestRunTest_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <chrono>
+#include <set>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "cmCTestTestHandler.h"
+#include "cmProcess.h" // IWYU pragma: keep (for unique_ptr)
+
+class cmCTest;
+class cmCTestMultiProcessHandler;
+
+/** \class cmRunTest
+ * \brief represents a single test to be run
+ *
+ * cmRunTest contains the information related to running a single test
+ */
+class cmCTestRunTest
+{
+public:
+  explicit cmCTestRunTest(cmCTestMultiProcessHandler& multiHandler);
+
+  ~cmCTestRunTest() = default;
+
+  void SetNumberOfRuns(int n) { this->NumberOfRunsLeft = n; }
+  void SetRunUntilFailOn() { this->RunUntilFail = true; }
+  void SetTestProperties(cmCTestTestHandler::cmCTestTestProperties* prop)
+  {
+    this->TestProperties = prop;
+  }
+
+  cmCTestTestHandler::cmCTestTestProperties* GetTestProperties()
+  {
+    return this->TestProperties;
+  }
+
+  void SetIndex(int i) { this->Index = i; }
+
+  int GetIndex() { return this->Index; }
+
+  void AddFailedDependency(const std::string& failedTest)
+  {
+    this->FailedDependencies.insert(failedTest);
+  }
+
+  std::string GetProcessOutput() { return this->ProcessOutput; }
+
+  cmCTestTestHandler::cmCTestTestResult GetTestResults()
+  {
+    return this->TestResult;
+  }
+
+  // Read and store output.  Returns true if it must be called again.
+  void CheckOutput(std::string const& line);
+
+  // Compresses the output, writing to CompressedOutput
+  void CompressOutput();
+
+  // launch the test process, return whether it started correctly
+  bool StartTest(size_t total);
+  // capture and report the test results
+  bool EndTest(size_t completed, size_t total, bool started);
+  // Called by ctest -N to log the command string
+  void ComputeArguments();
+
+  void ComputeWeightedCost();
+
+  bool StartAgain();
+
+  cmCTest* GetCTest() const { return this->CTest; }
+
+  void FinalizeTest();
+
+private:
+  bool NeedsToRerun();
+  void DartProcessing();
+  void ExeNotFound(std::string exe);
+  bool ForkProcess(std::chrono::duration<double> testTimeOut,
+                   bool explicitTimeout,
+                   std::vector<std::string>* environment);
+  void WriteLogOutputTop(size_t completed, size_t total);
+  // Run post processing of the process output for MemCheck
+  void MemCheckPostProcess();
+
+  cmCTestTestHandler::cmCTestTestProperties* TestProperties;
+  // Pointer back to the "parent"; the handler that invoked this test run
+  cmCTestTestHandler* TestHandler;
+  cmCTest* CTest;
+  std::unique_ptr<cmProcess> TestProcess;
+  std::string ProcessOutput;
+  std::string CompressedOutput;
+  double CompressionRatio;
+  // The test results
+  cmCTestTestHandler::cmCTestTestResult TestResult;
+  cmCTestMultiProcessHandler& MultiTestHandler;
+  int Index;
+  std::set<std::string> FailedDependencies;
+  std::string StartTime;
+  std::string ActualCommand;
+  std::vector<std::string> Arguments;
+  bool RunUntilFail;
+  int NumberOfRunsLeft;
+  bool RunAgain;
+  size_t TotalNumberOfTests;
+};
+
+inline int getNumWidth(size_t n)
+{
+  int numWidth = 1;
+  if (n >= 10) {
+    numWidth = 2;
+  }
+  if (n >= 100) {
+    numWidth = 3;
+  }
+  return numWidth;
+}
+
+#endif
diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx
new file mode 100644
index 0000000..ce96224
--- /dev/null
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -0,0 +1,559 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestSVN.h"
+
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmProcessTools.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+#include "cmXMLWriter.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <map>
+#include <ostream>
+#include <stdlib.h>
+#include <string.h>
+
+struct cmCTestSVN::Revision : public cmCTestVC::Revision
+{
+  cmCTestSVN::SVNInfo* SVNInfo;
+};
+
+cmCTestSVN::cmCTestSVN(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
+{
+  this->PriorRev = this->Unknown;
+}
+
+cmCTestSVN::~cmCTestSVN()
+{
+}
+
+void cmCTestSVN::CleanupImpl()
+{
+  std::vector<const char*> svn_cleanup;
+  svn_cleanup.push_back("cleanup");
+  OutputLogger out(this->Log, "cleanup-out> ");
+  OutputLogger err(this->Log, "cleanup-err> ");
+  this->RunSVNCommand(svn_cleanup, &out, &err);
+}
+
+class cmCTestSVN::InfoParser : public cmCTestVC::LineParser
+{
+public:
+  InfoParser(cmCTestSVN* svn, const char* prefix, std::string& rev,
+             SVNInfo& svninfo)
+    : Rev(rev)
+    , SVNRepo(svninfo)
+  {
+    this->SetLog(&svn->Log, prefix);
+    this->RegexRev.compile("^Revision: ([0-9]+)");
+    this->RegexURL.compile("^URL: +([^ ]+) *$");
+    this->RegexRoot.compile("^Repository Root: +([^ ]+) *$");
+  }
+
+private:
+  std::string& Rev;
+  cmCTestSVN::SVNInfo& SVNRepo;
+  cmsys::RegularExpression RegexRev;
+  cmsys::RegularExpression RegexURL;
+  cmsys::RegularExpression RegexRoot;
+  bool ProcessLine() override
+  {
+    if (this->RegexRev.find(this->Line)) {
+      this->Rev = this->RegexRev.match(1);
+    } else if (this->RegexURL.find(this->Line)) {
+      this->SVNRepo.URL = this->RegexURL.match(1);
+    } else if (this->RegexRoot.find(this->Line)) {
+      this->SVNRepo.Root = this->RegexRoot.match(1);
+    }
+    return true;
+  }
+};
+
+static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2)
+{
+  // Does path p1 start with path p2?
+  if (p1.size() == p2.size()) {
+    return p1 == p2;
+  }
+  if (p1.size() > p2.size() && p1[p2.size()] == '/') {
+    return strncmp(p1.c_str(), p2.c_str(), p2.size()) == 0;
+  }
+  return false;
+}
+
+std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo)
+{
+  // Run "svn info" to get the repository info from the work tree.
+  std::vector<const char*> svn_info;
+  svn_info.push_back("info");
+  svn_info.push_back(svninfo.LocalPath.c_str());
+  std::string rev;
+  InfoParser out(this, "info-out> ", rev, svninfo);
+  OutputLogger err(this->Log, "info-err> ");
+  this->RunSVNCommand(svn_info, &out, &err);
+  return rev;
+}
+
+bool cmCTestSVN::NoteOldRevision()
+{
+  if (!this->LoadRepositories()) {
+    return false;
+  }
+
+  for (SVNInfo& svninfo : this->Repositories) {
+    svninfo.OldRevision = this->LoadInfo(svninfo);
+    this->Log << "Revision for repository '" << svninfo.LocalPath
+              << "' before update: " << svninfo.OldRevision << "\n";
+    cmCTestLog(
+      this->CTest, HANDLER_OUTPUT, "   Old revision of external repository '"
+        << svninfo.LocalPath << "' is: " << svninfo.OldRevision << "\n");
+  }
+
+  // Set the global old revision to the one of the root
+  this->OldRevision = this->RootInfo->OldRevision;
+  this->PriorRev.Rev = this->OldRevision;
+  return true;
+}
+
+bool cmCTestSVN::NoteNewRevision()
+{
+  if (!this->LoadRepositories()) {
+    return false;
+  }
+
+  for (SVNInfo& svninfo : this->Repositories) {
+    svninfo.NewRevision = this->LoadInfo(svninfo);
+    this->Log << "Revision for repository '" << svninfo.LocalPath
+              << "' after update: " << svninfo.NewRevision << "\n";
+    cmCTestLog(
+      this->CTest, HANDLER_OUTPUT, "   New revision of external repository '"
+        << svninfo.LocalPath << "' is: " << svninfo.NewRevision << "\n");
+
+    // svninfo.Root = ""; // uncomment to test GuessBase
+    this->Log << "Repository '" << svninfo.LocalPath
+              << "' URL = " << svninfo.URL << "\n";
+    this->Log << "Repository '" << svninfo.LocalPath
+              << "' Root = " << svninfo.Root << "\n";
+
+    // Compute the base path the working tree has checked out under
+    // the repository root.
+    if (!svninfo.Root.empty() &&
+        cmCTestSVNPathStarts(svninfo.URL, svninfo.Root)) {
+      svninfo.Base =
+        cmCTest::DecodeURL(svninfo.URL.substr(svninfo.Root.size()));
+      svninfo.Base += "/";
+    }
+    this->Log << "Repository '" << svninfo.LocalPath
+              << "' Base = " << svninfo.Base << "\n";
+  }
+
+  // Set the global new revision to the one of the root
+  this->NewRevision = this->RootInfo->NewRevision;
+  return true;
+}
+
+void cmCTestSVN::GuessBase(SVNInfo& svninfo,
+                           std::vector<Change> const& changes)
+{
+  // Subversion did not give us a good repository root so we need to
+  // guess the base path from the URL and the paths in a revision with
+  // changes under it.
+
+  // Consider each possible URL suffix from longest to shortest.
+  for (std::string::size_type slash = svninfo.URL.find('/');
+       svninfo.Base.empty() && slash != std::string::npos;
+       slash = svninfo.URL.find('/', slash + 1)) {
+    // If the URL suffix is a prefix of at least one path then it is the base.
+    std::string base = cmCTest::DecodeURL(svninfo.URL.substr(slash));
+    for (std::vector<Change>::const_iterator ci = changes.begin();
+         svninfo.Base.empty() && ci != changes.end(); ++ci) {
+      if (cmCTestSVNPathStarts(ci->Path, base)) {
+        svninfo.Base = base;
+      }
+    }
+  }
+
+  // We always append a slash so that we know paths beginning in the
+  // base lie under its path.  If no base was found then the working
+  // tree must be a checkout of the entire repo and this will match
+  // the leading slash in all paths.
+  svninfo.Base += "/";
+
+  this->Log << "Guessed Base = " << svninfo.Base << "\n";
+}
+
+class cmCTestSVN::UpdateParser : public cmCTestVC::LineParser
+{
+public:
+  UpdateParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
+    this->SetLog(&svn->Log, prefix);
+    this->RegexUpdate.compile("^([ADUCGE ])([ADUCGE ])[B ] +(.+)$");
+  }
+
+private:
+  cmCTestSVN* SVN;
+  cmsys::RegularExpression RegexUpdate;
+
+  bool ProcessLine() override
+  {
+    if (this->RegexUpdate.find(this->Line)) {
+      this->DoPath(this->RegexUpdate.match(1)[0],
+                   this->RegexUpdate.match(2)[0], this->RegexUpdate.match(3));
+    }
+    return true;
+  }
+
+  void DoPath(char path_status, char prop_status, std::string const& path)
+  {
+    char status = (path_status != ' ') ? path_status : prop_status;
+    std::string dir = cmSystemTools::GetFilenamePath(path);
+    std::string name = cmSystemTools::GetFilenameName(path);
+    // See "svn help update".
+    switch (status) {
+      case 'G':
+        this->SVN->Dirs[dir][name].Status = PathModified;
+        break;
+      case 'C':
+        this->SVN->Dirs[dir][name].Status = PathConflicting;
+        break;
+      case 'A':
+      case 'D':
+      case 'U':
+        this->SVN->Dirs[dir][name].Status = PathUpdated;
+        break;
+      case 'E': // TODO?
+      case '?':
+      case ' ':
+      default:
+        break;
+    }
+  }
+};
+
+bool cmCTestSVN::UpdateImpl()
+{
+  // Get user-specified update options.
+  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
+  if (opts.empty()) {
+    opts = this->CTest->GetCTestConfiguration("SVNUpdateOptions");
+  }
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
+
+  // Specify the start time for nightly testing.
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
+    args.push_back("-r{" + this->GetNightlyTime() + " +0000}");
+  }
+
+  std::vector<char const*> svn_update;
+  svn_update.push_back("update");
+  for (std::string const& arg : args) {
+    svn_update.push_back(arg.c_str());
+  }
+
+  UpdateParser out(this, "up-out> ");
+  OutputLogger err(this->Log, "up-err> ");
+  return this->RunSVNCommand(svn_update, &out, &err);
+}
+
+bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
+                               OutputParser* out, OutputParser* err)
+{
+  if (parameters.empty()) {
+    return false;
+  }
+
+  std::vector<char const*> args;
+  args.push_back(this->CommandLineTool.c_str());
+
+  args.insert(args.end(), parameters.begin(), parameters.end());
+
+  args.push_back("--non-interactive");
+
+  std::string userOptions = this->CTest->GetCTestConfiguration("SVNOptions");
+
+  std::vector<std::string> parsedUserOptions =
+    cmSystemTools::ParseArguments(userOptions.c_str());
+  for (std::string const& opt : parsedUserOptions) {
+    args.push_back(opt.c_str());
+  }
+
+  args.push_back(nullptr);
+
+  if (strcmp(parameters[0], "update") == 0) {
+    return RunUpdateCommand(&args[0], out, err);
+  }
+  return RunChild(&args[0], out, err);
+}
+
+class cmCTestSVN::LogParser : public cmCTestVC::OutputLogger,
+                              private cmXMLParser
+{
+public:
+  LogParser(cmCTestSVN* svn, const char* prefix, SVNInfo& svninfo)
+    : OutputLogger(svn->Log, prefix)
+    , SVN(svn)
+    , SVNRepo(svninfo)
+  {
+    this->InitializeParser();
+  }
+  ~LogParser() override { this->CleanupParser(); }
+private:
+  cmCTestSVN* SVN;
+  cmCTestSVN::SVNInfo& SVNRepo;
+
+  typedef cmCTestSVN::Revision Revision;
+  typedef cmCTestSVN::Change Change;
+  Revision Rev;
+  std::vector<Change> Changes;
+  Change CurChange;
+  std::vector<char> CData;
+
+  bool ProcessChunk(const char* data, int length) override
+  {
+    this->OutputLogger::ProcessChunk(data, length);
+    this->ParseChunk(data, length);
+    return true;
+  }
+
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    this->CData.clear();
+    if (name == "logentry") {
+      this->Rev = Revision();
+      this->Rev.SVNInfo = &SVNRepo;
+      if (const char* rev = this->FindAttribute(atts, "revision")) {
+        this->Rev.Rev = rev;
+      }
+      this->Changes.clear();
+    } else if (name == "path") {
+      this->CurChange = Change();
+      if (const char* action = this->FindAttribute(atts, "action")) {
+        this->CurChange.Action = action[0];
+      }
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
+
+  void EndElement(const std::string& name) override
+  {
+    if (name == "logentry") {
+      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);
+      this->CurChange.Path.assign(new_path);
+      this->Changes.push_back(this->CurChange);
+    } else if (!this->CData.empty() && name == "author") {
+      this->Rev.Author.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "date") {
+      this->Rev.Date.assign(&this->CData[0], this->CData.size());
+    } else if (!this->CData.empty() && name == "msg") {
+      this->Rev.Log.assign(&this->CData[0], this->CData.size());
+    }
+    this->CData.clear();
+  }
+
+  void ReportError(int /*line*/, int /*column*/, const char* msg) override
+  {
+    this->SVN->Log << "Error parsing svn log xml: " << msg << "\n";
+  }
+};
+
+bool cmCTestSVN::LoadRevisions()
+{
+  bool result = true;
+  // Get revisions for all the external repositories
+  for (SVNInfo& svninfo : this->Repositories) {
+    result = this->LoadRevisions(svninfo) && result;
+  }
+  return result;
+}
+
+bool cmCTestSVN::LoadRevisions(SVNInfo& svninfo)
+{
+  // We are interested in every revision included in the update.
+  std::string revs;
+  if (atoi(svninfo.OldRevision.c_str()) < atoi(svninfo.NewRevision.c_str())) {
+    revs = "-r" + svninfo.OldRevision + ":" + svninfo.NewRevision;
+  } else {
+    revs = "-r" + svninfo.NewRevision;
+  }
+
+  // Run "svn log" to get all global revisions of interest.
+  std::vector<const char*> svn_log;
+  svn_log.push_back("log");
+  svn_log.push_back("--xml");
+  svn_log.push_back("-v");
+  svn_log.push_back(revs.c_str());
+  svn_log.push_back(svninfo.LocalPath.c_str());
+  LogParser out(this, "log-out> ", svninfo);
+  OutputLogger err(this->Log, "log-err> ");
+  return this->RunSVNCommand(svn_log, &out, &err);
+}
+
+void cmCTestSVN::DoRevisionSVN(Revision const& revision,
+                               std::vector<Change> const& changes)
+{
+  // Guess the base checkout path from the changes if necessary.
+  if (this->RootInfo->Base.empty() && !changes.empty()) {
+    this->GuessBase(*this->RootInfo, changes);
+  }
+
+  // Ignore changes in the old revision for external repositories
+  if (revision.Rev == revision.SVNInfo->OldRevision &&
+      !revision.SVNInfo->LocalPath.empty()) {
+    return;
+  }
+
+  this->cmCTestGlobalVC::DoRevision(revision, changes);
+}
+
+class cmCTestSVN::StatusParser : public cmCTestVC::LineParser
+{
+public:
+  StatusParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
+    this->SetLog(&svn->Log, prefix);
+    this->RegexStatus.compile("^([ACDIMRX?!~ ])([CM ])[ L]... +(.+)$");
+  }
+
+private:
+  cmCTestSVN* SVN;
+  cmsys::RegularExpression RegexStatus;
+  bool ProcessLine() override
+  {
+    if (this->RegexStatus.find(this->Line)) {
+      this->DoPath(this->RegexStatus.match(1)[0],
+                   this->RegexStatus.match(2)[0], this->RegexStatus.match(3));
+    }
+    return true;
+  }
+
+  void DoPath(char path_status, char prop_status, std::string const& path)
+  {
+    char status = (path_status != ' ') ? path_status : prop_status;
+    // See "svn help status".
+    switch (status) {
+      case 'M':
+      case '!':
+      case 'A':
+      case 'D':
+      case 'R':
+        this->SVN->DoModification(PathModified, path);
+        break;
+      case 'C':
+      case '~':
+        this->SVN->DoModification(PathConflicting, path);
+        break;
+      case 'X':
+      case 'I':
+      case '?':
+      case ' ':
+      default:
+        break;
+    }
+  }
+};
+
+bool cmCTestSVN::LoadModifications()
+{
+  // Run "svn status" which reports local modifications.
+  std::vector<const char*> svn_status;
+  svn_status.push_back("status");
+  StatusParser out(this, "status-out> ");
+  OutputLogger err(this->Log, "status-err> ");
+  this->RunSVNCommand(svn_status, &out, &err);
+  return true;
+}
+
+void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml)
+{
+  this->cmCTestGlobalVC::WriteXMLGlobal(xml);
+
+  xml.Element("SVNPath", this->RootInfo->Base);
+}
+
+class cmCTestSVN::ExternalParser : public cmCTestVC::LineParser
+{
+public:
+  ExternalParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
+    this->SetLog(&svn->Log, prefix);
+    this->RegexExternal.compile("^X..... +(.+)$");
+  }
+
+private:
+  cmCTestSVN* SVN;
+  cmsys::RegularExpression RegexExternal;
+  bool ProcessLine() override
+  {
+    if (this->RegexExternal.find(this->Line)) {
+      this->DoPath(this->RegexExternal.match(1));
+    }
+    return true;
+  }
+
+  void DoPath(std::string const& path)
+  {
+    // Get local path relative to the source directory
+    std::string local_path;
+    if (path.size() > this->SVN->SourceDirectory.size() &&
+        strncmp(path.c_str(), this->SVN->SourceDirectory.c_str(),
+                this->SVN->SourceDirectory.size()) == 0) {
+      local_path = path.c_str() + this->SVN->SourceDirectory.size() + 1;
+    } else {
+      local_path = path;
+    }
+    this->SVN->Repositories.push_back(SVNInfo(local_path.c_str()));
+  }
+};
+
+bool cmCTestSVN::LoadRepositories()
+{
+  if (!this->Repositories.empty()) {
+    return true;
+  }
+
+  // Info for root repository
+  this->Repositories.push_back(SVNInfo(""));
+  this->RootInfo = &(this->Repositories.back());
+
+  // Run "svn status" to get the list of external repositories
+  std::vector<const char*> svn_status;
+  svn_status.push_back("status");
+  ExternalParser out(this, "external-out> ");
+  OutputLogger err(this->Log, "external-err> ");
+  return this->RunSVNCommand(svn_status, &out, &err);
+}
+
+std::string cmCTestSVN::SVNInfo::BuildLocalPath(std::string const& path) const
+{
+  std::string local_path;
+
+  // Add local path prefix if not empty
+  if (!this->LocalPath.empty()) {
+    local_path += this->LocalPath;
+    local_path += "/";
+  }
+
+  // Add path with base prefix removed
+  if (path.size() > this->Base.size() &&
+      strncmp(path.c_str(), this->Base.c_str(), this->Base.size()) == 0) {
+    local_path += (path.c_str() + this->Base.size());
+  } else {
+    local_path += path;
+  }
+
+  return local_path;
+}
diff --git a/Source/CTest/cmCTestSVN.h b/Source/CTest/cmCTestSVN.h
new file mode 100644
index 0000000..dbc7fde
--- /dev/null
+++ b/Source/CTest/cmCTestSVN.h
@@ -0,0 +1,105 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestSVN_h
+#define cmCTestSVN_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGlobalVC.h"
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmXMLWriter;
+
+/** \class cmCTestSVN
+ * \brief Interaction with subversion command-line tool
+ *
+ */
+class cmCTestSVN : public cmCTestGlobalVC
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestSVN(cmCTest* ctest, std::ostream& log);
+
+  ~cmCTestSVN() override;
+
+private:
+  // Implement cmCTestVC internal API.
+  void CleanupImpl() override;
+  bool NoteOldRevision() override;
+  bool NoteNewRevision() override;
+  bool UpdateImpl() override;
+
+  bool RunSVNCommand(std::vector<char const*> const& parameters,
+                     OutputParser* out, OutputParser* err);
+
+  // Information about an SVN repository (root repository or external)
+  struct SVNInfo
+  {
+
+    SVNInfo(const char* path)
+      : LocalPath(path)
+    {
+    }
+    // Remove base from the filename
+    std::string BuildLocalPath(std::string const& path) const;
+
+    // LocalPath relative to the main source directory.
+    std::string LocalPath;
+
+    // URL of repository directory checked out in the working tree.
+    std::string URL;
+
+    // URL of repository root directory.
+    std::string Root;
+
+    // Directory under repository root checked out in working tree.
+    std::string Base;
+
+    // Old and new repository revisions.
+    std::string OldRevision;
+    std::string NewRevision;
+  };
+
+  // Extended revision structure to include info about external it refers to.
+  struct Revision;
+
+  friend struct Revision;
+
+  // Info of all the repositories (root, externals and nested ones).
+  std::vector<SVNInfo> Repositories;
+
+  // Pointer to the infos of the root repository.
+  SVNInfo* RootInfo;
+
+  std::string LoadInfo(SVNInfo& svninfo);
+  bool LoadRepositories();
+  bool LoadModifications() override;
+  bool LoadRevisions() override;
+  bool LoadRevisions(SVNInfo& svninfo);
+
+  void GuessBase(SVNInfo& svninfo, std::vector<Change> const& changes);
+
+  void DoRevisionSVN(Revision const& revision,
+                     std::vector<Change> const& changes);
+
+  void WriteXMLGlobal(cmXMLWriter& xml) override;
+
+  class ExternalParser;
+  // Parsing helper classes.
+  class InfoParser;
+  class LogParser;
+  class StatusParser;
+  class UpdateParser;
+
+  friend class InfoParser;
+  friend class LogParser;
+  friend class StatusParser;
+  friend class UpdateParser;
+  friend class ExternalParser;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
new file mode 100644
index 0000000..716ea10
--- /dev/null
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -0,0 +1,980 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestScriptHandler.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/Process.h"
+#include <map>
+#include <ratio>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utility>
+
+#include "cmCTest.h"
+#include "cmCTestBuildCommand.h"
+#include "cmCTestCommand.h"
+#include "cmCTestConfigureCommand.h"
+#include "cmCTestCoverageCommand.h"
+#include "cmCTestEmptyBinaryDirectoryCommand.h"
+#include "cmCTestMemCheckCommand.h"
+#include "cmCTestReadCustomFilesCommand.h"
+#include "cmCTestRunScriptCommand.h"
+#include "cmCTestSleepCommand.h"
+#include "cmCTestStartCommand.h"
+#include "cmCTestSubmitCommand.h"
+#include "cmCTestTestCommand.h"
+#include "cmCTestUpdateCommand.h"
+#include "cmCTestUploadCommand.h"
+#include "cmFunctionBlocker.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmStateDirectory.h"
+#include "cmStateSnapshot.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+class cmExecutionStatus;
+struct cmListFileFunction;
+
+#define CTEST_INITIAL_CMAKE_OUTPUT_FILE_NAME "CTestInitialCMakeOutput.log"
+
+// used to keep elapsed time up to date
+class cmCTestScriptFunctionBlocker : public cmFunctionBlocker
+{
+public:
+  cmCTestScriptFunctionBlocker() {}
+  ~cmCTestScriptFunctionBlocker() override {}
+  bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                         cmExecutionStatus& /*status*/) override;
+  // virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
+  // virtual void ScopeEnded(cmMakefile &mf);
+
+  cmCTestScriptHandler* CTestScriptHandler;
+};
+
+// simply update the time and don't block anything
+bool cmCTestScriptFunctionBlocker::IsFunctionBlocked(
+  const cmListFileFunction& /*lff*/, cmMakefile& /*mf*/,
+  cmExecutionStatus& /*status*/)
+{
+  this->CTestScriptHandler->UpdateElapsedTime();
+  return false;
+}
+
+cmCTestScriptHandler::cmCTestScriptHandler()
+{
+  this->Backup = false;
+  this->EmptyBinDir = false;
+  this->EmptyBinDirOnce = false;
+  this->Makefile = nullptr;
+  this->CMake = nullptr;
+  this->GlobalGenerator = nullptr;
+
+  this->ScriptStartTime = std::chrono::steady_clock::time_point();
+
+  // the *60 is because the settings are in minutes but GetTime is seconds
+  this->MinimumInterval = 30 * 60;
+  this->ContinuousDuration = -1;
+}
+
+void cmCTestScriptHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->Backup = false;
+  this->EmptyBinDir = false;
+  this->EmptyBinDirOnce = false;
+
+  this->SourceDir.clear();
+  this->BinaryDir.clear();
+  this->BackupSourceDir.clear();
+  this->BackupBinaryDir.clear();
+  this->CTestRoot.clear();
+  this->CVSCheckOut.clear();
+  this->CTestCmd.clear();
+  this->UpdateCmd.clear();
+  this->CTestEnv.clear();
+  this->InitialCache.clear();
+  this->CMakeCmd.clear();
+  this->CMOutFile.clear();
+  this->ExtraUpdates.clear();
+
+  this->MinimumInterval = 20 * 60;
+  this->ContinuousDuration = -1;
+
+  // what time in seconds did this script start running
+  this->ScriptStartTime = std::chrono::steady_clock::time_point();
+
+  delete this->Makefile;
+  this->Makefile = nullptr;
+
+  delete this->GlobalGenerator;
+  this->GlobalGenerator = nullptr;
+
+  delete this->CMake;
+}
+
+cmCTestScriptHandler::~cmCTestScriptHandler()
+{
+  delete this->Makefile;
+  delete this->GlobalGenerator;
+  delete this->CMake;
+}
+
+// just adds an argument to the vector
+void cmCTestScriptHandler::AddConfigurationScript(const char* script,
+                                                  bool pscope)
+{
+  this->ConfigurationScripts.push_back(script);
+  this->ScriptProcessScope.push_back(pscope);
+}
+
+// the generic entry point for handling scripts, this routine will run all
+// the scripts provides a -S arguments
+int cmCTestScriptHandler::ProcessHandler()
+{
+  int res = 0;
+  for (size_t i = 0; i < this->ConfigurationScripts.size(); ++i) {
+    // for each script run it
+    res |= this->RunConfigurationScript(
+      cmSystemTools::CollapseFullPath(this->ConfigurationScripts[i]),
+      this->ScriptProcessScope[i]);
+  }
+  if (res) {
+    return -1;
+  }
+  return 0;
+}
+
+void cmCTestScriptHandler::UpdateElapsedTime()
+{
+  if (this->Makefile) {
+    // set the current elapsed time
+    auto itime = std::chrono::duration_cast<std::chrono::seconds>(
+      std::chrono::steady_clock::now() - this->ScriptStartTime);
+    auto timeString = std::to_string(itime.count());
+    this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString.c_str());
+  }
+}
+
+void cmCTestScriptHandler::AddCTestCommand(std::string const& name,
+                                           cmCTestCommand* command)
+{
+  command->CTest = this->CTest;
+  command->CTestScriptHandler = this;
+  this->CMake->GetState()->AddBuiltinCommand(name, command);
+}
+
+int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
+{
+  // execute the script passing in the arguments to the script as well as the
+  // arguments from this invocation of cmake
+  std::vector<const char*> argv;
+  argv.push_back(cmSystemTools::GetCTestCommand().c_str());
+  argv.push_back("-SR");
+  argv.push_back(total_script_arg.c_str());
+
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Executable for CTest is: "
+               << cmSystemTools::GetCTestCommand() << "\n");
+
+  // now pass through all the other arguments
+  std::vector<std::string>& initArgs =
+    this->CTest->GetInitialCommandLineArguments();
+  //*** need to make sure this does not have the current script ***
+  for (size_t i = 1; i < initArgs.size(); ++i) {
+    argv.push_back(initArgs[i].c_str());
+  }
+  argv.push_back(nullptr);
+
+  // Now create process object
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*argv.begin());
+  // cmsysProcess_SetWorkingDirectory(cp, dir);
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  // cmsysProcess_SetTimeout(cp, timeout);
+  cmsysProcess_Execute(cp);
+
+  std::vector<char> out;
+  std::vector<char> err;
+  std::string line;
+  int pipe = cmSystemTools::WaitForLine(cp, line, 100.0, out, err);
+  while (pipe != cmsysProcess_Pipe_None) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Output: " << line
+                                                               << "\n");
+    if (pipe == cmsysProcess_Pipe_STDERR) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, line << "\n");
+    } else if (pipe == cmsysProcess_Pipe_STDOUT) {
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, line << "\n");
+    }
+    pipe = cmSystemTools::WaitForLine(cp, line, 100, out, err);
+  }
+
+  // Properly handle output of the build command
+  cmsysProcess_WaitForExit(cp, nullptr);
+  int result = cmsysProcess_GetState(cp);
+  int retVal = 0;
+  bool failed = false;
+  if (result == cmsysProcess_State_Exited) {
+    retVal = cmsysProcess_GetExitValue(cp);
+  } else if (result == cmsysProcess_State_Exception) {
+    retVal = cmsysProcess_GetExitException(cp);
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
+                 << cmsysProcess_GetExceptionString(cp) << " " << retVal
+                 << std::endl);
+    failed = true;
+  } else if (result == cmsysProcess_State_Expired) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
+                 << std::endl);
+    failed = true;
+  } else if (result == cmsysProcess_State_Error) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing ctest: "
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
+    failed = true;
+  }
+  cmsysProcess_Delete(cp);
+  if (failed) {
+    std::ostringstream message;
+    message << "Error running command: [";
+    message << result << "] ";
+    for (const char* arg : argv) {
+      if (arg) {
+        message << arg << " ";
+      }
+    }
+    cmCTestLog(this->CTest, ERROR_MESSAGE, message.str() << argv[0]
+                                                         << std::endl);
+    return -1;
+  }
+  return retVal;
+}
+
+static void ctestScriptProgressCallback(const char* m, float /*unused*/,
+                                        void* cd)
+{
+  cmCTest* ctest = static_cast<cmCTest*>(cd);
+  if (m && *m) {
+    cmCTestLog(ctest, HANDLER_OUTPUT, "-- " << m << std::endl);
+  }
+}
+
+void cmCTestScriptHandler::CreateCMake()
+{
+  // create a cmake instance to read the configuration script
+  if (this->CMake) {
+    delete this->CMake;
+    delete this->GlobalGenerator;
+    delete this->Makefile;
+  }
+  this->CMake = new cmake(cmake::RoleScript);
+  this->CMake->SetHomeDirectory("");
+  this->CMake->SetHomeOutputDirectory("");
+  this->CMake->GetCurrentSnapshot().SetDefaultDefinitions();
+  this->CMake->AddCMakePaths();
+  this->GlobalGenerator = new cmGlobalGenerator(this->CMake);
+
+  cmStateSnapshot snapshot = this->CMake->GetCurrentSnapshot();
+  std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
+  snapshot.GetDirectory().SetCurrentSource(cwd);
+  snapshot.GetDirectory().SetCurrentBinary(cwd);
+  this->Makefile = new cmMakefile(this->GlobalGenerator, snapshot);
+
+  this->CMake->SetProgressCallback(ctestScriptProgressCallback, this->CTest);
+
+  this->AddCTestCommand("ctest_build", new cmCTestBuildCommand);
+  this->AddCTestCommand("ctest_configure", new cmCTestConfigureCommand);
+  this->AddCTestCommand("ctest_coverage", new cmCTestCoverageCommand);
+  this->AddCTestCommand("ctest_empty_binary_directory",
+                        new cmCTestEmptyBinaryDirectoryCommand);
+  this->AddCTestCommand("ctest_memcheck", new cmCTestMemCheckCommand);
+  this->AddCTestCommand("ctest_read_custom_files",
+                        new cmCTestReadCustomFilesCommand);
+  this->AddCTestCommand("ctest_run_script", new cmCTestRunScriptCommand);
+  this->AddCTestCommand("ctest_sleep", new cmCTestSleepCommand);
+  this->AddCTestCommand("ctest_start", new cmCTestStartCommand);
+  this->AddCTestCommand("ctest_submit", new cmCTestSubmitCommand);
+  this->AddCTestCommand("ctest_test", new cmCTestTestCommand);
+  this->AddCTestCommand("ctest_update", new cmCTestUpdateCommand);
+  this->AddCTestCommand("ctest_upload", new cmCTestUploadCommand);
+}
+
+// this sets up some variables for the script to use, creates the required
+// cmake instance and generators, and then reads in the script
+int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
+{
+  // Reset the error flag so that the script is read in no matter what
+  cmSystemTools::ResetErrorOccuredFlag();
+
+  // if the argument has a , in it then it needs to be broken into the fist
+  // argument (which is the script) and the second argument which will be
+  // passed into the scripts as S_ARG
+  std::string script = total_script_arg;
+  std::string script_arg;
+  const std::string::size_type comma_pos = total_script_arg.find(',');
+  if (comma_pos != std::string::npos) {
+    script = total_script_arg.substr(0, comma_pos);
+    script_arg = total_script_arg.substr(comma_pos + 1);
+  }
+  // make sure the file exists
+  if (!cmSystemTools::FileExists(script.c_str())) {
+    cmSystemTools::Error("Cannot find file: ", script.c_str());
+    return 1;
+  }
+
+  // read in the list file to fill the cache
+  // create a cmake instance to read the configuration script
+  this->CreateCMake();
+
+  // set a variable with the path to the current script
+  this->Makefile->AddDefinition(
+    "CTEST_SCRIPT_DIRECTORY", cmSystemTools::GetFilenamePath(script).c_str());
+  this->Makefile->AddDefinition(
+    "CTEST_SCRIPT_NAME", cmSystemTools::GetFilenameName(script).c_str());
+  this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
+                                cmSystemTools::GetCTestCommand().c_str());
+  this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
+                                cmSystemTools::GetCMakeCommand().c_str());
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", true);
+  this->UpdateElapsedTime();
+
+  // add the script arg if defined
+  if (!script_arg.empty()) {
+    this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str());
+  }
+
+#if defined(__CYGWIN__)
+  this->Makefile->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");
+#endif
+
+  // always add a function blocker to update the elapsed time
+  cmCTestScriptFunctionBlocker* f = new cmCTestScriptFunctionBlocker();
+  f->CTestScriptHandler = this;
+  this->Makefile->AddFunctionBlocker(f);
+
+  /* Execute CTestScriptMode.cmake, which loads CMakeDetermineSystem and
+  CMakeSystemSpecificInformation, so
+  that variables like CMAKE_SYSTEM and also the search paths for libraries,
+  header and executables are set correctly and can be used. Makes new-style
+  ctest scripting easier. */
+  std::string systemFile =
+    this->Makefile->GetModulesFile("CTestScriptMode.cmake");
+  if (!this->Makefile->ReadListFile(systemFile.c_str()) ||
+      cmSystemTools::GetErrorOccuredFlag()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in read:" << systemFile
+                                                            << "\n");
+    return 2;
+  }
+
+  // Add definitions of variables passed in on the command line:
+  const std::map<std::string, std::string>& defs =
+    this->CTest->GetDefinitions();
+  for (auto const& d : defs) {
+    this->Makefile->AddDefinition(d.first, d.second.c_str());
+  }
+
+  // finally read in the script
+  if (!this->Makefile->ReadListFile(script.c_str()) ||
+      cmSystemTools::GetErrorOccuredFlag()) {
+    // Reset the error flag so that it can run more than
+    // one script with an error when you use ctest_run_script.
+    cmSystemTools::ResetErrorOccuredFlag();
+    return 2;
+  }
+
+  return 0;
+}
+
+// extract variables from the script to set ivars
+int cmCTestScriptHandler::ExtractVariables()
+{
+  // Temporary variables
+  const char* minInterval;
+  const char* contDuration;
+
+  this->SourceDir =
+    this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
+  this->BinaryDir =
+    this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
+
+  // add in translations for src and bin
+  cmSystemTools::AddKeepPath(this->SourceDir);
+  cmSystemTools::AddKeepPath(this->BinaryDir);
+
+  this->CTestCmd = this->Makefile->GetSafeDefinition("CTEST_COMMAND");
+  this->CVSCheckOut = this->Makefile->GetSafeDefinition("CTEST_CVS_CHECKOUT");
+  this->CTestRoot = this->Makefile->GetSafeDefinition("CTEST_DASHBOARD_ROOT");
+  this->UpdateCmd = this->Makefile->GetSafeDefinition("CTEST_UPDATE_COMMAND");
+  if (this->UpdateCmd.empty()) {
+    this->UpdateCmd = this->Makefile->GetSafeDefinition("CTEST_CVS_COMMAND");
+  }
+  this->CTestEnv = this->Makefile->GetSafeDefinition("CTEST_ENVIRONMENT");
+  this->InitialCache =
+    this->Makefile->GetSafeDefinition("CTEST_INITIAL_CACHE");
+  this->CMakeCmd = this->Makefile->GetSafeDefinition("CTEST_CMAKE_COMMAND");
+  this->CMOutFile =
+    this->Makefile->GetSafeDefinition("CTEST_CMAKE_OUTPUT_FILE_NAME");
+
+  this->Backup = this->Makefile->IsOn("CTEST_BACKUP_AND_RESTORE");
+  this->EmptyBinDir =
+    this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY");
+  this->EmptyBinDirOnce =
+    this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE");
+
+  minInterval =
+    this->Makefile->GetDefinition("CTEST_CONTINUOUS_MINIMUM_INTERVAL");
+  contDuration = this->Makefile->GetDefinition("CTEST_CONTINUOUS_DURATION");
+
+  char updateVar[40];
+  int i;
+  for (i = 1; i < 10; ++i) {
+    sprintf(updateVar, "CTEST_EXTRA_UPDATES_%i", i);
+    const char* updateVal = this->Makefile->GetDefinition(updateVar);
+    if (updateVal) {
+      if (this->UpdateCmd.empty()) {
+        cmSystemTools::Error(
+          updateVar, " specified without specifying CTEST_CVS_COMMAND.");
+        return 12;
+      }
+      this->ExtraUpdates.push_back(updateVal);
+    }
+  }
+
+  // in order to backup and restore we also must have the cvs root
+  if (this->Backup && this->CVSCheckOut.empty()) {
+    cmSystemTools::Error(
+      "Backup was requested without specifying CTEST_CVS_CHECKOUT.");
+    return 3;
+  }
+
+  // make sure the required info is here
+  if (this->SourceDir.empty() || this->BinaryDir.empty() ||
+      this->CTestCmd.empty()) {
+    std::string msg = "CTEST_SOURCE_DIRECTORY = ";
+    msg += (!this->SourceDir.empty()) ? this->SourceDir.c_str() : "(Null)";
+    msg += "\nCTEST_BINARY_DIRECTORY = ";
+    msg += (!this->BinaryDir.empty()) ? this->BinaryDir.c_str() : "(Null)";
+    msg += "\nCTEST_COMMAND = ";
+    msg += (!this->CTestCmd.empty()) ? this->CTestCmd.c_str() : "(Null)";
+    cmSystemTools::Error(
+      "Some required settings in the configuration file were missing:\n",
+      msg.c_str());
+    return 4;
+  }
+
+  // if the dashboard root isn't specified then we can compute it from the
+  // this->SourceDir
+  if (this->CTestRoot.empty()) {
+    this->CTestRoot = cmSystemTools::GetFilenamePath(this->SourceDir);
+  }
+
+  // the script may override the minimum continuous interval
+  if (minInterval) {
+    this->MinimumInterval = 60 * atof(minInterval);
+  }
+  if (contDuration) {
+    this->ContinuousDuration = 60.0 * atof(contDuration);
+  }
+
+  this->UpdateElapsedTime();
+
+  return 0;
+}
+
+void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait)
+{
+#if defined(_WIN32)
+  Sleep(1000 * secondsToWait);
+#else
+  sleep(secondsToWait);
+#endif
+}
+
+// run a specific script
+int cmCTestScriptHandler::RunConfigurationScript(
+  const std::string& total_script_arg, bool pscope)
+{
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  cmSystemTools::SaveRestoreEnvironment sre;
+#endif
+
+  int result;
+
+  this->ScriptStartTime = std::chrono::steady_clock::now();
+
+  // read in the script
+  if (pscope) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Reading Script: " << total_script_arg << std::endl);
+    result = this->ReadInScript(total_script_arg);
+  } else {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Executing Script: " << total_script_arg << std::endl);
+    result = this->ExecuteScript(total_script_arg);
+  }
+  if (result) {
+    return result;
+  }
+
+  // only run the curent script if we should
+  if (this->Makefile && this->Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT")) {
+    return this->RunCurrentScript();
+  }
+  return result;
+}
+
+int cmCTestScriptHandler::RunCurrentScript()
+{
+  int result;
+
+  // do not run twice
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", false);
+
+  // no popup widows
+  cmSystemTools::SetRunCommandHideConsole(true);
+
+  // extract the vars from the cache and store in ivars
+  result = this->ExtractVariables();
+  if (result) {
+    return result;
+  }
+
+  // set any environment variables
+  if (!this->CTestEnv.empty()) {
+    std::vector<std::string> envArgs;
+    cmSystemTools::ExpandListArgument(this->CTestEnv, envArgs);
+    cmSystemTools::AppendEnv(envArgs);
+  }
+
+  // now that we have done most of the error checking finally run the
+  // dashboard, we may be asked to repeatedly run this dashboard, such as
+  // for a continuous, do we ned to run it more than once?
+  if (this->ContinuousDuration >= 0) {
+    this->UpdateElapsedTime();
+    auto ending_time = std::chrono::steady_clock::now() +
+      std::chrono::duration<double>(this->ContinuousDuration);
+    if (this->EmptyBinDirOnce) {
+      this->EmptyBinDir = true;
+    }
+    do {
+      auto startOfInterval = std::chrono::steady_clock::now();
+      result = this->RunConfigurationDashboard();
+      auto interval = std::chrono::steady_clock::now() - startOfInterval;
+      auto minimumInterval =
+        std::chrono::duration<double>(this->MinimumInterval);
+      if (interval < minimumInterval) {
+        auto sleepTime = std::chrono::duration_cast<std::chrono::seconds>(
+                           minimumInterval - interval)
+                           .count();
+        this->SleepInSeconds(static_cast<unsigned int>(sleepTime));
+      }
+      if (this->EmptyBinDirOnce) {
+        this->EmptyBinDir = false;
+      }
+    } while (std::chrono::steady_clock::now() < ending_time);
+  }
+  // otherwise just run it once
+  else {
+    result = this->RunConfigurationDashboard();
+  }
+
+  return result;
+}
+
+int cmCTestScriptHandler::CheckOutSourceDir()
+{
+  std::string command;
+  std::string output;
+  int retVal;
+  bool res;
+
+  if (!cmSystemTools::FileExists(this->SourceDir.c_str()) &&
+      !this->CVSCheckOut.empty()) {
+    // we must now checkout the src dir
+    output.clear();
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Run cvs: " << this->CVSCheckOut << std::endl);
+    res = cmSystemTools::RunSingleCommand(
+      this->CVSCheckOut.c_str(), &output, &output, &retVal,
+      this->CTestRoot.c_str(), this->HandlerVerbose, 0 /*this->TimeOut*/);
+    if (!res || retVal != 0) {
+      cmSystemTools::Error("Unable to perform cvs checkout:\n",
+                           output.c_str());
+      return 6;
+    }
+  }
+  return 0;
+}
+
+int cmCTestScriptHandler::BackupDirectories()
+{
+  int retVal;
+
+  // compute the backup names
+  this->BackupSourceDir = this->SourceDir;
+  this->BackupSourceDir += "_CMakeBackup";
+  this->BackupBinaryDir = this->BinaryDir;
+  this->BackupBinaryDir += "_CMakeBackup";
+
+  // backup the binary and src directories if requested
+  if (this->Backup) {
+    // if for some reason those directories exist then first delete them
+    if (cmSystemTools::FileExists(this->BackupSourceDir.c_str())) {
+      cmSystemTools::RemoveADirectory(this->BackupSourceDir);
+    }
+    if (cmSystemTools::FileExists(this->BackupBinaryDir.c_str())) {
+      cmSystemTools::RemoveADirectory(this->BackupBinaryDir);
+    }
+
+    // first rename the src and binary directories
+    rename(this->SourceDir.c_str(), this->BackupSourceDir.c_str());
+    rename(this->BinaryDir.c_str(), this->BackupBinaryDir.c_str());
+
+    // we must now checkout the src dir
+    retVal = this->CheckOutSourceDir();
+    if (retVal) {
+      this->RestoreBackupDirectories();
+      return retVal;
+    }
+  }
+
+  return 0;
+}
+
+int cmCTestScriptHandler::PerformExtraUpdates()
+{
+  std::string command;
+  std::string output;
+  int retVal;
+  bool res;
+
+  // do an initial cvs update as required
+  command = this->UpdateCmd;
+  for (std::string const& eu : this->ExtraUpdates) {
+    std::vector<std::string> cvsArgs;
+    cmSystemTools::ExpandListArgument(eu, cvsArgs);
+    if (cvsArgs.size() == 2) {
+      std::string fullCommand = command;
+      fullCommand += " update ";
+      fullCommand += cvsArgs[1];
+      output.clear();
+      retVal = 0;
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Run Update: " << fullCommand << std::endl);
+      res = cmSystemTools::RunSingleCommand(
+        fullCommand.c_str(), &output, &output, &retVal, cvsArgs[0].c_str(),
+        this->HandlerVerbose, 0 /*this->TimeOut*/);
+      if (!res || retVal != 0) {
+        cmSystemTools::Error("Unable to perform extra updates:\n", eu.c_str(),
+                             "\nWith output:\n", output.c_str());
+        return 0;
+      }
+    }
+  }
+  return 0;
+}
+
+// run a single dashboard entry
+int cmCTestScriptHandler::RunConfigurationDashboard()
+{
+  // local variables
+  std::string command;
+  std::string output;
+  int retVal;
+  bool res;
+
+  // make sure the src directory is there, if it isn't then we might be able
+  // to check it out from cvs
+  retVal = this->CheckOutSourceDir();
+  if (retVal) {
+    return retVal;
+  }
+
+  // backup the dirs if requested
+  retVal = this->BackupDirectories();
+  if (retVal) {
+    return retVal;
+  }
+
+  // clear the binary directory?
+  if (this->EmptyBinDir) {
+    if (!cmCTestScriptHandler::EmptyBinaryDirectory(this->BinaryDir.c_str())) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Problem removing the binary directory" << std::endl);
+    }
+  }
+
+  // make sure the binary directory exists if it isn't the srcdir
+  if (!cmSystemTools::FileExists(this->BinaryDir.c_str()) &&
+      this->SourceDir != this->BinaryDir) {
+    if (!cmSystemTools::MakeDirectory(this->BinaryDir.c_str())) {
+      cmSystemTools::Error("Unable to create the binary directory:\n",
+                           this->BinaryDir.c_str());
+      this->RestoreBackupDirectories();
+      return 7;
+    }
+  }
+
+  // if the binary directory and the source directory are the same,
+  // and we are starting with an empty binary directory, then that means
+  // we must check out the source tree
+  if (this->EmptyBinDir && this->SourceDir == this->BinaryDir) {
+    // make sure we have the required info
+    if (this->CVSCheckOut.empty()) {
+      cmSystemTools::Error(
+        "You have specified the source and binary "
+        "directories to be the same (an in source build). You have also "
+        "specified that the binary directory is to be erased. This means "
+        "that the source will have to be checked out from CVS. But you have "
+        "not specified CTEST_CVS_CHECKOUT");
+      return 8;
+    }
+
+    // we must now checkout the src dir
+    retVal = this->CheckOutSourceDir();
+    if (retVal) {
+      this->RestoreBackupDirectories();
+      return retVal;
+    }
+  }
+
+  // backup the dirs if requested
+  retVal = this->PerformExtraUpdates();
+  if (retVal) {
+    return retVal;
+  }
+
+  // put the initial cache into the bin dir
+  if (!this->InitialCache.empty()) {
+    if (!this->WriteInitialCache(this->BinaryDir.c_str(),
+                                 this->InitialCache.c_str())) {
+      this->RestoreBackupDirectories();
+      return 9;
+    }
+  }
+
+  // do an initial cmake to setup the DartConfig file
+  int cmakeFailed = 0;
+  std::string cmakeFailedOuput;
+  if (!this->CMakeCmd.empty()) {
+    command = this->CMakeCmd;
+    command += " \"";
+    command += this->SourceDir;
+    output.clear();
+    command += "\"";
+    retVal = 0;
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Run cmake command: " << command << std::endl);
+    res = cmSystemTools::RunSingleCommand(
+      command.c_str(), &output, &output, &retVal, this->BinaryDir.c_str(),
+      this->HandlerVerbose, 0 /*this->TimeOut*/);
+
+    if (!this->CMOutFile.empty()) {
+      std::string cmakeOutputFile = this->CMOutFile;
+      if (!cmSystemTools::FileIsFullPath(cmakeOutputFile.c_str())) {
+        cmakeOutputFile = this->BinaryDir + "/" + cmakeOutputFile;
+      }
+
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Write CMake output to file: " << cmakeOutputFile
+                                                << std::endl);
+      cmGeneratedFileStream fout(cmakeOutputFile.c_str());
+      if (fout) {
+        fout << output.c_str();
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Cannot open CMake output file: "
+                     << cmakeOutputFile << " for writing" << std::endl);
+      }
+    }
+    if (!res || retVal != 0) {
+      // even if this fails continue to the next step
+      cmakeFailed = 1;
+      cmakeFailedOuput = output;
+    }
+  }
+
+  // run ctest, it may be more than one command in here
+  std::vector<std::string> ctestCommands;
+  cmSystemTools::ExpandListArgument(this->CTestCmd, ctestCommands);
+  // for each variable/argument do a putenv
+  for (std::string const& ctestCommand : ctestCommands) {
+    command = ctestCommand;
+    output.clear();
+    retVal = 0;
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Run ctest command: " << command << std::endl);
+    res = cmSystemTools::RunSingleCommand(
+      command.c_str(), &output, &output, &retVal, this->BinaryDir.c_str(),
+      this->HandlerVerbose, 0 /*this->TimeOut*/);
+
+    // did something critical fail in ctest
+    if (!res || cmakeFailed || retVal & cmCTest::BUILD_ERRORS) {
+      this->RestoreBackupDirectories();
+      if (cmakeFailed) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Unable to run cmake:" << std::endl
+                                          << cmakeFailedOuput << std::endl);
+        return 10;
+      }
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Unable to run ctest:" << std::endl
+                                        << "command: " << command << std::endl
+                                        << "output: " << output << std::endl);
+      if (!res) {
+        return 11;
+      }
+      return retVal * 100;
+    }
+  }
+
+  // if all was successful, delete the backup dirs to free up disk space
+  if (this->Backup) {
+    cmSystemTools::RemoveADirectory(this->BackupSourceDir);
+    cmSystemTools::RemoveADirectory(this->BackupBinaryDir);
+  }
+
+  return 0;
+}
+
+bool cmCTestScriptHandler::WriteInitialCache(const char* directory,
+                                             const char* text)
+{
+  std::string cacheFile = directory;
+  cacheFile += "/CMakeCache.txt";
+  cmGeneratedFileStream fout(cacheFile.c_str());
+  if (!fout) {
+    return false;
+  }
+
+  if (text != nullptr) {
+    fout.write(text, strlen(text));
+  }
+
+  // Make sure the operating system has finished writing the file
+  // before closing it.  This will ensure the file is finished before
+  // the check below.
+  fout.flush();
+  fout.close();
+  return true;
+}
+
+void cmCTestScriptHandler::RestoreBackupDirectories()
+{
+  // if we backed up the dirs and the build failed, then restore
+  // the backed up dirs
+  if (this->Backup) {
+    // if for some reason those directories exist then first delete them
+    if (cmSystemTools::FileExists(this->SourceDir.c_str())) {
+      cmSystemTools::RemoveADirectory(this->SourceDir);
+    }
+    if (cmSystemTools::FileExists(this->BinaryDir.c_str())) {
+      cmSystemTools::RemoveADirectory(this->BinaryDir);
+    }
+    // rename the src and binary directories
+    rename(this->BackupSourceDir.c_str(), this->SourceDir.c_str());
+    rename(this->BackupBinaryDir.c_str(), this->BinaryDir.c_str());
+  }
+}
+
+bool cmCTestScriptHandler::RunScript(cmCTest* ctest, const char* sname,
+                                     bool InProcess, int* returnValue)
+{
+  cmCTestScriptHandler* sh = new cmCTestScriptHandler();
+  sh->SetCTestInstance(ctest);
+  sh->AddConfigurationScript(sname, InProcess);
+  int res = sh->ProcessHandler();
+  if (returnValue) {
+    *returnValue = res;
+  }
+  delete sh;
+  return true;
+}
+
+bool cmCTestScriptHandler::EmptyBinaryDirectory(const char* sname)
+{
+  // try to avoid deleting root
+  if (!sname || strlen(sname) < 2) {
+    return false;
+  }
+
+  // consider non existing target directory a success
+  if (!cmSystemTools::FileExists(sname)) {
+    return true;
+  }
+
+  // try to avoid deleting directories that we shouldn't
+  std::string check = sname;
+  check += "/CMakeCache.txt";
+
+  if (!cmSystemTools::FileExists(check.c_str())) {
+    return false;
+  }
+
+  for (int i = 0; i < 5; ++i) {
+    if (TryToRemoveBinaryDirectoryOnce(sname)) {
+      return true;
+    }
+    cmSystemTools::Delay(100);
+  }
+
+  return false;
+}
+
+bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce(
+  const std::string& directoryPath)
+{
+  cmsys::Directory directory;
+  directory.Load(directoryPath);
+
+  for (unsigned long i = 0; i < directory.GetNumberOfFiles(); ++i) {
+    std::string path = directory.GetFile(i);
+
+    if (path == "." || path == ".." || path == "CMakeCache.txt") {
+      continue;
+    }
+
+    std::string fullPath = directoryPath + std::string("/") + path;
+
+    bool isDirectory = cmSystemTools::FileIsDirectory(fullPath) &&
+      !cmSystemTools::FileIsSymlink(fullPath);
+
+    if (isDirectory) {
+      if (!cmSystemTools::RemoveADirectory(fullPath)) {
+        return false;
+      }
+    } else {
+      if (!cmSystemTools::RemoveFile(fullPath)) {
+        return false;
+      }
+    }
+  }
+
+  return cmSystemTools::RemoveADirectory(directoryPath);
+}
+
+std::chrono::duration<double> cmCTestScriptHandler::GetRemainingTimeAllowed()
+{
+  if (!this->Makefile) {
+    return cmCTest::MaxDuration();
+  }
+
+  const char* timelimitS = this->Makefile->GetDefinition("CTEST_TIME_LIMIT");
+
+  if (!timelimitS) {
+    return cmCTest::MaxDuration();
+  }
+
+  auto timelimit = std::chrono::duration<double>(atof(timelimitS));
+
+  auto duration = std::chrono::duration_cast<std::chrono::duration<double>>(
+    std::chrono::steady_clock::now() - this->ScriptStartTime);
+  return (timelimit - duration);
+}
diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h
new file mode 100644
index 0000000..9b7fa75
--- /dev/null
+++ b/Source/CTest/cmCTestScriptHandler.h
@@ -0,0 +1,168 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestScriptHandler_h
+#define cmCTestScriptHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include <chrono>
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCommand;
+class cmGlobalGenerator;
+class cmMakefile;
+class cmake;
+
+/** \class cmCTestScriptHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ * CTest script is controlled using several variables that script has to
+ * specify and some optional ones. Required ones are:
+ *   CTEST_SOURCE_DIRECTORY - Source directory of the project
+ *   CTEST_BINARY_DIRECTORY - Binary directory of the project
+ *   CTEST_COMMAND          - Testing commands
+ *
+ * Optional variables are:
+ *   CTEST_BACKUP_AND_RESTORE
+ *   CTEST_CMAKE_COMMAND
+ *   CTEST_CMAKE_OUTPUT_FILE_NAME
+ *   CTEST_CONTINUOUS_DURATION
+ *   CTEST_CONTINUOUS_MINIMUM_INTERVAL
+ *   CTEST_CVS_CHECKOUT
+ *   CTEST_CVS_COMMAND
+ *   CTEST_UPDATE_COMMAND
+ *   CTEST_DASHBOARD_ROOT
+ *   CTEST_ENVIRONMENT
+ *   CTEST_INITIAL_CACHE
+ *   CTEST_START_WITH_EMPTY_BINARY_DIRECTORY
+ *   CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE
+ *
+ * In addition the following variables can be used. The number can be 1-10.
+ *   CTEST_EXTRA_UPDATES_1
+ *   CTEST_EXTRA_UPDATES_2
+ *   ...
+ *   CTEST_EXTRA_UPDATES_10
+ *
+ * CTest script can use the following arguments CTest provides:
+ *   CTEST_SCRIPT_ARG
+ *   CTEST_SCRIPT_DIRECTORY
+ *   CTEST_SCRIPT_NAME
+ *
+ */
+class cmCTestScriptHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /**
+   * Add a script to run, and if is should run in the current process
+   */
+  void AddConfigurationScript(const char*, bool pscope);
+
+  /**
+   * Run a dashboard using a specified confiuration script
+   */
+  int ProcessHandler() override;
+
+  /*
+   * Run a script
+   */
+  static bool RunScript(cmCTest* ctest, const char* script, bool InProcess,
+                        int* returnValue);
+  int RunCurrentScript();
+
+  /*
+   * Empty Binary Directory
+   */
+  static bool EmptyBinaryDirectory(const char* dir);
+
+  /*
+   * Write an initial CMakeCache.txt from the given contents.
+   */
+  static bool WriteInitialCache(const char* directory, const char* text);
+
+  /*
+   * Some elapsed time handling functions
+   */
+  static void SleepInSeconds(unsigned int secondsToWait);
+  void UpdateElapsedTime();
+
+  /**
+   * Return the time remaianing that the script is allowed to run in
+   * seconds if the user has set the variable CTEST_TIME_LIMIT. If that has
+   * not been set it returns a very large value.
+   */
+  std::chrono::duration<double> GetRemainingTimeAllowed();
+
+  cmCTestScriptHandler();
+  ~cmCTestScriptHandler() override;
+
+  void Initialize() override;
+
+  void CreateCMake();
+  cmake* GetCMake() { return this->CMake; }
+
+private:
+  // reads in a script
+  int ReadInScript(const std::string& total_script_arg);
+  int ExecuteScript(const std::string& total_script_arg);
+
+  // extract vars from the script to set ivars
+  int ExtractVariables();
+
+  // perform a CVS checkout of the source dir
+  int CheckOutSourceDir();
+
+  // perform any extra cvs updates that were requested
+  int PerformExtraUpdates();
+
+  // backup and restore dirs
+  int BackupDirectories();
+  void RestoreBackupDirectories();
+
+  int RunConfigurationScript(const std::string& script, bool pscope);
+  int RunConfigurationDashboard();
+
+  // Add ctest command
+  void AddCTestCommand(std::string const& name, cmCTestCommand* command);
+
+  // Try to remove the binary directory once
+  static bool TryToRemoveBinaryDirectoryOnce(const std::string& directoryPath);
+
+  std::vector<std::string> ConfigurationScripts;
+  std::vector<bool> ScriptProcessScope;
+
+  bool Backup;
+  bool EmptyBinDir;
+  bool EmptyBinDirOnce;
+
+  std::string SourceDir;
+  std::string BinaryDir;
+  std::string BackupSourceDir;
+  std::string BackupBinaryDir;
+  std::string CTestRoot;
+  std::string CVSCheckOut;
+  std::string CTestCmd;
+  std::string UpdateCmd;
+  std::string CTestEnv;
+  std::string InitialCache;
+  std::string CMakeCmd;
+  std::string CMOutFile;
+  std::vector<std::string> ExtraUpdates;
+
+  double MinimumInterval;
+  double ContinuousDuration;
+
+  // what time in seconds did this script start running
+  std::chrono::steady_clock::time_point ScriptStartTime;
+
+  cmMakefile* Makefile;
+  cmGlobalGenerator* GlobalGenerator;
+  cmake* CMake;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestSleepCommand.cxx b/Source/CTest/cmCTestSleepCommand.cxx
new file mode 100644
index 0000000..2752cd3
--- /dev/null
+++ b/Source/CTest/cmCTestSleepCommand.cxx
@@ -0,0 +1,43 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestSleepCommand.h"
+
+#include "cmCTestScriptHandler.h"
+
+#include <stdlib.h>
+
+class cmExecutionStatus;
+
+bool cmCTestSleepCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // sleep for specified seconds
+  unsigned int time1 = atoi(args[0].c_str());
+  if (args.size() == 1) {
+    cmCTestScriptHandler::SleepInSeconds(time1);
+    // update the elapsed time since it could have slept for a while
+    this->CTestScriptHandler->UpdateElapsedTime();
+    return true;
+  }
+
+  // sleep up to a duration
+  if (args.size() == 3) {
+    unsigned int duration = atoi(args[1].c_str());
+    unsigned int time2 = atoi(args[2].c_str());
+    if (time1 + duration > time2) {
+      duration = (time1 + duration - time2);
+      cmCTestScriptHandler::SleepInSeconds(duration);
+      // update the elapsed time since it could have slept for a while
+      this->CTestScriptHandler->UpdateElapsedTime();
+    }
+    return true;
+  }
+
+  this->SetError("called with incorrect number of arguments");
+  return false;
+}
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
new file mode 100644
index 0000000..5cd185a
--- /dev/null
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -0,0 +1,46 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestSleepCommand_h
+#define cmCTestSleepCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <string>
+#include <vector>
+
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestSleep
+ * \brief Run a ctest script
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmCTestSleepCommand : public cmCTestCommand
+{
+public:
+  cmCTestSleepCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestSleepCommand* ni = new cmCTestSleepCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
new file mode 100644
index 0000000..4f0d87b
--- /dev/null
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -0,0 +1,157 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestStartCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestVC.h"
+#include "cmGeneratedFileStream.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+
+#include <sstream>
+#include <stddef.h>
+
+class cmExecutionStatus;
+
+cmCTestStartCommand::cmCTestStartCommand()
+{
+  this->CreateNewTag = true;
+  this->Quiet = false;
+}
+
+bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  size_t cnt = 0;
+  const char* smodel = args[cnt].c_str();
+  const char* src_dir = nullptr;
+  const char* bld_dir = nullptr;
+
+  cnt++;
+
+  this->CTest->SetSpecificTrack(nullptr);
+  if (cnt < args.size() - 1) {
+    if (args[cnt] == "TRACK") {
+      cnt++;
+      this->CTest->SetSpecificTrack(args[cnt].c_str());
+      cnt++;
+    }
+  }
+
+  if (cnt < args.size()) {
+    if (args[cnt] == "APPEND") {
+      cnt++;
+      this->CreateNewTag = false;
+    }
+  }
+  if (cnt < args.size()) {
+    if (args[cnt] == "QUIET") {
+      cnt++;
+      this->Quiet = true;
+    }
+  }
+
+  if (cnt < args.size()) {
+    src_dir = args[cnt].c_str();
+    cnt++;
+    if (cnt < args.size()) {
+      bld_dir = args[cnt].c_str();
+    }
+  }
+  if (!src_dir) {
+    src_dir = this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
+  }
+  if (!bld_dir) {
+    bld_dir = this->Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
+  }
+  if (!src_dir) {
+    this->SetError("source directory not specified. Specify source directory "
+                   "as an argument or set CTEST_SOURCE_DIRECTORY");
+    return false;
+  }
+  if (!bld_dir) {
+    this->SetError("binary directory not specified. Specify binary directory "
+                   "as an argument or set CTEST_BINARY_DIRECTORY");
+    return false;
+  }
+
+  cmSystemTools::AddKeepPath(src_dir);
+  cmSystemTools::AddKeepPath(bld_dir);
+
+  this->CTest->EmptyCTestConfiguration();
+
+  std::string sourceDir = cmSystemTools::CollapseFullPath(src_dir);
+  std::string binaryDir = cmSystemTools::CollapseFullPath(bld_dir);
+  this->CTest->SetCTestConfiguration("SourceDirectory", sourceDir.c_str(),
+                                     this->Quiet);
+  this->CTest->SetCTestConfiguration("BuildDirectory", binaryDir.c_str(),
+                                     this->Quiet);
+
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Run dashboard with model "
+                       << smodel << std::endl
+                       << "   Source directory: " << src_dir << std::endl
+                       << "   Build directory: " << bld_dir << std::endl,
+                     this->Quiet);
+  const char* track = this->CTest->GetSpecificTrack();
+  if (track) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Track: " << track << std::endl, this->Quiet);
+  }
+
+  // Log startup actions.
+  std::string startLogFile = binaryDir + "/Testing/Temporary/LastStart.log";
+  cmGeneratedFileStream ofs(startLogFile.c_str());
+  if (!ofs) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create log file: LastStart.log" << std::endl);
+    return false;
+  }
+
+  // Make sure the source directory exists.
+  if (!this->InitialCheckout(ofs, sourceDir)) {
+    return false;
+  }
+  if (!cmSystemTools::FileIsDirectory(sourceDir)) {
+    std::ostringstream e;
+    e << "given source path\n"
+      << "  " << sourceDir << "\n"
+      << "which is not an existing directory.  "
+      << "Set CTEST_CHECKOUT_COMMAND to a command line to create it.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
+  this->CTest->SetSuppressUpdatingCTestConfiguration(true);
+  int model = this->CTest->GetTestModelFromString(smodel);
+  this->CTest->SetTestModel(model);
+  this->CTest->SetProduceXML(true);
+
+  return this->CTest->InitializeFromCommand(this);
+}
+
+bool cmCTestStartCommand::InitialCheckout(std::ostream& ofs,
+                                          std::string const& sourceDir)
+{
+  // Use the user-provided command to create the source tree.
+  const char* initialCheckoutCommand =
+    this->Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
+  if (!initialCheckoutCommand) {
+    initialCheckoutCommand =
+      this->Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
+  }
+  if (initialCheckoutCommand) {
+    // Use a generic VC object to run and log the command.
+    cmCTestVC vc(this->CTest, ofs);
+    vc.SetSourceDirectory(sourceDir);
+    if (!vc.InitialCheckout(initialCheckoutCommand)) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
new file mode 100644
index 0000000..542f27c
--- /dev/null
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -0,0 +1,63 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestStartCommand_h
+#define cmCTestStartCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestCommand.h"
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestStart
+ * \brief Run a ctest script
+ *
+ * cmCTestStartCommand defineds the command to start the nightly testing.
+ */
+class cmCTestStartCommand : public cmCTestCommand
+{
+public:
+  cmCTestStartCommand();
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestStartCommand* ni = new cmCTestStartCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    ni->CreateNewTag = this->CreateNewTag;
+    ni->Quiet = this->Quiet;
+    return ni;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  /**
+   * Will this invocation of ctest_start create a new TAG file?
+   */
+  bool ShouldCreateNewTag() { return this->CreateNewTag; }
+
+  /**
+   * Should this invocation of ctest_start output non-error messages?
+   */
+  bool ShouldBeQuiet() { return this->Quiet; }
+
+private:
+  bool InitialCheckout(std::ostream& ofs, std::string const& sourceDir);
+  bool CreateNewTag;
+  bool Quiet;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
new file mode 100644
index 0000000..1794ca6
--- /dev/null
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -0,0 +1,273 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestSubmitCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmCTestSubmitHandler.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <sstream>
+
+class cmExecutionStatus;
+
+cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
+{
+  const char* ctestDropMethod =
+    this->Makefile->GetDefinition("CTEST_DROP_METHOD");
+  const char* ctestDropSite = this->Makefile->GetDefinition("CTEST_DROP_SITE");
+  const char* ctestDropLocation =
+    this->Makefile->GetDefinition("CTEST_DROP_LOCATION");
+  const char* ctestTriggerSite =
+    this->Makefile->GetDefinition("CTEST_TRIGGER_SITE");
+  bool ctestDropSiteCDash = this->Makefile->IsOn("CTEST_DROP_SITE_CDASH");
+  const char* ctestProjectName =
+    this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
+  if (!ctestDropMethod) {
+    ctestDropMethod = "http";
+  }
+
+  if (!ctestDropSite) {
+    // error: CDash requires CTEST_DROP_SITE definition
+    // in CTestConfig.cmake
+  }
+  if (!ctestDropLocation) {
+    // error: CDash requires CTEST_DROP_LOCATION definition
+    // in CTestConfig.cmake
+  }
+  this->CTest->SetCTestConfiguration("ProjectName", ctestProjectName,
+                                     this->Quiet);
+  this->CTest->SetCTestConfiguration("DropMethod", ctestDropMethod,
+                                     this->Quiet);
+  this->CTest->SetCTestConfiguration("DropSite", ctestDropSite, this->Quiet);
+  this->CTest->SetCTestConfiguration("DropLocation", ctestDropLocation,
+                                     this->Quiet);
+
+  this->CTest->SetCTestConfiguration(
+    "IsCDash", ctestDropSiteCDash ? "TRUE" : "FALSE", this->Quiet);
+
+  // Only propagate TriggerSite for non-CDash projects:
+  //
+  if (!ctestDropSiteCDash) {
+    this->CTest->SetCTestConfiguration("TriggerSite", ctestTriggerSite,
+                                       this->Quiet);
+  }
+
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CurlOptions", "CTEST_CURL_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "DropSiteUser", "CTEST_DROP_SITE_USER", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "DropSitePassword", "CTEST_DROP_SITE_PASSWORD",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "ScpCommand", "CTEST_SCP_COMMAND", this->Quiet);
+
+  const char* notesFilesVariable =
+    this->Makefile->GetDefinition("CTEST_NOTES_FILES");
+  if (notesFilesVariable) {
+    std::vector<std::string> notesFiles;
+    cmCTest::VectorOfStrings newNotesFiles;
+    cmSystemTools::ExpandListArgument(notesFilesVariable, notesFiles);
+    newNotesFiles.insert(newNotesFiles.end(), notesFiles.begin(),
+                         notesFiles.end());
+    this->CTest->GenerateNotesFile(newNotesFiles);
+  }
+
+  const char* extraFilesVariable =
+    this->Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
+  if (extraFilesVariable) {
+    std::vector<std::string> extraFiles;
+    cmCTest::VectorOfStrings newExtraFiles;
+    cmSystemTools::ExpandListArgument(extraFilesVariable, extraFiles);
+    newExtraFiles.insert(newExtraFiles.end(), extraFiles.begin(),
+                         extraFiles.end());
+    if (!this->CTest->SubmitExtraFiles(newExtraFiles)) {
+      this->SetError("problem submitting extra files.");
+      return nullptr;
+    }
+  }
+
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("submit");
+  if (!handler) {
+    this->SetError("internal CTest error. Cannot instantiate submit handler");
+    return nullptr;
+  }
+
+  // If no FILES or PARTS given, *all* PARTS are submitted by default.
+  //
+  // If FILES are given, but not PARTS, only the FILES are submitted
+  // and *no* PARTS are submitted.
+  //  (This is why we select the empty "noParts" set in the
+  //   FilesMentioned block below...)
+  //
+  // If PARTS are given, only the selected PARTS are submitted.
+  //
+  // If both PARTS and FILES are given, only the selected PARTS *and*
+  // all the given FILES are submitted.
+
+  // If given explicit FILES to submit, pass them to the handler.
+  //
+  if (this->FilesMentioned) {
+    // Intentionally select *no* PARTS. (Pass an empty set.) If PARTS
+    // were also explicitly mentioned, they will be selected below...
+    // But FILES with no PARTS mentioned should just submit the FILES
+    // without any of the default parts.
+    //
+    std::set<cmCTest::Part> noParts;
+    static_cast<cmCTestSubmitHandler*>(handler)->SelectParts(noParts);
+
+    static_cast<cmCTestSubmitHandler*>(handler)->SelectFiles(this->Files);
+  }
+
+  // If a PARTS option was given, select only the named parts for submission.
+  //
+  if (this->PartsMentioned) {
+    static_cast<cmCTestSubmitHandler*>(handler)->SelectParts(this->Parts);
+  }
+
+  // Pass along any HTTPHEADER to the handler if this option was given.
+  if (!this->HttpHeaders.empty()) {
+    static_cast<cmCTestSubmitHandler*>(handler)->SetHttpHeaders(
+      this->HttpHeaders);
+  }
+
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "RetryDelay", this->RetryDelay.c_str());
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "RetryCount", this->RetryCount.c_str());
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "InternalTest", this->InternalTest ? "ON" : "OFF");
+
+  handler->SetQuiet(this->Quiet);
+
+  if (this->CDashUpload) {
+    static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+      "CDashUploadFile", this->CDashUploadFile.c_str());
+    static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+      "CDashUploadType", this->CDashUploadType.c_str());
+  }
+  return handler;
+}
+
+bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus& status)
+{
+  this->CDashUpload = !args.empty() && args[0] == "CDASH_UPLOAD";
+  return this->cmCTestHandlerCommand::InitialPass(args, status);
+}
+
+bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg)
+{
+  if (this->CDashUpload) {
+    // Arguments specific to the CDASH_UPLOAD signature.
+    if (arg == "CDASH_UPLOAD") {
+      this->ArgumentDoing = ArgumentDoingCDashUpload;
+      return true;
+    }
+
+    if (arg == "CDASH_UPLOAD_TYPE") {
+      this->ArgumentDoing = ArgumentDoingCDashUploadType;
+      return true;
+    }
+  } else {
+    // Arguments that cannot be used with CDASH_UPLOAD.
+    if (arg == "PARTS") {
+      this->ArgumentDoing = ArgumentDoingParts;
+      this->PartsMentioned = true;
+      return true;
+    }
+
+    if (arg == "FILES") {
+      this->ArgumentDoing = ArgumentDoingFiles;
+      this->FilesMentioned = true;
+      return true;
+    }
+  }
+  // Arguments used by both modes.
+  if (arg == "HTTPHEADER") {
+    this->ArgumentDoing = ArgumentDoingHttpHeader;
+    return true;
+  }
+
+  if (arg == "RETRY_COUNT") {
+    this->ArgumentDoing = ArgumentDoingRetryCount;
+    return true;
+  }
+
+  if (arg == "RETRY_DELAY") {
+    this->ArgumentDoing = ArgumentDoingRetryDelay;
+    return true;
+  }
+
+  if (arg == "INTERNAL_TEST_CHECKSUM") {
+    this->InternalTest = true;
+    return true;
+  }
+
+  // Look for other arguments.
+  return this->Superclass::CheckArgumentKeyword(arg);
+}
+
+bool cmCTestSubmitCommand::CheckArgumentValue(std::string const& arg)
+{
+  // Handle states specific to this command.
+  if (this->ArgumentDoing == ArgumentDoingParts) {
+    cmCTest::Part p = this->CTest->GetPartFromName(arg.c_str());
+    if (p != cmCTest::PartCount) {
+      this->Parts.insert(p);
+    } else {
+      std::ostringstream e;
+      e << "Part name \"" << arg << "\" is invalid.";
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      this->ArgumentDoing = ArgumentDoingError;
+    }
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingFiles) {
+    if (cmSystemTools::FileExists(arg.c_str())) {
+      this->Files.insert(arg);
+    } else {
+      std::ostringstream e;
+      e << "File \"" << arg << "\" does not exist. Cannot submit "
+        << "a non-existent file.";
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      this->ArgumentDoing = ArgumentDoingError;
+    }
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingHttpHeader) {
+    this->HttpHeaders.push_back(arg);
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingRetryCount) {
+    this->RetryCount = arg;
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingRetryDelay) {
+    this->RetryDelay = arg;
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingCDashUpload) {
+    this->ArgumentDoing = ArgumentDoingNone;
+    this->CDashUploadFile = arg;
+    return true;
+  }
+
+  if (this->ArgumentDoing == ArgumentDoingCDashUploadType) {
+    this->ArgumentDoing = ArgumentDoingNone;
+    this->CDashUploadType = arg;
+    return true;
+  }
+
+  // Look for other arguments.
+  return this->Superclass::CheckArgumentValue(arg);
+}
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
new file mode 100644
index 0000000..c4b84ce
--- /dev/null
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -0,0 +1,90 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestSubmitCommand_h
+#define cmCTestSubmitCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTest.h"
+#include "cmCTestHandlerCommand.h"
+
+#include <set>
+#include <string>
+#include <vector>
+
+class cmCTestGenericHandler;
+class cmCommand;
+class cmExecutionStatus;
+
+/** \class cmCTestSubmit
+ * \brief Run a ctest script
+ *
+ * cmCTestSubmitCommand defineds the command to submit the test results for
+ * the project.
+ */
+class cmCTestSubmitCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestSubmitCommand()
+  {
+    this->PartsMentioned = false;
+    this->FilesMentioned = false;
+    this->InternalTest = false;
+    this->RetryCount = "";
+    this->RetryDelay = "";
+    this->CDashUpload = false;
+  }
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestSubmitCommand* ni = new cmCTestSubmitCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_submit"; }
+
+  typedef cmCTestHandlerCommand Superclass;
+
+protected:
+  cmCTestGenericHandler* InitializeHandler() override;
+
+  bool CheckArgumentKeyword(std::string const& arg) override;
+  bool CheckArgumentValue(std::string const& arg) override;
+
+  enum
+  {
+    ArgumentDoingParts = Superclass::ArgumentDoingLast1,
+    ArgumentDoingFiles,
+    ArgumentDoingRetryDelay,
+    ArgumentDoingRetryCount,
+    ArgumentDoingCDashUpload,
+    ArgumentDoingCDashUploadType,
+    ArgumentDoingHttpHeader,
+    ArgumentDoingLast2
+  };
+
+  bool PartsMentioned;
+  std::set<cmCTest::Part> Parts;
+  bool FilesMentioned;
+  bool InternalTest;
+  cmCTest::SetOfStrings Files;
+  std::string RetryCount;
+  std::string RetryDelay;
+  bool CDashUpload;
+  std::string CDashUploadFile;
+  std::string CDashUploadType;
+  std::vector<std::string> HttpHeaders;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
new file mode 100644
index 0000000..86fee7a
--- /dev/null
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -0,0 +1,1598 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestSubmitHandler.h"
+
+#include "cm_curl.h"
+#include "cm_jsoncpp_reader.h"
+#include "cm_jsoncpp_value.h"
+#include "cmsys/Process.h"
+#include <chrono>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cmCTest.h"
+#include "cmCTestCurl.h"
+#include "cmCTestScriptHandler.h"
+#include "cmCryptoHash.h"
+#include "cmCurl.h"
+#include "cmGeneratedFileStream.h"
+#include "cmProcessOutput.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+#include "cmThirdParty.h"
+#include "cmWorkingDirectory.h"
+#include "cmXMLParser.h"
+#include "cmake.h"
+
+#if defined(CTEST_USE_XMLRPC)
+#include "cmVersion.h"
+#include "cm_sys_stat.h"
+#include "cm_xmlrpc.h"
+#endif
+
+#define SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT 120
+
+typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
+
+class cmCTestSubmitHandler::ResponseParser : public cmXMLParser
+{
+public:
+  ResponseParser() { this->Status = STATUS_OK; }
+  ~ResponseParser() override {}
+
+public:
+  enum StatusType
+  {
+    STATUS_OK,
+    STATUS_WARNING,
+    STATUS_ERROR
+  };
+
+  StatusType Status;
+  std::string Filename;
+  std::string MD5;
+  std::string Message;
+
+private:
+  std::vector<char> CurrentValue;
+
+  std::string GetCurrentValue()
+  {
+    std::string val;
+    if (!this->CurrentValue.empty()) {
+      val.assign(&this->CurrentValue[0], this->CurrentValue.size());
+    }
+    return val;
+  }
+
+  void StartElement(const std::string& /*name*/,
+                    const char** /*atts*/) override
+  {
+    this->CurrentValue.clear();
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    this->CurrentValue.insert(this->CurrentValue.end(), data, data + length);
+  }
+
+  void EndElement(const std::string& name) override
+  {
+    if (name == "status") {
+      std::string status = cmSystemTools::UpperCase(this->GetCurrentValue());
+      if (status == "OK" || status == "SUCCESS") {
+        this->Status = STATUS_OK;
+      } else if (status == "WARNING") {
+        this->Status = STATUS_WARNING;
+      } else {
+        this->Status = STATUS_ERROR;
+      }
+    } else if (name == "filename") {
+      this->Filename = this->GetCurrentValue();
+    } else if (name == "md5") {
+      this->MD5 = this->GetCurrentValue();
+    } else if (name == "message") {
+      this->Message = this->GetCurrentValue();
+    }
+  }
+};
+
+static size_t cmCTestSubmitHandlerWriteMemoryCallback(void* ptr, size_t size,
+                                                      size_t nmemb, void* data)
+{
+  int realsize = static_cast<int>(size * nmemb);
+
+  cmCTestSubmitHandlerVectorOfChar* vec =
+    static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  vec->insert(vec->end(), chPtr, chPtr + realsize);
+
+  return realsize;
+}
+
+static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL* /*unused*/,
+                                                    curl_infotype /*unused*/,
+                                                    char* chPtr, size_t size,
+                                                    void* data)
+{
+  cmCTestSubmitHandlerVectorOfChar* vec =
+    static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
+  vec->insert(vec->end(), chPtr, chPtr + size);
+
+  return size;
+}
+
+cmCTestSubmitHandler::cmCTestSubmitHandler()
+  : HTTPProxy()
+  , FTPProxy()
+{
+  this->Initialize();
+}
+
+void cmCTestSubmitHandler::Initialize()
+{
+  // We submit all available parts by default.
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
+    this->SubmitPart[p] = true;
+  }
+  this->CDash = false;
+  this->HasWarnings = false;
+  this->HasErrors = false;
+  this->Superclass::Initialize();
+  this->HTTPProxy.clear();
+  this->HTTPProxyType = 0;
+  this->HTTPProxyAuth.clear();
+  this->FTPProxy.clear();
+  this->FTPProxyType = 0;
+  this->LogFile = nullptr;
+  this->Files.clear();
+}
+
+bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
+                                          const std::set<std::string>& files,
+                                          const std::string& remoteprefix,
+                                          const std::string& url)
+{
+  CURL* curl;
+  CURLcode res;
+  FILE* ftpfile;
+  char error_buffer[1024];
+
+  /* In windows, this will init the winsock stuff */
+  ::curl_global_init(CURL_GLOBAL_ALL);
+
+  for (std::string const& file : files) {
+    /* get a curl handle */
+    curl = curl_easy_init();
+    if (curl) {
+      // Using proxy
+      if (this->FTPProxyType > 0) {
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->FTPProxy.c_str());
+        switch (this->FTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+        }
+      }
+
+      // enable uploading
+      ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+
+      // if there is little to no activity for too long stop submitting
+      ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
+      ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME,
+                         SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
+
+      ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+
+      std::string local_file = file;
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        local_file = localprefix + "/" + file;
+      }
+      std::string upload_as =
+        url + "/" + remoteprefix + cmSystemTools::GetFilenameName(file);
+
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Cannot find file: " << local_file << std::endl);
+        ::curl_easy_cleanup(curl);
+        ::curl_global_cleanup();
+        return false;
+      }
+      unsigned long filelen = cmSystemTools::FileLength(local_file);
+
+      ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
+      *this->LogFile << "\tUpload file: " << local_file << " to " << upload_as
+                     << std::endl;
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "   Upload file: " << local_file << " to "
+                                            << upload_as << std::endl,
+                         this->Quiet);
+
+      ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+      // specify target
+      ::curl_easy_setopt(curl, CURLOPT_URL, upload_as.c_str());
+
+      // now specify which file to upload
+      ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
+
+      // and give the size of the upload (optional)
+      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(filelen));
+
+      // and give curl the buffer for errors
+      ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
+
+      // specify handler for output
+      ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                         cmCTestSubmitHandlerWriteMemoryCallback);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
+                         cmCTestSubmitHandlerCurlDebugCallback);
+
+      /* we pass our 'chunk' struct to the callback function */
+      cmCTestSubmitHandlerVectorOfChar chunk;
+      cmCTestSubmitHandlerVectorOfChar chunkDebug;
+      ::curl_easy_setopt(curl, CURLOPT_FILE, &chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &chunkDebug);
+
+      // Now run off and do what you've been told!
+      res = ::curl_easy_perform(curl);
+
+      if (!chunk.empty()) {
+        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
+
+      fclose(ftpfile);
+      if (res) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when uploading file: "
+                     << local_file << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error message was: " << error_buffer << std::endl);
+        *this->LogFile << "   Error when uploading file: " << local_file
+                       << std::endl
+                       << "   Error message was: " << error_buffer << std::endl
+                       << "   Curl output was: ";
+        // avoid dereference of empty vector
+        if (!chunk.empty()) {
+          *this->LogFile << cmCTestLogWrite(&*chunk.begin(), chunk.size());
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
+        *this->LogFile << std::endl;
+        ::curl_easy_cleanup(curl);
+        ::curl_global_cleanup();
+        return false;
+      }
+      // always cleanup
+      ::curl_easy_cleanup(curl);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Uploaded: " + local_file << std::endl,
+                         this->Quiet);
+    }
+  }
+  ::curl_global_cleanup();
+  return true;
+}
+
+// Uploading files is simpler
+bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
+                                           const std::set<std::string>& files,
+                                           const std::string& remoteprefix,
+                                           const std::string& url)
+{
+  CURL* curl;
+  CURLcode res;
+  FILE* ftpfile;
+  char error_buffer[1024];
+  // Set Content-Type to satisfy fussy modsecurity rules.
+  struct curl_slist* headers =
+    ::curl_slist_append(nullptr, "Content-Type: text/xml");
+
+  // Add any additional headers that the user specified.
+  for (std::string const& h : this->HttpHeaders) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Add HTTP Header: \"" << h << "\"" << std::endl,
+                       this->Quiet);
+    headers = ::curl_slist_append(headers, h.c_str());
+  }
+
+  /* In windows, this will init the winsock stuff */
+  ::curl_global_init(CURL_GLOBAL_ALL);
+  std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
+  std::string curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
+  std::vector<std::string> args;
+  cmSystemTools::ExpandListArgument(curlopt, args);
+  bool verifyPeerOff = false;
+  bool verifyHostOff = false;
+  for (std::string const& arg : args) {
+    if (arg == "CURLOPT_SSL_VERIFYPEER_OFF") {
+      verifyPeerOff = true;
+    }
+    if (arg == "CURLOPT_SSL_VERIFYHOST_OFF") {
+      verifyHostOff = true;
+    }
+  }
+  for (std::string const& file : files) {
+    /* get a curl handle */
+    curl = curl_easy_init();
+    if (curl) {
+      cmCurlSetCAInfo(curl);
+      if (verifyPeerOff) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "  Set CURLOPT_SSL_VERIFYPEER to off\n",
+                           this->Quiet);
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
+      }
+      if (verifyHostOff) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "  Set CURLOPT_SSL_VERIFYHOST to off\n",
+                           this->Quiet);
+        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
+      }
+
+      // Using proxy
+      if (this->HTTPProxyType > 0) {
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
+        switch (this->HTTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+            if (!this->HTTPProxyAuth.empty()) {
+              curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
+                               this->HTTPProxyAuth.c_str());
+            }
+        }
+      }
+      if (this->CTest->ShouldUseHTTP10()) {
+        curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
+      }
+      // enable HTTP ERROR parsing
+      curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+      /* enable uploading */
+      curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+
+      // if there is little to no activity for too long stop submitting
+      ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
+      ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME,
+                         SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
+
+      /* HTTP PUT please */
+      ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
+      ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+      ::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+      std::string local_file = file;
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        local_file = localprefix + "/" + file;
+      }
+      std::string remote_file =
+        remoteprefix + cmSystemTools::GetFilenameName(file);
+
+      *this->LogFile << "\tUpload file: " << local_file << " to "
+                     << remote_file << std::endl;
+
+      std::string ofile;
+      for (char c : remote_file) {
+        char hexCh[4] = { 0, 0, 0, 0 };
+        hexCh[0] = c;
+        switch (c) {
+          case '+':
+          case '?':
+          case '/':
+          case '\\':
+          case '&':
+          case ' ':
+          case '=':
+          case '%':
+            sprintf(hexCh, "%%%02X", static_cast<int>(c));
+            ofile.append(hexCh);
+            break;
+          default:
+            ofile.append(hexCh);
+        }
+      }
+      std::string upload_as = url +
+        ((url.find('?') == std::string::npos) ? '?' : '&') + "FileName=" +
+        ofile;
+
+      upload_as += "&MD5=";
+
+      if (cmSystemTools::IsOn(this->GetOption("InternalTest"))) {
+        upload_as += "bad_md5sum";
+      } else {
+        upload_as +=
+          cmSystemTools::ComputeFileHash(local_file, cmCryptoHash::AlgoMD5);
+      }
+
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Cannot find file: " << local_file << std::endl);
+        ::curl_easy_cleanup(curl);
+        ::curl_slist_free_all(headers);
+        ::curl_global_cleanup();
+        return false;
+      }
+      unsigned long filelen = cmSystemTools::FileLength(local_file);
+
+      ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "   Upload file: " << local_file << " to "
+                                            << upload_as << " Size: "
+                                            << filelen << std::endl,
+                         this->Quiet);
+
+      // specify target
+      ::curl_easy_setopt(curl, CURLOPT_URL, upload_as.c_str());
+
+      // now specify which file to upload
+      ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
+
+      // and give the size of the upload (optional)
+      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(filelen));
+
+      // and give curl the buffer for errors
+      ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
+
+      // specify handler for output
+      ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                         cmCTestSubmitHandlerWriteMemoryCallback);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
+                         cmCTestSubmitHandlerCurlDebugCallback);
+
+      /* we pass our 'chunk' struct to the callback function */
+      cmCTestSubmitHandlerVectorOfChar chunk;
+      cmCTestSubmitHandlerVectorOfChar chunkDebug;
+      ::curl_easy_setopt(curl, CURLOPT_FILE, &chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &chunkDebug);
+
+      // Now run off and do what you've been told!
+      res = ::curl_easy_perform(curl);
+
+      if (!chunk.empty()) {
+        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
+        this->ParseResponse(chunk);
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
+
+      // If curl failed for any reason, or checksum fails, wait and retry
+      //
+      if (res != CURLE_OK || this->HasErrors) {
+        std::string retryDelay = this->GetOption("RetryDelay") == nullptr
+          ? ""
+          : this->GetOption("RetryDelay");
+        std::string retryCount = this->GetOption("RetryCount") == nullptr
+          ? ""
+          : this->GetOption("RetryCount");
+
+        auto delay = std::chrono::duration<double>(
+          retryDelay.empty()
+            ? atoi(this->CTest->GetCTestConfiguration("CTestSubmitRetryDelay")
+                     .c_str())
+            : atoi(retryDelay.c_str()));
+        int count = retryCount.empty()
+          ? atoi(this->CTest->GetCTestConfiguration("CTestSubmitRetryCount")
+                   .c_str())
+          : atoi(retryCount.c_str());
+
+        for (int i = 0; i < count; i++) {
+          cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                             "   Submit failed, waiting " << delay.count()
+                                                          << " seconds...\n",
+                             this->Quiet);
+
+          auto stop = std::chrono::steady_clock::now() + delay;
+          while (std::chrono::steady_clock::now() < stop) {
+            cmSystemTools::Delay(100);
+          }
+
+          cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                             "   Retry submission: Attempt "
+                               << (i + 1) << " of " << count << std::endl,
+                             this->Quiet);
+
+          ::fclose(ftpfile);
+          ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
+          ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
+
+          chunk.clear();
+          chunkDebug.clear();
+          this->HasErrors = false;
+
+          res = ::curl_easy_perform(curl);
+
+          if (!chunk.empty()) {
+            cmCTestOptionalLog(
+              this->CTest, DEBUG, "CURL output: ["
+                << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                << std::endl,
+              this->Quiet);
+            this->ParseResponse(chunk);
+          }
+
+          if (res == CURLE_OK && !this->HasErrors) {
+            break;
+          }
+        }
+      }
+
+      fclose(ftpfile);
+      if (res) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when uploading file: "
+                     << local_file << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error message was: " << error_buffer << std::endl);
+        *this->LogFile << "   Error when uploading file: " << local_file
+                       << std::endl
+                       << "   Error message was: " << error_buffer
+                       << std::endl;
+        // avoid deref of begin for zero size array
+        if (!chunk.empty()) {
+          *this->LogFile << "   Curl output was: "
+                         << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                         << std::endl;
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
+        ::curl_easy_cleanup(curl);
+        ::curl_slist_free_all(headers);
+        ::curl_global_cleanup();
+        return false;
+      }
+      // always cleanup
+      ::curl_easy_cleanup(curl);
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Uploaded: " + local_file << std::endl,
+                         this->Quiet);
+    }
+  }
+  ::curl_slist_free_all(headers);
+  ::curl_global_cleanup();
+  return true;
+}
+
+void cmCTestSubmitHandler::ParseResponse(
+  cmCTestSubmitHandlerVectorOfChar chunk)
+{
+  std::string output;
+  output.append(chunk.begin(), chunk.end());
+
+  if (output.find("<cdash") != std::string::npos) {
+    ResponseParser parser;
+    parser.Parse(output.c_str());
+
+    if (parser.Status != ResponseParser::STATUS_OK) {
+      this->HasErrors = true;
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "   Submission failed: " << parser.Message << std::endl);
+      return;
+    }
+  }
+  output = cmSystemTools::UpperCase(output);
+  if (output.find("WARNING") != std::string::npos) {
+    this->HasWarnings = true;
+  }
+  if (output.find("ERROR") != std::string::npos) {
+    this->HasErrors = true;
+  }
+
+  if (this->HasWarnings || this->HasErrors) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Server Response:\n"
+                 << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "\n");
+  }
+}
+
+bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set<std::string>& files,
+                                            const std::string& remoteprefix,
+                                            const std::string& url)
+{
+  CURL* curl;
+  char error_buffer[1024];
+
+  /* In windows, this will init the winsock stuff */
+  ::curl_global_init(CURL_GLOBAL_ALL);
+
+  for (std::string const& file : files) {
+    /* get a curl handle */
+    curl = curl_easy_init();
+    if (curl) {
+      // Using proxy
+      if (this->HTTPProxyType > 0) {
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
+        switch (this->HTTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+            if (!this->HTTPProxyAuth.empty()) {
+              curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
+                               this->HTTPProxyAuth.c_str());
+            }
+        }
+      }
+
+      ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+      // and give curl the buffer for errors
+      ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
+
+      // specify handler for output
+      ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                         cmCTestSubmitHandlerWriteMemoryCallback);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
+                         cmCTestSubmitHandlerCurlDebugCallback);
+
+      /* we pass our 'chunk' struct to the callback function */
+      cmCTestSubmitHandlerVectorOfChar chunk;
+      cmCTestSubmitHandlerVectorOfChar chunkDebug;
+      ::curl_easy_setopt(curl, CURLOPT_FILE, &chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &chunkDebug);
+
+      std::string rfile = remoteprefix + cmSystemTools::GetFilenameName(file);
+      std::string ofile;
+      for (char c : rfile) {
+        char hexCh[4] = { 0, 0, 0, 0 };
+        hexCh[0] = c;
+        switch (c) {
+          case '+':
+          case '?':
+          case '/':
+          case '\\':
+          case '&':
+          case ' ':
+          case '=':
+          case '%':
+            sprintf(hexCh, "%%%02X", static_cast<int>(c));
+            ofile.append(hexCh);
+            break;
+          default:
+            ofile.append(hexCh);
+        }
+      }
+      std::string turl = url +
+        ((url.find('?') == std::string::npos) ? '?' : '&') + "xmlfile=" +
+        ofile;
+      *this->LogFile << "Trigger url: " << turl << std::endl;
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "   Trigger url: " << turl << std::endl, this->Quiet);
+      curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+      curl_easy_setopt(curl, CURLOPT_URL, turl.c_str());
+      if (curl_easy_perform(curl)) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error when triggering: " << turl << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error message was: " << error_buffer << std::endl);
+        *this->LogFile << "\tTriggering failed with error: " << error_buffer
+                       << std::endl
+                       << "   Error message was: " << error_buffer
+                       << std::endl;
+        if (!chunk.empty()) {
+          *this->LogFile << "   Curl output was: "
+                         << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                         << std::endl;
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
+        ::curl_easy_cleanup(curl);
+        ::curl_global_cleanup();
+        return false;
+      }
+
+      if (!chunk.empty()) {
+        cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
+
+      // always cleanup
+      ::curl_easy_cleanup(curl);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
+                         this->Quiet);
+    }
+  }
+  ::curl_global_cleanup();
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "   Dart server triggered..." << std::endl, this->Quiet);
+  return true;
+}
+
+bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command,
+                                          const std::string& localprefix,
+                                          const std::set<std::string>& files,
+                                          const std::string& remoteprefix,
+                                          const std::string& url)
+{
+  if (scp_command.empty() || localprefix.empty() || files.empty() ||
+      remoteprefix.empty() || url.empty()) {
+    return false;
+  }
+
+  std::vector<const char*> argv;
+  argv.push_back(scp_command.c_str()); // Scp command
+  argv.push_back(scp_command.c_str()); // Dummy string for file
+  argv.push_back(scp_command.c_str()); // Dummy string for remote url
+  argv.push_back(nullptr);
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  // cmsysProcess_SetTimeout(cp, timeout);
+
+  int problems = 0;
+
+  for (std::string const& file : files) {
+    int retVal;
+
+    std::string lfname = localprefix;
+    cmSystemTools::ConvertToUnixSlashes(lfname);
+    lfname += "/" + file;
+    lfname = cmSystemTools::ConvertToOutputPath(lfname.c_str());
+    argv[1] = lfname.c_str();
+    std::string rfname = url + "/" + remoteprefix + file;
+    argv[2] = rfname.c_str();
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Execute \""
+                         << argv[0] << "\" \"" << argv[1] << "\" \"" << argv[2]
+                         << "\"" << std::endl,
+                       this->Quiet);
+    *this->LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
+                   << argv[2] << "\"" << std::endl;
+
+    cmsysProcess_SetCommand(cp, &*argv.begin());
+    cmsysProcess_Execute(cp);
+    char* data;
+    int length;
+    cmProcessOutput processOutput;
+    std::string strdata;
+
+    while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
+      processOutput.DecodeText(data, length, strdata);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         cmCTestLogWrite(strdata.c_str(), strdata.size()),
+                         this->Quiet);
+    }
+    processOutput.DecodeText(std::string(), strdata);
+    if (!strdata.empty()) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         cmCTestLogWrite(strdata.c_str(), strdata.size()),
+                         this->Quiet);
+    }
+
+    cmsysProcess_WaitForExit(cp, nullptr);
+
+    int result = cmsysProcess_GetState(cp);
+
+    if (result == cmsysProcess_State_Exited) {
+      retVal = cmsysProcess_GetExitValue(cp);
+      if (retVal != 0) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "\tSCP returned: " << retVal << std::endl,
+                           this->Quiet);
+        *this->LogFile << "\tSCP returned: " << retVal << std::endl;
+        problems++;
+      }
+    } else if (result == cmsysProcess_State_Exception) {
+      retVal = cmsysProcess_GetExitException(cp);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "\tThere was an exception: " << retVal << std::endl);
+      *this->LogFile << "\tThere was an exception: " << retVal << std::endl;
+      problems++;
+    } else if (result == cmsysProcess_State_Expired) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
+                   << std::endl);
+      *this->LogFile << "\tThere was a timeout" << std::endl;
+      problems++;
+    } else if (result == cmsysProcess_State_Error) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing SCP: "
+                   << cmsysProcess_GetErrorString(cp) << std::endl);
+      *this->LogFile << "\tError executing SCP: "
+                     << cmsysProcess_GetErrorString(cp) << std::endl;
+      problems++;
+    }
+  }
+  cmsysProcess_Delete(cp);
+  return problems == 0;
+}
+
+bool cmCTestSubmitHandler::SubmitUsingCP(const std::string& localprefix,
+                                         const std::set<std::string>& files,
+                                         const std::string& remoteprefix,
+                                         const std::string& destination)
+{
+  if (localprefix.empty() || files.empty() || remoteprefix.empty() ||
+      destination.empty()) {
+    /* clang-format off */
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Missing arguments for submit via cp:\n"
+               << "\tlocalprefix: " << localprefix << "\n"
+               << "\tNumber of files: " << files.size() << "\n"
+               << "\tremoteprefix: " << remoteprefix << "\n"
+               << "\tdestination: " << destination << std::endl);
+    /* clang-format on */
+    return false;
+  }
+
+  for (std::string const& file : files) {
+    std::string lfname = localprefix;
+    cmSystemTools::ConvertToUnixSlashes(lfname);
+    lfname += "/" + file;
+    std::string rfname = destination + "/" + remoteprefix + file;
+    cmSystemTools::CopyFileAlways(lfname, rfname);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Copy file: "
+                         << lfname << " to " << rfname << std::endl,
+                       this->Quiet);
+  }
+  std::string tagDoneFile = destination + "/" + remoteprefix + "DONE";
+  cmSystemTools::Touch(tagDoneFile, true);
+  return true;
+}
+
+#if defined(CTEST_USE_XMLRPC)
+bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
+  const std::string& localprefix, const std::set<std::string>& files,
+  const std::string& remoteprefix, const std::string& url)
+{
+  xmlrpc_env env;
+  char ctestString[] = "CTest";
+  std::string ctestVersionString = cmVersion::GetCMakeVersion();
+  char* ctestVersion = const_cast<char*>(ctestVersionString.c_str());
+
+  std::string realURL = url + "/" + remoteprefix + "/Command/";
+
+  /* Start up our XML-RPC client library. */
+  xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, ctestString, ctestVersion);
+
+  /* Initialize our error-handling environment. */
+  xmlrpc_env_init(&env);
+
+  /* Call the famous server at UserLand. */
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submitting to: "
+                       << realURL << " (" << remoteprefix << ")" << std::endl,
+                     this->Quiet);
+  for (std::string const& file : files) {
+    xmlrpc_value* result;
+
+    std::string local_file = file;
+    if (!cmSystemTools::FileExists(local_file.c_str())) {
+      local_file = localprefix + "/" + file;
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submit file: " << local_file << std::endl,
+                       this->Quiet);
+    struct stat st;
+    if (::stat(local_file.c_str(), &st)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot find file: " << local_file << std::endl);
+      return false;
+    }
+
+    // off_t can be bigger than size_t.  fread takes size_t.
+    // make sure the file is not too big.
+    if (static_cast<off_t>(static_cast<size_t>(st.st_size)) !=
+        static_cast<off_t>(st.st_size)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  File too big: " << local_file
+                                                                << std::endl);
+      return false;
+    }
+    size_t fileSize = static_cast<size_t>(st.st_size);
+    FILE* fp = cmsys::SystemTools::Fopen(local_file, "rb");
+    if (!fp) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot open file: " << local_file << std::endl);
+      return false;
+    }
+
+    unsigned char* fileBuffer = new unsigned char[fileSize];
+    if (fread(fileBuffer, 1, fileSize, fp) != fileSize) {
+      delete[] fileBuffer;
+      fclose(fp);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot read file: " << local_file << std::endl);
+      return false;
+    }
+    fclose(fp);
+
+    char remoteCommand[] = "Submit.put";
+    char* pRealURL = const_cast<char*>(realURL.c_str());
+    result =
+      xmlrpc_client_call(&env, pRealURL, remoteCommand, "(6)", fileBuffer,
+                         static_cast<xmlrpc_int32>(fileSize));
+
+    delete[] fileBuffer;
+
+    if (env.fault_occurred) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, " Submission problem: "
+                   << env.fault_string << " (" << env.fault_code << ")"
+                   << std::endl);
+      xmlrpc_env_clean(&env);
+      xmlrpc_client_cleanup();
+      return false;
+    }
+
+    /* Dispose of our result value. */
+    xmlrpc_DECREF(result);
+  }
+
+  /* Clean up our error-handling environment. */
+  xmlrpc_env_clean(&env);
+
+  /* Shutdown our XML-RPC client library. */
+  xmlrpc_client_cleanup();
+  return true;
+}
+#else
+bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
+  std::string const& /*unused*/, std::set<std::string> const& /*unused*/,
+  std::string const& /*unused*/, std::string const& /*unused*/)
+{
+  return false;
+}
+#endif
+
+void cmCTestSubmitHandler::ConstructCDashURL(std::string& dropMethod,
+                                             std::string& url)
+{
+  dropMethod = this->CTest->GetCTestConfiguration("DropMethod");
+  url = dropMethod;
+  url += "://";
+  if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
+    url += this->CTest->GetCTestConfiguration("DropSiteUser");
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_OUTPUT,
+      this->CTest->GetCTestConfiguration("DropSiteUser").c_str(), this->Quiet);
+    if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty()) {
+      url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******", this->Quiet);
+    }
+    url += "@";
+  }
+  url += this->CTest->GetCTestConfiguration("DropSite") +
+    this->CTest->GetCTestConfiguration("DropLocation");
+}
+
+int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
+                                                std::string const& typeString)
+{
+  if (file.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Upload file not specified\n");
+    return -1;
+  }
+  if (!cmSystemTools::FileExists(file)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Upload file not found: '"
+                 << file << "'\n");
+    return -1;
+  }
+  cmCTestCurl curl(this->CTest);
+  curl.SetQuiet(this->Quiet);
+  std::string curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
+  std::vector<std::string> args;
+  cmSystemTools::ExpandListArgument(curlopt, args);
+  curl.SetCurlOptions(args);
+  curl.SetTimeOutSeconds(SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
+  curl.SetHttpHeaders(this->HttpHeaders);
+  std::string dropMethod;
+  std::string url;
+  this->ConstructCDashURL(dropMethod, url);
+  std::string::size_type pos = url.find("submit.php?");
+  url = url.substr(0, pos + 10);
+  if (!(dropMethod == "http" || dropMethod == "https")) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Only http and https are supported for CDASH_UPLOAD\n");
+    return -1;
+  }
+  bool internalTest = cmSystemTools::IsOn(this->GetOption("InternalTest"));
+
+  // Get RETRY_COUNT and RETRY_DELAY values if they were set.
+  std::string retryDelayString = this->GetOption("RetryDelay") == nullptr
+    ? ""
+    : this->GetOption("RetryDelay");
+  std::string retryCountString = this->GetOption("RetryCount") == nullptr
+    ? ""
+    : this->GetOption("RetryCount");
+  auto retryDelay = std::chrono::seconds(0);
+  if (!retryDelayString.empty()) {
+    unsigned long retryDelayValue = 0;
+    if (!cmSystemTools::StringToULong(retryDelayString.c_str(),
+                                      &retryDelayValue)) {
+      cmCTestLog(this->CTest, WARNING, "Invalid value for 'RETRY_DELAY' : "
+                   << retryDelayString << std::endl);
+    } else {
+      retryDelay = std::chrono::seconds(retryDelayValue);
+    }
+  }
+  unsigned long retryCount = 0;
+  if (!retryCountString.empty()) {
+    if (!cmSystemTools::StringToULong(retryCountString.c_str(), &retryCount)) {
+      cmCTestLog(this->CTest, WARNING, "Invalid value for 'RETRY_DELAY' : "
+                   << retryCountString << std::endl);
+    }
+  }
+
+  std::string md5sum =
+    cmSystemTools::ComputeFileHash(file, cmCryptoHash::AlgoMD5);
+  // 1. request the buildid and check to see if the file
+  //    has already been uploaded
+  // TODO I added support for subproject. You would need to add
+  // a "&subproject=subprojectname" to the first POST.
+  cmCTestScriptHandler* ch =
+    static_cast<cmCTestScriptHandler*>(this->CTest->GetHandler("script"));
+  cmake* cm = ch->GetCMake();
+  const char* subproject = cm->GetState()->GetGlobalProperty("SubProject");
+  // TODO: Encode values for a URL instead of trusting caller.
+  std::ostringstream str;
+  str << "project="
+      << curl.Escape(this->CTest->GetCTestConfiguration("ProjectName")) << "&";
+  if (subproject) {
+    str << "subproject=" << curl.Escape(subproject) << "&";
+  }
+  auto timeNow =
+    std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+  str << "stamp=" << curl.Escape(this->CTest->GetCurrentTag()) << "-"
+      << curl.Escape(this->CTest->GetTestModelString()) << "&"
+      << "model=" << curl.Escape(this->CTest->GetTestModelString()) << "&"
+      << "build="
+      << curl.Escape(this->CTest->GetCTestConfiguration("BuildName")) << "&"
+      << "site=" << curl.Escape(this->CTest->GetCTestConfiguration("Site"))
+      << "&"
+      << "track=" << curl.Escape(this->CTest->GetTestModelString()) << "&"
+      << "starttime=" << timeNow << "&"
+      << "endtime=" << timeNow << "&"
+      << "datafilesmd5[0]=" << md5sum << "&"
+      << "type=" << curl.Escape(typeString);
+  std::string fields = str.str();
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "fields: " << fields << "\nurl:" << url
+                                << "\nfile: " << file << "\n",
+                     this->Quiet);
+  std::string response;
+
+  bool requestSucceeded = curl.HttpRequest(url, fields, response);
+  if (!internalTest && !requestSucceeded) {
+    // If request failed, wait and retry.
+    for (unsigned long i = 0; i < retryCount; i++) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Request failed, waiting " << retryDelay.count()
+                                                       << " seconds...\n",
+                         this->Quiet);
+
+      auto stop = std::chrono::steady_clock::now() + retryDelay;
+      while (std::chrono::steady_clock::now() < stop) {
+        cmSystemTools::Delay(100);
+      }
+
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Retry request: Attempt "
+                           << (i + 1) << " of " << retryCount << std::endl,
+                         this->Quiet);
+
+      requestSucceeded = curl.HttpRequest(url, fields, response);
+      if (requestSucceeded) {
+        break;
+      }
+    }
+  }
+  if (!internalTest && !requestSucceeded) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in HttpRequest\n"
+                 << response);
+    return -1;
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Request upload response: [" << response << "]\n",
+                     this->Quiet);
+  Json::Value json;
+  Json::Reader reader;
+  if (!internalTest && !reader.parse(response, json)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error parsing json string ["
+                 << response << "]\n"
+                 << reader.getFormattedErrorMessages() << "\n");
+    return -1;
+  }
+  if (!internalTest && json["status"].asInt() != 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Bad status returned from CDash: " << json["status"].asInt());
+    return -1;
+  }
+  if (!internalTest) {
+    if (json["datafilesmd5"].isArray()) {
+      int datares = json["datafilesmd5"][0].asInt();
+      if (datares == 1) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "File already exists on CDash, skip upload "
+                             << file << "\n",
+                           this->Quiet);
+        return 0;
+      }
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "bad datafilesmd5 value in response " << response << "\n");
+      return -1;
+    }
+  }
+
+  std::string upload_as = cmSystemTools::GetFilenameName(file);
+  std::ostringstream fstr;
+  fstr << "type=" << curl.Escape(typeString) << "&"
+       << "md5=" << md5sum << "&"
+       << "filename=" << curl.Escape(upload_as) << "&"
+       << "buildid=" << json["buildid"].asString();
+
+  bool uploadSucceeded = false;
+  if (!internalTest) {
+    uploadSucceeded = curl.UploadFile(file, url, fstr.str(), response);
+  }
+
+  if (!uploadSucceeded) {
+    // If upload failed, wait and retry.
+    for (unsigned long i = 0; i < retryCount; i++) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Upload failed, waiting " << retryDelay.count()
+                                                      << " seconds...\n",
+                         this->Quiet);
+
+      auto stop = std::chrono::steady_clock::now() + retryDelay;
+      while (std::chrono::steady_clock::now() < stop) {
+        cmSystemTools::Delay(100);
+      }
+
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Retry upload: Attempt "
+                           << (i + 1) << " of " << retryCount << std::endl,
+                         this->Quiet);
+
+      if (!internalTest) {
+        uploadSucceeded = curl.UploadFile(file, url, fstr.str(), response);
+      }
+      if (uploadSucceeded) {
+        break;
+      }
+    }
+  }
+
+  if (!uploadSucceeded) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error uploading to CDash. "
+                 << file << " " << url << " " << fstr.str());
+    return -1;
+  }
+  if (!reader.parse(response, json)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error parsing json string ["
+                 << response << "]\n"
+                 << reader.getFormattedErrorMessages() << "\n");
+    return -1;
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Upload file response: [" << response << "]\n",
+                     this->Quiet);
+  return 0;
+}
+
+int cmCTestSubmitHandler::ProcessHandler()
+{
+  const char* cdashUploadFile = this->GetOption("CDashUploadFile");
+  const char* cdashUploadType = this->GetOption("CDashUploadType");
+  if (cdashUploadFile && cdashUploadType) {
+    return this->HandleCDashUploadFile(cdashUploadFile, cdashUploadType);
+  }
+  std::string iscdash = this->CTest->GetCTestConfiguration("IsCDash");
+  // cdash does not need to trigger so just return true
+  if (!iscdash.empty()) {
+    this->CDash = true;
+  }
+
+  const std::string& buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  if (getenv("HTTP_PROXY")) {
+    this->HTTPProxyType = 1;
+    this->HTTPProxy = getenv("HTTP_PROXY");
+    if (getenv("HTTP_PROXY_PORT")) {
+      this->HTTPProxy += ":";
+      this->HTTPProxy += getenv("HTTP_PROXY_PORT");
+    }
+    if (getenv("HTTP_PROXY_TYPE")) {
+      std::string type = getenv("HTTP_PROXY_TYPE");
+      // HTTP/SOCKS4/SOCKS5
+      if (type == "HTTP") {
+        this->HTTPProxyType = 1;
+      } else if (type == "SOCKS4") {
+        this->HTTPProxyType = 2;
+      } else if (type == "SOCKS5") {
+        this->HTTPProxyType = 3;
+      }
+    }
+    if (getenv("HTTP_PROXY_USER")) {
+      this->HTTPProxyAuth = getenv("HTTP_PROXY_USER");
+    }
+    if (getenv("HTTP_PROXY_PASSWD")) {
+      this->HTTPProxyAuth += ":";
+      this->HTTPProxyAuth += getenv("HTTP_PROXY_PASSWD");
+    }
+  }
+
+  if (getenv("FTP_PROXY")) {
+    this->FTPProxyType = 1;
+    this->FTPProxy = getenv("FTP_PROXY");
+    if (getenv("FTP_PROXY_PORT")) {
+      this->FTPProxy += ":";
+      this->FTPProxy += getenv("FTP_PROXY_PORT");
+    }
+    if (getenv("FTP_PROXY_TYPE")) {
+      std::string type = getenv("FTP_PROXY_TYPE");
+      // HTTP/SOCKS4/SOCKS5
+      if (type == "HTTP") {
+        this->FTPProxyType = 1;
+      } else if (type == "SOCKS4") {
+        this->FTPProxyType = 2;
+      } else if (type == "SOCKS5") {
+        this->FTPProxyType = 3;
+      }
+    }
+  }
+
+  if (!this->HTTPProxy.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Use HTTP Proxy: " << this->HTTPProxy << std::endl,
+                       this->Quiet);
+  }
+  if (!this->FTPProxy.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Use FTP Proxy: " << this->FTPProxy << std::endl,
+                       this->Quiet);
+  }
+  cmGeneratedFileStream ofs;
+  this->StartLogFile("Submit", ofs);
+
+  cmCTest::SetOfStrings files;
+  std::string prefix = this->GetSubmitResultsPrefix();
+
+  if (!this->Files.empty()) {
+    // Submit the explicitly selected files:
+    //
+    files.insert(this->Files.begin(), this->Files.end());
+  }
+
+  // Add to the list of files to submit from any selected, existing parts:
+  //
+
+  // TODO:
+  // Check if test is enabled
+
+  this->CTest->AddIfExists(cmCTest::PartUpdate, "Update.xml");
+  this->CTest->AddIfExists(cmCTest::PartConfigure, "Configure.xml");
+  this->CTest->AddIfExists(cmCTest::PartBuild, "Build.xml");
+  this->CTest->AddIfExists(cmCTest::PartTest, "Test.xml");
+  if (this->CTest->AddIfExists(cmCTest::PartCoverage, "Coverage.xml")) {
+    std::vector<std::string> gfiles;
+    std::string gpath =
+      buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
+    std::string::size_type glen = gpath.size() + 1;
+    gpath = gpath + "/CoverageLog*";
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Globbing for: " << gpath << std::endl, this->Quiet);
+    if (cmSystemTools::SimpleGlob(gpath, gfiles, 1)) {
+      for (std::string& gfile : gfiles) {
+        gfile = gfile.substr(glen);
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "Glob file: " << gfile << std::endl, this->Quiet);
+        this->CTest->AddSubmitFile(cmCTest::PartCoverage, gfile.c_str());
+      }
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem globbing" << std::endl);
+    }
+  }
+  this->CTest->AddIfExists(cmCTest::PartMemCheck, "DynamicAnalysis.xml");
+  this->CTest->AddIfExists(cmCTest::PartMemCheck, "Purify.xml");
+  this->CTest->AddIfExists(cmCTest::PartNotes, "Notes.xml");
+  this->CTest->AddIfExists(cmCTest::PartUpload, "Upload.xml");
+
+  // Query parts for files to submit.
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
+    // Skip parts we are not submitting.
+    if (!this->SubmitPart[p]) {
+      continue;
+    }
+
+    // Submit files from this part.
+    std::vector<std::string> const& pfiles = this->CTest->GetSubmitFiles(p);
+    files.insert(pfiles.begin(), pfiles.end());
+  }
+
+  if (ofs) {
+    ofs << "Upload files:" << std::endl;
+    int cnt = 0;
+    for (std::string const& file : files) {
+      ofs << cnt << "\t" << file << std::endl;
+      cnt++;
+    }
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Submit files (using "
+                       << this->CTest->GetCTestConfiguration("DropMethod")
+                       << ")" << std::endl,
+                     this->Quiet);
+  const char* specificTrack = this->CTest->GetSpecificTrack();
+  if (specificTrack) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Send to track: " << specificTrack << std::endl,
+                       this->Quiet);
+  }
+  this->SetLogFile(&ofs);
+
+  std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
+
+  if (dropMethod.empty() || dropMethod == "ftp") {
+    ofs << "Using drop method: FTP" << std::endl;
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Using FTP submit method" << std::endl
+                                                    << "   Drop site: ftp://",
+                       this->Quiet);
+    std::string url = "ftp://";
+    url += cmCTest::MakeURLSafe(
+             this->CTest->GetCTestConfiguration("DropSiteUser")) +
+      ":" + cmCTest::MakeURLSafe(
+              this->CTest->GetCTestConfiguration("DropSitePassword")) +
+      "@" + this->CTest->GetCTestConfiguration("DropSite") +
+      cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration("DropLocation"));
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT,
+        this->CTest->GetCTestConfiguration("DropSiteUser").c_str(),
+        this->Quiet);
+      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty()) {
+        cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******",
+                           this->Quiet);
+      }
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "@", this->Quiet);
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       this->CTest->GetCTestConfiguration("DropSite")
+                         << this->CTest->GetCTestConfiguration("DropLocation")
+                         << std::endl,
+                       this->Quiet);
+    if (!this->SubmitUsingFTP(buildDirectory + "/Testing/" +
+                                this->CTest->GetCurrentTag(),
+                              files, prefix, url)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Problems when submitting via FTP" << std::endl);
+      ofs << "   Problems when submitting via FTP" << std::endl;
+      return -1;
+    }
+    if (!this->CDash) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+          << std::endl
+          << "   Trigger site: "
+          << this->CTest->GetCTestConfiguration("TriggerSite") << std::endl,
+        this->Quiet);
+      if (!this->TriggerUsingHTTP(
+            files, prefix,
+            this->CTest->GetCTestConfiguration("TriggerSite"))) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Problems when triggering via HTTP" << std::endl);
+        ofs << "   Problems when triggering via HTTP" << std::endl;
+        return -1;
+      }
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         "   Submission successful" << std::endl, this->Quiet);
+      ofs << "   Submission successful" << std::endl;
+      return 0;
+    }
+  } else if (dropMethod == "http" || dropMethod == "https") {
+    std::string url = dropMethod;
+    url += "://";
+    ofs << "Using drop method: " << dropMethod << std::endl;
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Using HTTP submit method" << std::endl
+                                                     << "   Drop site:" << url,
+                       this->Quiet);
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
+      url += this->CTest->GetCTestConfiguration("DropSiteUser");
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT,
+        this->CTest->GetCTestConfiguration("DropSiteUser").c_str(),
+        this->Quiet);
+      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty()) {
+        url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
+        cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******",
+                           this->Quiet);
+      }
+      url += "@";
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "@", this->Quiet);
+    }
+    url += this->CTest->GetCTestConfiguration("DropSite") +
+      this->CTest->GetCTestConfiguration("DropLocation");
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       this->CTest->GetCTestConfiguration("DropSite")
+                         << this->CTest->GetCTestConfiguration("DropLocation")
+                         << std::endl,
+                       this->Quiet);
+    if (!this->SubmitUsingHTTP(buildDirectory + "/Testing/" +
+                                 this->CTest->GetCurrentTag(),
+                               files, prefix, url)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Problems when submitting via HTTP" << std::endl);
+      ofs << "   Problems when submitting via HTTP" << std::endl;
+      return -1;
+    }
+    if (!this->CDash) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+          << std::endl
+          << "   Trigger site: "
+          << this->CTest->GetCTestConfiguration("TriggerSite") << std::endl,
+        this->Quiet);
+      if (!this->TriggerUsingHTTP(
+            files, prefix,
+            this->CTest->GetCTestConfiguration("TriggerSite"))) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Problems when triggering via HTTP" << std::endl);
+        ofs << "   Problems when triggering via HTTP" << std::endl;
+        return -1;
+      }
+    }
+    if (this->HasErrors) {
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Errors occurred during "
+                                              "submission."
+                   << std::endl);
+      ofs << "   Errors occurred during submission. " << std::endl;
+    } else {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Submission successful"
+          << (this->HasWarnings ? ", with warnings." : "") << std::endl,
+        this->Quiet);
+      ofs << "   Submission successful"
+          << (this->HasWarnings ? ", with warnings." : "") << std::endl;
+    }
+
+    return 0;
+  } else if (dropMethod == "xmlrpc") {
+#if defined(CTEST_USE_XMLRPC)
+    ofs << "Using drop method: XML-RPC" << std::endl;
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Using XML-RPC submit method" << std::endl,
+                       this->Quiet);
+    std::string url = this->CTest->GetCTestConfiguration("DropSite");
+    prefix = this->CTest->GetCTestConfiguration("DropLocation");
+    if (!this->SubmitUsingXMLRPC(buildDirectory + "/Testing/" +
+                                   this->CTest->GetCurrentTag(),
+                                 files, prefix, url)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Problems when submitting via XML-RPC" << std::endl);
+      ofs << "   Problems when submitting via XML-RPC" << std::endl;
+      return -1;
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
+    ofs << "   Submission successful" << std::endl;
+    return 0;
+#else
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "   Submission method \"xmlrpc\" not compiled into CTest!"
+                 << std::endl);
+    return -1;
+#endif
+  } else if (dropMethod == "scp") {
+    std::string url;
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
+      url += this->CTest->GetCTestConfiguration("DropSiteUser") + "@";
+    }
+    url += this->CTest->GetCTestConfiguration("DropSite") + ":" +
+      this->CTest->GetCTestConfiguration("DropLocation");
+
+    // change to the build directory so that we can uses a relative path
+    // on windows since scp doesn't support "c:" a drive in the path
+    cmWorkingDirectory workdir(buildDirectory);
+
+    if (!this->SubmitUsingSCP(this->CTest->GetCTestConfiguration("ScpCommand"),
+                              "Testing/" + this->CTest->GetCurrentTag(), files,
+                              prefix, url)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Problems when submitting via SCP" << std::endl);
+      ofs << "   Problems when submitting via SCP" << std::endl;
+      return -1;
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
+    ofs << "   Submission successful" << std::endl;
+    return 0;
+  } else if (dropMethod == "cp") {
+    std::string location = this->CTest->GetCTestConfiguration("DropLocation");
+
+    // change to the build directory so that we can uses a relative path
+    // on windows since scp doesn't support "c:" a drive in the path
+    cmWorkingDirectory workdir(buildDirectory);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "   Change directory: " << buildDirectory << std::endl,
+                       this->Quiet);
+
+    if (!this->SubmitUsingCP("Testing/" + this->CTest->GetCurrentTag(), files,
+                             prefix, location)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "   Problems when submitting via CP" << std::endl);
+      ofs << "   Problems when submitting via cp" << std::endl;
+      return -1;
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
+    ofs << "   Submission successful" << std::endl;
+    return 0;
+  }
+
+  cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown submission method: \""
+               << dropMethod << "\"" << std::endl);
+  return -1;
+}
+
+std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
+{
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
+  std::string name = this->CTest->GetCTestConfiguration("Site") + "___" +
+    buildname + "___" + this->CTest->GetCurrentTag() + "-" +
+    this->CTest->GetTestModelString() + "___XML___";
+  return name;
+}
+
+void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts)
+{
+  // Check whether each part is selected.
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
+    this->SubmitPart[p] =
+      (std::set<cmCTest::Part>::const_iterator(parts.find(p)) != parts.end());
+  }
+}
+
+void cmCTestSubmitHandler::SelectFiles(cmCTest::SetOfStrings const& files)
+{
+  this->Files.insert(files.begin(), files.end());
+}
diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h
new file mode 100644
index 0000000..b4d0e77
--- /dev/null
+++ b/Source/CTest/cmCTestSubmitHandler.h
@@ -0,0 +1,106 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestSubmitHandler_h
+#define cmCTestSubmitHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+/** \class cmCTestSubmitHandler
+ * \brief Helper class for CTest
+ *
+ * Submit testing results
+ *
+ */
+class cmCTestSubmitHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  cmCTestSubmitHandler();
+  ~cmCTestSubmitHandler() override { this->LogFile = nullptr; }
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  void Initialize() override;
+
+  /** Specify a set of parts (by name) to submit.  */
+  void SelectParts(std::set<cmCTest::Part> const& parts);
+
+  /** Specify a set of files to submit.  */
+  void SelectFiles(cmCTest::SetOfStrings const& files);
+
+  // handle the cdash file upload protocol
+  int HandleCDashUploadFile(std::string const& file, std::string const& type);
+
+  void SetHttpHeaders(std::vector<std::string> const& v)
+  {
+    this->HttpHeaders = v;
+  }
+
+  void ConstructCDashURL(std::string& dropMethod, std::string& url);
+
+private:
+  void SetLogFile(std::ostream* ost) { this->LogFile = ost; }
+
+  /**
+   * Submit file using various ways
+   */
+  bool SubmitUsingFTP(const std::string& localprefix,
+                      const std::set<std::string>& files,
+                      const std::string& remoteprefix, const std::string& url);
+  bool SubmitUsingHTTP(const std::string& localprefix,
+                       const std::set<std::string>& files,
+                       const std::string& remoteprefix,
+                       const std::string& url);
+  bool SubmitUsingSCP(const std::string& scp_command,
+                      const std::string& localprefix,
+                      const std::set<std::string>& files,
+                      const std::string& remoteprefix, const std::string& url);
+
+  bool SubmitUsingCP(const std::string& localprefix,
+                     const std::set<std::string>& files,
+                     const std::string& remoteprefix, const std::string& url);
+
+  bool TriggerUsingHTTP(const std::set<std::string>& files,
+                        const std::string& remoteprefix,
+                        const std::string& url);
+
+  bool SubmitUsingXMLRPC(const std::string& localprefix,
+                         const std::set<std::string>& files,
+                         const std::string& remoteprefix,
+                         const std::string& url);
+
+  typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
+
+  void ParseResponse(cmCTestSubmitHandlerVectorOfChar chunk);
+
+  std::string GetSubmitResultsPrefix();
+
+  class ResponseParser;
+
+  std::string HTTPProxy;
+  int HTTPProxyType;
+  std::string HTTPProxyAuth;
+  std::string FTPProxy;
+  int FTPProxyType;
+  std::ostream* LogFile;
+  bool SubmitPart[cmCTest::PartCount];
+  bool CDash;
+  bool HasWarnings;
+  bool HasErrors;
+  cmCTest::SetOfStrings Files;
+  std::vector<std::string> HttpHeaders;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
new file mode 100644
index 0000000..232bd58
--- /dev/null
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -0,0 +1,141 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestTestCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+
+#include <chrono>
+#include <sstream>
+#include <stdlib.h>
+#include <vector>
+
+cmCTestTestCommand::cmCTestTestCommand()
+{
+  this->Arguments[ctt_START] = "START";
+  this->Arguments[ctt_END] = "END";
+  this->Arguments[ctt_STRIDE] = "STRIDE";
+  this->Arguments[ctt_EXCLUDE] = "EXCLUDE";
+  this->Arguments[ctt_INCLUDE] = "INCLUDE";
+  this->Arguments[ctt_EXCLUDE_LABEL] = "EXCLUDE_LABEL";
+  this->Arguments[ctt_INCLUDE_LABEL] = "INCLUDE_LABEL";
+  this->Arguments[ctt_EXCLUDE_FIXTURE] = "EXCLUDE_FIXTURE";
+  this->Arguments[ctt_EXCLUDE_FIXTURE_SETUP] = "EXCLUDE_FIXTURE_SETUP";
+  this->Arguments[ctt_EXCLUDE_FIXTURE_CLEANUP] = "EXCLUDE_FIXTURE_CLEANUP";
+  this->Arguments[ctt_PARALLEL_LEVEL] = "PARALLEL_LEVEL";
+  this->Arguments[ctt_SCHEDULE_RANDOM] = "SCHEDULE_RANDOM";
+  this->Arguments[ctt_STOP_TIME] = "STOP_TIME";
+  this->Arguments[ctt_TEST_LOAD] = "TEST_LOAD";
+  this->Arguments[ctt_LAST] = nullptr;
+  this->Last = ctt_LAST;
+}
+
+cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
+{
+  const char* ctestTimeout =
+    this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
+
+  std::chrono::duration<double> timeout;
+  if (ctestTimeout) {
+    timeout = std::chrono::duration<double>(atof(ctestTimeout));
+  } else {
+    timeout = this->CTest->GetTimeOut();
+    if (timeout <= std::chrono::duration<double>::zero()) {
+      // By default use timeout of 10 minutes
+      timeout = std::chrono::minutes(10);
+    }
+  }
+  this->CTest->SetTimeOut(timeout);
+  cmCTestGenericHandler* handler = this->InitializeActualHandler();
+  if (this->Values[ctt_START] || this->Values[ctt_END] ||
+      this->Values[ctt_STRIDE]) {
+    std::ostringstream testsToRunString;
+    if (this->Values[ctt_START]) {
+      testsToRunString << this->Values[ctt_START];
+    }
+    testsToRunString << ",";
+    if (this->Values[ctt_END]) {
+      testsToRunString << this->Values[ctt_END];
+    }
+    testsToRunString << ",";
+    if (this->Values[ctt_STRIDE]) {
+      testsToRunString << this->Values[ctt_STRIDE];
+    }
+    handler->SetOption("TestsToRunInformation",
+                       testsToRunString.str().c_str());
+  }
+  if (this->Values[ctt_EXCLUDE]) {
+    handler->SetOption("ExcludeRegularExpression", this->Values[ctt_EXCLUDE]);
+  }
+  if (this->Values[ctt_INCLUDE]) {
+    handler->SetOption("IncludeRegularExpression", this->Values[ctt_INCLUDE]);
+  }
+  if (this->Values[ctt_EXCLUDE_LABEL]) {
+    handler->SetOption("ExcludeLabelRegularExpression",
+                       this->Values[ctt_EXCLUDE_LABEL]);
+  }
+  if (this->Values[ctt_INCLUDE_LABEL]) {
+    handler->SetOption("LabelRegularExpression",
+                       this->Values[ctt_INCLUDE_LABEL]);
+  }
+  if (this->Values[ctt_EXCLUDE_FIXTURE]) {
+    handler->SetOption("ExcludeFixtureRegularExpression",
+                       this->Values[ctt_EXCLUDE_FIXTURE]);
+  }
+  if (this->Values[ctt_EXCLUDE_FIXTURE_SETUP]) {
+    handler->SetOption("ExcludeFixtureSetupRegularExpression",
+                       this->Values[ctt_EXCLUDE_FIXTURE_SETUP]);
+  }
+  if (this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]) {
+    handler->SetOption("ExcludeFixtureCleanupRegularExpression",
+                       this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]);
+  }
+  if (this->Values[ctt_PARALLEL_LEVEL]) {
+    handler->SetOption("ParallelLevel", this->Values[ctt_PARALLEL_LEVEL]);
+  }
+  if (this->Values[ctt_SCHEDULE_RANDOM]) {
+    handler->SetOption("ScheduleRandom", this->Values[ctt_SCHEDULE_RANDOM]);
+  }
+  if (this->Values[ctt_STOP_TIME]) {
+    this->CTest->SetStopTime(this->Values[ctt_STOP_TIME]);
+  }
+
+  // Test load is determined by: TEST_LOAD argument,
+  // or CTEST_TEST_LOAD script variable, or ctest --test-load
+  // command line argument... in that order.
+  unsigned long testLoad;
+  const char* ctestTestLoad = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
+  if (this->Values[ctt_TEST_LOAD] && *this->Values[ctt_TEST_LOAD]) {
+    if (!cmSystemTools::StringToULong(this->Values[ctt_TEST_LOAD],
+                                      &testLoad)) {
+      testLoad = 0;
+      cmCTestLog(this->CTest, WARNING, "Invalid value for 'TEST_LOAD' : "
+                   << this->Values[ctt_TEST_LOAD] << std::endl);
+    }
+  } else if (ctestTestLoad && *ctestTestLoad) {
+    if (!cmSystemTools::StringToULong(ctestTestLoad, &testLoad)) {
+      testLoad = 0;
+      cmCTestLog(this->CTest, WARNING, "Invalid value for 'CTEST_TEST_LOAD' : "
+                   << ctestTestLoad << std::endl);
+    }
+  } else {
+    testLoad = this->CTest->GetTestLoad();
+  }
+  handler->SetTestLoad(testLoad);
+
+  if (const char* labelsForSubprojects =
+        this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
+    this->CTest->SetCTestConfiguration("LabelsForSubprojects",
+                                       labelsForSubprojects, this->Quiet);
+  }
+
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
+
+cmCTestGenericHandler* cmCTestTestCommand::InitializeActualHandler()
+{
+  return this->CTest->GetInitializedHandler("test");
+}
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
new file mode 100644
index 0000000..11c0db9
--- /dev/null
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -0,0 +1,67 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestTestCommand_h
+#define cmCTestTestCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestHandlerCommand.h"
+
+#include <string>
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestTest
+ * \brief Run a ctest script
+ *
+ * cmCTestTestCommand defineds the command to test the project.
+ */
+class cmCTestTestCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestTestCommand();
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestTestCommand* ni = new cmCTestTestCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_test"; }
+
+protected:
+  virtual cmCTestGenericHandler* InitializeActualHandler();
+  cmCTestGenericHandler* InitializeHandler() override;
+
+  enum
+  {
+    ctt_BUILD = ct_LAST,
+    ctt_RETURN_VALUE,
+    ctt_START,
+    ctt_END,
+    ctt_STRIDE,
+    ctt_EXCLUDE,
+    ctt_INCLUDE,
+    ctt_EXCLUDE_LABEL,
+    ctt_INCLUDE_LABEL,
+    ctt_EXCLUDE_FIXTURE,
+    ctt_EXCLUDE_FIXTURE_SETUP,
+    ctt_EXCLUDE_FIXTURE_CLEANUP,
+    ctt_PARALLEL_LEVEL,
+    ctt_SCHEDULE_RANDOM,
+    ctt_STOP_TIME,
+    ctt_TEST_LOAD,
+    ctt_LAST
+  };
+};
+
+#endif
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
new file mode 100644
index 0000000..4c7cefb
--- /dev/null
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -0,0 +1,2357 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestTestHandler.h"
+#include <algorithm>
+#include <chrono>
+#include <cmsys/Base64.h>
+#include <cmsys/Directory.hxx>
+#include <cmsys/RegularExpression.hxx>
+#include <functional>
+#include <iomanip>
+#include <iterator>
+#include <memory> // IWYU pragma: keep
+#include <set>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "cmAlgorithms.h"
+#include "cmCTest.h"
+#include "cmCTestMultiProcessHandler.h"
+#include "cmCommand.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmStateSnapshot.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+#include "cmXMLWriter.h"
+#include "cm_utf8.h"
+#include "cmake.h"
+#include "cmsys/FStream.hxx"
+
+class cmExecutionStatus;
+
+class cmCTestSubdirCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestSubdirCommand* c = new cmCTestSubdirCommand;
+    c->TestHandler = this->TestHandler;
+    return c;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& /*unused*/) override;
+
+  cmCTestTestHandler* TestHandler;
+};
+
+bool cmCTestSubdirCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
+  for (std::string const& arg : args) {
+    std::string fname;
+
+    if (cmSystemTools::FileIsFullPath(arg.c_str())) {
+      fname = arg;
+    } else {
+      fname = cwd;
+      fname += "/";
+      fname += arg;
+    }
+
+    if (!cmSystemTools::FileIsDirectory(fname)) {
+      // No subdirectory? So what...
+      continue;
+    }
+    bool readit = false;
+    {
+      cmWorkingDirectory workdir(fname);
+      const char* testFilename;
+      if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
+        // does the CTestTestfile.cmake exist ?
+        testFilename = "CTestTestfile.cmake";
+      } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
+        // does the DartTestfile.txt exist ?
+        testFilename = "DartTestfile.txt";
+      } else {
+        // No CTestTestfile? Who cares...
+        continue;
+      }
+      fname += "/";
+      fname += testFilename;
+      readit = this->Makefile->ReadDependentFile(fname.c_str());
+    }
+    if (!readit) {
+      std::string m = "Could not find include file: ";
+      m += fname;
+      this->SetError(m);
+      return false;
+    }
+  }
+  return true;
+}
+
+class cmCTestAddSubdirectoryCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestAddSubdirectoryCommand* c = new cmCTestAddSubdirectoryCommand;
+    c->TestHandler = this->TestHandler;
+    return c;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& /*unused*/) override;
+
+  cmCTestTestHandler* TestHandler;
+};
+
+bool cmCTestAddSubdirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  std::string fname = cmSystemTools::GetCurrentWorkingDirectory();
+  fname += "/";
+  fname += args[0];
+
+  if (!cmSystemTools::FileExists(fname.c_str())) {
+    // No subdirectory? So what...
+    return true;
+  }
+  bool readit = false;
+  {
+    const char* testFilename;
+    if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
+      // does the CTestTestfile.cmake exist ?
+      testFilename = "CTestTestfile.cmake";
+    } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
+      // does the DartTestfile.txt exist ?
+      testFilename = "DartTestfile.txt";
+    } else {
+      // No CTestTestfile? Who cares...
+      return true;
+    }
+    fname += "/";
+    fname += testFilename;
+    readit = this->Makefile->ReadDependentFile(fname.c_str());
+  }
+  if (!readit) {
+    std::string m = "Could not find include file: ";
+    m += fname;
+    this->SetError(m);
+    return false;
+  }
+  return true;
+}
+
+class cmCTestAddTestCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestAddTestCommand* c = new cmCTestAddTestCommand;
+    c->TestHandler = this->TestHandler;
+    return c;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& /*args*/,
+                   cmExecutionStatus& /*unused*/) override;
+
+  cmCTestTestHandler* TestHandler;
+};
+
+bool cmCTestAddTestCommand::InitialPass(std::vector<std::string> const& args,
+                                        cmExecutionStatus& /*unused*/)
+{
+  if (args.size() < 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  return this->TestHandler->AddTest(args);
+}
+
+class cmCTestSetTestsPropertiesCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestSetTestsPropertiesCommand* c = new cmCTestSetTestsPropertiesCommand;
+    c->TestHandler = this->TestHandler;
+    return c;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& /*args*/,
+                   cmExecutionStatus& /*unused*/) override;
+
+  cmCTestTestHandler* TestHandler;
+};
+
+bool cmCTestSetTestsPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
+{
+  return this->TestHandler->SetTestsProperties(args);
+}
+
+class cmCTestSetDirectoryPropertiesCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestSetDirectoryPropertiesCommand* c =
+      new cmCTestSetDirectoryPropertiesCommand;
+    c->TestHandler = this->TestHandler;
+    return c;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+  */
+  bool InitialPass(std::vector<std::string> const& /*unused*/,
+                   cmExecutionStatus& /*unused*/) override;
+
+  cmCTestTestHandler* TestHandler;
+};
+
+bool cmCTestSetDirectoryPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  return this->TestHandler->SetDirectoryProperties(args);
+}
+
+// get the next number in a string with numbers separated by ,
+// pos is the start of the search and pos2 is the end of the search
+// pos becomes pos2 after a call to GetNextNumber.
+// -1 is returned at the end of the list.
+inline int GetNextNumber(std::string const& in, int& val,
+                         std::string::size_type& pos,
+                         std::string::size_type& pos2)
+{
+  pos2 = in.find(',', pos);
+  if (pos2 != std::string::npos) {
+    if (pos2 - pos == 0) {
+      val = -1;
+    } else {
+      val = atoi(in.substr(pos, pos2 - pos).c_str());
+    }
+    pos = pos2 + 1;
+    return 1;
+  }
+  if (in.size() - pos == 0) {
+    val = -1;
+  } else {
+    val = atoi(in.substr(pos, in.size() - pos).c_str());
+  }
+  return 0;
+}
+
+// get the next number in a string with numbers separated by ,
+// pos is the start of the search and pos2 is the end of the search
+// pos becomes pos2 after a call to GetNextNumber.
+// -1 is returned at the end of the list.
+inline int GetNextRealNumber(std::string const& in, double& val,
+                             std::string::size_type& pos,
+                             std::string::size_type& pos2)
+{
+  pos2 = in.find(',', pos);
+  if (pos2 != std::string::npos) {
+    if (pos2 - pos == 0) {
+      val = -1;
+    } else {
+      val = atof(in.substr(pos, pos2 - pos).c_str());
+    }
+    pos = pos2 + 1;
+    return 1;
+  }
+  if (in.size() - pos == 0) {
+    val = -1;
+  } else {
+    val = atof(in.substr(pos, in.size() - pos).c_str());
+  }
+  return 0;
+}
+
+cmCTestTestHandler::cmCTestTestHandler()
+{
+  this->UseUnion = false;
+
+  this->UseIncludeLabelRegExpFlag = false;
+  this->UseExcludeLabelRegExpFlag = false;
+  this->UseIncludeRegExpFlag = false;
+  this->UseExcludeRegExpFlag = false;
+  this->UseExcludeRegExpFirst = false;
+
+  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
+  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
+
+  this->MemCheck = false;
+
+  this->LogFile = nullptr;
+
+  // regex to detect <DartMeasurement>...</DartMeasurement>
+  this->DartStuff.compile("(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
+  // regex to detect each individual <DartMeasurement>...</DartMeasurement>
+  this->DartStuff1.compile(
+    "(<DartMeasurement[^<]*</DartMeasurement[a-zA-Z]*>)");
+}
+
+void cmCTestTestHandler::Initialize()
+{
+  this->Superclass::Initialize();
+
+  this->ElapsedTestingTime = std::chrono::duration<double>();
+
+  this->TestResults.clear();
+
+  this->CustomTestsIgnore.clear();
+  this->StartTest.clear();
+  this->EndTest.clear();
+
+  this->CustomPreTest.clear();
+  this->CustomPostTest.clear();
+  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
+  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
+
+  this->TestsToRun.clear();
+
+  this->UseIncludeLabelRegExpFlag = false;
+  this->UseExcludeLabelRegExpFlag = false;
+  this->UseIncludeRegExpFlag = false;
+  this->UseExcludeRegExpFlag = false;
+  this->UseExcludeRegExpFirst = false;
+  this->IncludeLabelRegularExpression = "";
+  this->ExcludeLabelRegularExpression = "";
+  this->IncludeRegExp.clear();
+  this->ExcludeRegExp.clear();
+  this->ExcludeFixtureRegExp.clear();
+  this->ExcludeFixtureSetupRegExp.clear();
+  this->ExcludeFixtureCleanupRegExp.clear();
+
+  TestsToRunString.clear();
+  this->UseUnion = false;
+  this->TestList.clear();
+}
+
+void cmCTestTestHandler::PopulateCustomVectors(cmMakefile* mf)
+{
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST",
+                                    this->CustomPreTest);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_TEST",
+                                    this->CustomPostTest);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_TESTS_IGNORE",
+                                    this->CustomTestsIgnore);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
+    this->CustomMaximumPassedTestOutputSize);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
+    this->CustomMaximumFailedTestOutputSize);
+}
+
+int cmCTestTestHandler::PreProcessHandler()
+{
+  if (!this->ExecuteCommands(this->CustomPreTest)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Problem executing pre-test command(s)." << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+int cmCTestTestHandler::PostProcessHandler()
+{
+  if (!this->ExecuteCommands(this->CustomPostTest)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Problem executing post-test command(s)." << std::endl);
+    return 0;
+  }
+  return 1;
+}
+
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
+int cmCTestTestHandler::ProcessHandler()
+{
+  // Update internal data structure from generic one
+  this->SetTestsToRunInformation(this->GetOption("TestsToRunInformation"));
+  this->SetUseUnion(cmSystemTools::IsOn(this->GetOption("UseUnion")));
+  if (cmSystemTools::IsOn(this->GetOption("ScheduleRandom"))) {
+    this->CTest->SetScheduleType("Random");
+  }
+  if (this->GetOption("ParallelLevel")) {
+    this->CTest->SetParallelLevel(atoi(this->GetOption("ParallelLevel")));
+  }
+
+  const char* val;
+  val = this->GetOption("LabelRegularExpression");
+  if (val) {
+    this->UseIncludeLabelRegExpFlag = true;
+    this->IncludeLabelRegExp = val;
+  }
+  val = this->GetOption("ExcludeLabelRegularExpression");
+  if (val) {
+    this->UseExcludeLabelRegExpFlag = true;
+    this->ExcludeLabelRegExp = val;
+  }
+  val = this->GetOption("IncludeRegularExpression");
+  if (val) {
+    this->UseIncludeRegExp();
+    this->SetIncludeRegExp(val);
+  }
+  val = this->GetOption("ExcludeRegularExpression");
+  if (val) {
+    this->UseExcludeRegExp();
+    this->SetExcludeRegExp(val);
+  }
+  val = this->GetOption("ExcludeFixtureRegularExpression");
+  if (val) {
+    this->ExcludeFixtureRegExp = val;
+  }
+  val = this->GetOption("ExcludeFixtureSetupRegularExpression");
+  if (val) {
+    this->ExcludeFixtureSetupRegExp = val;
+  }
+  val = this->GetOption("ExcludeFixtureCleanupRegularExpression");
+  if (val) {
+    this->ExcludeFixtureCleanupRegExp = val;
+  }
+  this->SetRerunFailed(cmSystemTools::IsOn(this->GetOption("RerunFailed")));
+
+  this->TestResults.clear();
+
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT, (this->MemCheck ? "Memory check" : "Test")
+      << " project " << cmSystemTools::GetCurrentWorkingDirectory()
+      << std::endl,
+    this->Quiet);
+  if (!this->PreProcessHandler()) {
+    return -1;
+  }
+
+  cmGeneratedFileStream mLogFile;
+  this->StartLogFile((this->MemCheck ? "DynamicAnalysis" : "Test"), mLogFile);
+  this->LogFile = &mLogFile;
+
+  std::vector<std::string> passed;
+  std::vector<std::string> failed;
+  int total;
+
+  // start the real time clock
+  auto clock_start = std::chrono::steady_clock::now();
+
+  this->ProcessDirectory(passed, failed);
+
+  auto clock_finish = std::chrono::steady_clock::now();
+
+  total = int(passed.size()) + int(failed.size());
+
+  if (total == 0) {
+    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!"
+                   << std::endl);
+    }
+  } else {
+    if (this->HandlerVerbose && !passed.empty() &&
+        (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag)) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+                           << "The following tests passed:" << std::endl,
+                         this->Quiet);
+      for (std::string const& j : passed) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "\t" << j << std::endl, this->Quiet);
+      }
+    }
+
+    typedef std::set<cmCTestTestHandler::cmCTestTestResult,
+                     cmCTestTestResultLess>
+      SetOfTests;
+    SetOfTests resultsSet(this->TestResults.begin(), this->TestResults.end());
+    std::vector<cmCTestTestHandler::cmCTestTestResult> disabledTests;
+
+    for (cmCTestTestResult const& ft : resultsSet) {
+      if (cmHasLiteralPrefix(ft.CompletionStatus, "SKIP_RETURN_CODE=") ||
+          ft.CompletionStatus == "Disabled") {
+        disabledTests.push_back(ft);
+      }
+    }
+
+    float percent = float(passed.size()) * 100.0f / float(total);
+    if (!failed.empty() && percent > 99) {
+      percent = 99;
+    }
+
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+                 << static_cast<int>(percent + .5f) << "% tests passed, "
+                 << failed.size() << " tests failed out of " << total
+                 << std::endl);
+    if ((!this->CTest->GetLabelsForSubprojects().empty() &&
+         this->CTest->GetSubprojectSummary())) {
+      this->PrintLabelOrSubprojectSummary(true);
+    }
+    if (this->CTest->GetLabelSummary()) {
+      this->PrintLabelOrSubprojectSummary(false);
+    }
+    char realBuf[1024];
+    std::chrono::duration<double> durationInSecs = clock_finish - clock_start;
+    sprintf(realBuf, "%6.2f sec", durationInSecs.count());
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "\nTotal Test time (real) = " << realBuf << "\n",
+                       this->Quiet);
+
+    if (!disabledTests.empty()) {
+      cmGeneratedFileStream ofs;
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+                   << "The following tests did not run:" << std::endl);
+      this->StartLogFile("TestsDisabled", ofs);
+
+      const char* disabled_reason;
+      for (cmCTestTestResult const& dt : disabledTests) {
+        ofs << dt.TestCount << ":" << dt.Name << std::endl;
+        if (dt.CompletionStatus == "Disabled") {
+          disabled_reason = "Disabled";
+        } else {
+          disabled_reason = "Skipped";
+        }
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t"
+                     << std::setw(3) << dt.TestCount << " - " << dt.Name
+                     << " (" << disabled_reason << ")" << std::endl);
+      }
+    }
+
+    if (!failed.empty()) {
+      cmGeneratedFileStream ofs;
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
+                   << "The following tests FAILED:" << std::endl);
+      this->StartLogFile("TestsFailed", ofs);
+
+      for (cmCTestTestResult const& ft : resultsSet) {
+        if (ft.Status != cmCTestTestHandler::COMPLETED &&
+            !cmHasLiteralPrefix(ft.CompletionStatus, "SKIP_RETURN_CODE=") &&
+            ft.CompletionStatus != "Disabled") {
+          ofs << ft.TestCount << ":" << ft.Name << std::endl;
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t"
+                       << std::setw(3) << ft.TestCount << " - " << ft.Name
+                       << " (" << this->GetTestStatus(ft) << ")" << std::endl);
+        }
+      }
+    }
+  }
+
+  if (this->CTest->GetProduceXML()) {
+    cmGeneratedFileStream xmlfile;
+    if (!this->StartResultingXML(
+          (this->MemCheck ? cmCTest::PartMemCheck : cmCTest::PartTest),
+          (this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create "
+                   << (this->MemCheck ? "memory check" : "testing")
+                   << " XML file" << std::endl);
+      this->LogFile = nullptr;
+      return 1;
+    }
+    cmXMLWriter xml(xmlfile);
+    this->GenerateDartOutput(xml);
+  }
+
+  if (!this->PostProcessHandler()) {
+    this->LogFile = nullptr;
+    return -1;
+  }
+
+  if (!failed.empty()) {
+    this->LogFile = nullptr;
+    return -1;
+  }
+  this->LogFile = nullptr;
+  return 0;
+}
+
+void cmCTestTestHandler::PrintLabelOrSubprojectSummary(bool doSubProject)
+{
+  // collect subproject labels
+  std::vector<std::string> subprojects =
+    this->CTest->GetLabelsForSubprojects();
+  std::map<std::string, double> labelTimes;
+  std::map<std::string, int> labelCounts;
+  std::set<std::string> labels;
+  std::string::size_type maxlen = 0;
+  // initialize maps
+  for (cmCTestTestProperties& p : this->TestList) {
+    for (std::string const& l : p.Labels) {
+      // first check to see if the current label is a subproject label
+      bool isSubprojectLabel = false;
+      std::vector<std::string>::iterator subproject =
+        std::find(subprojects.begin(), subprojects.end(), l);
+      if (subproject != subprojects.end()) {
+        isSubprojectLabel = true;
+      }
+      // if we are doing sub projects and this label is one, then use it
+      // if we are not doing sub projects and the label is not one use it
+      if ((doSubProject && isSubprojectLabel) ||
+          (!doSubProject && !isSubprojectLabel)) {
+        if (l.size() > maxlen) {
+          maxlen = l.size();
+        }
+        labels.insert(l);
+        labelTimes[l] = 0;
+        labelCounts[l] = 0;
+      }
+    }
+  }
+  // fill maps
+  for (cmCTestTestResult& result : this->TestResults) {
+    cmCTestTestProperties& p = *result.Properties;
+    for (std::string const& l : p.Labels) {
+      // only use labels found in labels
+      if (labels.find(l) != labels.end()) {
+        labelTimes[l] +=
+          result.ExecutionTime.count() * result.Properties->Processors;
+        ++labelCounts[l];
+      }
+    }
+  }
+  // if no labels are found return and print nothing
+  if (labels.empty()) {
+    return;
+  }
+  // now print times
+  if (doSubProject) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "\nSubproject Time Summary:", this->Quiet);
+  } else {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:",
+                       this->Quiet);
+  }
+  for (std::string const& i : labels) {
+    std::string label = i;
+    label.resize(maxlen + 3, ' ');
+
+    char buf[1024];
+    sprintf(buf, "%6.2f sec*proc", labelTimes[i]);
+
+    std::ostringstream labelCountStr;
+    labelCountStr << "(" << labelCounts[i] << " test";
+    if (labelCounts[i] > 1) {
+      labelCountStr << "s";
+    }
+    labelCountStr << ")";
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n"
+                         << label << " = " << buf << " "
+                         << labelCountStr.str(),
+                       this->Quiet);
+    if (this->LogFile) {
+      *this->LogFile << "\n" << i << " = " << buf << "\n";
+    }
+  }
+  if (this->LogFile) {
+    *this->LogFile << "\n";
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n", this->Quiet);
+}
+
+void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
+{
+  // if not using Labels to filter then return
+  if (!this->UseIncludeLabelRegExpFlag) {
+    return;
+  }
+  // if there are no labels and we are filtering by labels
+  // then exclude the test as it does not have the label
+  if (it.Labels.empty()) {
+    it.IsInBasedOnREOptions = false;
+    return;
+  }
+  // check to see if the label regular expression matches
+  bool found = false; // assume it does not match
+  // loop over all labels and look for match
+  for (std::string const& l : it.Labels) {
+    if (this->IncludeLabelRegularExpression.find(l)) {
+      found = true;
+    }
+  }
+  // if no match was found, exclude the test
+  if (!found) {
+    it.IsInBasedOnREOptions = false;
+  }
+}
+
+void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it)
+{
+  // if not using Labels to filter then return
+  if (!this->UseExcludeLabelRegExpFlag) {
+    return;
+  }
+  // if there are no labels and we are excluding by labels
+  // then do nothing as a no label can not be a match
+  if (it.Labels.empty()) {
+    return;
+  }
+  // check to see if the label regular expression matches
+  bool found = false; // assume it does not match
+  // loop over all labels and look for match
+  for (std::string const& l : it.Labels) {
+    if (this->ExcludeLabelRegularExpression.find(l)) {
+      found = true;
+    }
+  }
+  // if match was found, exclude the test
+  if (found) {
+    it.IsInBasedOnREOptions = false;
+  }
+}
+
+void cmCTestTestHandler::CheckLabelFilter(cmCTestTestProperties& it)
+{
+  this->CheckLabelFilterInclude(it);
+  this->CheckLabelFilterExclude(it);
+}
+
+void cmCTestTestHandler::ComputeTestList()
+{
+  this->TestList.clear(); // clear list of test
+  this->GetListOfTests();
+
+  if (this->RerunFailed) {
+    this->ComputeTestListForRerunFailed();
+    return;
+  }
+
+  cmCTestTestHandler::ListOfTests::size_type tmsize = this->TestList.size();
+  // how many tests are in based on RegExp?
+  int inREcnt = 0;
+  for (cmCTestTestProperties& tp : this->TestList) {
+    this->CheckLabelFilter(tp);
+    if (tp.IsInBasedOnREOptions) {
+      inREcnt++;
+    }
+  }
+  // expand the test list based on the union flag
+  if (this->UseUnion) {
+    this->ExpandTestsToRunInformation(static_cast<int>(tmsize));
+  } else {
+    this->ExpandTestsToRunInformation(inREcnt);
+  }
+  // Now create a final list of tests to run
+  int cnt = 0;
+  inREcnt = 0;
+  std::string last_directory;
+  ListOfTests finalList;
+  for (cmCTestTestProperties& tp : this->TestList) {
+    cnt++;
+    if (tp.IsInBasedOnREOptions) {
+      inREcnt++;
+    }
+
+    if (this->UseUnion) {
+      // if it is not in the list and not in the regexp then skip
+      if ((!this->TestsToRun.empty() &&
+           std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
+             this->TestsToRun.end()) &&
+          !tp.IsInBasedOnREOptions) {
+        continue;
+      }
+    } else {
+      // is this test in the list of tests to run? If not then skip it
+      if ((!this->TestsToRun.empty() &&
+           std::find(this->TestsToRun.begin(), this->TestsToRun.end(),
+                     inREcnt) == this->TestsToRun.end()) ||
+          !tp.IsInBasedOnREOptions) {
+        continue;
+      }
+    }
+    tp.Index = cnt; // save the index into the test list for this test
+    finalList.push_back(tp);
+  }
+
+  UpdateForFixtures(finalList);
+
+  // Save the total number of tests before exclusions
+  this->TotalNumberOfTests = this->TestList.size();
+  // Set the TestList to the final list of all test
+  this->TestList = finalList;
+
+  this->UpdateMaxTestNameWidth();
+}
+
+void cmCTestTestHandler::ComputeTestListForRerunFailed()
+{
+  this->ExpandTestsToRunInformationForRerunFailed();
+
+  ListOfTests finalList;
+  int cnt = 0;
+  for (cmCTestTestProperties& tp : this->TestList) {
+    cnt++;
+
+    // if this test is not in our list of tests to run, then skip it.
+    if ((!this->TestsToRun.empty() &&
+         std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
+           this->TestsToRun.end())) {
+      continue;
+    }
+
+    tp.Index = cnt;
+    finalList.push_back(tp);
+  }
+
+  UpdateForFixtures(finalList);
+
+  // Save the total number of tests before exclusions
+  this->TotalNumberOfTests = this->TestList.size();
+
+  // Set the TestList to the list of failed tests to rerun
+  this->TestList = finalList;
+
+  this->UpdateMaxTestNameWidth();
+}
+
+void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Updating test list for fixtures" << std::endl,
+                     this->Quiet);
+
+  // Prepare regular expression evaluators
+  std::string setupRegExp(this->ExcludeFixtureRegExp);
+  std::string cleanupRegExp(this->ExcludeFixtureRegExp);
+  if (!this->ExcludeFixtureSetupRegExp.empty()) {
+    if (setupRegExp.empty()) {
+      setupRegExp = this->ExcludeFixtureSetupRegExp;
+    } else {
+      setupRegExp.append("(" + setupRegExp + ")|(" +
+                         this->ExcludeFixtureSetupRegExp + ")");
+    }
+  }
+  if (!this->ExcludeFixtureCleanupRegExp.empty()) {
+    if (cleanupRegExp.empty()) {
+      cleanupRegExp = this->ExcludeFixtureCleanupRegExp;
+    } else {
+      cleanupRegExp.append("(" + cleanupRegExp + ")|(" +
+                           this->ExcludeFixtureCleanupRegExp + ")");
+    }
+  }
+  cmsys::RegularExpression excludeSetupRegex(setupRegExp);
+  cmsys::RegularExpression excludeCleanupRegex(cleanupRegExp);
+
+  // Prepare some maps to help us find setup and cleanup tests for
+  // any given fixture
+  typedef ListOfTests::const_iterator TestIterator;
+  typedef std::multimap<std::string, TestIterator> FixtureDependencies;
+  typedef FixtureDependencies::const_iterator FixtureDepsIterator;
+  FixtureDependencies fixtureSetups;
+  FixtureDependencies fixtureCleanups;
+
+  for (ListOfTests::const_iterator it = this->TestList.begin();
+       it != this->TestList.end(); ++it) {
+    const cmCTestTestProperties& p = *it;
+
+    for (std::string const& deps : p.FixturesSetup) {
+      fixtureSetups.insert(std::make_pair(deps, it));
+    }
+
+    for (std::string const& deps : p.FixturesCleanup) {
+      fixtureCleanups.insert(std::make_pair(deps, it));
+    }
+  }
+
+  // Prepare fast lookup of tests already included in our list of tests
+  std::set<std::string> addedTests;
+  for (cmCTestTestProperties const& p : tests) {
+    addedTests.insert(p.Name);
+  }
+
+  // These are lookups of fixture name to a list of indices into the final
+  // tests array for tests which require that fixture and tests which are
+  // setups for that fixture. They are needed at the end to populate
+  // dependencies of the cleanup tests in our final list of tests.
+  std::map<std::string, std::vector<size_t>> fixtureRequirements;
+  std::map<std::string, std::vector<size_t>> setupFixturesAdded;
+
+  // Use integer index for iteration because we append to
+  // the tests vector as we go
+  size_t fixtureTestsAdded = 0;
+  std::set<std::string> addedFixtures;
+  for (size_t i = 0; i < tests.size(); ++i) {
+    // Skip disabled tests
+    if (tests[i].Disabled) {
+      continue;
+    }
+
+    // There are two things to do for each test:
+    //   1. For every fixture required by this test, record that fixture as
+    //      being required and create dependencies on that fixture's setup
+    //      tests.
+    //   2. Record all setup tests in the final test list so we can later make
+    //      cleanup tests in the test list depend on their associated setup
+    //      tests to enforce correct ordering.
+
+    // 1. Handle fixture requirements
+    //
+    // Must copy the set of fixtures required because we may invalidate
+    // the tests array by appending to it
+    std::set<std::string> fixtures = tests[i].FixturesRequired;
+    for (std::string const& requiredFixtureName : fixtures) {
+      if (requiredFixtureName.empty()) {
+        continue;
+      }
+
+      fixtureRequirements[requiredFixtureName].push_back(i);
+
+      // Add dependencies to this test for all of the setup tests
+      // associated with the required fixture. If any of those setup
+      // tests fail, this test should not run. We make the fixture's
+      // cleanup tests depend on this test case later.
+      std::pair<FixtureDepsIterator, FixtureDepsIterator> setupRange =
+        fixtureSetups.equal_range(requiredFixtureName);
+      for (FixtureDepsIterator sIt = setupRange.first;
+           sIt != setupRange.second; ++sIt) {
+        const std::string& setupTestName = sIt->second->Name;
+        tests[i].RequireSuccessDepends.insert(setupTestName);
+        if (std::find(tests[i].Depends.begin(), tests[i].Depends.end(),
+                      setupTestName) == tests[i].Depends.end()) {
+          tests[i].Depends.push_back(setupTestName);
+        }
+      }
+
+      // Append any fixture setup/cleanup tests to our test list if they
+      // are not already in it (they could have been in the original
+      // set of tests passed to us at the outset or have already been
+      // added from a previously checked test). A fixture isn't required
+      // to have setup/cleanup tests.
+      if (!addedFixtures.insert(requiredFixtureName).second) {
+        // Already seen this fixture, no need to check it again
+        continue;
+      }
+
+      // Only add setup tests if this fixture has not been excluded
+      if (setupRegExp.empty() ||
+          !excludeSetupRegex.find(requiredFixtureName)) {
+        std::pair<FixtureDepsIterator, FixtureDepsIterator> fixtureRange =
+          fixtureSetups.equal_range(requiredFixtureName);
+        for (FixtureDepsIterator it = fixtureRange.first;
+             it != fixtureRange.second; ++it) {
+          ListOfTests::const_iterator lotIt = it->second;
+          const cmCTestTestProperties& p = *lotIt;
+
+          if (!addedTests.insert(p.Name).second) {
+            // Already have p in our test list
+            continue;
+          }
+
+          // This is a test not yet in our list, so add it and
+          // update its index to reflect where it was in the original
+          // full list of all tests (needed to track individual tests
+          // across ctest runs for re-run failed, etc.)
+          tests.push_back(p);
+          tests.back().Index =
+            1 + static_cast<int>(std::distance(this->TestList.begin(), lotIt));
+          ++fixtureTestsAdded;
+
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "Added setup test "
+                               << p.Name << " required by fixture "
+                               << requiredFixtureName << std::endl,
+                             this->Quiet);
+        }
+      }
+
+      // Only add cleanup tests if this fixture has not been excluded
+      if (cleanupRegExp.empty() ||
+          !excludeCleanupRegex.find(requiredFixtureName)) {
+        std::pair<FixtureDepsIterator, FixtureDepsIterator> fixtureRange =
+          fixtureCleanups.equal_range(requiredFixtureName);
+        for (FixtureDepsIterator it = fixtureRange.first;
+             it != fixtureRange.second; ++it) {
+          ListOfTests::const_iterator lotIt = it->second;
+          const cmCTestTestProperties& p = *lotIt;
+
+          if (!addedTests.insert(p.Name).second) {
+            // Already have p in our test list
+            continue;
+          }
+
+          // This is a test not yet in our list, so add it and
+          // update its index to reflect where it was in the original
+          // full list of all tests (needed to track individual tests
+          // across ctest runs for re-run failed, etc.)
+          tests.push_back(p);
+          tests.back().Index =
+            1 + static_cast<int>(std::distance(this->TestList.begin(), lotIt));
+          ++fixtureTestsAdded;
+
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "Added cleanup test "
+                               << p.Name << " required by fixture "
+                               << requiredFixtureName << std::endl,
+                             this->Quiet);
+        }
+      }
+    }
+
+    // 2. Record all setup fixtures included in the final list of tests
+    for (std::string const& setupFixtureName : tests[i].FixturesSetup) {
+      if (setupFixtureName.empty()) {
+        continue;
+      }
+
+      setupFixturesAdded[setupFixtureName].push_back(i);
+    }
+  }
+
+  // Now that we have the final list of tests, we can update all cleanup
+  // tests to depend on those tests which require that fixture and on any
+  // setup tests for that fixture. The latter is required to handle the
+  // pathological case where setup and cleanup tests are in the test set
+  // but no other test has that fixture as a requirement.
+  for (cmCTestTestProperties& p : tests) {
+    const std::set<std::string>& cleanups = p.FixturesCleanup;
+    for (std::string const& fixture : cleanups) {
+      // This cleanup test could be part of the original test list that was
+      // passed in. It is then possible that no other test requires the
+      // fIt fixture, so we have to check for this.
+      std::map<std::string, std::vector<size_t>>::const_iterator cIt =
+        fixtureRequirements.find(fixture);
+      if (cIt != fixtureRequirements.end()) {
+        const std::vector<size_t>& indices = cIt->second;
+        for (size_t index : indices) {
+          const std::string& reqTestName = tests[index].Name;
+          if (std::find(p.Depends.begin(), p.Depends.end(), reqTestName) ==
+              p.Depends.end()) {
+            p.Depends.push_back(reqTestName);
+          }
+        }
+      }
+
+      // Ensure fixture cleanup tests always run after their setup tests, even
+      // if no other test cases require the fixture
+      cIt = setupFixturesAdded.find(fixture);
+      if (cIt != setupFixturesAdded.end()) {
+        const std::vector<size_t>& indices = cIt->second;
+        for (size_t index : indices) {
+          const std::string& setupTestName = tests[index].Name;
+          if (std::find(p.Depends.begin(), p.Depends.end(), setupTestName) ==
+              p.Depends.end()) {
+            p.Depends.push_back(setupTestName);
+          }
+        }
+      }
+    }
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Added "
+                       << fixtureTestsAdded
+                       << " tests to meet fixture requirements" << std::endl,
+                     this->Quiet);
+}
+
+void cmCTestTestHandler::UpdateMaxTestNameWidth()
+{
+  std::string::size_type max = this->CTest->GetMaxTestNameWidth();
+  for (cmCTestTestProperties& p : this->TestList) {
+    if (max < p.Name.size()) {
+      max = p.Name.size();
+    }
+  }
+  if (static_cast<std::string::size_type>(
+        this->CTest->GetMaxTestNameWidth()) != max) {
+    this->CTest->SetMaxTestNameWidth(static_cast<int>(max));
+  }
+}
+
+bool cmCTestTestHandler::GetValue(const char* tag, int& value,
+                                  std::istream& fin)
+{
+  std::string line;
+  bool ret = true;
+  cmSystemTools::GetLineFromStream(fin, line);
+  if (line == tag) {
+    fin >> value;
+    ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
+    ret = false;
+  }
+  return ret;
+}
+
+bool cmCTestTestHandler::GetValue(const char* tag, double& value,
+                                  std::istream& fin)
+{
+  std::string line;
+  cmSystemTools::GetLineFromStream(fin, line);
+  bool ret = true;
+  if (line == tag) {
+    fin >> value;
+    ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
+    ret = false;
+  }
+  return ret;
+}
+
+bool cmCTestTestHandler::GetValue(const char* tag, bool& value,
+                                  std::istream& fin)
+{
+  std::string line;
+  cmSystemTools::GetLineFromStream(fin, line);
+  bool ret = true;
+  if (line == tag) {
+#ifdef __HAIKU__
+    int tmp = 0;
+    fin >> tmp;
+    value = false;
+    if (tmp) {
+      value = true;
+    }
+#else
+    fin >> value;
+#endif
+    ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
+    ret = false;
+  }
+  return ret;
+}
+
+bool cmCTestTestHandler::GetValue(const char* tag, size_t& value,
+                                  std::istream& fin)
+{
+  std::string line;
+  cmSystemTools::GetLineFromStream(fin, line);
+  bool ret = true;
+  if (line == tag) {
+    fin >> value;
+    ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
+    ret = false;
+  }
+  return ret;
+}
+
+bool cmCTestTestHandler::GetValue(const char* tag, std::string& value,
+                                  std::istream& fin)
+{
+  std::string line;
+  cmSystemTools::GetLineFromStream(fin, line);
+  bool ret = true;
+  if (line == tag) {
+    ret = cmSystemTools::GetLineFromStream(fin, value);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
+    ret = false;
+  }
+  return ret;
+}
+
+void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed,
+                                          std::vector<std::string>& failed)
+{
+  this->ComputeTestList();
+  this->StartTest = this->CTest->CurrentTime();
+  this->StartTestTime = std::chrono::system_clock::now();
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+
+  cmCTestMultiProcessHandler* parallel = new cmCTestMultiProcessHandler;
+  parallel->SetCTest(this->CTest);
+  parallel->SetParallelLevel(this->CTest->GetParallelLevel());
+  parallel->SetTestHandler(this);
+  parallel->SetQuiet(this->Quiet);
+  if (this->TestLoad > 0) {
+    parallel->SetTestLoad(this->TestLoad);
+  } else {
+    parallel->SetTestLoad(this->CTest->GetTestLoad());
+  }
+
+  *this->LogFile
+    << "Start testing: " << this->CTest->CurrentTime() << std::endl
+    << "----------------------------------------------------------"
+    << std::endl;
+
+  cmCTestMultiProcessHandler::TestMap tests;
+  cmCTestMultiProcessHandler::PropertiesMap properties;
+
+  bool randomSchedule = this->CTest->GetScheduleType() == "Random";
+  if (randomSchedule) {
+    srand(static_cast<unsigned>(time(nullptr)));
+  }
+
+  for (cmCTestTestProperties& p : this->TestList) {
+    cmCTestMultiProcessHandler::TestSet depends;
+
+    if (randomSchedule) {
+      p.Cost = static_cast<float>(rand());
+    }
+
+    if (p.Timeout == std::chrono::duration<double>::zero() &&
+        this->CTest->GetGlobalTimeout() !=
+          std::chrono::duration<double>::zero()) {
+      p.Timeout = this->CTest->GetGlobalTimeout();
+    }
+
+    if (!p.Depends.empty()) {
+      for (std::string const& i : p.Depends) {
+        for (cmCTestTestProperties const& it2 : this->TestList) {
+          if (it2.Name == i) {
+            depends.insert(it2.Index);
+            break; // break out of test loop as name can only match 1
+          }
+        }
+      }
+    }
+    tests[p.Index] = depends;
+    properties[p.Index] = &p;
+  }
+  parallel->SetTests(tests, properties);
+  parallel->SetPassFailVectors(&passed, &failed);
+  this->TestResults.clear();
+  parallel->SetTestResults(&this->TestResults);
+
+  if (this->CTest->ShouldPrintLabels()) {
+    parallel->PrintLabels();
+  } else if (this->CTest->GetShowOnly()) {
+    parallel->PrintTestList();
+  } else {
+    parallel->RunTests();
+  }
+  delete parallel;
+  this->EndTest = this->CTest->CurrentTime();
+  this->EndTestTime = std::chrono::system_clock::now();
+  this->ElapsedTestingTime =
+    std::chrono::steady_clock::now() - elapsed_time_start;
+  *this->LogFile << "End testing: " << this->CTest->CurrentTime() << std::endl;
+}
+
+void cmCTestTestHandler::GenerateTestCommand(
+  std::vector<std::string>& /*unused*/, int /*unused*/)
+{
+}
+
+void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
+{
+  if (!this->CTest->GetProduceXML()) {
+    return;
+  }
+
+  this->CTest->StartXML(xml, this->AppendXML);
+  this->CTest->GenerateSubprojectsOutput(xml);
+  xml.StartElement("Testing");
+  xml.Element("StartDateTime", this->StartTest);
+  xml.Element("StartTestTime", this->StartTestTime);
+  xml.StartElement("TestList");
+  for (cmCTestTestResult const& result : this->TestResults) {
+    std::string testPath = result.Path + "/" + result.Name;
+    xml.Element("Test", this->CTest->GetShortPathToFile(testPath.c_str()));
+  }
+  xml.EndElement(); // TestList
+  for (cmCTestTestResult& result : this->TestResults) {
+    this->WriteTestResultHeader(xml, result);
+    xml.StartElement("Results");
+
+    if (result.Status != cmCTestTestHandler::NOT_RUN) {
+      if (result.Status != cmCTestTestHandler::COMPLETED ||
+          result.ReturnValue) {
+        xml.StartElement("NamedMeasurement");
+        xml.Attribute("type", "text/string");
+        xml.Attribute("name", "Exit Code");
+        xml.Element("Value", this->GetTestStatus(result));
+        xml.EndElement(); // NamedMeasurement
+
+        xml.StartElement("NamedMeasurement");
+        xml.Attribute("type", "text/string");
+        xml.Attribute("name", "Exit Value");
+        xml.Element("Value", result.ReturnValue);
+        xml.EndElement(); // NamedMeasurement
+      }
+      this->GenerateRegressionImages(xml, result.DartString);
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute("type", "numeric/double");
+      xml.Attribute("name", "Execution Time");
+      xml.Element("Value", result.ExecutionTime.count());
+      xml.EndElement(); // NamedMeasurement
+      if (!result.Reason.empty()) {
+        const char* reasonType = "Pass Reason";
+        if (result.Status != cmCTestTestHandler::COMPLETED) {
+          reasonType = "Fail Reason";
+        }
+        xml.StartElement("NamedMeasurement");
+        xml.Attribute("type", "text/string");
+        xml.Attribute("name", reasonType);
+        xml.Element("Value", result.Reason);
+        xml.EndElement(); // NamedMeasurement
+      }
+    }
+
+    xml.StartElement("NamedMeasurement");
+    xml.Attribute("type", "numeric/double");
+    xml.Attribute("name", "Processors");
+    xml.Element("Value", result.Properties->Processors);
+    xml.EndElement(); // NamedMeasurement
+
+    xml.StartElement("NamedMeasurement");
+    xml.Attribute("type", "text/string");
+    xml.Attribute("name", "Completion Status");
+    xml.Element("Value", result.CompletionStatus);
+    xml.EndElement(); // NamedMeasurement
+
+    xml.StartElement("NamedMeasurement");
+    xml.Attribute("type", "text/string");
+    xml.Attribute("name", "Command Line");
+    xml.Element("Value", result.FullCommandLine);
+    xml.EndElement(); // NamedMeasurement
+    for (auto const& measure : result.Properties->Measurements) {
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute("type", "text/string");
+      xml.Attribute("name", measure.first);
+      xml.Element("Value", measure.second);
+      xml.EndElement(); // NamedMeasurement
+    }
+    xml.StartElement("Measurement");
+    xml.StartElement("Value");
+    if (result.CompressOutput) {
+      xml.Attribute("encoding", "base64");
+      xml.Attribute("compression", "gzip");
+    }
+    xml.Content(result.Output);
+    xml.EndElement(); // Value
+    xml.EndElement(); // Measurement
+    xml.EndElement(); // Results
+
+    this->AttachFiles(xml, result);
+    this->WriteTestResultFooter(xml, result);
+  }
+
+  xml.Element("EndDateTime", this->EndTest);
+  xml.Element("EndTestTime", this->EndTestTime);
+  xml.Element(
+    "ElapsedMinutes",
+    std::chrono::duration_cast<std::chrono::minutes>(this->ElapsedTestingTime)
+      .count());
+  xml.EndElement(); // Testing
+  this->CTest->EndXML(xml);
+}
+
+void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml,
+                                               cmCTestTestResult const& result)
+{
+  xml.StartElement("Test");
+  if (result.Status == cmCTestTestHandler::COMPLETED) {
+    xml.Attribute("Status", "passed");
+  } else if (result.Status == cmCTestTestHandler::NOT_RUN) {
+    xml.Attribute("Status", "notrun");
+  } else {
+    xml.Attribute("Status", "failed");
+  }
+  std::string testPath = result.Path + "/" + result.Name;
+  xml.Element("Name", result.Name);
+  xml.Element("Path", this->CTest->GetShortPathToFile(result.Path.c_str()));
+  xml.Element("FullName", this->CTest->GetShortPathToFile(testPath.c_str()));
+  xml.Element("FullCommandLine", result.FullCommandLine);
+}
+
+void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml,
+                                               cmCTestTestResult const& result)
+{
+  if (!result.Properties->Labels.empty()) {
+    xml.StartElement("Labels");
+    std::vector<std::string> const& labels = result.Properties->Labels;
+    for (std::string const& label : labels) {
+      xml.Element("Label", label);
+    }
+    xml.EndElement(); // Labels
+  }
+
+  xml.EndElement(); // Test
+}
+
+void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml,
+                                     cmCTestTestResult& result)
+{
+  if (result.Status != cmCTestTestHandler::COMPLETED &&
+      !result.Properties->AttachOnFail.empty()) {
+    result.Properties->AttachedFiles.insert(
+      result.Properties->AttachedFiles.end(),
+      result.Properties->AttachOnFail.begin(),
+      result.Properties->AttachOnFail.end());
+  }
+  for (std::string const& file : result.Properties->AttachedFiles) {
+    const std::string& base64 = this->CTest->Base64GzipEncodeFile(file);
+    std::string const fname = cmSystemTools::GetFilenameName(file);
+    xml.StartElement("NamedMeasurement");
+    xml.Attribute("name", "Attached File");
+    xml.Attribute("encoding", "base64");
+    xml.Attribute("compression", "tar/gzip");
+    xml.Attribute("filename", fname);
+    xml.Attribute("type", "file");
+    xml.Element("Value", base64);
+    xml.EndElement(); // NamedMeasurement
+  }
+}
+
+int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
+{
+  for (std::string const& it : vec) {
+    int retVal = 0;
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Run command: " << it << std::endl, this->Quiet);
+    if (!cmSystemTools::RunSingleCommand(it.c_str(), nullptr, nullptr, &retVal,
+                                         nullptr, cmSystemTools::OUTPUT_MERGE
+                                         /*this->Verbose*/) ||
+        retVal != 0) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Problem running command: " << it << std::endl);
+      return 0;
+    }
+  }
+  return 1;
+}
+
+// Find the appropriate executable to run for a test
+std::string cmCTestTestHandler::FindTheExecutable(const char* exe)
+{
+  std::string resConfig;
+  std::vector<std::string> extraPaths;
+  std::vector<std::string> failedPaths;
+  if (strcmp(exe, "NOT_AVAILABLE") == 0) {
+    return exe;
+  }
+  return cmCTestTestHandler::FindExecutable(this->CTest, exe, resConfig,
+                                            extraPaths, failedPaths);
+}
+
+// add additional configurations to the search path
+void cmCTestTestHandler::AddConfigurations(
+  cmCTest* ctest, std::vector<std::string>& attempted,
+  std::vector<std::string>& attemptedConfigs, std::string filepath,
+  std::string& filename)
+{
+  std::string tempPath;
+
+  if (!filepath.empty() && filepath[filepath.size() - 1] != '/') {
+    filepath += "/";
+  }
+  tempPath = filepath + filename;
+  attempted.push_back(tempPath);
+  attemptedConfigs.push_back("");
+
+  if (!ctest->GetConfigType().empty()) {
+    tempPath = filepath;
+    tempPath += ctest->GetConfigType();
+    tempPath += "/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back(ctest->GetConfigType());
+    // If the file is an OSX bundle then the configtype
+    // will be at the start of the path
+    tempPath = ctest->GetConfigType();
+    tempPath += "/";
+    tempPath += filepath;
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back(ctest->GetConfigType());
+  } else {
+    // no config specified - try some options...
+    tempPath = filepath;
+    tempPath += "Release/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("Release");
+    tempPath = filepath;
+    tempPath += "Debug/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("Debug");
+    tempPath = filepath;
+    tempPath += "MinSizeRel/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("MinSizeRel");
+    tempPath = filepath;
+    tempPath += "RelWithDebInfo/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("RelWithDebInfo");
+    tempPath = filepath;
+    tempPath += "Deployment/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("Deployment");
+    tempPath = filepath;
+    tempPath += "Development/";
+    tempPath += filename;
+    attempted.push_back(tempPath);
+    attemptedConfigs.push_back("Deployment");
+  }
+}
+
+// Find the appropriate executable to run for a test
+std::string cmCTestTestHandler::FindExecutable(
+  cmCTest* ctest, const char* testCommand, std::string& resultingConfig,
+  std::vector<std::string>& extraPaths, std::vector<std::string>& failed)
+{
+  // now run the compiled test if we can find it
+  std::vector<std::string> attempted;
+  std::vector<std::string> attemptedConfigs;
+  std::string tempPath;
+  std::string filepath = cmSystemTools::GetFilenamePath(testCommand);
+  std::string filename = cmSystemTools::GetFilenameName(testCommand);
+
+  cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                        filepath, filename);
+
+  // even if a fullpath was specified also try it relative to the current
+  // directory
+  if (!filepath.empty() && filepath[0] == '/') {
+    std::string localfilepath = filepath.substr(1, filepath.size() - 1);
+    cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                          localfilepath, filename);
+  }
+
+  // if extraPaths are provided and we were not passed a full path, try them,
+  // try any extra paths
+  if (filepath.empty()) {
+    for (std::string const& extraPath : extraPaths) {
+      std::string filepathExtra = cmSystemTools::GetFilenamePath(extraPath);
+      std::string filenameExtra = cmSystemTools::GetFilenameName(extraPath);
+      cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                            filepathExtra, filenameExtra);
+    }
+  }
+
+  // store the final location in fullPath
+  std::string fullPath;
+
+  // now look in the paths we specified above
+  for (unsigned int ai = 0; ai < attempted.size() && fullPath.empty(); ++ai) {
+    // first check without exe extension
+    if (cmSystemTools::FileExists(attempted[ai].c_str()) &&
+        !cmSystemTools::FileIsDirectory(attempted[ai])) {
+      fullPath = cmSystemTools::CollapseFullPath(attempted[ai]);
+      resultingConfig = attemptedConfigs[ai];
+    }
+    // then try with the exe extension
+    else {
+      failed.push_back(attempted[ai]);
+      tempPath = attempted[ai];
+      tempPath += cmSystemTools::GetExecutableExtension();
+      if (cmSystemTools::FileExists(tempPath.c_str()) &&
+          !cmSystemTools::FileIsDirectory(tempPath)) {
+        fullPath = cmSystemTools::CollapseFullPath(tempPath);
+        resultingConfig = attemptedConfigs[ai];
+      } else {
+        failed.push_back(tempPath);
+      }
+    }
+  }
+
+  // if everything else failed, check the users path, but only if a full path
+  // wasn't specified
+  if (fullPath.empty() && filepath.empty()) {
+    std::string const path = cmSystemTools::FindProgram(filename.c_str());
+    if (!path.empty()) {
+      resultingConfig.clear();
+      return path;
+    }
+  }
+  if (fullPath.empty()) {
+    cmCTestLog(ctest, HANDLER_OUTPUT, "Could not find executable "
+                 << testCommand << "\n"
+                 << "Looked in the following places:\n");
+    for (std::string const& f : failed) {
+      cmCTestLog(ctest, HANDLER_OUTPUT, f << "\n");
+    }
+  }
+
+  return fullPath;
+}
+
+void cmCTestTestHandler::GetListOfTests()
+{
+  if (!this->IncludeLabelRegExp.empty()) {
+    this->IncludeLabelRegularExpression.compile(
+      this->IncludeLabelRegExp.c_str());
+  }
+  if (!this->ExcludeLabelRegExp.empty()) {
+    this->ExcludeLabelRegularExpression.compile(
+      this->ExcludeLabelRegExp.c_str());
+  }
+  if (!this->IncludeRegExp.empty()) {
+    this->IncludeTestsRegularExpression.compile(this->IncludeRegExp.c_str());
+  }
+  if (!this->ExcludeRegExp.empty()) {
+    this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str());
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Constructing a list of tests" << std::endl, this->Quiet);
+  cmake cm(cmake::RoleScript);
+  cm.SetHomeDirectory("");
+  cm.SetHomeOutputDirectory("");
+  cm.GetCurrentSnapshot().SetDefaultDefinitions();
+  cmGlobalGenerator gg(&cm);
+  cmMakefile mf(&gg, cm.GetCurrentSnapshot());
+  mf.AddDefinition("CTEST_CONFIGURATION_TYPE",
+                   this->CTest->GetConfigType().c_str());
+
+  // Add handler for ADD_TEST
+  cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand;
+  newCom1->TestHandler = this;
+  cm.GetState()->AddBuiltinCommand("add_test", newCom1);
+
+  // Add handler for SUBDIRS
+  cmCTestSubdirCommand* newCom2 = new cmCTestSubdirCommand;
+  newCom2->TestHandler = this;
+  cm.GetState()->AddBuiltinCommand("subdirs", newCom2);
+
+  // Add handler for ADD_SUBDIRECTORY
+  cmCTestAddSubdirectoryCommand* newCom3 = new cmCTestAddSubdirectoryCommand;
+  newCom3->TestHandler = this;
+  cm.GetState()->AddBuiltinCommand("add_subdirectory", newCom3);
+
+  // Add handler for SET_TESTS_PROPERTIES
+  cmCTestSetTestsPropertiesCommand* newCom4 =
+    new cmCTestSetTestsPropertiesCommand;
+  newCom4->TestHandler = this;
+  cm.GetState()->AddBuiltinCommand("set_tests_properties", newCom4);
+
+  // Add handler for SET_DIRECTORY_PROPERTIES
+  cmCTestSetDirectoryPropertiesCommand* newCom5 =
+    new cmCTestSetDirectoryPropertiesCommand;
+  newCom5->TestHandler = this;
+  cm.GetState()->AddBuiltinCommand("set_directory_properties", newCom5);
+
+  const char* testFilename;
+  if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
+    // does the CTestTestfile.cmake exist ?
+    testFilename = "CTestTestfile.cmake";
+  } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
+    // does the DartTestfile.txt exist ?
+    testFilename = "DartTestfile.txt";
+  } else {
+    return;
+  }
+
+  if (!mf.ReadListFile(testFilename)) {
+    return;
+  }
+  if (cmSystemTools::GetErrorOccuredFlag()) {
+    return;
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Done constructing a list of tests" << std::endl,
+                     this->Quiet);
+}
+
+void cmCTestTestHandler::UseIncludeRegExp()
+{
+  this->UseIncludeRegExpFlag = true;
+}
+
+void cmCTestTestHandler::UseExcludeRegExp()
+{
+  this->UseExcludeRegExpFlag = true;
+  this->UseExcludeRegExpFirst = !this->UseIncludeRegExpFlag;
+}
+
+const char* cmCTestTestHandler::GetTestStatus(cmCTestTestResult const& result)
+{
+  static const char* statuses[] = { "Not Run",     "Timeout",   "SEGFAULT",
+                                    "ILLEGAL",     "INTERRUPT", "NUMERICAL",
+                                    "OTHER_FAULT", "Failed",    "BAD_COMMAND",
+                                    "Completed" };
+  int status = result.Status;
+  if (status < cmCTestTestHandler::NOT_RUN ||
+      status > cmCTestTestHandler::COMPLETED) {
+    return "No Status";
+  }
+  if (status == cmCTestTestHandler::OTHER_FAULT) {
+    return result.ExceptionStatus.c_str();
+  }
+  return statuses[status];
+}
+
+void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests)
+{
+  if (this->TestsToRunString.empty()) {
+    return;
+  }
+
+  int start;
+  int end = -1;
+  double stride = -1;
+  std::string::size_type pos = 0;
+  std::string::size_type pos2;
+  // read start
+  if (GetNextNumber(this->TestsToRunString, start, pos, pos2)) {
+    // read end
+    if (GetNextNumber(this->TestsToRunString, end, pos, pos2)) {
+      // read stride
+      if (GetNextRealNumber(this->TestsToRunString, stride, pos, pos2)) {
+        int val = 0;
+        // now read specific numbers
+        while (GetNextNumber(this->TestsToRunString, val, pos, pos2)) {
+          this->TestsToRun.push_back(val);
+        }
+        this->TestsToRun.push_back(val);
+      }
+    }
+  }
+
+  // if start is not specified then we assume we start at 1
+  if (start == -1) {
+    start = 1;
+  }
+
+  // if end isnot specified then we assume we end with the last test
+  if (end == -1) {
+    end = static_cast<int>(numTests);
+  }
+
+  // if the stride wasn't specified then it defaults to 1
+  if (stride == -1) {
+    stride = 1;
+  }
+
+  // if we have a range then add it
+  if (end != -1 && start != -1 && stride > 0) {
+    int i = 0;
+    while (i * stride + start <= end) {
+      this->TestsToRun.push_back(static_cast<int>(i * stride + start));
+      ++i;
+    }
+  }
+
+  // sort the array
+  std::sort(this->TestsToRun.begin(), this->TestsToRun.end(),
+            std::less<int>());
+  // remove duplicates
+  std::vector<int>::iterator new_end =
+    std::unique(this->TestsToRun.begin(), this->TestsToRun.end());
+  this->TestsToRun.erase(new_end, this->TestsToRun.end());
+}
+
+void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
+{
+
+  std::string dirName = this->CTest->GetBinaryDir() + "/Testing/Temporary";
+
+  cmsys::Directory directory;
+  if (directory.Load(dirName) == 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to read the contents of "
+                 << dirName << std::endl);
+    return;
+  }
+
+  int numFiles =
+    static_cast<int>(cmsys::Directory::GetNumberOfFilesInDirectory(dirName));
+  std::string pattern = "LastTestsFailed";
+  std::string logName;
+
+  for (int i = 0; i < numFiles; ++i) {
+    std::string fileName = directory.GetFile(i);
+    // bcc crashes if we attempt a normal substring comparison,
+    // hence the following workaround
+    std::string fileNameSubstring = fileName.substr(0, pattern.length());
+    if (fileNameSubstring != pattern) {
+      continue;
+    }
+    if (logName.empty()) {
+      logName = fileName;
+    } else {
+      // if multiple matching logs were found we use the most recently
+      // modified one.
+      int res;
+      cmSystemTools::FileTimeCompare(logName, fileName, &res);
+      if (res == -1) {
+        logName = fileName;
+      }
+    }
+  }
+
+  std::string lastTestsFailedLog =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/" + logName;
+
+  if (!cmSystemTools::FileExists(lastTestsFailedLog.c_str())) {
+    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, lastTestsFailedLog
+                   << " does not exist!" << std::endl);
+    }
+    return;
+  }
+
+  // parse the list of tests to rerun from LastTestsFailed.log
+  cmsys::ifstream ifs(lastTestsFailedLog.c_str());
+  if (ifs) {
+    std::string line;
+    std::string::size_type pos;
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      pos = line.find(':', 0);
+      if (pos == std::string::npos) {
+        continue;
+      }
+
+      int val = atoi(line.substr(0, pos).c_str());
+      this->TestsToRun.push_back(val);
+    }
+    ifs.close();
+  } else if (!this->CTest->GetShowOnly() &&
+             !this->CTest->ShouldPrintLabels()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem reading file: "
+                 << lastTestsFailedLog
+                 << " while generating list of previously failed tests."
+                 << std::endl);
+  }
+}
+
+// Just for convenience
+#define SPACE_REGEX "[ \t\r\n]"
+void cmCTestTestHandler::GenerateRegressionImages(cmXMLWriter& xml,
+                                                  const std::string& dart)
+{
+  cmsys::RegularExpression twoattributes(
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
+  cmsys::RegularExpression threeattributes(
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
+  cmsys::RegularExpression fourattributes(
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
+  cmsys::RegularExpression cdatastart(
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>" SPACE_REGEX "*<!\\[CDATA\\[");
+  cmsys::RegularExpression cdataend("]]>" SPACE_REGEX "*</DartMeasurement>");
+  cmsys::RegularExpression measurementfile(
+    "<DartMeasurementFile" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurementFile>");
+
+  bool done = false;
+  std::string cxml = dart;
+  while (!done) {
+    if (twoattributes.find(cxml)) {
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute(twoattributes.match(1).c_str(), twoattributes.match(2));
+      xml.Attribute(twoattributes.match(3).c_str(), twoattributes.match(4));
+      xml.Element("Value", twoattributes.match(5));
+      xml.EndElement();
+      cxml.erase(twoattributes.start(),
+                 twoattributes.end() - twoattributes.start());
+    } else if (threeattributes.find(cxml)) {
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute(threeattributes.match(1).c_str(),
+                    threeattributes.match(2));
+      xml.Attribute(threeattributes.match(3).c_str(),
+                    threeattributes.match(4));
+      xml.Attribute(threeattributes.match(5).c_str(),
+                    threeattributes.match(6));
+      xml.Element("Value", twoattributes.match(7));
+      xml.EndElement();
+      cxml.erase(threeattributes.start(),
+                 threeattributes.end() - threeattributes.start());
+    } else if (fourattributes.find(cxml)) {
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute(fourattributes.match(1).c_str(), fourattributes.match(2));
+      xml.Attribute(fourattributes.match(3).c_str(), fourattributes.match(4));
+      xml.Attribute(fourattributes.match(5).c_str(), fourattributes.match(6));
+      xml.Attribute(fourattributes.match(7).c_str(), fourattributes.match(8));
+      xml.Element("Value", twoattributes.match(9));
+      xml.EndElement();
+      cxml.erase(fourattributes.start(),
+                 fourattributes.end() - fourattributes.start());
+    } else if (cdatastart.find(cxml) && cdataend.find(cxml)) {
+      xml.StartElement("NamedMeasurement");
+      xml.Attribute(cdatastart.match(1).c_str(), cdatastart.match(2));
+      xml.Attribute(cdatastart.match(3).c_str(), cdatastart.match(4));
+      xml.StartElement("Value");
+      xml.CData(
+        cxml.substr(cdatastart.end(), cdataend.start() - cdatastart.end()));
+      xml.EndElement(); // Value
+      xml.EndElement(); // NamedMeasurement
+      cxml.erase(cdatastart.start(), cdataend.end() - cdatastart.start());
+    } else if (measurementfile.find(cxml)) {
+      const std::string& filename =
+        cmCTest::CleanString(measurementfile.match(5));
+      if (cmSystemTools::FileExists(filename.c_str())) {
+        long len = cmSystemTools::FileLength(filename);
+        if (len == 0) {
+          std::string k1 = measurementfile.match(1);
+          std::string v1 = measurementfile.match(2);
+          std::string k2 = measurementfile.match(3);
+          std::string v2 = measurementfile.match(4);
+          if (cmSystemTools::LowerCase(k1) == "type") {
+            v1 = "text/string";
+          }
+          if (cmSystemTools::LowerCase(k2) == "type") {
+            v2 = "text/string";
+          }
+
+          xml.StartElement("NamedMeasurement");
+          xml.Attribute(k1.c_str(), v1);
+          xml.Attribute(k2.c_str(), v2);
+          xml.Attribute("encoding", "none");
+          xml.Element("Value", "Image " + filename + " is empty");
+          xml.EndElement();
+        } else {
+          cmsys::ifstream ifs(filename.c_str(), std::ios::in
+#ifdef _WIN32
+                                | std::ios::binary
+#endif
+                              );
+          unsigned char* file_buffer = new unsigned char[len + 1];
+          ifs.read(reinterpret_cast<char*>(file_buffer), len);
+          unsigned char* encoded_buffer = new unsigned char[static_cast<int>(
+            static_cast<double>(len) * 1.5 + 5.0)];
+
+          size_t rlen =
+            cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
+
+          xml.StartElement("NamedMeasurement");
+          xml.Attribute(measurementfile.match(1).c_str(),
+                        measurementfile.match(2));
+          xml.Attribute(measurementfile.match(3).c_str(),
+                        measurementfile.match(4));
+          xml.Attribute("encoding", "base64");
+          std::ostringstream ostr;
+          for (size_t cc = 0; cc < rlen; cc++) {
+            ostr << encoded_buffer[cc];
+            if (cc % 60 == 0 && cc) {
+              ostr << std::endl;
+            }
+          }
+          xml.Element("Value", ostr.str());
+          xml.EndElement(); // NamedMeasurement
+          delete[] file_buffer;
+          delete[] encoded_buffer;
+        }
+      } else {
+        int idx = 4;
+        if (measurementfile.match(1) == "name") {
+          idx = 2;
+        }
+        xml.StartElement("NamedMeasurement");
+        xml.Attribute("name", measurementfile.match(idx));
+        xml.Attribute("text", "text/string");
+        xml.Element("Value", "File " + filename + " not found");
+        xml.EndElement();
+        cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "File \""
+                             << filename << "\" not found." << std::endl,
+                           this->Quiet);
+      }
+      cxml.erase(measurementfile.start(),
+                 measurementfile.end() - measurementfile.start());
+    } else {
+      done = true;
+    }
+  }
+}
+
+void cmCTestTestHandler::SetIncludeRegExp(const char* arg)
+{
+  this->IncludeRegExp = arg;
+}
+
+void cmCTestTestHandler::SetExcludeRegExp(const char* arg)
+{
+  this->ExcludeRegExp = arg;
+}
+
+void cmCTestTestHandler::SetTestsToRunInformation(const char* in)
+{
+  if (!in) {
+    return;
+  }
+  this->TestsToRunString = in;
+  // if the argument is a file, then read it and use the contents as the
+  // string
+  if (cmSystemTools::FileExists(in)) {
+    cmsys::ifstream fin(in);
+    unsigned long filelen = cmSystemTools::FileLength(in);
+    char* buff = new char[filelen + 1];
+    fin.getline(buff, filelen);
+    buff[fin.gcount()] = 0;
+    this->TestsToRunString = buff;
+    delete[] buff;
+  }
+}
+
+bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length)
+{
+  if (!length || length >= output.size() ||
+      output.find("CTEST_FULL_OUTPUT") != std::string::npos) {
+    return true;
+  }
+
+  // Truncate at given length but do not break in the middle of a multi-byte
+  // UTF-8 encoding.
+  char const* const begin = output.c_str();
+  char const* const end = begin + output.size();
+  char const* const truncate = begin + length;
+  char const* current = begin;
+  while (current < truncate) {
+    unsigned int ch;
+    if (const char* next = cm_utf8_decode_character(current, end, &ch)) {
+      if (next > truncate) {
+        break;
+      }
+      current = next;
+    } else // Bad byte will be handled by cmXMLWriter.
+    {
+      ++current;
+    }
+  }
+  output = output.substr(0, current - begin);
+
+  // Append truncation message.
+  std::ostringstream msg;
+  msg << "...\n"
+         "The rest of the test output was removed since it exceeds the "
+         "threshold "
+         "of "
+      << length << " bytes.\n";
+  output += msg.str();
+  return true;
+}
+
+bool cmCTestTestHandler::SetTestsProperties(
+  const std::vector<std::string>& args)
+{
+  std::vector<std::string>::const_iterator it;
+  std::vector<std::string> tests;
+  bool found = false;
+  for (it = args.begin(); it != args.end(); ++it) {
+    if (*it == "PROPERTIES") {
+      found = true;
+      break;
+    }
+    tests.push_back(*it);
+  }
+  if (!found) {
+    return false;
+  }
+  ++it; // skip PROPERTIES
+  for (; it != args.end(); ++it) {
+    std::string key = *it;
+    ++it;
+    if (it == args.end()) {
+      break;
+    }
+    std::string val = *it;
+    for (std::string const& t : tests) {
+      for (cmCTestTestProperties& rt : this->TestList) {
+        if (t == rt.Name) {
+          if (key == "WILL_FAIL") {
+            rt.WillFail = cmSystemTools::IsOn(val.c_str());
+          }
+          if (key == "DISABLED") {
+            rt.Disabled = cmSystemTools::IsOn(val.c_str());
+          }
+          if (key == "ATTACHED_FILES") {
+            cmSystemTools::ExpandListArgument(val, rt.AttachedFiles);
+          }
+          if (key == "ATTACHED_FILES_ON_FAIL") {
+            cmSystemTools::ExpandListArgument(val, rt.AttachOnFail);
+          }
+          if (key == "RESOURCE_LOCK") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+
+            rt.LockedResources.insert(lval.begin(), lval.end());
+          }
+          if (key == "FIXTURES_SETUP") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+
+            rt.FixturesSetup.insert(lval.begin(), lval.end());
+          }
+          if (key == "FIXTURES_CLEANUP") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+
+            rt.FixturesCleanup.insert(lval.begin(), lval.end());
+          }
+          if (key == "FIXTURES_REQUIRED") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+
+            rt.FixturesRequired.insert(lval.begin(), lval.end());
+          }
+          if (key == "TIMEOUT") {
+            rt.Timeout = std::chrono::duration<double>(atof(val.c_str()));
+            rt.ExplicitTimeout = true;
+          }
+          if (key == "COST") {
+            rt.Cost = static_cast<float>(atof(val.c_str()));
+          }
+          if (key == "REQUIRED_FILES") {
+            cmSystemTools::ExpandListArgument(val, rt.RequiredFiles);
+          }
+          if (key == "RUN_SERIAL") {
+            rt.RunSerial = cmSystemTools::IsOn(val.c_str());
+          }
+          if (key == "FAIL_REGULAR_EXPRESSION") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+            for (std::string const& cr : lval) {
+              rt.ErrorRegularExpressions.push_back(
+                std::pair<cmsys::RegularExpression, std::string>(
+                  cmsys::RegularExpression(cr.c_str()), std::string(cr)));
+            }
+          }
+          if (key == "PROCESSORS") {
+            rt.Processors = atoi(val.c_str());
+            if (rt.Processors < 1) {
+              rt.Processors = 1;
+            }
+          }
+          if (key == "SKIP_RETURN_CODE") {
+            rt.SkipReturnCode = atoi(val.c_str());
+            if (rt.SkipReturnCode < 0 || rt.SkipReturnCode > 255) {
+              rt.SkipReturnCode = -1;
+            }
+          }
+          if (key == "DEPENDS") {
+            cmSystemTools::ExpandListArgument(val, rt.Depends);
+          }
+          if (key == "ENVIRONMENT") {
+            cmSystemTools::ExpandListArgument(val, rt.Environment);
+          }
+          if (key == "LABELS") {
+            std::vector<std::string> Labels;
+            cmSystemTools::ExpandListArgument(val, Labels);
+            rt.Labels.insert(rt.Labels.end(), Labels.begin(), Labels.end());
+            // sort the array
+            std::sort(rt.Labels.begin(), rt.Labels.end());
+            // remove duplicates
+            std::vector<std::string>::iterator new_end =
+              std::unique(rt.Labels.begin(), rt.Labels.end());
+            rt.Labels.erase(new_end, rt.Labels.end());
+          }
+          if (key == "MEASUREMENT") {
+            size_t pos = val.find_first_of('=');
+            if (pos != std::string::npos) {
+              std::string mKey = val.substr(0, pos);
+              const char* mVal = val.c_str() + pos + 1;
+              rt.Measurements[mKey] = mVal;
+            } else {
+              rt.Measurements[val] = "1";
+            }
+          }
+          if (key == "PASS_REGULAR_EXPRESSION") {
+            std::vector<std::string> lval;
+            cmSystemTools::ExpandListArgument(val, lval);
+            for (std::string const& cr : lval) {
+              rt.RequiredRegularExpressions.push_back(
+                std::pair<cmsys::RegularExpression, std::string>(
+                  cmsys::RegularExpression(cr.c_str()), std::string(cr)));
+            }
+          }
+          if (key == "WORKING_DIRECTORY") {
+            rt.Directory = val;
+          }
+          if (key == "TIMEOUT_AFTER_MATCH") {
+            std::vector<std::string> propArgs;
+            cmSystemTools::ExpandListArgument(val, propArgs);
+            if (propArgs.size() != 2) {
+              cmCTestLog(this->CTest, WARNING,
+                         "TIMEOUT_AFTER_MATCH expects two arguments, found "
+                           << propArgs.size() << std::endl);
+            } else {
+              rt.AlternateTimeout =
+                std::chrono::duration<double>(atof(propArgs[0].c_str()));
+              std::vector<std::string> lval;
+              cmSystemTools::ExpandListArgument(propArgs[1], lval);
+              for (std::string const& cr : lval) {
+                rt.TimeoutRegularExpressions.push_back(
+                  std::pair<cmsys::RegularExpression, std::string>(
+                    cmsys::RegularExpression(cr.c_str()), std::string(cr)));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool cmCTestTestHandler::SetDirectoryProperties(
+  const std::vector<std::string>& args)
+{
+  std::vector<std::string>::const_iterator it;
+  std::vector<std::string> tests;
+  bool found = false;
+  for (it = args.begin(); it != args.end(); ++it) {
+    if (*it == "PROPERTIES") {
+      found = true;
+      break;
+    }
+    tests.push_back(*it);
+  }
+
+  if (!found) {
+    return false;
+  }
+  ++it; // skip PROPERTIES
+  for (; it != args.end(); ++it) {
+    std::string key = *it;
+    ++it;
+    if (it == args.end()) {
+      break;
+    }
+    std::string val = *it;
+    for (cmCTestTestProperties& rt : this->TestList) {
+      std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
+      if (cwd == rt.Directory) {
+        if (key == "LABELS") {
+          std::vector<std::string> DirectoryLabels;
+          cmSystemTools::ExpandListArgument(val, DirectoryLabels);
+          rt.Labels.insert(rt.Labels.end(), DirectoryLabels.begin(),
+                           DirectoryLabels.end());
+
+          // sort the array
+          std::sort(rt.Labels.begin(), rt.Labels.end());
+          // remove duplicates
+          std::vector<std::string>::iterator new_end =
+            std::unique(rt.Labels.begin(), rt.Labels.end());
+          rt.Labels.erase(new_end, rt.Labels.end());
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
+{
+  const std::string& testname = args[0];
+  cmCTestOptionalLog(this->CTest, DEBUG, "Add test: " << args[0] << std::endl,
+                     this->Quiet);
+
+  if (this->UseExcludeRegExpFlag && this->UseExcludeRegExpFirst &&
+      this->ExcludeTestsRegularExpression.find(testname.c_str())) {
+    return true;
+  }
+  if (this->MemCheck) {
+    std::vector<std::string>::iterator it;
+    bool found = false;
+    for (it = this->CustomTestsIgnore.begin();
+         it != this->CustomTestsIgnore.end(); ++it) {
+      if (*it == testname) {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Ignore memcheck: " << *it << std::endl, this->Quiet);
+      return true;
+    }
+  } else {
+    std::vector<std::string>::iterator it;
+    bool found = false;
+    for (it = this->CustomTestsIgnore.begin();
+         it != this->CustomTestsIgnore.end(); ++it) {
+      if (*it == testname) {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Ignore test: " << *it << std::endl, this->Quiet);
+      return true;
+    }
+  }
+
+  cmCTestTestProperties test;
+  test.Name = testname;
+  test.Args = args;
+  test.Directory = cmSystemTools::GetCurrentWorkingDirectory();
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Set test directory: " << test.Directory << std::endl,
+                     this->Quiet);
+
+  test.IsInBasedOnREOptions = true;
+  test.WillFail = false;
+  test.Disabled = false;
+  test.RunSerial = false;
+  test.Timeout = std::chrono::duration<double>::zero();
+  test.ExplicitTimeout = false;
+  test.Cost = 0;
+  test.Processors = 1;
+  test.SkipReturnCode = -1;
+  test.PreviousRuns = 0;
+  if (this->UseIncludeRegExpFlag &&
+      !this->IncludeTestsRegularExpression.find(testname.c_str())) {
+    test.IsInBasedOnREOptions = false;
+  } else if (this->UseExcludeRegExpFlag && !this->UseExcludeRegExpFirst &&
+             this->ExcludeTestsRegularExpression.find(testname.c_str())) {
+    test.IsInBasedOnREOptions = false;
+  }
+  this->TestList.push_back(test);
+  return true;
+}
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
new file mode 100644
index 0000000..4fb067a
--- /dev/null
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -0,0 +1,317 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestTestHandler_h
+#define cmCTestTestHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <chrono>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <stddef.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+class cmCTest;
+class cmMakefile;
+class cmXMLWriter;
+
+/** \class cmCTestTestHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestTestHandler : public cmCTestGenericHandler
+{
+  friend class cmCTestRunTest;
+  friend class cmCTestMultiProcessHandler;
+
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /**
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  /**
+   * When both -R and -I are used should the resulting test list be the
+   * intersection or the union of the lists. By default it is the
+   * intersection.
+   */
+  void SetUseUnion(bool val) { this->UseUnion = val; }
+
+  /**
+   * Set whether or not CTest should only execute the tests that failed
+   * on the previous run.  By default this is false.
+   */
+  void SetRerunFailed(bool val) { this->RerunFailed = val; }
+
+  /**
+   * This method is called when reading CTest custom file
+   */
+  void PopulateCustomVectors(cmMakefile* mf) override;
+
+  ///! Control the use of the regular expresisons, call these methods to turn
+  /// them on
+  void UseIncludeRegExp();
+  void UseExcludeRegExp();
+  void SetIncludeRegExp(const char*);
+  void SetExcludeRegExp(const char*);
+
+  void SetMaxIndex(int n) { this->MaxIndex = n; }
+  int GetMaxIndex() { return this->MaxIndex; }
+
+  void SetTestOutputSizePassed(int n)
+  {
+    this->CustomMaximumPassedTestOutputSize = n;
+  }
+  void SetTestOutputSizeFailed(int n)
+  {
+    this->CustomMaximumFailedTestOutputSize = n;
+  }
+
+  ///! pass the -I argument down
+  void SetTestsToRunInformation(const char*);
+
+  cmCTestTestHandler();
+
+  /*
+   * Add the test to the list of tests to be executed
+   */
+  bool AddTest(const std::vector<std::string>& args);
+
+  /*
+   * Set tests properties
+   */
+  bool SetTestsProperties(const std::vector<std::string>& args);
+
+  /**
+   * Set directory properties
+   */
+  bool SetDirectoryProperties(const std::vector<std::string>& args);
+
+  void Initialize() override;
+
+  // NOTE: This struct is Saved/Restored
+  // in cmCTestTestHandler, if you add to this class
+  // then you must add the new members to that code or
+  // ctest -j N will break for that feature
+  struct cmCTestTestProperties
+  {
+    std::string Name;
+    std::string Directory;
+    std::vector<std::string> Args;
+    std::vector<std::string> RequiredFiles;
+    std::vector<std::string> Depends;
+    std::vector<std::string> AttachedFiles;
+    std::vector<std::string> AttachOnFail;
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
+      ErrorRegularExpressions;
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
+      RequiredRegularExpressions;
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
+      TimeoutRegularExpressions;
+    std::map<std::string, std::string> Measurements;
+    bool IsInBasedOnREOptions;
+    bool WillFail;
+    bool Disabled;
+    float Cost;
+    int PreviousRuns;
+    bool RunSerial;
+    std::chrono::duration<double> Timeout;
+    bool ExplicitTimeout;
+    std::chrono::duration<double> AlternateTimeout;
+    int Index;
+    // Requested number of process slots
+    int Processors;
+    // return code of test which will mark test as "not run"
+    int SkipReturnCode;
+    std::vector<std::string> Environment;
+    std::vector<std::string> Labels;
+    std::set<std::string> LockedResources;
+    std::set<std::string> FixturesSetup;
+    std::set<std::string> FixturesCleanup;
+    std::set<std::string> FixturesRequired;
+    std::set<std::string> RequireSuccessDepends;
+  };
+
+  struct cmCTestTestResult
+  {
+    std::string Name;
+    std::string Path;
+    std::string Reason;
+    std::string FullCommandLine;
+    std::chrono::duration<double> ExecutionTime;
+    int ReturnValue;
+    int Status;
+    std::string ExceptionStatus;
+    bool CompressOutput;
+    std::string CompletionStatus;
+    std::string Output;
+    std::string DartString;
+    int TestCount;
+    cmCTestTestProperties* Properties;
+  };
+
+  struct cmCTestTestResultLess
+  {
+    bool operator()(const cmCTestTestResult& lhs,
+                    const cmCTestTestResult& rhs) const
+    {
+      return lhs.TestCount < rhs.TestCount;
+    }
+  };
+
+  // add configurations to a search path for an executable
+  static void AddConfigurations(cmCTest* ctest,
+                                std::vector<std::string>& attempted,
+                                std::vector<std::string>& attemptedConfigs,
+                                std::string filepath, std::string& filename);
+
+  // full signature static method to find an executable
+  static std::string FindExecutable(cmCTest* ctest, const char* testCommand,
+                                    std::string& resultingConfig,
+                                    std::vector<std::string>& extraPaths,
+                                    std::vector<std::string>& failed);
+
+  typedef std::vector<cmCTestTestProperties> ListOfTests;
+
+protected:
+  // compute a final test list
+  virtual int PreProcessHandler();
+  virtual int PostProcessHandler();
+  virtual void GenerateTestCommand(std::vector<std::string>& args, int test);
+  int ExecuteCommands(std::vector<std::string>& vec);
+
+  void WriteTestResultHeader(cmXMLWriter& xml,
+                             cmCTestTestResult const& result);
+  void WriteTestResultFooter(cmXMLWriter& xml,
+                             cmCTestTestResult const& result);
+  // Write attached test files into the xml
+  void AttachFiles(cmXMLWriter& xml, cmCTestTestResult& result);
+
+  //! Clean test output to specified length
+  bool CleanTestOutput(std::string& output, size_t length);
+
+  std::chrono::duration<double> ElapsedTestingTime;
+
+  typedef std::vector<cmCTestTestResult> TestResultsVector;
+  TestResultsVector TestResults;
+
+  std::vector<std::string> CustomTestsIgnore;
+  std::string StartTest;
+  std::string EndTest;
+  std::chrono::system_clock::time_point StartTestTime;
+  std::chrono::system_clock::time_point EndTestTime;
+  bool MemCheck;
+  int CustomMaximumPassedTestOutputSize;
+  int CustomMaximumFailedTestOutputSize;
+  int MaxIndex;
+
+public:
+  enum
+  { // Program statuses
+    NOT_RUN = 0,
+    TIMEOUT,
+    SEGFAULT,
+    ILLEGAL,
+    INTERRUPT,
+    NUMERICAL,
+    OTHER_FAULT,
+    FAILED,
+    BAD_COMMAND,
+    COMPLETED
+  };
+
+private:
+  /**
+   * Generate the Dart compatible output
+   */
+  virtual void GenerateDartOutput(cmXMLWriter& xml);
+
+  void PrintLabelOrSubprojectSummary(bool isSubProject);
+
+  /**
+   * Run the tests for a directory and any subdirectories
+   */
+  void ProcessDirectory(std::vector<std::string>& passed,
+                        std::vector<std::string>& failed);
+
+  /**
+   * Get the list of tests in directory and subdirectories.
+   */
+  void GetListOfTests();
+  // compute the lists of tests that will actually run
+  // based on union regex and -I stuff
+  void ComputeTestList();
+
+  // compute the lists of tests that will actually run
+  // based on LastTestFailed.log
+  void ComputeTestListForRerunFailed();
+
+  // add required setup/cleanup tests not already in the
+  // list of tests to be run and update dependencies between
+  // tests to account for fixture setup/cleanup
+  void UpdateForFixtures(ListOfTests& tests) const;
+
+  void UpdateMaxTestNameWidth();
+
+  bool GetValue(const char* tag, std::string& value, std::istream& fin);
+  bool GetValue(const char* tag, int& value, std::istream& fin);
+  bool GetValue(const char* tag, size_t& value, std::istream& fin);
+  bool GetValue(const char* tag, bool& value, std::istream& fin);
+  bool GetValue(const char* tag, double& value, std::istream& fin);
+  /**
+   * Find the executable for a test
+   */
+  std::string FindTheExecutable(const char* exe);
+
+  const char* GetTestStatus(cmCTestTestResult const&);
+  void ExpandTestsToRunInformation(size_t numPossibleTests);
+  void ExpandTestsToRunInformationForRerunFailed();
+
+  std::vector<std::string> CustomPreTest;
+  std::vector<std::string> CustomPostTest;
+
+  std::vector<int> TestsToRun;
+
+  bool UseIncludeLabelRegExpFlag;
+  bool UseExcludeLabelRegExpFlag;
+  bool UseIncludeRegExpFlag;
+  bool UseExcludeRegExpFlag;
+  bool UseExcludeRegExpFirst;
+  std::string IncludeLabelRegExp;
+  std::string ExcludeLabelRegExp;
+  std::string IncludeRegExp;
+  std::string ExcludeRegExp;
+  std::string ExcludeFixtureRegExp;
+  std::string ExcludeFixtureSetupRegExp;
+  std::string ExcludeFixtureCleanupRegExp;
+  cmsys::RegularExpression IncludeLabelRegularExpression;
+  cmsys::RegularExpression ExcludeLabelRegularExpression;
+  cmsys::RegularExpression IncludeTestsRegularExpression;
+  cmsys::RegularExpression ExcludeTestsRegularExpression;
+
+  void GenerateRegressionImages(cmXMLWriter& xml, const std::string& dart);
+  cmsys::RegularExpression DartStuff1;
+  void CheckLabelFilter(cmCTestTestProperties& it);
+  void CheckLabelFilterExclude(cmCTestTestProperties& it);
+  void CheckLabelFilterInclude(cmCTestTestProperties& it);
+
+  std::string TestsToRunString;
+  bool UseUnion;
+  ListOfTests TestList;
+  size_t TotalNumberOfTests;
+  cmsys::RegularExpression DartStuff;
+
+  std::ostream* LogFile;
+
+  bool RerunFailed;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
new file mode 100644
index 0000000..3d800f8
--- /dev/null
+++ b/Source/CTest/cmCTestUpdateCommand.cxx
@@ -0,0 +1,91 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestUpdateCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+
+#include <vector>
+
+cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
+{
+  if (this->Values[ct_SOURCE]) {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_SOURCE]).c_str(),
+      this->Quiet);
+  } else {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(
+        this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY"))
+        .c_str(),
+      this->Quiet);
+  }
+  std::string source_dir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateCommand", "CTEST_UPDATE_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateOptions", "CTEST_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CVSCommand", "CTEST_CVS_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CVSUpdateOptions", "CTEST_CVS_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNCommand", "CTEST_SVN_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNOptions", "CTEST_SVN_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "BZRCommand", "CTEST_BZR_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "BZRUpdateOptions", "CTEST_BZR_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITCommand", "CTEST_GIT_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITUpdateOptions", "CTEST_GIT_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITInitSubmodules", "CTEST_GIT_INIT_SUBMODULES",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITUpdateCustom", "CTEST_GIT_UPDATE_CUSTOM", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateVersionOnly", "CTEST_UPDATE_VERSION_ONLY",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "HGCommand", "CTEST_HG_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "HGUpdateOptions", "CTEST_HG_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Command", "CTEST_P4_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4UpdateOptions", "CTEST_P4_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Client", "CTEST_P4_CLIENT", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Options", "CTEST_P4_OPTIONS", this->Quiet);
+
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("update");
+  if (!handler) {
+    this->SetError("internal CTest error. Cannot instantiate update handler");
+    return nullptr;
+  }
+  handler->SetCommand(this);
+  if (source_dir.empty()) {
+    this->SetError("source directory not specified. Please use SOURCE tag");
+    return nullptr;
+  }
+  handler->SetOption("SourceDirectory", source_dir.c_str());
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
new file mode 100644
index 0000000..3b2f3e1
--- /dev/null
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestUpdateCommand_h
+#define cmCTestUpdateCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestHandlerCommand.h"
+
+#include <string>
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestUpdate
+ * \brief Run a ctest script
+ *
+ * cmCTestUpdateCommand defineds the command to updates the repository.
+ */
+class cmCTestUpdateCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestUpdateCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestUpdateCommand* ni = new cmCTestUpdateCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_update"; }
+
+protected:
+  cmCTestGenericHandler* InitializeHandler() override;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
new file mode 100644
index 0000000..809abd1
--- /dev/null
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -0,0 +1,352 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestUpdateHandler.h"
+
+#include "cmAlgorithms.h"
+#include "cmCLocaleEnvironmentScope.h"
+#include "cmCTest.h"
+#include "cmCTestBZR.h"
+#include "cmCTestCVS.h"
+#include "cmCTestGIT.h"
+#include "cmCTestHG.h"
+#include "cmCTestP4.h"
+#include "cmCTestSVN.h"
+#include "cmCTestVC.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmXMLWriter.h"
+
+#include <chrono>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+
+static const char* cmCTestUpdateHandlerUpdateStrings[] = {
+  "Unknown", "CVS", "SVN", "BZR", "GIT", "HG", "P4"
+};
+
+static const char* cmCTestUpdateHandlerUpdateToString(int type)
+{
+  if (type < cmCTestUpdateHandler::e_UNKNOWN ||
+      type >= cmCTestUpdateHandler::e_LAST) {
+    return cmCTestUpdateHandlerUpdateStrings[cmCTestUpdateHandler::e_UNKNOWN];
+  }
+  return cmCTestUpdateHandlerUpdateStrings[type];
+}
+
+cmCTestUpdateHandler::cmCTestUpdateHandler()
+{
+}
+
+void cmCTestUpdateHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->UpdateCommand.clear();
+  this->UpdateType = e_CVS;
+}
+
+int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
+{
+  cmCTestOptionalLog(this->CTest, DEBUG, "Determine update type from command: "
+                       << cmd << " and type: " << type << std::endl,
+                     this->Quiet);
+  if (type && *type) {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Type specified: " << type << std::endl, this->Quiet);
+    std::string stype = cmSystemTools::LowerCase(type);
+    if (stype.find("cvs") != std::string::npos) {
+      return cmCTestUpdateHandler::e_CVS;
+    }
+    if (stype.find("svn") != std::string::npos) {
+      return cmCTestUpdateHandler::e_SVN;
+    }
+    if (stype.find("bzr") != std::string::npos) {
+      return cmCTestUpdateHandler::e_BZR;
+    }
+    if (stype.find("git") != std::string::npos) {
+      return cmCTestUpdateHandler::e_GIT;
+    }
+    if (stype.find("hg") != std::string::npos) {
+      return cmCTestUpdateHandler::e_HG;
+    }
+    if (stype.find("p4") != std::string::npos) {
+      return cmCTestUpdateHandler::e_P4;
+    }
+  } else {
+    cmCTestOptionalLog(
+      this->CTest, DEBUG,
+      "Type not specified, check command: " << cmd << std::endl, this->Quiet);
+    std::string stype = cmSystemTools::LowerCase(cmd);
+    if (stype.find("cvs") != std::string::npos) {
+      return cmCTestUpdateHandler::e_CVS;
+    }
+    if (stype.find("svn") != std::string::npos) {
+      return cmCTestUpdateHandler::e_SVN;
+    }
+    if (stype.find("bzr") != std::string::npos) {
+      return cmCTestUpdateHandler::e_BZR;
+    }
+    if (stype.find("git") != std::string::npos) {
+      return cmCTestUpdateHandler::e_GIT;
+    }
+    if (stype.find("hg") != std::string::npos) {
+      return cmCTestUpdateHandler::e_HG;
+    }
+    if (stype.find("p4") != std::string::npos) {
+      return cmCTestUpdateHandler::e_P4;
+    }
+  }
+  return cmCTestUpdateHandler::e_UNKNOWN;
+}
+
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
+int cmCTestUpdateHandler::ProcessHandler()
+{
+  // Make sure VCS tool messages are in English so we can parse them.
+  cmCLocaleEnvironmentScope fixLocale;
+  static_cast<void>(fixLocale);
+
+  // Get source dir
+  const char* sourceDirectory = this->GetOption("SourceDirectory");
+  if (!sourceDirectory) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot find SourceDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
+    return -1;
+  }
+
+  cmGeneratedFileStream ofs;
+  if (!this->CTest->GetShowOnly()) {
+    this->StartLogFile("Update", ofs);
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "   Updating the repository: " << sourceDirectory
+                                                    << std::endl,
+                     this->Quiet);
+
+  if (!this->SelectVCS()) {
+    return -1;
+  }
+
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Use "
+                       << cmCTestUpdateHandlerUpdateToString(this->UpdateType)
+                       << " repository type" << std::endl;
+                     , this->Quiet);
+
+  // Create an object to interact with the VCS tool.
+  std::unique_ptr<cmCTestVC> vc;
+  switch (this->UpdateType) {
+    case e_CVS:
+      vc = cm::make_unique<cmCTestCVS>(this->CTest, ofs);
+      break;
+    case e_SVN:
+      vc = cm::make_unique<cmCTestSVN>(this->CTest, ofs);
+      break;
+    case e_BZR:
+      vc = cm::make_unique<cmCTestBZR>(this->CTest, ofs);
+      break;
+    case e_GIT:
+      vc = cm::make_unique<cmCTestGIT>(this->CTest, ofs);
+      break;
+    case e_HG:
+      vc = cm::make_unique<cmCTestHG>(this->CTest, ofs);
+      break;
+    case e_P4:
+      vc = cm::make_unique<cmCTestP4>(this->CTest, ofs);
+      break;
+    default:
+      vc = cm::make_unique<cmCTestVC>(this->CTest, ofs);
+      break;
+  }
+  vc->SetCommandLineTool(this->UpdateCommand);
+  vc->SetSourceDirectory(sourceDirectory);
+
+  // Cleanup the working tree.
+  vc->Cleanup();
+
+  //
+  // Now update repository and remember what files were updated
+  //
+  cmGeneratedFileStream os;
+  if (!this->StartResultingXML(cmCTest::PartUpdate, "Update", os)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file"
+                 << std::endl);
+    return -1;
+  }
+  std::string start_time = this->CTest->CurrentTime();
+  auto start_time_time = std::chrono::system_clock::now();
+  auto elapsed_time_start = std::chrono::steady_clock::now();
+
+  bool updated = vc->Update();
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
+
+  cmXMLWriter xml(os);
+  xml.StartDocument();
+  xml.StartElement("Update");
+  xml.Attribute("mode", "Client");
+  xml.Attribute("Generator",
+                std::string("ctest-") + cmVersion::GetCMakeVersion());
+  xml.Element("Site", this->CTest->GetCTestConfiguration("Site"));
+  xml.Element("BuildName", buildname);
+  xml.Element("BuildStamp", this->CTest->GetCurrentTag() + "-" +
+                this->CTest->GetTestModelString());
+  xml.Element("StartDateTime", start_time);
+  xml.Element("StartTime", start_time_time);
+  xml.Element("UpdateCommand", vc->GetUpdateCommandLine());
+  xml.Element("UpdateType",
+              cmCTestUpdateHandlerUpdateToString(this->UpdateType));
+
+  bool loadedMods = vc->WriteXML(xml);
+
+  int localModifications = 0;
+  int numUpdated = vc->GetPathCount(cmCTestVC::PathUpdated);
+  if (numUpdated) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Found " << numUpdated << " updated files\n",
+                       this->Quiet);
+  }
+  if (int numModified = vc->GetPathCount(cmCTestVC::PathModified)) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Found "
+                         << numModified << " locally modified files\n",
+                       this->Quiet);
+    localModifications += numModified;
+  }
+  if (int numConflicting = vc->GetPathCount(cmCTestVC::PathConflicting)) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Found " << numConflicting << " conflicting files\n",
+                       this->Quiet);
+    localModifications += numConflicting;
+  }
+
+  cmCTestOptionalLog(this->CTest, DEBUG, "End" << std::endl, this->Quiet);
+  std::string end_time = this->CTest->CurrentTime();
+  xml.Element("EndDateTime", end_time);
+  xml.Element("EndTime", std::chrono::system_clock::now());
+  xml.Element("ElapsedMinutes",
+              std::chrono::duration_cast<std::chrono::minutes>(
+                std::chrono::steady_clock::now() - elapsed_time_start)
+                .count());
+
+  xml.StartElement("UpdateReturnStatus");
+  if (localModifications) {
+    xml.Content("Update error: "
+                "There are modified or conflicting files in the repository");
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "   There are modified or conflicting files in the repository"
+                 << std::endl);
+  }
+  if (!updated) {
+    xml.Content("Update command failed:\n");
+    xml.Content(vc->GetUpdateCommandLine());
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Update command failed: "
+                 << vc->GetUpdateCommandLine() << "\n");
+  }
+  xml.EndElement(); // UpdateReturnStatus
+  xml.EndElement(); // Update
+  xml.EndDocument();
+  return updated && loadedMods ? numUpdated : -1;
+}
+
+int cmCTestUpdateHandler::DetectVCS(const char* dir)
+{
+  std::string sourceDirectory = dir;
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Check directory: " << sourceDirectory << std::endl,
+                     this->Quiet);
+  sourceDirectory += "/.svn";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_SVN;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/CVS";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_CVS;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/.bzr";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_BZR;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/.git";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_GIT;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/.hg";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_HG;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/.p4";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_P4;
+  }
+  sourceDirectory = dir;
+  sourceDirectory += "/.p4config";
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
+    return cmCTestUpdateHandler::e_P4;
+  }
+  return cmCTestUpdateHandler::e_UNKNOWN;
+}
+
+bool cmCTestUpdateHandler::SelectVCS()
+{
+  // Get update command
+  this->UpdateCommand = this->CTest->GetCTestConfiguration("UpdateCommand");
+
+  // Detect the VCS managing the source tree.
+  this->UpdateType = this->DetectVCS(this->GetOption("SourceDirectory"));
+  if (this->UpdateType == e_UNKNOWN) {
+    // The source tree does not have a recognized VCS.  Check the
+    // configuration value or command name.
+    this->UpdateType = this->DetermineType(
+      this->UpdateCommand.c_str(),
+      this->CTest->GetCTestConfiguration("UpdateType").c_str());
+  }
+
+  // If no update command was specified, lookup one for this VCS tool.
+  if (this->UpdateCommand.empty()) {
+    const char* key = nullptr;
+    switch (this->UpdateType) {
+      case e_CVS:
+        key = "CVSCommand";
+        break;
+      case e_SVN:
+        key = "SVNCommand";
+        break;
+      case e_BZR:
+        key = "BZRCommand";
+        break;
+      case e_GIT:
+        key = "GITCommand";
+        break;
+      case e_HG:
+        key = "HGCommand";
+        break;
+      case e_P4:
+        key = "P4Command";
+        break;
+      default:
+        break;
+    }
+    if (key) {
+      this->UpdateCommand = this->CTest->GetCTestConfiguration(key);
+    }
+    if (this->UpdateCommand.empty()) {
+      std::ostringstream e;
+      e << "Cannot find UpdateCommand ";
+      if (key) {
+        e << "or " << key;
+      }
+      e << " configuration key.";
+      cmCTestLog(this->CTest, ERROR_MESSAGE, e.str() << std::endl);
+      return false;
+    }
+  }
+
+  return true;
+}
diff --git a/Source/CTest/cmCTestUpdateHandler.h b/Source/CTest/cmCTestUpdateHandler.h
new file mode 100644
index 0000000..0f51d3f
--- /dev/null
+++ b/Source/CTest/cmCTestUpdateHandler.h
@@ -0,0 +1,67 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestUpdateHandler_h
+#define cmCTestUpdateHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTestGenericHandler.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+/** \class cmCTestUpdateHandler
+ * \brief A class that handles ctest -S invocations
+ *
+ */
+class cmCTestUpdateHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  cmCTestUpdateHandler();
+
+  enum
+  {
+    e_UNKNOWN = 0,
+    e_CVS,
+    e_SVN,
+    e_BZR,
+    e_GIT,
+    e_HG,
+    e_P4,
+    e_LAST
+  };
+
+  /**
+   * Initialize handler
+   */
+  void Initialize() override;
+
+private:
+  // Some structures needed for update
+  struct StringPair : public std::pair<std::string, std::string>
+  {
+  };
+  struct UpdateFiles : public std::vector<StringPair>
+  {
+  };
+
+  // Determine the type of version control
+  int DetermineType(const char* cmd, const char* type);
+
+  // The VCS command to update the working tree.
+  std::string UpdateCommand;
+  int UpdateType;
+
+  int DetectVCS(const char* dir);
+  bool SelectVCS();
+};
+
+#endif
diff --git a/Source/CTest/cmCTestUploadCommand.cxx b/Source/CTest/cmCTestUploadCommand.cxx
new file mode 100644
index 0000000..d85f35f
--- /dev/null
+++ b/Source/CTest/cmCTestUploadCommand.cxx
@@ -0,0 +1,68 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestUploadCommand.h"
+
+#include <sstream>
+#include <vector>
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+#include "cmCTestUploadHandler.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
+{
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("upload");
+  if (!handler) {
+    this->SetError("internal CTest error. Cannot instantiate upload handler");
+    return nullptr;
+  }
+  static_cast<cmCTestUploadHandler*>(handler)->SetFiles(this->Files);
+
+  handler->SetQuiet(this->Quiet);
+  return handler;
+}
+
+bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg)
+{
+  if (arg == "FILES") {
+    this->ArgumentDoing = ArgumentDoingFiles;
+    return true;
+  }
+  if (arg == "QUIET") {
+    this->ArgumentDoing = ArgumentDoingNone;
+    this->Quiet = true;
+    return true;
+  }
+  if (arg == "CAPTURE_CMAKE_ERROR") {
+    this->ArgumentDoing = ArgumentDoingCaptureCMakeError;
+    return true;
+  }
+  return false;
+}
+
+bool cmCTestUploadCommand::CheckArgumentValue(std::string const& arg)
+{
+  if (this->ArgumentDoing == ArgumentDoingCaptureCMakeError) {
+    this->Values[ct_CAPTURE_CMAKE_ERROR] = arg.c_str();
+    return true;
+  }
+  if (this->ArgumentDoing == ArgumentDoingFiles) {
+    if (cmSystemTools::FileExists(arg.c_str())) {
+      this->Files.insert(arg);
+      return true;
+    }
+    std::ostringstream e;
+    e << "File \"" << arg << "\" does not exist. Cannot submit "
+      << "a non-existent file.";
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+    this->ArgumentDoing = ArgumentDoingError;
+    return false;
+  }
+
+  // Look for other arguments.
+  return this->Superclass::CheckArgumentValue(arg);
+}
diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h
new file mode 100644
index 0000000..61bf1cc
--- /dev/null
+++ b/Source/CTest/cmCTestUploadCommand.h
@@ -0,0 +1,61 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestUploadCommand_h
+#define cmCTestUploadCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTest.h"
+#include "cmCTestHandlerCommand.h"
+
+#include <string>
+
+class cmCTestGenericHandler;
+class cmCommand;
+
+/** \class cmCTestUpload
+ * \brief Run a ctest script
+ *
+ * cmCTestUploadCommand defines the command to upload result files for
+ * the project.
+ */
+class cmCTestUploadCommand : public cmCTestHandlerCommand
+{
+public:
+  cmCTestUploadCommand() {}
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    cmCTestUploadCommand* ni = new cmCTestUploadCommand;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
+    return ni;
+  }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  std::string GetName() const override { return "ctest_upload"; }
+
+  typedef cmCTestHandlerCommand Superclass;
+
+protected:
+  cmCTestGenericHandler* InitializeHandler() override;
+
+  bool CheckArgumentKeyword(std::string const& arg) override;
+  bool CheckArgumentValue(std::string const& arg) override;
+
+  enum
+  {
+    ArgumentDoingFiles = Superclass::ArgumentDoingLast1,
+    ArgumentDoingCaptureCMakeError,
+    ArgumentDoingLast2
+  };
+
+  cmCTest::SetOfStrings Files;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestUploadHandler.cxx b/Source/CTest/cmCTestUploadHandler.cxx
new file mode 100644
index 0000000..59a5de4
--- /dev/null
+++ b/Source/CTest/cmCTestUploadHandler.cxx
@@ -0,0 +1,71 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestUploadHandler.h"
+
+#include "cmGeneratedFileStream.h"
+#include "cmVersion.h"
+#include "cmXMLWriter.h"
+
+#include <ostream>
+#include <string>
+
+cmCTestUploadHandler::cmCTestUploadHandler()
+{
+  this->Initialize();
+}
+
+void cmCTestUploadHandler::Initialize()
+{
+  this->Superclass::Initialize();
+  this->Files.clear();
+}
+
+void cmCTestUploadHandler::SetFiles(const cmCTest::SetOfStrings& files)
+{
+  this->Files = files;
+}
+
+int cmCTestUploadHandler::ProcessHandler()
+{
+  cmGeneratedFileStream ofs;
+  if (!this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(), "Upload.xml",
+                                   ofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open Upload.xml file"
+                 << std::endl);
+    return -1;
+  }
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
+
+  cmXMLWriter xml(ofs);
+  xml.StartDocument();
+  xml.ProcessingInstruction("xml-stylesheet",
+                            "type=\"text/xsl\" "
+                            "href=\"Dart/Source/Server/XSL/Build.xsl "
+                            "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
+  xml.StartElement("Site");
+  xml.Attribute("BuildName", buildname);
+  xml.Attribute("BuildStamp", this->CTest->GetCurrentTag() + "-" +
+                  this->CTest->GetTestModelString());
+  xml.Attribute("Name", this->CTest->GetCTestConfiguration("Site"));
+  xml.Attribute("Generator",
+                std::string("ctest") + cmVersion::GetCMakeVersion());
+  this->CTest->AddSiteProperties(xml);
+  xml.StartElement("Upload");
+
+  for (std::string const& file : this->Files) {
+    cmCTestOptionalLog(this->CTest, OUTPUT,
+                       "\tUpload file: " << file << std::endl, this->Quiet);
+    xml.StartElement("File");
+    xml.Attribute("filename", file);
+    xml.StartElement("Content");
+    xml.Attribute("encoding", "base64");
+    xml.Content(this->CTest->Base64EncodeFile(file));
+    xml.EndElement(); // Content
+    xml.EndElement(); // File
+  }
+  xml.EndElement(); // Upload
+  xml.EndElement(); // Site
+  xml.EndDocument();
+  return 0;
+}
diff --git a/Source/CTest/cmCTestUploadHandler.h b/Source/CTest/cmCTestUploadHandler.h
new file mode 100644
index 0000000..ff50574
--- /dev/null
+++ b/Source/CTest/cmCTestUploadHandler.h
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestUploadHandler_h
+#define cmCTestUploadHandler_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+
+/** \class cmCTestUploadHandler
+ * \brief Helper class for CTest
+ *
+ * Submit arbitrary files
+ *
+ */
+class cmCTestUploadHandler : public cmCTestGenericHandler
+{
+public:
+  typedef cmCTestGenericHandler Superclass;
+
+  cmCTestUploadHandler();
+  ~cmCTestUploadHandler() override {}
+
+  /*
+   * The main entry point for this class
+   */
+  int ProcessHandler() override;
+
+  void Initialize() override;
+
+  /** Specify a set of files to submit.  */
+  void SetFiles(cmCTest::SetOfStrings const& files);
+
+private:
+  cmCTest::SetOfStrings Files;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestVC.cxx b/Source/CTest/cmCTestVC.cxx
new file mode 100644
index 0000000..fd7f37a
--- /dev/null
+++ b/Source/CTest/cmCTestVC.cxx
@@ -0,0 +1,215 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTestVC.h"
+
+#include "cmCTest.h"
+#include "cmSystemTools.h"
+#include "cmXMLWriter.h"
+
+#include "cmsys/Process.h"
+#include <sstream>
+#include <stdio.h>
+#include <time.h>
+#include <vector>
+
+cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log)
+  : CTest(ct)
+  , Log(log)
+{
+  this->PathCount[PathUpdated] = 0;
+  this->PathCount[PathModified] = 0;
+  this->PathCount[PathConflicting] = 0;
+  this->Unknown.Date = "Unknown";
+  this->Unknown.Author = "Unknown";
+  this->Unknown.Rev = "Unknown";
+}
+
+cmCTestVC::~cmCTestVC()
+{
+}
+
+void cmCTestVC::SetCommandLineTool(std::string const& tool)
+{
+  this->CommandLineTool = tool;
+}
+
+void cmCTestVC::SetSourceDirectory(std::string const& dir)
+{
+  this->SourceDirectory = dir;
+}
+
+bool cmCTestVC::InitialCheckout(const char* command)
+{
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   First perform the initial checkout: " << command << "\n");
+
+  // Make the parent directory in which to perform the checkout.
+  std::string parent = cmSystemTools::GetFilenamePath(this->SourceDirectory);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+             "   Perform checkout in directory: " << parent << "\n");
+  if (!cmSystemTools::MakeDirectory(parent.c_str())) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create directory: " << parent << std::endl);
+    return false;
+  }
+
+  // Construct the initial checkout command line.
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
+  std::vector<char const*> vc_co;
+  vc_co.reserve(args.size() + 1);
+  for (std::string const& arg : args) {
+    vc_co.push_back(arg.c_str());
+  }
+  vc_co.push_back(nullptr);
+
+  // Run the initial checkout command and log its output.
+  this->Log << "--- Begin Initial Checkout ---\n";
+  OutputLogger out(this->Log, "co-out> ");
+  OutputLogger err(this->Log, "co-err> ");
+  bool result = this->RunChild(&vc_co[0], &out, &err, parent.c_str());
+  this->Log << "--- End Initial Checkout ---\n";
+  if (!result) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initial checkout failed!"
+                 << std::endl);
+  }
+  return result;
+}
+
+bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out,
+                         OutputParser* err, const char* workDir,
+                         Encoding encoding)
+{
+  this->Log << this->ComputeCommandLine(cmd) << "\n";
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, cmd);
+  workDir = workDir ? workDir : this->SourceDirectory.c_str();
+  cmsysProcess_SetWorkingDirectory(cp, workDir);
+  this->RunProcess(cp, out, err, encoding);
+  int result = cmsysProcess_GetExitValue(cp);
+  cmsysProcess_Delete(cp);
+  return result == 0;
+}
+
+std::string cmCTestVC::ComputeCommandLine(char const* const* cmd)
+{
+  std::ostringstream line;
+  const char* sep = "";
+  for (const char* const* arg = cmd; *arg; ++arg) {
+    line << sep << "\"" << *arg << "\"";
+    sep = " ";
+  }
+  return line.str();
+}
+
+bool cmCTestVC::RunUpdateCommand(char const* const* cmd, OutputParser* out,
+                                 OutputParser* err, Encoding encoding)
+{
+  // Report the command line.
+  this->UpdateCommandLine = this->ComputeCommandLine(cmd);
+  if (this->CTest->GetShowOnly()) {
+    this->Log << this->UpdateCommandLine << "\n";
+    return true;
+  }
+
+  // Run the command.
+  return this->RunChild(cmd, out, err, nullptr, encoding);
+}
+
+std::string cmCTestVC::GetNightlyTime()
+{
+  // Get the nightly start time corresponding to the current dau.
+  struct tm* t = this->CTest->GetNightlyTime(
+    this->CTest->GetCTestConfiguration("NightlyStartTime"),
+    this->CTest->GetTomorrowTag());
+  char current_time[1024];
+  sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900,
+          t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+  return std::string(current_time);
+}
+
+void cmCTestVC::Cleanup()
+{
+  this->Log << "--- Begin Cleanup ---\n";
+  this->CleanupImpl();
+  this->Log << "--- End Cleanup ---\n";
+}
+
+void cmCTestVC::CleanupImpl()
+{
+  // We do no cleanup by default.
+}
+
+bool cmCTestVC::Update()
+{
+  bool result = true;
+  // if update version only is on then do not actually update,
+  // just note the current version and finish
+  if (!cmSystemTools::IsOn(
+        this->CTest->GetCTestConfiguration("UpdateVersionOnly").c_str())) {
+    result = this->NoteOldRevision() && result;
+    this->Log << "--- Begin Update ---\n";
+    result = this->UpdateImpl() && result;
+    this->Log << "--- End Update ---\n";
+  }
+  result = this->NoteNewRevision() && result;
+  return result;
+}
+
+bool cmCTestVC::NoteOldRevision()
+{
+  // We do nothing by default.
+  return true;
+}
+
+bool cmCTestVC::NoteNewRevision()
+{
+  // We do nothing by default.
+  return true;
+}
+
+bool cmCTestVC::UpdateImpl()
+{
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             "* Unknown VCS tool, not updating!" << std::endl);
+  return true;
+}
+
+bool cmCTestVC::WriteXML(cmXMLWriter& xml)
+{
+  this->Log << "--- Begin Revisions ---\n";
+  bool result = this->WriteXMLUpdates(xml);
+  this->Log << "--- End Revisions ---\n";
+  return result;
+}
+
+bool cmCTestVC::WriteXMLUpdates(cmXMLWriter& /*unused*/)
+{
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             "* CTest cannot extract updates for this VCS tool.\n");
+  return true;
+}
+
+void cmCTestVC::WriteXMLEntry(cmXMLWriter& xml, std::string const& path,
+                              std::string const& name, std::string const& full,
+                              File const& f)
+{
+  static const char* desc[3] = { "Updated", "Modified", "Conflicting" };
+  Revision const& rev = f.Rev ? *f.Rev : this->Unknown;
+  std::string prior = f.PriorRev ? f.PriorRev->Rev : std::string("Unknown");
+  xml.StartElement(desc[f.Status]);
+  xml.Element("File", name);
+  xml.Element("Directory", path);
+  xml.Element("FullName", full);
+  xml.Element("CheckinDate", rev.Date);
+  xml.Element("Author", rev.Author);
+  xml.Element("Email", rev.EMail);
+  xml.Element("Committer", rev.Committer);
+  xml.Element("CommitterEmail", rev.CommitterEMail);
+  xml.Element("CommitDate", rev.CommitDate);
+  xml.Element("Log", rev.Log);
+  xml.Element("Revision", rev.Rev);
+  xml.Element("PriorRevision", prior);
+  xml.EndElement();
+  ++this->PathCount[f.Status];
+}
diff --git a/Source/CTest/cmCTestVC.h b/Source/CTest/cmCTestVC.h
new file mode 100644
index 0000000..69a3bf0
--- /dev/null
+++ b/Source/CTest/cmCTestVC.h
@@ -0,0 +1,153 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTestVC_h
+#define cmCTestVC_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <string>
+
+#include "cmProcessOutput.h"
+#include "cmProcessTools.h"
+
+class cmCTest;
+class cmXMLWriter;
+
+/** \class cmCTestVC
+ * \brief Base class for version control system handlers
+ *
+ */
+class cmCTestVC : public cmProcessTools
+{
+public:
+  /** Construct with a CTest instance and update log stream.  */
+  cmCTestVC(cmCTest* ctest, std::ostream& log);
+
+  virtual ~cmCTestVC();
+
+  /** Command line tool to invoke.  */
+  void SetCommandLineTool(std::string const& tool);
+
+  /** Top-level source directory.  */
+  void SetSourceDirectory(std::string const& dir);
+
+  /** Get the date/time specification for the current nightly start time.  */
+  std::string GetNightlyTime();
+
+  /** Prepare the work tree.  */
+  bool InitialCheckout(const char* command);
+
+  /** Perform cleanup operations on the work tree.  */
+  void Cleanup();
+
+  /** Update the working tree to the new revision.  */
+  bool Update();
+
+  /** Get the command line used by the Update method.  */
+  std::string const& GetUpdateCommandLine() const
+  {
+    return this->UpdateCommandLine;
+  }
+
+  /** Write Update.xml entries for the updates found.  */
+  bool WriteXML(cmXMLWriter& xml);
+
+  /** Enumerate non-trivial working tree states during update.  */
+  enum PathStatus
+  {
+    PathUpdated,
+    PathModified,
+    PathConflicting
+  };
+
+  /** Get the number of working tree paths in each state after update.  */
+  int GetPathCount(PathStatus s) const { return this->PathCount[s]; }
+
+protected:
+  // Internal API to be implemented by subclasses.
+  virtual void CleanupImpl();
+  virtual bool NoteOldRevision();
+  virtual bool UpdateImpl();
+  virtual bool NoteNewRevision();
+  virtual bool WriteXMLUpdates(cmXMLWriter& xml);
+
+#if defined(__SUNPRO_CC) && __SUNPRO_CC <= 0x510
+  // Sun CC 5.1 needs help to allow cmCTestSVN::Revision to see this
+public:
+#endif
+  /** Basic information about one revision of a tree or file.  */
+  struct Revision
+  {
+    std::string Rev;
+    std::string Date;
+    std::string Author;
+    std::string EMail;
+    std::string Committer;
+    std::string CommitterEMail;
+    std::string CommitDate;
+    std::string Log;
+  };
+
+protected:
+  friend struct File;
+
+  /** Represent change to one file.  */
+  struct File
+  {
+    PathStatus Status;
+    Revision const* Rev;
+    Revision const* PriorRev;
+    File()
+      : Status(PathUpdated)
+      , Rev(nullptr)
+      , PriorRev(nullptr)
+    {
+    }
+    File(PathStatus status, Revision const* rev, Revision const* priorRev)
+      : Status(status)
+      , Rev(rev)
+      , PriorRev(priorRev)
+    {
+    }
+  };
+
+  /** Convert a list of arguments to a human-readable command line.  */
+  static std::string ComputeCommandLine(char const* const* cmd);
+
+  /** Run a command line and send output to given parsers.  */
+  bool RunChild(char const* const* cmd, OutputParser* out, OutputParser* err,
+                const char* workDir = nullptr,
+                Encoding encoding = cmProcessOutput::Auto);
+
+  /** Run VC update command line and send output to given parsers.  */
+  bool RunUpdateCommand(char const* const* cmd, OutputParser* out,
+                        OutputParser* err = nullptr,
+                        Encoding encoding = cmProcessOutput::Auto);
+
+  /** Write xml element for one file.  */
+  void WriteXMLEntry(cmXMLWriter& xml, std::string const& path,
+                     std::string const& name, std::string const& full,
+                     File const& f);
+
+  // Instance of cmCTest running the script.
+  cmCTest* CTest;
+
+  // A stream to which we write log information.
+  std::ostream& Log;
+
+  // Basic information about the working tree.
+  std::string CommandLineTool;
+  std::string SourceDirectory;
+
+  // Record update command info.
+  std::string UpdateCommandLine;
+
+  // Placeholder for unknown revisions.
+  Revision Unknown;
+
+  // Count paths reported with each PathStatus value.
+  int PathCount[3];
+};
+
+#endif
diff --git a/Source/CTest/cmParseBlanketJSCoverage.cxx b/Source/CTest/cmParseBlanketJSCoverage.cxx
new file mode 100644
index 0000000..308e6f7
--- /dev/null
+++ b/Source/CTest/cmParseBlanketJSCoverage.cxx
@@ -0,0 +1,137 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmParseBlanketJSCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/FStream.hxx"
+#include <stdio.h>
+#include <stdlib.h>
+
+class cmParseBlanketJSCoverage::JSONParser
+{
+public:
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
+  JSONParser(cmCTestCoverageHandlerContainer& cont)
+    : Coverage(cont)
+  {
+  }
+
+  virtual ~JSONParser() {}
+
+  std::string getValue(std::string const& line, int type)
+  {
+    size_t begIndex;
+    size_t endIndex;
+    endIndex = line.rfind(',');
+    begIndex = line.find_first_of(':');
+    if (type == 0) {
+      //  A unique substring to remove the extra characters
+      //  around the files name in the JSON (extra " and ,)
+      std::string foundFileName =
+        line.substr(begIndex + 3, endIndex - (begIndex + 4));
+      return foundFileName;
+    }
+    return line.substr(begIndex);
+  }
+  bool ParseFile(std::string const& file)
+  {
+    FileLinesType localCoverageVector;
+    std::string filename;
+    bool foundFile = false;
+    bool inSource = false;
+    std::string covResult;
+    std::string line;
+
+    cmsys::ifstream in(file.c_str());
+    if (!in) {
+      return false;
+    }
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      if (line.find("filename") != std::string::npos) {
+        if (foundFile) {
+          /*
+           * Upon finding a second file name, generate a
+           * vector within the total coverage to capture the
+           * information in the local vector
+           */
+          FileLinesType& CoverageVector =
+            this->Coverage.TotalCoverage[filename];
+          CoverageVector = localCoverageVector;
+          localCoverageVector.clear();
+        }
+        foundFile = true;
+        inSource = false;
+        filename = getValue(line, 0);
+      } else if ((line.find("coverage") != std::string::npos) && foundFile &&
+                 inSource) {
+        /*
+         *  two types of "coverage" in the JSON structure
+         *
+         *  The coverage result over the file or set of files
+         *  and the coverage for each individual line
+         *
+         *  FoundFile and foundSource ensure that
+         *  only the value of the line coverage is captured
+         */
+        std::string result = getValue(line, 1);
+        result = result.substr(2);
+        if (result == "\"\"") {
+          // Empty quotation marks indicate that the
+          // line is not executable
+          localCoverageVector.push_back(-1);
+        } else {
+          // Else, it contains the number of time executed
+          localCoverageVector.push_back(atoi(result.c_str()));
+        }
+      } else if (line.find("source") != std::string::npos) {
+        inSource = true;
+      }
+    }
+
+    // On exit, capture end of last file covered.
+    FileLinesType& CoverageVector = this->Coverage.TotalCoverage[filename];
+    CoverageVector = localCoverageVector;
+    localCoverageVector.clear();
+    return true;
+  }
+
+private:
+  cmCTestCoverageHandlerContainer& Coverage;
+};
+
+cmParseBlanketJSCoverage::cmParseBlanketJSCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+bool cmParseBlanketJSCoverage::LoadCoverageData(std::vector<std::string> files)
+{
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Found " << files.size() << " Files" << std::endl,
+                     this->Coverage.Quiet);
+  for (std::string const& file : files) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading JSON File " << file << std::endl,
+                       this->Coverage.Quiet);
+
+    if (!this->ReadJSONFile(file)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool cmParseBlanketJSCoverage::ReadJSONFile(std::string const& file)
+{
+  cmParseBlanketJSCoverage::JSONParser parser(this->Coverage);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Parsing " << file << std::endl, this->Coverage.Quiet);
+  parser.ParseFile(file);
+  return true;
+}
diff --git a/Source/CTest/cmParseBlanketJSCoverage.h b/Source/CTest/cmParseBlanketJSCoverage.h
new file mode 100644
index 0000000..696121f
--- /dev/null
+++ b/Source/CTest/cmParseBlanketJSCoverage.h
@@ -0,0 +1,42 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseBlanketJSCoverage_h
+#define cmParseBlanketJSCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseBlanketJSCoverage
+ * \brief Parse BlanketJS coverage information
+ *
+ * This class is used to parse BlanketJS(Pascal) coverage information
+ * generated by the Blanket.js library when used in conjunction with the
+ * test runner mocha.js, which is used to write out the JSON format.
+ *
+ *  Blanket.js:
+ *  http://blanketjs.org/
+ *
+ *  Mocha.js
+ *  http://visionmedia.github.io/mocha/
+ */
+class cmParseBlanketJSCoverage
+{
+public:
+  cmParseBlanketJSCoverage(cmCTestCoverageHandlerContainer& cont,
+                           cmCTest* ctest);
+  bool LoadCoverageData(std::vector<std::string> files);
+  //  Read the JSON output
+  bool ReadJSONFile(std::string const& file);
+
+protected:
+  class JSONParser;
+
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+#endif
diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
new file mode 100644
index 0000000..4cd6588
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -0,0 +1,198 @@
+#include "cmParseCacheCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include <map>
+#include <stdio.h>
+#include <stdlib.h>
+#include <utility>
+
+cmParseCacheCoverage::cmParseCacheCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+bool cmParseCacheCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if (!dir.Load(d)) {
+    return false;
+  }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++) {
+    std::string file = dir.GetFile(i);
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if (cmSystemTools::GetFilenameLastExtension(path) == ".cmcov") {
+        if (!this->ReadCMCovFile(path.c_str())) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// not currently used, but leave it in case we want it in the future
+void cmParseCacheCoverage::RemoveUnCoveredFiles()
+{
+  // loop over the coverage data computed and remove all files
+  // that only have -1 or 0 for the lines.
+  cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator ci =
+    this->Coverage.TotalCoverage.begin();
+  while (ci != this->Coverage.TotalCoverage.end()) {
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v = ci->second;
+    bool nothing = true;
+    for (int i : v) {
+      if (i > 0) {
+        nothing = false;
+        break;
+      }
+    }
+    if (nothing) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "No coverage found in: " << ci->first << std::endl,
+                         this->Coverage.Quiet);
+      this->Coverage.TotalCoverage.erase(ci++);
+    } else {
+      ++ci;
+    }
+  }
+}
+
+bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
+                                       std::string const& line)
+{
+  std::string::size_type pos1 = 0;
+  std::string::size_type pos2 = line.find(',', 0);
+  if (pos2 == std::string::npos) {
+    return false;
+  }
+  std::string arg;
+  while (pos2 != std::string::npos) {
+    arg = line.substr(pos1, pos2 - pos1);
+    args.push_back(arg);
+    pos1 = pos2 + 1;
+    pos2 = line.find(',', pos1);
+  }
+  arg = line.substr(pos1);
+  args.push_back(arg);
+  return true;
+}
+
+bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
+{
+  cmsys::ifstream in(file);
+  if (!in) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not open : " << file << "\n");
+    return false;
+  }
+  std::string line;
+  std::vector<std::string> separateLine;
+  if (!cmSystemTools::GetLineFromStream(in, line)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Empty file : "
+                 << file << "  referenced in this line of cmcov data:\n"
+                            "["
+                 << line << "]\n");
+    return false;
+  }
+  separateLine.clear();
+  this->SplitString(separateLine, line);
+  if (separateLine.size() != 4 || separateLine[0] != "Routine" ||
+      separateLine[1] != "Line" || separateLine[2] != "RtnLine" ||
+      separateLine[3] != "Code") {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Bad first line of cmcov file : " << file << "  line:\n"
+                                                            "["
+                                                 << line << "]\n");
+  }
+  std::string routine;
+  std::string filepath;
+  while (cmSystemTools::GetLineFromStream(in, line)) {
+    // clear out line argument vector
+    separateLine.clear();
+    // parse the comma separated line
+    this->SplitString(separateLine, line);
+    // might have more because code could have a quoted , in it
+    // but we only care about the first 3 args anyway
+    if (separateLine.size() < 4) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Bad line of cmcov file expected at least 4 found: "
+                   << separateLine.size() << " " << file << "  line:\n"
+                                                            "["
+                   << line << "]\n");
+      for (std::string::size_type i = 0; i < separateLine.size(); ++i) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "" << separateLine[1] << " ");
+      }
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\n");
+      return false;
+    }
+    // if we do not have a routine yet, then it should be
+    // the first argument in the vector
+    if (routine.empty()) {
+      routine = separateLine[0];
+      // Find the full path to the file
+      if (!this->FindMumpsFile(routine, filepath)) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Could not find mumps file for routine: " << routine
+                                                             << "\n");
+        filepath.clear();
+        continue; // move to next line
+      }
+    }
+    // if we have a routine name, check for end of routine
+    else {
+      // Totals in arg 0 marks the end of a routine
+      if (separateLine[0].substr(0, 6) == "Totals") {
+        routine.clear(); // at the end of this routine
+        filepath.clear();
+        continue; // move to next line
+      }
+    }
+    // if the file path was not found for the routine
+    // move to next line. We should have already warned
+    // after the call to FindMumpsFile that we did not find
+    // it, so don't report again to cut down on output
+    if (filepath.empty()) {
+      continue;
+    }
+    // now we are ready to set the coverage from the line of data
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+      this->Coverage.TotalCoverage[filepath];
+    std::string::size_type linenumber = atoi(separateLine[1].c_str()) - 1;
+    int count = atoi(separateLine[2].c_str());
+    if (linenumber > coverageVector.size()) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Parse error line is greater than number of lines in file: "
+                   << linenumber << " " << filepath << "\n");
+      continue; // skip setting count to avoid crash
+    }
+    // now add to count for linenumber
+    // for some reason the cache coverage adds extra lines to the
+    // end of the file in some cases. Since they do not exist, we will
+    // mark them as non executable
+    while (linenumber >= coverageVector.size()) {
+      coverageVector.push_back(-1);
+    }
+    // Accounts for lines that were previously marked
+    // as non-executable code (-1). if the parser comes back with
+    // a non-zero count, increase the count by 1 to push the line
+    // into the executable code set in addition to the count found.
+    if (coverageVector[linenumber] == -1 && count > 0) {
+      coverageVector[linenumber] += count + 1;
+    } else {
+      coverageVector[linenumber] += count;
+    }
+  }
+  return true;
+}
diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h
new file mode 100644
index 0000000..081f5fa
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseCacheCoverage_h
+#define cmParseCacheCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmParseMumpsCoverage.h"
+
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseCacheCoverage
+ * \brief Parse Cache coverage information
+ *
+ * This class is used to parse Cache coverage information for
+ * mumps.
+ */
+class cmParseCacheCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseCacheCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir) override;
+  // remove files with no coverage
+  void RemoveUnCoveredFiles();
+  // Read a single mcov file
+  bool ReadCMCovFile(const char* f);
+  // split a string based on ,
+  bool SplitString(std::vector<std::string>& args, std::string const& line);
+};
+
+#endif
diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx
new file mode 100644
index 0000000..61ce7d4
--- /dev/null
+++ b/Source/CTest/cmParseCoberturaCoverage.cxx
@@ -0,0 +1,170 @@
+#include "cmParseCoberturaCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+
+#include "cmsys/FStream.hxx"
+#include <stdlib.h>
+#include <string.h>
+
+class cmParseCoberturaCoverage::XMLParser : public cmXMLParser
+{
+public:
+  XMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
+    : CTest(ctest)
+    , Coverage(cont)
+  {
+    this->InSources = false;
+    this->InSource = false;
+    this->SkipThisClass = false;
+    this->FilePaths.push_back(this->Coverage.SourceDir);
+    this->FilePaths.push_back(this->Coverage.BinaryDir);
+    this->CurFileName.clear();
+  }
+
+  ~XMLParser() override {}
+
+protected:
+  void EndElement(const std::string& name) override
+  {
+    if (name == "source") {
+      this->InSource = false;
+    } else if (name == "sources") {
+      this->InSources = false;
+    } else if (name == "class") {
+      this->SkipThisClass = false;
+    }
+  }
+
+  void CharacterDataHandler(const char* data, int length) override
+  {
+    std::string tmp;
+    tmp.insert(0, data, length);
+    if (this->InSources && this->InSource) {
+      this->FilePaths.push_back(tmp);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Adding Source: " << tmp << std::endl,
+                         this->Coverage.Quiet);
+    }
+  }
+
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    std::string FoundSource;
+    std::string finalpath;
+    if (name == "source") {
+      this->InSource = true;
+    } else if (name == "sources") {
+      this->InSources = true;
+    } else if (name == "class") {
+      int tagCount = 0;
+      while (true) {
+        if (strcmp(atts[tagCount], "filename") == 0) {
+          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                             "Reading file: " << atts[tagCount + 1]
+                                              << std::endl,
+                             this->Coverage.Quiet);
+          std::string filename = atts[tagCount + 1];
+          this->CurFileName.clear();
+
+          // Check if this is an absolute path that falls within our
+          // source or binary directories.
+          for (std::string const& filePath : FilePaths) {
+            if (filename.find(filePath) == 0) {
+              this->CurFileName = filename;
+              break;
+            }
+          }
+
+          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) {
+              finalpath = filePath + "/" + filename;
+              if (cmSystemTools::FileExists(finalpath.c_str())) {
+                this->CurFileName = finalpath;
+                break;
+              }
+            }
+          }
+
+          cmsys::ifstream fin(this->CurFileName.c_str());
+          if (this->CurFileName.empty() || !fin) {
+            this->CurFileName =
+              this->Coverage.BinaryDir + "/" + atts[tagCount + 1];
+            fin.open(this->CurFileName.c_str());
+            if (!fin) {
+              cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                                 "Skipping system file " << filename
+                                                         << std::endl,
+                                 this->Coverage.Quiet);
+
+              this->SkipThisClass = true;
+              break;
+            }
+          }
+          std::string line;
+          FileLinesType& curFileLines =
+            this->Coverage.TotalCoverage[this->CurFileName];
+          while (cmSystemTools::GetLineFromStream(fin, line)) {
+            curFileLines.push_back(-1);
+          }
+
+          break;
+        }
+        ++tagCount;
+      }
+    } else if (name == "line") {
+      int tagCount = 0;
+      int curNumber = -1;
+      int curHits = -1;
+      while (true) {
+        if (this->SkipThisClass) {
+          break;
+        }
+        if (strcmp(atts[tagCount], "hits") == 0) {
+          curHits = atoi(atts[tagCount + 1]);
+        } else if (strcmp(atts[tagCount], "number") == 0) {
+          curNumber = atoi(atts[tagCount + 1]);
+        }
+
+        if (curHits > -1 && curNumber > 0) {
+          FileLinesType& curFileLines =
+            this->Coverage.TotalCoverage[this->CurFileName];
+          {
+            curFileLines[curNumber - 1] = curHits;
+          }
+          break;
+        }
+        ++tagCount;
+      }
+    }
+  }
+
+private:
+  bool InSources;
+  bool InSource;
+  bool SkipThisClass;
+  std::vector<std::string> FilePaths;
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
+  cmCTest* CTest;
+  cmCTestCoverageHandlerContainer& Coverage;
+  std::string CurFileName;
+};
+
+cmParseCoberturaCoverage::cmParseCoberturaCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+bool cmParseCoberturaCoverage::ReadCoverageXML(const char* xmlFile)
+{
+  cmParseCoberturaCoverage::XMLParser parser(this->CTest, this->Coverage);
+  parser.ParseFile(xmlFile);
+  return true;
+}
diff --git a/Source/CTest/cmParseCoberturaCoverage.h b/Source/CTest/cmParseCoberturaCoverage.h
new file mode 100644
index 0000000..cb6d097
--- /dev/null
+++ b/Source/CTest/cmParseCoberturaCoverage.h
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseCoberturaCoverage_h
+#define cmParseCoberturaCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParsePythonCoverage
+ * \brief Parse coverage.py Python coverage information
+ *
+ * This class is used to parse the output of the coverage.py tool that
+ * is currently maintained by Ned Batchelder. That tool has a command
+ * that produces xml output in the format typically output by the common
+ * Java-based Cobertura coverage application. This helper class parses
+ * that XML file to fill the coverage-handler container.
+ */
+class cmParseCoberturaCoverage
+{
+public:
+  //! Create the coverage parser by passing in the coverage handler
+  //! container and the cmCTest object
+  cmParseCoberturaCoverage(cmCTestCoverageHandlerContainer& cont,
+                           cmCTest* ctest);
+
+  bool inSources;
+  bool inSource;
+  std::vector<std::string> filepaths;
+  //! Read the XML produced by running `coverage xml`
+  bool ReadCoverageXML(const char* xmlFile);
+
+private:
+  class XMLParser;
+
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+  std::string CurFileName;
+};
+
+#endif
diff --git a/Source/CTest/cmParseDelphiCoverage.cxx b/Source/CTest/cmParseDelphiCoverage.cxx
new file mode 100644
index 0000000..6d82cb2
--- /dev/null
+++ b/Source/CTest/cmParseDelphiCoverage.cxx
@@ -0,0 +1,230 @@
+#include "cmParseDelphiCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include <stdio.h>
+#include <stdlib.h>
+
+class cmParseDelphiCoverage::HTMLParser
+{
+public:
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
+  HTMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
+    : CTest(ctest)
+    , Coverage(cont)
+  {
+  }
+
+  virtual ~HTMLParser() {}
+
+  bool initializeDelphiFile(
+    std::string const& filename,
+    cmParseDelphiCoverage::HTMLParser::FileLinesType& coverageVector)
+  {
+    std::string line;
+    size_t comPos;
+    size_t semiPos;
+    bool blockComFlag = false;
+    bool lineComFlag = false;
+    std::vector<std::string> beginSet;
+    cmsys::ifstream in(filename.c_str());
+    if (!in) {
+      return false;
+    }
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      lineComFlag = false;
+      // Unique cases found in lines.
+      size_t beginPos = line.find("begin");
+
+      // Check that the begin is the first non-space string on the line
+      if ((beginPos == line.find_first_not_of(' ')) &&
+          beginPos != std::string::npos) {
+        beginSet.push_back("begin");
+        coverageVector.push_back(-1);
+        continue;
+      }
+      if (line.find('{') != std::string::npos) {
+        blockComFlag = true;
+      } else if (line.find('}') != std::string::npos) {
+        blockComFlag = false;
+        coverageVector.push_back(-1);
+        continue;
+      } else if ((line.find("end;") != std::string::npos) &&
+                 !beginSet.empty()) {
+        beginSet.pop_back();
+        coverageVector.push_back(-1);
+        continue;
+      }
+
+      //  This checks for comments after lines of code, finding the
+      //  comment symbol after the ending semicolon.
+      comPos = line.find("//");
+      if (comPos != std::string::npos) {
+        semiPos = line.find(';');
+        if (comPos < semiPos) {
+          lineComFlag = true;
+        }
+      }
+      // Based up what was found, add a line to the coverageVector
+      if (!beginSet.empty() && !line.empty() && !blockComFlag &&
+          !lineComFlag) {
+        coverageVector.push_back(0);
+      } else {
+        coverageVector.push_back(-1);
+      }
+    }
+    return true;
+  }
+  bool ParseFile(const char* file)
+  {
+    std::string line = file;
+    std::string lineresult;
+    std::string lastroutine;
+    std::string filename;
+    std::string filelineoffset;
+    size_t afterLineNum = 0;
+    size_t lastoffset = 0;
+    size_t endcovpos = 0;
+    size_t endnamepos = 0;
+    size_t pos = 0;
+
+    /*
+     *  This first 'while' section goes through the found HTML
+     *  file name and attempts to capture the source file name
+     *   which is set as part of the HTML file name: the name of
+     *   the file is found in parenthesis '()'
+     *
+     *   See test HTML file name: UTCovTest(UTCovTest.pas).html.
+     *
+     *   Find the text inside each pair of parenthesis and check
+     *   to see if it ends in '.pas'.  If it can't be found,
+     *   exit the function.
+     */
+    while (true) {
+      lastoffset = line.find('(', pos);
+      if (lastoffset == std::string::npos) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, endnamepos
+                             << "File not found  " << lastoffset << std::endl,
+                           this->Coverage.Quiet);
+        return false;
+      }
+      endnamepos = line.find(')', lastoffset);
+      filename = line.substr(lastoffset + 1, (endnamepos - 1) - lastoffset);
+      if (filename.find(".pas") != std::string::npos) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "Coverage found for file:  " << filename
+                                                        << std::endl,
+                           this->Coverage.Quiet);
+        break;
+      }
+      pos = lastoffset + 1;
+    }
+    /*
+     *  Glob through the source directory for the
+     *  file found above
+     */
+    cmsys::Glob gl;
+    gl.RecurseOn();
+    gl.RecurseThroughSymlinksOff();
+    std::string glob = Coverage.SourceDir + "*/" + filename;
+    gl.FindFiles(glob);
+    std::vector<std::string> const& files = gl.GetFiles();
+    if (files.empty()) {
+      /*
+       *  If that doesn't find any matching files
+       *  return a failure.
+       */
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Unable to find file matching" << glob << std::endl,
+                         this->Coverage.Quiet);
+      return false;
+    }
+    FileLinesType& coverageVector = this->Coverage.TotalCoverage[files[0]];
+
+    /*
+     *  Initialize the file to have all code between 'begin' and
+     *  'end' tags marked as executable
+     */
+
+    this->initializeDelphiFile(files[0], coverageVector);
+
+    cmsys::ifstream in(file);
+    if (!in) {
+      return false;
+    }
+
+    /*
+     *  Now read the HTML file, looking for the lines that have an
+     *  "inline" in it. Then parse out the "class" value of that
+     *  line to determine if the line is executed or not.
+     *
+     *  Sample HTML line:
+     *
+     *  <tr class="covered"><td>47</td><td><pre style="display:inline;">
+     *    &nbsp;CheckEquals(1,2-1);</pre></td></tr>
+     *
+     */
+
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      if (line.find("inline") == std::string::npos) {
+        continue;
+      }
+
+      lastoffset = line.find("class=");
+      endcovpos = line.find('>', lastoffset);
+      lineresult = line.substr(lastoffset + 7, (endcovpos - 8) - lastoffset);
+
+      if (lineresult == "covered") {
+        afterLineNum = line.find('<', endcovpos + 5);
+        filelineoffset =
+          line.substr(endcovpos + 5, afterLineNum - (endcovpos + 5));
+        coverageVector[atoi(filelineoffset.c_str()) - 1] = 1;
+      }
+    }
+    return true;
+  }
+
+private:
+  cmCTest* CTest;
+  cmCTestCoverageHandlerContainer& Coverage;
+};
+
+cmParseDelphiCoverage::cmParseDelphiCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+bool cmParseDelphiCoverage::LoadCoverageData(
+  std::vector<std::string> const& files)
+{
+  size_t i;
+  std::string path;
+  size_t numf = files.size();
+  for (i = 0; i < numf; i++) {
+    path = files[i];
+
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading HTML File " << path << std::endl,
+                       this->Coverage.Quiet);
+    if (cmSystemTools::GetFilenameLastExtension(path) == ".html") {
+      if (!this->ReadDelphiHTML(path.c_str())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool cmParseDelphiCoverage::ReadDelphiHTML(const char* file)
+{
+  cmParseDelphiCoverage::HTMLParser parser(this->CTest, this->Coverage);
+  parser.ParseFile(file);
+  return true;
+}
diff --git a/Source/CTest/cmParseDelphiCoverage.h b/Source/CTest/cmParseDelphiCoverage.h
new file mode 100644
index 0000000..1b37405
--- /dev/null
+++ b/Source/CTest/cmParseDelphiCoverage.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseDelphiCoverage_h
+#define cmParseDelphiCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseDelphiCoverage
+ * \brief Parse Delphi coverage information
+ *
+ * This class is used to parse Delphi(Pascal) coverage information
+ * generated by the Delphi-Code-Coverage tool
+ *
+ * https://code.google.com/p/delphi-code-coverage/
+ */
+
+class cmParseDelphiCoverage
+{
+public:
+  cmParseDelphiCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+  bool LoadCoverageData(std::vector<std::string> const& files);
+  bool ReadDelphiHTML(const char* file);
+  // Read a single HTML file from output
+  bool ReadHTMLFile(const char* f);
+
+protected:
+  class HTMLParser;
+
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+#endif
diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx
new file mode 100644
index 0000000..f965048
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.cxx
@@ -0,0 +1,244 @@
+#include "cmParseGTMCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include <map>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+
+cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
+                                       cmCTest* ctest)
+  : cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+bool cmParseGTMCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if (!dir.Load(d)) {
+    return false;
+  }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++) {
+    std::string file = dir.GetFile(i);
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if (cmSystemTools::GetFilenameLastExtension(path) == ".mcov") {
+        if (!this->ReadMCovFile(path.c_str())) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool cmParseGTMCoverage::ReadMCovFile(const char* file)
+{
+  cmsys::ifstream in(file);
+  if (!in) {
+    return false;
+  }
+  std::string line;
+  std::string lastfunction;
+  std::string lastroutine;
+  std::string lastpath;
+  int lastoffset = 0;
+  while (cmSystemTools::GetLineFromStream(in, line)) {
+    // only look at lines that have coverage data
+    if (line.find("^ZZCOVERAGE") == std::string::npos) {
+      continue;
+    }
+    std::string filepath;
+    std::string function;
+    std::string routine;
+    int linenumber = 0;
+    int count = 0;
+    this->ParseMCOVLine(line, routine, function, linenumber, count);
+    // skip this one
+    if (routine == "RSEL") {
+      continue;
+    }
+    // no need to search the file if we just did it
+    if (function == lastfunction && lastroutine == routine) {
+      if (!lastpath.empty()) {
+        this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber] +=
+          count;
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
+                     << lastroutine
+                     << "  referenced in this line of mcov data:\n"
+                        "["
+                     << line << "]\n");
+      }
+      continue;
+    }
+    // Find the full path to the file
+    bool found = this->FindMumpsFile(routine, filepath);
+    if (found) {
+      int lineoffset = 0;
+      if (this->FindFunctionInMumpsFile(filepath, function, lineoffset)) {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+          coverageVector = this->Coverage.TotalCoverage[filepath];
+        // This section accounts for lines that were previously marked
+        // as non-executable code (-1), if the parser comes back with
+        // a non-zero count, increase the count by 1 to push the line
+        // into the executable code set in addition to the count found.
+        if (coverageVector[lineoffset + linenumber] == -1 && count > 0) {
+          coverageVector[lineoffset + linenumber] += count + 1;
+        } else {
+          coverageVector[lineoffset + linenumber] += count;
+        }
+        lastoffset = lineoffset;
+      }
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
+                   << routine << "  referenced in this line of mcov data:\n"
+                                 "["
+                   << line << "]\n");
+    }
+    lastfunction = function;
+    lastroutine = routine;
+    lastpath = filepath;
+  }
+  return true;
+}
+
+bool cmParseGTMCoverage::FindFunctionInMumpsFile(std::string const& filepath,
+                                                 std::string const& function,
+                                                 int& lineoffset)
+{
+  cmsys::ifstream in(filepath.c_str());
+  if (!in) {
+    return false;
+  }
+  std::string line;
+  int linenum = 0;
+  while (cmSystemTools::GetLineFromStream(in, line)) {
+    std::string::size_type pos = line.find(function);
+    if (pos == 0) {
+      char nextchar = line[function.size()];
+      if (nextchar == ' ' || nextchar == '(' || nextchar == '\t') {
+        lineoffset = linenum;
+        return true;
+      }
+    }
+    if (pos == 1) {
+      char prevchar = line[0];
+      char nextchar = line[function.size() + 1];
+      if (prevchar == '%' && (nextchar == ' ' || nextchar == '(')) {
+        lineoffset = linenum;
+        return true;
+      }
+    }
+    linenum++; // move to next line count
+  }
+  lineoffset = 0;
+  cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not find entry point : "
+               << function << " in " << filepath << "\n");
+  return false;
+}
+
+bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
+                                       std::string& routine,
+                                       std::string& function, int& linenumber,
+                                       int& count)
+{
+  // this method parses lines from the .mcov file
+  // each line has ^COVERAGE(...) in it, and there
+  // are several varients of coverage lines:
+  //
+  // ^COVERAGE("DIC11","PR1",0)="2:0:0:0"
+  //          ( file  , entry, line ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","SRC")="1:0:0:0"
+  //          ( file  , entry ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","init",8,"FOR_LOOP",1)=1
+  //          ( file  , entry, line, IGNORE ) =number_executed
+  std::vector<std::string> args;
+  std::string::size_type pos = line.find('(', 0);
+  // if no ( is found, then return line has no coverage
+  if (pos == std::string::npos) {
+    return false;
+  }
+  std::string arg;
+  bool done = false;
+  // separate out all of the comma separated arguments found
+  // in the COVERAGE(...) line
+  while (line[pos] && !done) {
+    // save the char we are looking at
+    char cur = line[pos];
+    // , or ) means end of argument
+    if (cur == ',' || cur == ')') {
+      // save the argument into the argument vector
+      args.push_back(arg);
+      // start on a new argument
+      arg.clear();
+      // if we are at the end of the ), then finish while loop
+      if (cur == ')') {
+        done = true;
+      }
+    } else {
+      // all chars except ", (, and % get stored in the arg string
+      if (cur != '\"' && cur != '(' && cur != '%') {
+        arg.append(1, line[pos]);
+      }
+    }
+    // move to next char
+    pos++;
+  }
+  // now parse the right hand side of the =
+  pos = line.find('=');
+  // no = found, this is an error
+  if (pos == std::string::npos) {
+    return false;
+  }
+  pos++; // move past =
+
+  // if the next positing is not a ", then this is a
+  // COVERAGE(..)=count line and turn the rest of the string
+  // past the = into an integer and set it to count
+  if (line[pos] != '\"') {
+    count = atoi(line.substr(pos).c_str());
+  } else {
+    // this means line[pos] is a ", and we have a
+    // COVERAGE(...)="1:0:0:0" type of line
+    pos++; // move past "
+    // find the first : past the "
+    std::string::size_type pos2 = line.find(':', pos);
+    // turn the string between the " and the first : into an integer
+    // and set it to count
+    count = atoi(line.substr(pos, pos2 - pos).c_str());
+  }
+  // less then two arguments is an error
+  if (args.size() < 2) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing mcov line: ["
+                 << line << "]\n");
+    return false;
+  }
+  routine = args[0];  // the routine is the first argument
+  function = args[1]; // the function in the routine is the second
+  // in the two argument only format
+  // ^COVERAGE("%RSEL","SRC"), the line offset is 0
+  if (args.size() == 2) {
+    // To avoid double counting of line 0 of each entry point,
+    // Don't count the lines that do not give an explicit line
+    // number.
+    routine.clear();
+    function.clear();
+  } else {
+    // this is the format for this line
+    // ^COVERAGE("%RSEL","SRC",count)
+    linenumber = atoi(args[2].c_str());
+  }
+  return true;
+}
diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h
new file mode 100644
index 0000000..13afbbc
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.h
@@ -0,0 +1,41 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseGTMCoverage_h
+#define cmParseGTMCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmParseMumpsCoverage.h"
+
+#include <string>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseGTMCoverage
+ * \brief Parse GTM coverage information
+ *
+ * This class is used to parse GTM coverage information for
+ * mumps.
+ */
+class cmParseGTMCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir) override;
+  // Read a single mcov file
+  bool ReadMCovFile(const char* f);
+  // find out what line in a mumps file (filepath) the given entry point
+  // or function is.  lineoffset is set by this method.
+  bool FindFunctionInMumpsFile(std::string const& filepath,
+                               std::string const& function, int& lineoffset);
+  // parse a line from a .mcov file, and fill in the
+  // routine, function, linenumber and coverage count
+  bool ParseMCOVLine(std::string const& line, std::string& routine,
+                     std::string& function, int& linenumber, int& count);
+};
+
+#endif
diff --git a/Source/CTest/cmParseJacocoCoverage.cxx b/Source/CTest/cmParseJacocoCoverage.cxx
new file mode 100644
index 0000000..7acb5ca
--- /dev/null
+++ b/Source/CTest/cmParseJacocoCoverage.cxx
@@ -0,0 +1,181 @@
+#include "cmParseJacocoCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+#include "cmXMLParser.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include <stdlib.h>
+#include <string.h>
+
+class cmParseJacocoCoverage::XMLParser : public cmXMLParser
+{
+public:
+  XMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
+    : CTest(ctest)
+    , Coverage(cont)
+  {
+    this->FilePath.clear();
+    this->PackagePath.clear();
+    this->PackageName.clear();
+  }
+
+  ~XMLParser() override {}
+
+protected:
+  void EndElement(const std::string& /*name*/) override {}
+
+  void StartElement(const std::string& name, const char** atts) override
+  {
+    if (name == "package") {
+      this->PackageName = atts[1];
+      this->PackagePath.clear();
+    } else if (name == "sourcefile") {
+      std::string fileName = atts[1];
+
+      if (this->PackagePath.empty()) {
+        if (!this->FindPackagePath(fileName)) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
+                       << this->PackageName << "/" << fileName << std::endl);
+          this->Coverage.Error++;
+          return;
+        }
+      }
+
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Reading file: " << fileName << std::endl,
+                         this->Coverage.Quiet);
+
+      this->FilePath = this->PackagePath + "/" + fileName;
+      cmsys::ifstream fin(this->FilePath.c_str());
+      if (!fin) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Jacoco Coverage: Error opening " << this->FilePath
+                                                     << std::endl);
+      }
+      std::string line;
+      FileLinesType& curFileLines =
+        this->Coverage.TotalCoverage[this->FilePath];
+      if (fin) {
+        curFileLines.push_back(-1);
+      }
+      while (cmSystemTools::GetLineFromStream(fin, line)) {
+        curFileLines.push_back(-1);
+      }
+    } else if (name == "line") {
+      int tagCount = 0;
+      int nr = -1;
+      int ci = -1;
+      while (true) {
+        if (strcmp(atts[tagCount], "ci") == 0) {
+          ci = atoi(atts[tagCount + 1]);
+        } else if (strcmp(atts[tagCount], "nr") == 0) {
+          nr = atoi(atts[tagCount + 1]);
+        }
+        if (ci > -1 && nr > 0) {
+          FileLinesType& curFileLines =
+            this->Coverage.TotalCoverage[this->FilePath];
+          if (!curFileLines.empty()) {
+            curFileLines[nr - 1] = ci;
+          }
+          break;
+        }
+        ++tagCount;
+      }
+    }
+  }
+
+  virtual bool FindPackagePath(std::string const& fileName)
+  {
+    // Search for the source file in the source directory.
+    if (this->PackagePathFound(fileName, this->Coverage.SourceDir)) {
+      return true;
+    }
+
+    // If not found there, check the binary directory.
+    if (this->PackagePathFound(fileName, this->Coverage.BinaryDir)) {
+      return true;
+    }
+    return false;
+  }
+
+  virtual bool PackagePathFound(std::string const& fileName,
+                                std::string const& baseDir)
+  {
+    // Search for the file in the baseDir and its subdirectories.
+    std::string packageGlob = baseDir;
+    packageGlob += "/";
+    packageGlob += fileName;
+    cmsys::Glob gl;
+    gl.RecurseOn();
+    gl.RecurseThroughSymlinksOn();
+    gl.FindFiles(packageGlob);
+    std::vector<std::string> const& files = gl.GetFiles();
+    if (files.empty()) {
+      return false;
+    }
+
+    // Check if any of the locations found match our package.
+    for (std::string const& f : files) {
+      std::string dir = cmsys::SystemTools::GetParentDirectory(f);
+      if (cmsys::SystemTools::StringEndsWith(dir, this->PackageName.c_str())) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "Found package directory for " << fileName << ": "
+                                                          << dir << std::endl,
+                           this->Coverage.Quiet);
+        this->PackagePath = dir;
+        return true;
+      }
+    }
+    return false;
+  }
+
+private:
+  std::string FilePath;
+  std::string PackagePath;
+  std::string PackageName;
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
+  cmCTest* CTest;
+  cmCTestCoverageHandlerContainer& Coverage;
+};
+
+cmParseJacocoCoverage::cmParseJacocoCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+bool cmParseJacocoCoverage::LoadCoverageData(
+  std::vector<std::string> const& files)
+{
+  // load all the jacoco.xml files in the source directory
+  cmsys::Directory dir;
+  size_t i;
+  std::string path;
+  size_t numf = files.size();
+  for (i = 0; i < numf; i++) {
+    path = files[i];
+
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading XML File " << path << std::endl,
+                       this->Coverage.Quiet);
+    if (cmSystemTools::GetFilenameLastExtension(path) == ".xml") {
+      if (!this->ReadJacocoXML(path.c_str())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool cmParseJacocoCoverage::ReadJacocoXML(const char* file)
+{
+  cmParseJacocoCoverage::XMLParser parser(this->CTest, this->Coverage);
+  parser.ParseFile(file);
+  return true;
+}
diff --git a/Source/CTest/cmParseJacocoCoverage.h b/Source/CTest/cmParseJacocoCoverage.h
new file mode 100644
index 0000000..f2aec6d
--- /dev/null
+++ b/Source/CTest/cmParseJacocoCoverage.h
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseJacocoCoverage_h
+#define cmParseJacocoCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+#include <vector>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseJacocoCoverage
+ * \brief Parse JaCoCO coverage information
+ *
+ * This class is used to parse coverage information for
+ * java using the JaCoCo tool:
+ *
+ * http://www.eclemma.org/jacoco/trunk/index.html
+ */
+class cmParseJacocoCoverage
+{
+public:
+  cmParseJacocoCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+  bool LoadCoverageData(std::vector<std::string> const& files);
+
+  std::string PackageName;
+  std::string FileName;
+  std::string ModuleName;
+  std::string CurFileName;
+
+private:
+  // implement virtual from parent
+  // remove files with no coverage
+  void RemoveUnCoveredFiles();
+  // Read a single mcov file
+  bool ReadJacocoXML(const char* f);
+  // split a string based on ,
+  bool SplitString(std::vector<std::string>& args, std::string const& line);
+  bool FindJavaFile(std::string const& routine, std::string& filepath);
+  void InitializeJavaFile(std::string& file);
+  bool LoadSource(std::string d);
+
+  class XMLParser;
+
+  std::map<std::string, std::string> RoutineToDirectory;
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+
+#endif
diff --git a/Source/CTest/cmParseMumpsCoverage.cxx b/Source/CTest/cmParseMumpsCoverage.cxx
new file mode 100644
index 0000000..18412ba
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.cxx
@@ -0,0 +1,144 @@
+#include "cmParseMumpsCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include <map>
+#include <string>
+#include <utility>
+
+cmParseMumpsCoverage::cmParseMumpsCoverage(
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+cmParseMumpsCoverage::~cmParseMumpsCoverage()
+{
+}
+
+bool cmParseMumpsCoverage::ReadCoverageFile(const char* file)
+{
+  // Read the gtm_coverage.mcov file, that has two lines of data:
+  // packages:/full/path/to/Vista/Packages
+  // coverage_dir:/full/path/to/dir/with/*.mcov
+  cmsys::ifstream in(file);
+  if (!in) {
+    return false;
+  }
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(in, line)) {
+    std::string::size_type pos = line.find(':', 0);
+    std::string packages;
+    if (pos != std::string::npos) {
+      std::string type = line.substr(0, pos);
+      std::string path = line.substr(pos + 1);
+      if (type == "packages") {
+        this->LoadPackages(path.c_str());
+      } else if (type == "coverage_dir") {
+        this->LoadCoverageData(path.c_str());
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Parse Error in Mumps coverage file :\n"
+                     << file << "\ntype: [" << type << "]\npath:[" << path
+                     << "]\n"
+                        "input line: ["
+                     << line << "]\n");
+      }
+    }
+  }
+  return true;
+}
+
+void cmParseMumpsCoverage::InitializeMumpsFile(std::string& file)
+{
+  // initialize the coverage information for a given mumps file
+  cmsys::ifstream in(file.c_str());
+  if (!in) {
+    return;
+  }
+  std::string line;
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+    this->Coverage.TotalCoverage[file];
+  if (!cmSystemTools::GetLineFromStream(in, line)) {
+    return;
+  }
+  // first line of a .m file can never be run
+  coverageVector.push_back(-1);
+  while (cmSystemTools::GetLineFromStream(in, line)) {
+    // putting in a 0 for a line means it is executable code
+    // putting in a -1 for a line means it is not executable code
+    int val = -1; // assume line is not executable
+    bool found = false;
+    std::string::size_type i = 0;
+    // (1) Search for the first whitespace or semicolon character on a line.
+    // This will skip over labels if the line starts with one, or will simply
+    // be the first character on the line for non-label lines.
+    for (; i < line.size(); ++i) {
+      if (line[i] == ' ' || line[i] == '\t' || line[i] == ';') {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      // (2) If the first character found above is whitespace or a period
+      // then continue the search for the first following non-whitespace
+      // character.
+      if (line[i] == ' ' || line[i] == '\t') {
+        while (i < line.size() &&
+               (line[i] == ' ' || line[i] == '\t' || line[i] == '.')) {
+          i++;
+        }
+      }
+      // (3) If the character found is not a semicolon then the line counts for
+      // coverage.
+      if (i < line.size() && line[i] != ';') {
+        val = 0;
+      }
+    }
+    coverageVector.push_back(val);
+  }
+}
+
+bool cmParseMumpsCoverage::LoadPackages(const char* d)
+{
+  cmsys::Glob glob;
+  glob.RecurseOn();
+  std::string pat = d;
+  pat += "/*.m";
+  glob.FindFiles(pat);
+  for (std::string& file : glob.GetFiles()) {
+    std::string name = cmSystemTools::GetFilenameName(file);
+    this->RoutineToDirectory[name.substr(0, name.size() - 2)] = file;
+    // initialize each file, this is left out until CDash is fixed
+    // to handle large numbers of files
+    this->InitializeMumpsFile(file);
+  }
+  return true;
+}
+
+bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine,
+                                         std::string& filepath)
+{
+  std::map<std::string, std::string>::iterator i =
+    this->RoutineToDirectory.find(routine);
+  if (i != this->RoutineToDirectory.end()) {
+    filepath = i->second;
+    return true;
+  }
+  // try some alternate names
+  const char* tryname[] = { "GUX", "GTM", "ONT", nullptr };
+  for (int k = 0; tryname[k] != nullptr; k++) {
+    std::string routine2 = routine + tryname[k];
+    i = this->RoutineToDirectory.find(routine2);
+    if (i != this->RoutineToDirectory.end()) {
+      filepath = i->second;
+      return true;
+    }
+  }
+  return false;
+}
diff --git a/Source/CTest/cmParseMumpsCoverage.h b/Source/CTest/cmParseMumpsCoverage.h
new file mode 100644
index 0000000..2c54495
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.h
@@ -0,0 +1,47 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParseMumpsCoverage_h
+#define cmParseMumpsCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParseMumpsCoverage
+ * \brief Parse Mumps coverage information
+ *
+ * This class is used as the base class for Mumps coverage
+ * parsing.
+ */
+class cmParseMumpsCoverage
+{
+public:
+  cmParseMumpsCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+  virtual ~cmParseMumpsCoverage();
+  // This is the toplevel coverage file locating the coverage files
+  // and the mumps source code package tree.
+  bool ReadCoverageFile(const char* file);
+
+protected:
+  // sub classes will use this to
+  // load all coverage files found in the given directory
+  virtual bool LoadCoverageData(const char* d) = 0;
+  // search the package directory for mumps files and fill
+  // in the RoutineToDirectory map
+  bool LoadPackages(const char* dir);
+  // initialize the coverage information for a single mumps file
+  void InitializeMumpsFile(std::string& file);
+  // Find mumps file for routine
+  bool FindMumpsFile(std::string const& routine, std::string& filepath);
+
+protected:
+  std::map<std::string, std::string> RoutineToDirectory;
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+
+#endif
diff --git a/Source/CTest/cmParsePHPCoverage.cxx b/Source/CTest/cmParsePHPCoverage.cxx
new file mode 100644
index 0000000..761ebec
--- /dev/null
+++ b/Source/CTest/cmParsePHPCoverage.cxx
@@ -0,0 +1,221 @@
+#include "cmParsePHPCoverage.h"
+
+#include "cmCTest.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include <stdlib.h>
+#include <string.h>
+
+/*
+  To setup coverage for php.
+
+  - edit php.ini to add auto prepend and append php files from phpunit
+  auto_prepend_file =
+  auto_append_file =
+  - run the tests
+  - run this program on all the files in c:/tmp
+
+*/
+
+cmParsePHPCoverage::cmParsePHPCoverage(cmCTestCoverageHandlerContainer& cont,
+                                       cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
+
+bool cmParsePHPCoverage::ReadUntil(std::istream& in, char until)
+{
+  char c = 0;
+  while (in.get(c) && c != until) {
+  }
+  return c == until;
+}
+bool cmParsePHPCoverage::ReadCoverageArray(std::istream& in,
+                                           std::string const& fileName)
+{
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+    this->Coverage.TotalCoverage[fileName];
+
+  char c;
+  char buf[4];
+  in.read(buf, 3);
+  buf[3] = 0;
+  if (strcmp(buf, ";a:") != 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "failed to read start of coverage array, found : " << buf
+                                                                  << "\n");
+    return false;
+  }
+  int size = 0;
+  if (!this->ReadInt(in, size)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read size ");
+    return false;
+  }
+  if (!in.get(c) && c == '{') {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read open {\n");
+    return false;
+  }
+  for (int i = 0; i < size; i++) {
+    this->ReadUntil(in, ':');
+    int line = 0;
+    this->ReadInt(in, line);
+    // ok xdebug may have a bug here
+    // it seems to be 1 based but often times
+    // seems to have a 0'th line.
+    line--;
+    if (line < 0) {
+      line = 0;
+    }
+    this->ReadUntil(in, ':');
+    int value = 0;
+    this->ReadInt(in, value);
+    // make sure the vector is the right size and is
+    // initialized with -1 for each line
+    while (coverageVector.size() <= static_cast<size_t>(line)) {
+      coverageVector.push_back(-1);
+    }
+    // if value is less than 0, set it to zero
+    // TODO figure out the difference between
+    // -1 and -2 in xdebug coverage??  For now
+    // assume less than 0 is just not covered
+    // CDash expects -1 for non executable code (like comments)
+    // and 0 for uncovered code, and a positive value
+    // for number of times a line was executed
+    if (value < 0) {
+      value = 0;
+    }
+    // if unset then set it to value
+    if (coverageVector[line] == -1) {
+      coverageVector[line] = value;
+    }
+    // otherwise increment by value
+    else {
+      coverageVector[line] += value;
+    }
+  }
+  return true;
+}
+
+bool cmParsePHPCoverage::ReadInt(std::istream& in, int& v)
+{
+  std::string s;
+  char c = 0;
+  while (in.get(c) && c != ':' && c != ';') {
+    s += c;
+  }
+  v = atoi(s.c_str());
+  return true;
+}
+
+bool cmParsePHPCoverage::ReadArraySize(std::istream& in, int& size)
+{
+  char c = 0;
+  in.get(c);
+  if (c != 'a') {
+    return false;
+  }
+  if (in.get(c) && c == ':') {
+    if (this->ReadInt(in, size)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool cmParsePHPCoverage::ReadFileInformation(std::istream& in)
+{
+  char buf[4];
+  in.read(buf, 2);
+  buf[2] = 0;
+  if (strcmp(buf, "s:") != 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "failed to read start of file info found: [" << buf << "]\n");
+    return false;
+  }
+  char c;
+  int size = 0;
+  if (this->ReadInt(in, size)) {
+    size++; // add one for null termination
+    char* s = new char[size + 1];
+    // read open quote
+    if (in.get(c) && c != '"') {
+      delete[] s;
+      return false;
+    }
+    // read the string data
+    in.read(s, size - 1);
+    s[size - 1] = 0;
+    std::string fileName = s;
+    delete[] s;
+    // read close quote
+    if (in.get(c) && c != '"') {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read close quote\n"
+                   << "read [" << c << "]\n");
+      return false;
+    }
+    if (!this->ReadCoverageArray(in, fileName)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "failed to read coverage array for file: " << fileName
+                                                            << "\n");
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+bool cmParsePHPCoverage::ReadPHPData(const char* file)
+{
+  cmsys::ifstream in(file);
+  if (!in) {
+    return false;
+  }
+  int size = 0;
+  this->ReadArraySize(in, size);
+  char c = 0;
+  in.get(c);
+  if (c != '{') {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read open array\n");
+    return false;
+  }
+  for (int i = 0; i < size; i++) {
+    if (!this->ReadFileInformation(in)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Failed to read file #" << i
+                                                                     << "\n");
+      return false;
+    }
+    in.get(c);
+    if (c != '}') {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read close array\n");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool cmParsePHPCoverage::ReadPHPCoverageDirectory(const char* d)
+{
+  cmsys::Directory dir;
+  if (!dir.Load(d)) {
+    return false;
+  }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++) {
+    std::string file = dir.GetFile(i);
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if (!this->ReadPHPData(path.c_str())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
diff --git a/Source/CTest/cmParsePHPCoverage.h b/Source/CTest/cmParsePHPCoverage.h
new file mode 100644
index 0000000..ff0e636
--- /dev/null
+++ b/Source/CTest/cmParsePHPCoverage.h
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmParsePHPCoverage_h
+#define cmParsePHPCoverage_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <string>
+
+class cmCTest;
+class cmCTestCoverageHandlerContainer;
+
+/** \class cmParsePHPCoverage
+ * \brief Parse xdebug PHP coverage information
+ *
+ * This class is used to parse php coverage information produced
+ * by xdebug.  The data is stored as a php dump of the array
+ * return by xdebug coverage.  It is an array of arrays.
+ */
+class cmParsePHPCoverage
+{
+public:
+  cmParsePHPCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+  bool ReadPHPCoverageDirectory(const char* dir);
+  void PrintCoverage();
+
+private:
+  bool ReadPHPData(const char* file);
+  bool ReadArraySize(std::istream& in, int& size);
+  bool ReadFileInformation(std::istream& in);
+  bool ReadInt(std::istream& in, int& v);
+  bool ReadCoverageArray(std::istream& in, std::string const&);
+  bool ReadUntil(std::istream& in, char until);
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+
+#endif
diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx
new file mode 100644
index 0000000..e332a77
--- /dev/null
+++ b/Source/CTest/cmProcess.cxx
@@ -0,0 +1,719 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmProcess.h"
+
+#include "cmCTest.h"
+#include "cmCTestRunTest.h"
+#include "cmCTestTestHandler.h"
+#include "cmsys/Process.h"
+
+#include <algorithm>
+#include <fcntl.h>
+#include <iostream>
+#include <signal.h>
+#include <string>
+#if !defined(_WIN32)
+#include <unistd.h>
+#endif
+
+#define CM_PROCESS_BUF_SIZE 65536
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <io.h>
+
+static int cmProcessGetPipes(int* fds)
+{
+  SECURITY_ATTRIBUTES attr;
+  HANDLE readh, writeh;
+  attr.nLength = sizeof(attr);
+  attr.lpSecurityDescriptor = nullptr;
+  attr.bInheritHandle = FALSE;
+  if (!CreatePipe(&readh, &writeh, &attr, 0))
+    return uv_translate_sys_error(GetLastError());
+  fds[0] = _open_osfhandle((intptr_t)readh, 0);
+  fds[1] = _open_osfhandle((intptr_t)writeh, 0);
+  if (fds[0] == -1 || fds[1] == -1) {
+    CloseHandle(readh);
+    CloseHandle(writeh);
+    return uv_translate_sys_error(GetLastError());
+  }
+  return 0;
+}
+#else
+#include <errno.h>
+
+static int cmProcessGetPipes(int* fds)
+{
+  if (pipe(fds) == -1) {
+    return uv_translate_sys_error(errno);
+  }
+
+  if (fcntl(fds[0], F_SETFD, FD_CLOEXEC) == -1 ||
+      fcntl(fds[1], F_SETFD, FD_CLOEXEC) == -1) {
+    close(fds[0]);
+    close(fds[1]);
+    return uv_translate_sys_error(errno);
+  }
+  return 0;
+}
+#endif
+
+cmProcess::cmProcess(cmCTestRunTest& runner)
+  : Runner(runner)
+  , Conv(cmProcessOutput::UTF8, CM_PROCESS_BUF_SIZE)
+{
+  this->Timeout = std::chrono::duration<double>::zero();
+  this->TotalTime = std::chrono::duration<double>::zero();
+  this->ExitValue = 0;
+  this->Id = 0;
+  this->StartTime = std::chrono::steady_clock::time_point();
+}
+
+cmProcess::~cmProcess()
+{
+}
+
+void cmProcess::SetCommand(const char* command)
+{
+  this->Command = command;
+}
+
+void cmProcess::SetCommandArguments(std::vector<std::string> const& args)
+{
+  this->Arguments = args;
+}
+
+bool cmProcess::StartProcess(uv_loop_t& loop)
+{
+  this->ProcessState = cmProcess::State::Error;
+  if (this->Command.empty()) {
+    return false;
+  }
+  this->StartTime = std::chrono::steady_clock::now();
+  this->ProcessArgs.clear();
+  // put the command as arg0
+  this->ProcessArgs.push_back(this->Command.c_str());
+  // now put the command arguments in
+  for (std::string const& arg : this->Arguments) {
+    this->ProcessArgs.push_back(arg.c_str());
+  }
+  this->ProcessArgs.push_back(nullptr); // null terminate the list
+
+  cm::uv_timer_ptr timer;
+  int status = timer.init(loop, this);
+  if (status != 0) {
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE,
+               "Error initializing timer: " << uv_strerror(status)
+                                            << std::endl);
+    return false;
+  }
+
+  cm::uv_pipe_ptr pipe_writer;
+  cm::uv_pipe_ptr pipe_reader;
+
+  pipe_writer.init(loop, 0);
+  pipe_reader.init(loop, 0, this);
+
+  int fds[2] = { -1, -1 };
+  status = cmProcessGetPipes(fds);
+  if (status != 0) {
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE,
+               "Error initializing pipe: " << uv_strerror(status)
+                                           << std::endl);
+    return false;
+  }
+
+  uv_pipe_open(pipe_reader, fds[0]);
+  uv_pipe_open(pipe_writer, fds[1]);
+
+  uv_stdio_container_t stdio[3];
+  stdio[0].flags = UV_IGNORE;
+  stdio[1].flags = UV_INHERIT_STREAM;
+  stdio[1].data.stream = pipe_writer;
+  stdio[2] = stdio[1];
+
+  uv_process_options_t options = uv_process_options_t();
+  options.file = this->Command.data();
+  options.args = const_cast<char**>(this->ProcessArgs.data());
+  options.stdio_count = 3; // in, out and err
+  options.exit_cb = &cmProcess::OnExitCB;
+  options.stdio = stdio;
+
+  status =
+    uv_read_start(pipe_reader, &cmProcess::OnAllocateCB, &cmProcess::OnReadCB);
+
+  if (status != 0) {
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE,
+               "Error starting read events: " << uv_strerror(status)
+                                              << std::endl);
+    return false;
+  }
+
+  status = this->Process.spawn(loop, options, this);
+  if (status != 0) {
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE, "Process not started\n "
+                 << this->Command << "\n[" << uv_strerror(status) << "]\n");
+    return false;
+  }
+
+  this->PipeReader = std::move(pipe_reader);
+  this->Timer = std::move(timer);
+
+  this->StartTimer();
+
+  this->ProcessState = cmProcess::State::Executing;
+  return true;
+}
+
+void cmProcess::StartTimer()
+{
+  auto properties = this->Runner.GetTestProperties();
+  auto msec =
+    std::chrono::duration_cast<std::chrono::milliseconds>(this->Timeout);
+
+  if (msec != std::chrono::milliseconds(0) || !properties->ExplicitTimeout) {
+    this->Timer.start(&cmProcess::OnTimeoutCB,
+                      static_cast<uint64_t>(msec.count()), 0);
+  }
+}
+
+bool cmProcess::Buffer::GetLine(std::string& line)
+{
+  // Scan for the next newline.
+  for (size_type sz = this->size(); this->Last != sz; ++this->Last) {
+    if ((*this)[this->Last] == '\n' || (*this)[this->Last] == '\0') {
+      // Extract the range first..last as a line.
+      const char* text = &*this->begin() + this->First;
+      size_type length = this->Last - this->First;
+      while (length && text[length - 1] == '\r') {
+        length--;
+      }
+      line.assign(text, length);
+
+      // Start a new range for the next line.
+      ++this->Last;
+      this->First = Last;
+
+      // Return the line extracted.
+      return true;
+    }
+  }
+
+  // Available data have been exhausted without a newline.
+  if (this->First != 0) {
+    // Move the partial line to the beginning of the buffer.
+    this->erase(this->begin(), this->begin() + this->First);
+    this->First = 0;
+    this->Last = this->size();
+  }
+  return false;
+}
+
+bool cmProcess::Buffer::GetLast(std::string& line)
+{
+  // Return the partial last line, if any.
+  if (!this->empty()) {
+    line.assign(&*this->begin(), this->size());
+    this->First = this->Last = 0;
+    this->clear();
+    return true;
+  }
+  return false;
+}
+
+void cmProcess::OnReadCB(uv_stream_t* stream, ssize_t nread,
+                         const uv_buf_t* buf)
+{
+  auto self = static_cast<cmProcess*>(stream->data);
+  self->OnRead(nread, buf);
+}
+
+void cmProcess::OnRead(ssize_t nread, const uv_buf_t* buf)
+{
+  std::string line;
+  if (nread > 0) {
+    std::string strdata;
+    this->Conv.DecodeText(buf->base, static_cast<size_t>(nread), strdata);
+    this->Output.insert(this->Output.end(), strdata.begin(), strdata.end());
+
+    while (this->Output.GetLine(line)) {
+      this->Runner.CheckOutput(line);
+      line.clear();
+    }
+
+    return;
+  }
+
+  if (nread == 0) {
+    return;
+  }
+
+  // The process will provide no more data.
+  if (nread != UV_EOF) {
+    auto error = static_cast<int>(nread);
+    cmCTestLog(this->Runner.GetCTest(), ERROR_MESSAGE,
+               "Error reading stream: " << uv_strerror(error) << std::endl);
+  }
+
+  // Look for partial last lines.
+  if (this->Output.GetLast(line)) {
+    this->Runner.CheckOutput(line);
+  }
+
+  this->ReadHandleClosed = true;
+  this->PipeReader.reset();
+  if (this->ProcessHandleClosed) {
+    uv_timer_stop(this->Timer);
+    this->Runner.FinalizeTest();
+  }
+}
+
+void cmProcess::OnAllocateCB(uv_handle_t* handle, size_t suggested_size,
+                             uv_buf_t* buf)
+{
+  auto self = static_cast<cmProcess*>(handle->data);
+  self->OnAllocate(suggested_size, buf);
+}
+
+void cmProcess::OnAllocate(size_t /*suggested_size*/, uv_buf_t* buf)
+{
+  if (this->Buf.size() != CM_PROCESS_BUF_SIZE) {
+    this->Buf.resize(CM_PROCESS_BUF_SIZE);
+  }
+
+  *buf =
+    uv_buf_init(this->Buf.data(), static_cast<unsigned int>(this->Buf.size()));
+}
+
+void cmProcess::OnTimeoutCB(uv_timer_t* timer)
+{
+  auto self = static_cast<cmProcess*>(timer->data);
+  self->OnTimeout();
+}
+
+void cmProcess::OnTimeout()
+{
+  if (this->ProcessState != cmProcess::State::Executing) {
+    return;
+  }
+  this->ProcessState = cmProcess::State::Expired;
+  bool const was_still_reading = !this->ReadHandleClosed;
+  if (!this->ReadHandleClosed) {
+    this->ReadHandleClosed = true;
+    this->PipeReader.reset();
+  }
+  if (!this->ProcessHandleClosed) {
+    // Kill the child and let our on-exit handler finish the test.
+    cmsysProcess_KillPID(static_cast<unsigned long>(this->Process->pid));
+  } else if (was_still_reading) {
+    // Our on-exit handler already ran but did not finish the test
+    // because we were still reading output.  We've just dropped
+    // our read handler, so we need to finish the test now.
+    this->Runner.FinalizeTest();
+  }
+}
+
+void cmProcess::OnExitCB(uv_process_t* process, int64_t exit_status,
+                         int term_signal)
+{
+  auto self = static_cast<cmProcess*>(process->data);
+  self->OnExit(exit_status, term_signal);
+}
+
+void cmProcess::OnExit(int64_t exit_status, int term_signal)
+{
+  if (this->ProcessState != cmProcess::State::Expired) {
+    if (
+#if defined(_WIN32)
+      ((DWORD)exit_status & 0xF0000000) == 0xC0000000
+#else
+      term_signal != 0
+#endif
+      ) {
+      this->ProcessState = cmProcess::State::Exception;
+    } else {
+      this->ProcessState = cmProcess::State::Exited;
+    }
+  }
+
+  // Record exit information.
+  this->ExitValue = static_cast<int>(exit_status);
+  this->Signal = term_signal;
+  this->TotalTime = std::chrono::steady_clock::now() - this->StartTime;
+  // Because of a processor clock scew the runtime may become slightly
+  // negative. If someone changed the system clock while the process was
+  // running this may be even more. Make sure not to report a negative
+  // duration here.
+  if (this->TotalTime <= std::chrono::duration<double>::zero()) {
+    this->TotalTime = std::chrono::duration<double>::zero();
+  }
+
+  this->ProcessHandleClosed = true;
+  if (this->ReadHandleClosed) {
+    uv_timer_stop(this->Timer);
+    this->Runner.FinalizeTest();
+  }
+}
+
+cmProcess::State cmProcess::GetProcessStatus()
+{
+  return this->ProcessState;
+}
+
+void cmProcess::ChangeTimeout(std::chrono::duration<double> t)
+{
+  this->Timeout = t;
+  this->StartTimer();
+}
+
+void cmProcess::ResetStartTime()
+{
+  this->StartTime = std::chrono::steady_clock::now();
+}
+
+cmProcess::Exception cmProcess::GetExitException()
+{
+  auto exception = Exception::None;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  auto exit_code = (DWORD) this->ExitValue;
+  if ((exit_code & 0xF0000000) != 0xC0000000) {
+    return exception;
+  }
+
+  if (exit_code) {
+    switch (exit_code) {
+      case STATUS_DATATYPE_MISALIGNMENT:
+      case STATUS_ACCESS_VIOLATION:
+      case STATUS_IN_PAGE_ERROR:
+      case STATUS_INVALID_HANDLE:
+      case STATUS_NONCONTINUABLE_EXCEPTION:
+      case STATUS_INVALID_DISPOSITION:
+      case STATUS_ARRAY_BOUNDS_EXCEEDED:
+      case STATUS_STACK_OVERFLOW:
+        exception = Exception::Fault;
+        break;
+      case STATUS_FLOAT_DENORMAL_OPERAND:
+      case STATUS_FLOAT_DIVIDE_BY_ZERO:
+      case STATUS_FLOAT_INEXACT_RESULT:
+      case STATUS_FLOAT_INVALID_OPERATION:
+      case STATUS_FLOAT_OVERFLOW:
+      case STATUS_FLOAT_STACK_CHECK:
+      case STATUS_FLOAT_UNDERFLOW:
+#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
+      case STATUS_FLOAT_MULTIPLE_FAULTS:
+#endif
+#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
+      case STATUS_FLOAT_MULTIPLE_TRAPS:
+#endif
+      case STATUS_INTEGER_DIVIDE_BY_ZERO:
+      case STATUS_INTEGER_OVERFLOW:
+        exception = Exception::Numerical;
+        break;
+      case STATUS_CONTROL_C_EXIT:
+        exception = Exception::Interrupt;
+        break;
+      case STATUS_ILLEGAL_INSTRUCTION:
+      case STATUS_PRIVILEGED_INSTRUCTION:
+        exception = Exception::Illegal;
+        break;
+      default:
+        exception = Exception::Other;
+    }
+  }
+#else
+  if (this->Signal) {
+    switch (this->Signal) {
+      case SIGSEGV:
+        exception = Exception::Fault;
+        break;
+      case SIGFPE:
+        exception = Exception::Numerical;
+        break;
+      case SIGINT:
+        exception = Exception::Interrupt;
+        break;
+      case SIGILL:
+        exception = Exception::Illegal;
+        break;
+      default:
+        exception = Exception::Other;
+    }
+  }
+#endif
+  return exception;
+}
+
+std::string cmProcess::GetExitExceptionString()
+{
+  std::string exception_str;
+#if defined(_WIN32)
+  switch (this->ExitValue) {
+    case STATUS_CONTROL_C_EXIT:
+      exception_str = "User interrupt";
+      break;
+    case STATUS_FLOAT_DENORMAL_OPERAND:
+      exception_str = "Floating-point exception (denormal operand)";
+      break;
+    case STATUS_FLOAT_DIVIDE_BY_ZERO:
+      exception_str = "Divide-by-zero";
+      break;
+    case STATUS_FLOAT_INEXACT_RESULT:
+      exception_str = "Floating-point exception (inexact result)";
+      break;
+    case STATUS_FLOAT_INVALID_OPERATION:
+      exception_str = "Invalid floating-point operation";
+      break;
+    case STATUS_FLOAT_OVERFLOW:
+      exception_str = "Floating-point overflow";
+      break;
+    case STATUS_FLOAT_STACK_CHECK:
+      exception_str = "Floating-point stack check failed";
+      break;
+    case STATUS_FLOAT_UNDERFLOW:
+      exception_str = "Floating-point underflow";
+      break;
+#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
+    case STATUS_FLOAT_MULTIPLE_FAULTS:
+      exception_str = "Floating-point exception (multiple faults)";
+      break;
+#endif
+#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
+    case STATUS_FLOAT_MULTIPLE_TRAPS:
+      exception_str = "Floating-point exception (multiple traps)";
+      break;
+#endif
+    case STATUS_INTEGER_DIVIDE_BY_ZERO:
+      exception_str = "Integer divide-by-zero";
+      break;
+    case STATUS_INTEGER_OVERFLOW:
+      exception_str = "Integer overflow";
+      break;
+
+    case STATUS_DATATYPE_MISALIGNMENT:
+      exception_str = "Datatype misalignment";
+      break;
+    case STATUS_ACCESS_VIOLATION:
+      exception_str = "Access violation";
+      break;
+    case STATUS_IN_PAGE_ERROR:
+      exception_str = "In-page error";
+      break;
+    case STATUS_INVALID_HANDLE:
+      exception_str = "Invalid handle";
+      break;
+    case STATUS_NONCONTINUABLE_EXCEPTION:
+      exception_str = "Noncontinuable exception";
+      break;
+    case STATUS_INVALID_DISPOSITION:
+      exception_str = "Invalid disposition";
+      break;
+    case STATUS_ARRAY_BOUNDS_EXCEEDED:
+      exception_str = "Array bounds exceeded";
+      break;
+    case STATUS_STACK_OVERFLOW:
+      exception_str = "Stack overflow";
+      break;
+
+    case STATUS_ILLEGAL_INSTRUCTION:
+      exception_str = "Illegal instruction";
+      break;
+    case STATUS_PRIVILEGED_INSTRUCTION:
+      exception_str = "Privileged instruction";
+      break;
+    case STATUS_NO_MEMORY:
+    default:
+      char buf[1024];
+      _snprintf(buf, 1024, "Exit code 0x%x\n", this->ExitValue);
+      exception_str.assign(buf);
+  }
+#else
+  switch (this->Signal) {
+#ifdef SIGSEGV
+    case SIGSEGV:
+      exception_str = "Segmentation fault";
+      break;
+#endif
+#ifdef SIGBUS
+#if !defined(SIGSEGV) || SIGBUS != SIGSEGV
+    case SIGBUS:
+      exception_str = "Bus error";
+      break;
+#endif
+#endif
+#ifdef SIGFPE
+    case SIGFPE:
+      exception_str = "Floating-point exception";
+      break;
+#endif
+#ifdef SIGILL
+    case SIGILL:
+      exception_str = "Illegal instruction";
+      break;
+#endif
+#ifdef SIGINT
+    case SIGINT:
+      exception_str = "User interrupt";
+      break;
+#endif
+#ifdef SIGABRT
+    case SIGABRT:
+      exception_str = "Child aborted";
+      break;
+#endif
+#ifdef SIGKILL
+    case SIGKILL:
+      exception_str = "Child killed";
+      break;
+#endif
+#ifdef SIGTERM
+    case SIGTERM:
+      exception_str = "Child terminated";
+      break;
+#endif
+#ifdef SIGHUP
+    case SIGHUP:
+      exception_str = "SIGHUP";
+      break;
+#endif
+#ifdef SIGQUIT
+    case SIGQUIT:
+      exception_str = "SIGQUIT";
+      break;
+#endif
+#ifdef SIGTRAP
+    case SIGTRAP:
+      exception_str = "SIGTRAP";
+      break;
+#endif
+#ifdef SIGIOT
+#if !defined(SIGABRT) || SIGIOT != SIGABRT
+    case SIGIOT:
+      exception_str = "SIGIOT";
+      break;
+#endif
+#endif
+#ifdef SIGUSR1
+    case SIGUSR1:
+      exception_str = "SIGUSR1";
+      break;
+#endif
+#ifdef SIGUSR2
+    case SIGUSR2:
+      exception_str = "SIGUSR2";
+      break;
+#endif
+#ifdef SIGPIPE
+    case SIGPIPE:
+      exception_str = "SIGPIPE";
+      break;
+#endif
+#ifdef SIGALRM
+    case SIGALRM:
+      exception_str = "SIGALRM";
+      break;
+#endif
+#ifdef SIGSTKFLT
+    case SIGSTKFLT:
+      exception_str = "SIGSTKFLT";
+      break;
+#endif
+#ifdef SIGCHLD
+    case SIGCHLD:
+      exception_str = "SIGCHLD";
+      break;
+#elif defined(SIGCLD)
+    case SIGCLD:
+      exception_str = "SIGCLD";
+      break;
+#endif
+#ifdef SIGCONT
+    case SIGCONT:
+      exception_str = "SIGCONT";
+      break;
+#endif
+#ifdef SIGSTOP
+    case SIGSTOP:
+      exception_str = "SIGSTOP";
+      break;
+#endif
+#ifdef SIGTSTP
+    case SIGTSTP:
+      exception_str = "SIGTSTP";
+      break;
+#endif
+#ifdef SIGTTIN
+    case SIGTTIN:
+      exception_str = "SIGTTIN";
+      break;
+#endif
+#ifdef SIGTTOU
+    case SIGTTOU:
+      exception_str = "SIGTTOU";
+      break;
+#endif
+#ifdef SIGURG
+    case SIGURG:
+      exception_str = "SIGURG";
+      break;
+#endif
+#ifdef SIGXCPU
+    case SIGXCPU:
+      exception_str = "SIGXCPU";
+      break;
+#endif
+#ifdef SIGXFSZ
+    case SIGXFSZ:
+      exception_str = "SIGXFSZ";
+      break;
+#endif
+#ifdef SIGVTALRM
+    case SIGVTALRM:
+      exception_str = "SIGVTALRM";
+      break;
+#endif
+#ifdef SIGPROF
+    case SIGPROF:
+      exception_str = "SIGPROF";
+      break;
+#endif
+#ifdef SIGWINCH
+    case SIGWINCH:
+      exception_str = "SIGWINCH";
+      break;
+#endif
+#ifdef SIGPOLL
+    case SIGPOLL:
+      exception_str = "SIGPOLL";
+      break;
+#endif
+#ifdef SIGIO
+#if !defined(SIGPOLL) || SIGIO != SIGPOLL
+    case SIGIO:
+      exception_str = "SIGIO";
+      break;
+#endif
+#endif
+#ifdef SIGPWR
+    case SIGPWR:
+      exception_str = "SIGPWR";
+      break;
+#endif
+#ifdef SIGSYS
+    case SIGSYS:
+      exception_str = "SIGSYS";
+      break;
+#endif
+#ifdef SIGUNUSED
+#if !defined(SIGSYS) || SIGUNUSED != SIGSYS
+    case SIGUNUSED:
+      exception_str = "SIGUNUSED";
+      break;
+#endif
+#endif
+    default:
+      exception_str = "Signal ";
+      exception_str += std::to_string(this->Signal);
+  }
+#endif
+  return exception_str;
+}
diff --git a/Source/CTest/cmProcess.h b/Source/CTest/cmProcess.h
new file mode 100644
index 0000000..633be24
--- /dev/null
+++ b/Source/CTest/cmProcess.h
@@ -0,0 +1,127 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmProcess_h
+#define cmProcess_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmProcessOutput.h"
+#include "cmUVHandlePtr.h"
+#include "cm_uv.h"
+
+#include <chrono>
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+class cmCTestRunTest;
+
+/** \class cmProcess
+ * \brief run a process with c++
+ *
+ * cmProcess wraps the kwsys process stuff in a c++ class.
+ */
+class cmProcess
+{
+public:
+  explicit cmProcess(cmCTestRunTest& runner);
+  ~cmProcess();
+  const char* GetCommand() { return this->Command.c_str(); }
+  void SetCommand(const char* command);
+  void SetCommandArguments(std::vector<std::string> const& arg);
+  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir; }
+  void SetTimeout(std::chrono::duration<double> t) { this->Timeout = t; }
+  void ChangeTimeout(std::chrono::duration<double> t);
+  void ResetStartTime();
+  // Return true if the process starts
+  bool StartProcess(uv_loop_t& loop);
+
+  enum class State
+  {
+    Starting,
+    Error,
+    Exception,
+    Executing,
+    Exited,
+    Expired,
+    Killed,
+    Disowned
+  };
+
+  State GetProcessStatus();
+  int GetId() { return this->Id; }
+  void SetId(int id) { this->Id = id; }
+  int GetExitValue() { return this->ExitValue; }
+  std::chrono::duration<double> GetTotalTime() { return this->TotalTime; }
+
+  enum class Exception
+  {
+    None,
+    Fault,
+    Illegal,
+    Interrupt,
+    Numerical,
+    Other
+  };
+
+  Exception GetExitException();
+  std::string GetExitExceptionString();
+
+private:
+  std::chrono::duration<double> Timeout;
+  std::chrono::steady_clock::time_point StartTime;
+  std::chrono::duration<double> TotalTime;
+  bool ReadHandleClosed = false;
+  bool ProcessHandleClosed = false;
+
+  cm::uv_process_ptr Process;
+  cm::uv_pipe_ptr PipeReader;
+  cm::uv_timer_ptr Timer;
+  std::vector<char> Buf;
+
+  cmCTestRunTest& Runner;
+  cmProcessOutput Conv;
+  int Signal = 0;
+  cmProcess::State ProcessState = cmProcess::State::Starting;
+
+  static void OnExitCB(uv_process_t* process, int64_t exit_status,
+                       int term_signal);
+  static void OnTimeoutCB(uv_timer_t* timer);
+  static void OnReadCB(uv_stream_t* stream, ssize_t nread,
+                       const uv_buf_t* buf);
+  static void OnAllocateCB(uv_handle_t* handle, size_t suggested_size,
+                           uv_buf_t* buf);
+
+  void OnExit(int64_t exit_status, int term_signal);
+  void OnTimeout();
+  void OnRead(ssize_t nread, const uv_buf_t* buf);
+  void OnAllocate(size_t suggested_size, uv_buf_t* buf);
+
+  void StartTimer();
+
+  class Buffer : public std::vector<char>
+  {
+    // Half-open index range of partial line already scanned.
+    size_type First;
+    size_type Last;
+
+  public:
+    Buffer()
+      : First(0)
+      , Last(0)
+    {
+    }
+    bool GetLine(std::string& line);
+    bool GetLast(std::string& line);
+  };
+  Buffer Output;
+  std::string Command;
+  std::string WorkingDirectory;
+  std::vector<std::string> Arguments;
+  std::vector<const char*> ProcessArgs;
+  int Id;
+  int ExitValue;
+};
+
+#endif
diff --git a/Source/Checks/cm_c11_thread_local.c b/Source/Checks/cm_c11_thread_local.c
new file mode 100644
index 0000000..bdf91aa
--- /dev/null
+++ b/Source/Checks/cm_c11_thread_local.c
@@ -0,0 +1,5 @@
+_Thread_local int i = 42;
+int main(void)
+{
+  return 0;
+}
diff --git a/Source/Checks/cm_c11_thread_local.cmake b/Source/Checks/cm_c11_thread_local.cmake
new file mode 100644
index 0000000..6b8d10b
--- /dev/null
+++ b/Source/Checks/cm_c11_thread_local.cmake
@@ -0,0 +1,33 @@
+set(CMake_C11_THREAD_LOCAL_BROKEN 0)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_C11_STANDARD_COMPILE_OPTION)
+  if(NOT DEFINED CMake_C11_THREAD_LOCAL_WORKS)
+    message(STATUS "Checking if compiler supports C11 _Thread_local")
+    try_compile(CMake_C11_THREAD_LOCAL_WORKS
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_LIST_DIR}/cm_c11_thread_local.c
+      CMAKE_FLAGS -DCMAKE_C_STANDARD=11
+      OUTPUT_VARIABLE OUTPUT
+      )
+    if(CMake_C11_THREAD_LOCAL_WORKS AND "${OUTPUT}" MATCHES "error: expected '=', ',', ';', 'asm' or '__attribute__' before 'int'")
+      set_property(CACHE CMake_C11_THREAD_LOCAL_WORKS PROPERTY VALUE 0)
+    endif()
+    if(CMake_C11_THREAD_LOCAL_WORKS)
+      message(STATUS "Checking if compiler supports C11 _Thread_local - yes")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if compiler supports C11 _Thread_local passed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    else()
+      message(STATUS "Checking if compiler supports C11 _Thread_local - no")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if compiler supports C11 _Thread_local failed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    endif()
+  endif()
+  if(NOT CMake_C11_THREAD_LOCAL_WORKS)
+    set(CMake_C11_THREAD_LOCAL_BROKEN 1)
+  endif()
+endif()
diff --git a/Source/Checks/cm_cxx14_check.cmake b/Source/Checks/cm_cxx14_check.cmake
new file mode 100644
index 0000000..a78ba35
--- /dev/null
+++ b/Source/Checks/cm_cxx14_check.cmake
@@ -0,0 +1,36 @@
+set(CMake_CXX14_BROKEN 0)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  if(NOT CMAKE_CXX14_STANDARD_COMPILE_OPTION)
+    set(CMake_CXX14_WORKS 0)
+  endif()
+  if(NOT DEFINED CMake_CXX14_WORKS)
+    message(STATUS "Checking if compiler supports needed C++14 constructs")
+    try_compile(CMake_CXX14_WORKS
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_LIST_DIR}/cm_cxx14_check.cpp
+      CMAKE_FLAGS -DCMAKE_CXX_STANDARD=14
+      OUTPUT_VARIABLE OUTPUT
+      )
+    if(CMake_CXX14_WORKS AND "${OUTPUT}" MATCHES "error: no member named.*gets.*in the global namespace")
+      set_property(CACHE CMake_CXX14_WORKS PROPERTY VALUE 0)
+    endif()
+    if(CMake_CXX14_WORKS)
+      message(STATUS "Checking if compiler supports needed C++14 constructs - yes")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if compiler supports needed C++14 constructs passed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    else()
+      message(STATUS "Checking if compiler supports needed C++14 constructs - no")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if compiler supports needed C++14 constructs failed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    endif()
+  endif()
+  if(NOT CMake_CXX14_WORKS)
+    set(CMake_CXX14_BROKEN 1)
+  endif()
+endif()
diff --git a/Source/Checks/cm_cxx14_check.cpp b/Source/Checks/cm_cxx14_check.cpp
new file mode 100644
index 0000000..f5806a9
--- /dev/null
+++ b/Source/Checks/cm_cxx14_check.cpp
@@ -0,0 +1,5 @@
+#include <cstdio>
+int main()
+{
+  return 0;
+}
diff --git a/Source/Checks/cm_cxx17_check.cmake b/Source/Checks/cm_cxx17_check.cmake
new file mode 100644
index 0000000..83d3971
--- /dev/null
+++ b/Source/Checks/cm_cxx17_check.cmake
@@ -0,0 +1,36 @@
+set(CMake_CXX17_BROKEN 0)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  if(NOT CMAKE_CXX17_STANDARD_COMPILE_OPTION)
+    set(CMake_CXX17_WORKS 0)
+  endif()
+  if(NOT DEFINED CMake_CXX17_WORKS)
+    message(STATUS "Checking if compiler supports needed C++17 constructs")
+    try_compile(CMake_CXX17_WORKS
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_LIST_DIR}/cm_cxx17_check.cpp
+      CMAKE_FLAGS -DCMAKE_CXX_STANDARD=17
+      OUTPUT_VARIABLE OUTPUT
+      )
+    if(CMake_CXX17_WORKS AND "${OUTPUT}" MATCHES "error: no member named.*gets.*in the global namespace")
+      set_property(CACHE CMake_CXX17_WORKS PROPERTY VALUE 0)
+    endif()
+    if(CMake_CXX17_WORKS)
+      message(STATUS "Checking if compiler supports needed C++17 constructs - yes")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if compiler supports needed C++17 constructs passed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    else()
+      message(STATUS "Checking if compiler supports needed C++17 constructs - no")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if compiler supports needed C++17 constructs failed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    endif()
+  endif()
+  if(NOT CMake_CXX17_WORKS)
+    set(CMake_CXX17_BROKEN 1)
+  endif()
+endif()
diff --git a/Source/Checks/cm_cxx17_check.cpp b/Source/Checks/cm_cxx17_check.cpp
new file mode 100644
index 0000000..2cbf1d5
--- /dev/null
+++ b/Source/Checks/cm_cxx17_check.cpp
@@ -0,0 +1,7 @@
+#include <cstdio>
+#include <unordered_map>
+
+int main()
+{
+  return 0;
+}
diff --git a/Source/Checks/cm_cxx_features.cmake b/Source/Checks/cm_cxx_features.cmake
new file mode 100644
index 0000000..2704c40
--- /dev/null
+++ b/Source/Checks/cm_cxx_features.cmake
@@ -0,0 +1,48 @@
+
+function(cm_check_cxx_feature name)
+  string(TOUPPER ${name} FEATURE)
+  if(NOT DEFINED CMake_HAVE_CXX_${FEATURE})
+    message(STATUS "Checking if compiler supports C++ ${name}")
+    if(CMAKE_CXX_STANDARD)
+      set(maybe_cxx_standard -DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD})
+    else()
+      set(maybe_cxx_standard "")
+    endif()
+    try_compile(CMake_HAVE_CXX_${FEATURE}
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx
+      CMAKE_FLAGS ${maybe_cxx_standard}
+      OUTPUT_VARIABLE OUTPUT
+      )
+    set(check_output "${OUTPUT}")
+    # Filter out MSBuild output that looks like a warning.
+    string(REGEX REPLACE " +0 Warning\\(s\\)" "" check_output "${check_output}")
+    # Filter out warnings caused by user flags.
+    string(REGEX REPLACE "[^\n]*warning:[^\n]*-Winvalid-command-line-argument[^\n]*" "" check_output "${check_output}")
+    # If using the feature causes warnings, treat it as broken/unavailable.
+    if(check_output MATCHES "[Ww]arning")
+      set(CMake_HAVE_CXX_${FEATURE} OFF CACHE INTERNAL "TRY_COMPILE" FORCE)
+    endif()
+    if(CMake_HAVE_CXX_${FEATURE})
+      message(STATUS "Checking if compiler supports C++ ${name} - yes")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if compiler supports C++ ${name} passed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    else()
+      message(STATUS "Checking if compiler supports C++ ${name} - no")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if compiler supports C++ ${name} failed with the following output:\n"
+        "${OUTPUT}\n"
+        "\n"
+        )
+    endif()
+  endif()
+endfunction()
+
+cm_check_cxx_feature(make_unique)
+if(CMake_HAVE_CXX_MAKE_UNIQUE)
+  set(CMake_HAVE_CXX_UNIQUE_PTR 1)
+endif()
+cm_check_cxx_feature(unique_ptr)
diff --git a/Source/Checks/cm_cxx_make_unique.cxx b/Source/Checks/cm_cxx_make_unique.cxx
new file mode 100644
index 0000000..a3ff68f
--- /dev/null
+++ b/Source/Checks/cm_cxx_make_unique.cxx
@@ -0,0 +1,6 @@
+#include <memory>
+int main()
+{
+  std::unique_ptr<int> u = std::make_unique<int>(0);
+  return *u;
+}
diff --git a/Source/Checks/cm_cxx_unique_ptr.cxx b/Source/Checks/cm_cxx_unique_ptr.cxx
new file mode 100644
index 0000000..a9d4ce5
--- /dev/null
+++ b/Source/Checks/cm_cxx_unique_ptr.cxx
@@ -0,0 +1,6 @@
+#include <memory>
+int main()
+{
+  std::unique_ptr<int> u(new int(0));
+  return *u;
+}
diff --git a/Source/CursesDialog/.NoDartCoverage b/Source/CursesDialog/.NoDartCoverage
new file mode 100644
index 0000000..3c99729
--- /dev/null
+++ b/Source/CursesDialog/.NoDartCoverage
@@ -0,0 +1 @@
+# do not do coverage in this directory
diff --git a/Source/CursesDialog/CMakeLists.txt b/Source/CursesDialog/CMakeLists.txt
new file mode 100644
index 0000000..c51b0dd
--- /dev/null
+++ b/Source/CursesDialog/CMakeLists.txt
@@ -0,0 +1,38 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+set( CURSES_SRCS
+              CursesDialog/cmCursesOptionsWidget.cxx
+              CursesDialog/cmCursesBoolWidget.cxx
+              CursesDialog/cmCursesCacheEntryComposite.cxx
+              CursesDialog/cmCursesDummyWidget.cxx
+              CursesDialog/cmCursesFilePathWidget.cxx
+              CursesDialog/cmCursesForm.cxx
+              CursesDialog/cmCursesLabelWidget.cxx
+              CursesDialog/cmCursesLongMessageForm.cxx
+              CursesDialog/cmCursesMainForm.cxx
+              CursesDialog/cmCursesPathWidget.cxx
+              CursesDialog/cmCursesStringWidget.cxx
+              CursesDialog/cmCursesWidget.cxx
+              CursesDialog/ccmake.cxx
+   )
+
+include_directories(${CURSES_INCLUDE_PATH})
+
+
+add_executable(ccmake ${CURSES_SRCS} )
+target_link_libraries(ccmake CMakeLib)
+if(CMAKE_USE_SYSTEM_FORM)
+  target_link_libraries(ccmake
+    ${CURSES_FORM_LIBRARY}
+    ${CURSES_LIBRARY}
+  )
+  if(CURSES_EXTRA_LIBRARY)
+    target_link_libraries(ccmake ${CURSES_EXTRA_LIBRARY})
+  endif()
+else()
+  target_link_libraries(ccmake cmForm)
+endif()
+
+CMake_OPTIONAL_COMPONENT(ccmake)
+install(TARGETS ccmake DESTINATION ${CMAKE_BIN_DIR} ${COMPONENT})
diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx
new file mode 100644
index 0000000..17cf628
--- /dev/null
+++ b/Source/CursesDialog/ccmake.cxx
@@ -0,0 +1,176 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmCursesForm.h"
+#include "cmCursesMainForm.h"
+#include "cmCursesStandardIncludes.h"
+#include "cmDocumentation.h"
+#include "cmDocumentationEntry.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include "cmsys/Encoding.hxx"
+#include <iostream>
+#include <signal.h>
+#include <string.h>
+#include <string>
+#include <vector>
+
+static const char* cmDocumentationName[][2] = {
+  { nullptr, "  ccmake - Curses Interface for CMake." },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationUsage[][2] = {
+  { nullptr, "  ccmake <path-to-source>\n"
+             "  ccmake <path-to-existing-build>" },
+  { nullptr, "Specify a source directory to (re-)generate a build system for "
+             "it in the current working directory.  Specify an existing build "
+             "directory to re-generate its build system." },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationUsageNote[][2] = {
+  { nullptr, "Run 'ccmake --help' for more information." },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationOptions[]
+                                         [2] = { CMAKE_STANDARD_OPTIONS_TABLE,
+                                                 { nullptr, nullptr } };
+
+cmCursesForm* cmCursesForm::CurrentForm = nullptr;
+
+extern "C" {
+
+void onsig(int /*unused*/)
+{
+  if (cmCursesForm::CurrentForm) {
+    endwin();
+    initscr();            /* Initialization */
+    noecho();             /* Echo off */
+    cbreak();             /* nl- or cr not needed */
+    keypad(stdscr, true); /* Use key symbols as KEY_DOWN */
+    refresh();
+    int x, y;
+    getmaxyx(stdscr, y, x);
+    cmCursesForm::CurrentForm->Render(1, 1, x, y);
+    cmCursesForm::CurrentForm->UpdateStatusBar();
+  }
+  signal(SIGWINCH, onsig);
+}
+}
+
+void CMakeMessageHandler(const char* message, const char* title,
+                         bool& /*unused*/, void* clientData)
+{
+  cmCursesForm* self = static_cast<cmCursesForm*>(clientData);
+  self->AddError(message, title);
+}
+
+int main(int argc, char const* const* argv)
+{
+  cmsys::Encoding::CommandLineArguments encoding_args =
+    cmsys::Encoding::CommandLineArguments::Main(argc, argv);
+  argc = encoding_args.argc();
+  argv = encoding_args.argv();
+
+  cmSystemTools::InitializeLibUV();
+  cmSystemTools::FindCMakeResources(argv[0]);
+  cmDocumentation doc;
+  doc.addCMakeStandardDocSections();
+  if (doc.CheckOptions(argc, argv)) {
+    cmake hcm(cmake::RoleInternal);
+    hcm.SetHomeDirectory("");
+    hcm.SetHomeOutputDirectory("");
+    hcm.AddCMakePaths();
+    std::vector<cmDocumentationEntry> generators;
+    hcm.GetGeneratorDocumentation(generators);
+    doc.SetName("ccmake");
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    if (argc == 1) {
+      doc.AppendSection("Usage", cmDocumentationUsageNote);
+    }
+    doc.SetSection("Generators", generators);
+    doc.PrependSection("Options", cmDocumentationOptions);
+    return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
+  }
+
+  bool debug = false;
+  unsigned int i;
+  int j;
+  std::vector<std::string> args;
+  for (j = 0; j < argc; ++j) {
+    if (strcmp(argv[j], "-debug") == 0) {
+      debug = true;
+    } else {
+      args.push_back(argv[j]);
+    }
+  }
+
+  std::string cacheDir = cmSystemTools::GetCurrentWorkingDirectory();
+  for (i = 1; i < args.size(); ++i) {
+    std::string arg = args[i];
+    if (arg.find("-B", 0) == 0) {
+      cacheDir = arg.substr(2);
+    }
+  }
+
+  cmSystemTools::DisableRunCommandOutput();
+
+  if (debug) {
+    cmCursesForm::DebugStart();
+  }
+
+  initscr();            /* Initialization */
+  noecho();             /* Echo off */
+  cbreak();             /* nl- or cr not needed */
+  keypad(stdscr, true); /* Use key symbols as KEY_DOWN */
+
+  signal(SIGWINCH, onsig);
+
+  int x, y;
+  getmaxyx(stdscr, y, x);
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
+    endwin();
+    std::cerr << "Window is too small. A size of at least "
+              << cmCursesMainForm::MIN_WIDTH << " x "
+              << cmCursesMainForm::MIN_HEIGHT << " is required to run ccmake."
+              << std::endl;
+    return 1;
+  }
+
+  cmCursesMainForm* myform;
+
+  myform = new cmCursesMainForm(args, x);
+  if (myform->LoadCache(cacheDir.c_str())) {
+    curses_clear();
+    touchwin(stdscr);
+    endwin();
+    delete myform;
+    std::cerr << "Error running cmake::LoadCache().  Aborting.\n";
+    return 1;
+  }
+
+  cmSystemTools::SetMessageCallback(CMakeMessageHandler, myform);
+
+  cmCursesForm::CurrentForm = myform;
+
+  myform->InitializeUI();
+  if (myform->Configure(1) == 0) {
+    myform->Render(1, 1, x, y);
+    myform->HandleInput();
+  }
+
+  // Need to clean-up better
+  curses_clear();
+  touchwin(stdscr);
+  endwin();
+  delete cmCursesForm::CurrentForm;
+  cmCursesForm::CurrentForm = nullptr;
+
+  std::cout << std::endl << std::endl;
+
+  return 0;
+}
diff --git a/Source/CursesDialog/cmCursesBoolWidget.cxx b/Source/CursesDialog/cmCursesBoolWidget.cxx
new file mode 100644
index 0000000..80a5b5b
--- /dev/null
+++ b/Source/CursesDialog/cmCursesBoolWidget.cxx
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesBoolWidget.h"
+
+#include "cmCursesWidget.h"
+#include "cmStateTypes.h"
+
+#include <string>
+
+cmCursesBoolWidget::cmCursesBoolWidget(int width, int height, int left,
+                                       int top)
+  : cmCursesWidget(width, height, left, top)
+{
+  this->Type = cmStateEnums::BOOL;
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
+  this->SetValueAsBool(false);
+}
+
+bool cmCursesBoolWidget::HandleInput(int& key, cmCursesMainForm* /*fm*/,
+                                     WINDOW* w)
+{
+
+  // toggle boolean values with enter or space
+  // 10 == enter
+  if (key == 10 || key == KEY_ENTER || key == ' ') {
+    if (this->GetValueAsBool()) {
+      this->SetValueAsBool(false);
+    } else {
+      this->SetValueAsBool(true);
+    }
+
+    touchwin(w);
+    wrefresh(w);
+    return true;
+  }
+  return false;
+}
+
+void cmCursesBoolWidget::SetValueAsBool(bool value)
+{
+  if (value) {
+    this->SetValue("ON");
+  } else {
+    this->SetValue("OFF");
+  }
+}
+
+bool cmCursesBoolWidget::GetValueAsBool()
+{
+  return this->Value == "ON";
+}
diff --git a/Source/CursesDialog/cmCursesBoolWidget.h b/Source/CursesDialog/cmCursesBoolWidget.h
new file mode 100644
index 0000000..cdb9478
--- /dev/null
+++ b/Source/CursesDialog/cmCursesBoolWidget.h
@@ -0,0 +1,32 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesBoolWidget_h
+#define cmCursesBoolWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+
+class cmCursesMainForm;
+
+class cmCursesBoolWidget : public cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesBoolWidget)
+
+public:
+  cmCursesBoolWidget(int width, int height, int left, int top);
+
+  // Description:
+  // Handle user input. Called by the container of this widget
+  // when this widget has focus. Returns true if the input was
+  // handled.
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+
+  // Description:
+  // Set/Get the value (on/off).
+  void SetValueAsBool(bool value);
+  bool GetValueAsBool();
+};
+
+#endif // cmCursesBoolWidget_h
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
new file mode 100644
index 0000000..e7ed097
--- /dev/null
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -0,0 +1,107 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesCacheEntryComposite.h"
+
+#include "cmCursesBoolWidget.h"
+#include "cmCursesFilePathWidget.h"
+#include "cmCursesLabelWidget.h"
+#include "cmCursesOptionsWidget.h"
+#include "cmCursesPathWidget.h"
+#include "cmCursesStringWidget.h"
+#include "cmCursesWidget.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <assert.h>
+#include <vector>
+
+cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
+  const std::string& key, int labelwidth, int entrywidth)
+  : Key(key)
+  , LabelWidth(labelwidth)
+  , EntryWidth(entrywidth)
+{
+  this->Label = new cmCursesLabelWidget(this->LabelWidth, 1, 1, 1, key);
+  this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " ");
+  this->Entry = nullptr;
+  this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1);
+}
+
+cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
+  const std::string& key, cmake* cm, bool isNew, int labelwidth,
+  int entrywidth)
+  : Key(key)
+  , LabelWidth(labelwidth)
+  , EntryWidth(entrywidth)
+{
+  this->Label = new cmCursesLabelWidget(this->LabelWidth, 1, 1, 1, key);
+  if (isNew) {
+    this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, "*");
+  } else {
+    this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " ");
+  }
+
+  this->Entry = nullptr;
+  const char* value = cm->GetState()->GetCacheEntryValue(key);
+  assert(value);
+  switch (cm->GetState()->GetCacheEntryType(key)) {
+    case cmStateEnums::BOOL:
+      this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
+      if (cmSystemTools::IsOn(value)) {
+        static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(true);
+      } else {
+        static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(false);
+      }
+      break;
+    case cmStateEnums::PATH:
+      this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
+      static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
+      break;
+    case cmStateEnums::FILEPATH:
+      this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
+      static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
+      break;
+    case cmStateEnums::STRING: {
+      const char* stringsProp =
+        cm->GetState()->GetCacheEntryProperty(key, "STRINGS");
+      if (stringsProp) {
+        cmCursesOptionsWidget* ow =
+          new cmCursesOptionsWidget(this->EntryWidth, 1, 1, 1);
+        this->Entry = ow;
+        std::vector<std::string> options;
+        cmSystemTools::ExpandListArgument(stringsProp, options);
+        for (auto const& opt : options) {
+          ow->AddOption(opt);
+        }
+        ow->SetOption(value);
+      } else {
+        this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1);
+        static_cast<cmCursesStringWidget*>(this->Entry)->SetString(value);
+      }
+      break;
+    }
+    case cmStateEnums::UNINITIALIZED:
+      cmSystemTools::Error("Found an undefined variable: ", key.c_str());
+      break;
+    default:
+      // TODO : put warning message here
+      break;
+  }
+}
+
+cmCursesCacheEntryComposite::~cmCursesCacheEntryComposite()
+{
+  delete this->Label;
+  delete this->IsNewLabel;
+  delete this->Entry;
+}
+
+const char* cmCursesCacheEntryComposite::GetValue()
+{
+  if (this->Label) {
+    return this->Label->GetValue();
+  }
+  return nullptr;
+}
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
new file mode 100644
index 0000000..54b2f1f
--- /dev/null
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesCacheEntryComposite_h
+#define cmCursesCacheEntryComposite_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+class cmCursesLabelWidget;
+class cmCursesWidget;
+class cmake;
+
+class cmCursesCacheEntryComposite
+{
+  CM_DISABLE_COPY(cmCursesCacheEntryComposite)
+
+public:
+  cmCursesCacheEntryComposite(const std::string& key, int labelwidth,
+                              int entrywidth);
+  cmCursesCacheEntryComposite(const std::string& key, cmake* cm, bool isNew,
+                              int labelwidth, int entrywidth);
+  ~cmCursesCacheEntryComposite();
+  const char* GetValue();
+
+  friend class cmCursesMainForm;
+
+protected:
+  cmCursesLabelWidget* Label;
+  cmCursesLabelWidget* IsNewLabel;
+  cmCursesWidget* Entry;
+  std::string Key;
+  int LabelWidth;
+  int EntryWidth;
+};
+
+#endif // cmCursesCacheEntryComposite_h
diff --git a/Source/CursesDialog/cmCursesDummyWidget.cxx b/Source/CursesDialog/cmCursesDummyWidget.cxx
new file mode 100644
index 0000000..da0478a
--- /dev/null
+++ b/Source/CursesDialog/cmCursesDummyWidget.cxx
@@ -0,0 +1,19 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesDummyWidget.h"
+
+#include "cmCursesWidget.h"
+#include "cmStateTypes.h"
+
+cmCursesDummyWidget::cmCursesDummyWidget(int width, int height, int left,
+                                         int top)
+  : cmCursesWidget(width, height, left, top)
+{
+  this->Type = cmStateEnums::INTERNAL;
+}
+
+bool cmCursesDummyWidget::HandleInput(int& /*key*/, cmCursesMainForm* /*fm*/,
+                                      WINDOW* /*w*/)
+{
+  return false;
+}
diff --git a/Source/CursesDialog/cmCursesDummyWidget.h b/Source/CursesDialog/cmCursesDummyWidget.h
new file mode 100644
index 0000000..c509ae7
--- /dev/null
+++ b/Source/CursesDialog/cmCursesDummyWidget.h
@@ -0,0 +1,27 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesDummyWidget_h
+#define cmCursesDummyWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+
+class cmCursesMainForm;
+
+class cmCursesDummyWidget : public cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesDummyWidget)
+
+public:
+  cmCursesDummyWidget(int width, int height, int left, int top);
+
+  // Description:
+  // Handle user input. Called by the container of this widget
+  // when this widget has focus. Returns true if the input was
+  // handled.
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+};
+
+#endif // cmCursesDummyWidget_h
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.cxx b/Source/CursesDialog/cmCursesFilePathWidget.cxx
new file mode 100644
index 0000000..518da4f
--- /dev/null
+++ b/Source/CursesDialog/cmCursesFilePathWidget.cxx
@@ -0,0 +1,13 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesFilePathWidget.h"
+
+#include "cmCursesPathWidget.h"
+#include "cmStateTypes.h"
+
+cmCursesFilePathWidget::cmCursesFilePathWidget(int width, int height, int left,
+                                               int top)
+  : cmCursesPathWidget(width, height, left, top)
+{
+  this->Type = cmStateEnums::FILEPATH;
+}
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.h b/Source/CursesDialog/cmCursesFilePathWidget.h
new file mode 100644
index 0000000..0a30402
--- /dev/null
+++ b/Source/CursesDialog/cmCursesFilePathWidget.h
@@ -0,0 +1,18 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesFilePathWidget_h
+#define cmCursesFilePathWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesPathWidget.h"
+
+class cmCursesFilePathWidget : public cmCursesPathWidget
+{
+  CM_DISABLE_COPY(cmCursesFilePathWidget)
+
+public:
+  cmCursesFilePathWidget(int width, int height, int left, int top);
+};
+
+#endif // cmCursesFilePathWidget_h
diff --git a/Source/CursesDialog/cmCursesForm.cxx b/Source/CursesDialog/cmCursesForm.cxx
new file mode 100644
index 0000000..bd65c4a
--- /dev/null
+++ b/Source/CursesDialog/cmCursesForm.cxx
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesForm.h"
+
+cmsys::ofstream cmCursesForm::DebugFile;
+bool cmCursesForm::Debug = false;
+
+cmCursesForm::cmCursesForm()
+{
+  this->Form = nullptr;
+}
+
+cmCursesForm::~cmCursesForm()
+{
+  if (this->Form) {
+    unpost_form(this->Form);
+    free_form(this->Form);
+    this->Form = nullptr;
+  }
+}
+
+void cmCursesForm::DebugStart()
+{
+  cmCursesForm::Debug = true;
+  cmCursesForm::DebugFile.open("ccmakelog.txt");
+}
+
+void cmCursesForm::DebugEnd()
+{
+  if (!cmCursesForm::Debug) {
+    return;
+  }
+
+  cmCursesForm::Debug = false;
+  cmCursesForm::DebugFile.close();
+}
+
+void cmCursesForm::LogMessage(const char* msg)
+{
+  if (!cmCursesForm::Debug) {
+    return;
+  }
+
+  cmCursesForm::DebugFile << msg << std::endl;
+}
diff --git a/Source/CursesDialog/cmCursesForm.h b/Source/CursesDialog/cmCursesForm.h
new file mode 100644
index 0000000..249b349
--- /dev/null
+++ b/Source/CursesDialog/cmCursesForm.h
@@ -0,0 +1,63 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesForm_h
+#define cmCursesForm_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+
+#include "cmsys/FStream.hxx"
+
+class cmCursesForm
+{
+  CM_DISABLE_COPY(cmCursesForm)
+
+public:
+  cmCursesForm();
+  virtual ~cmCursesForm();
+
+  // Description:
+  // Handle user input.
+  virtual void HandleInput() = 0;
+
+  // Description:
+  // Display form.
+  virtual void Render(int left, int top, int width, int height) = 0;
+
+  // Description:
+  // This method should normally  called only by the form.
+  // The only exception is during a resize.
+  virtual void UpdateStatusBar() = 0;
+
+  // Description:
+  // During a CMake run, an error handle should add errors
+  // to be displayed afterwards.
+  virtual void AddError(const char*, const char*) {}
+
+  // Description:
+  // Turn debugging on. This will create ccmakelog.txt.
+  static void DebugStart();
+
+  // Description:
+  // Turn debugging off. This will close ccmakelog.txt.
+  static void DebugEnd();
+
+  // Description:
+  // Write a debugging message.
+  static void LogMessage(const char* msg);
+
+  // Description:
+  // Return the FORM. Should be only used by low-level methods.
+  FORM* GetForm() { return this->Form; }
+
+  static cmCursesForm* CurrentForm;
+
+protected:
+  static cmsys::ofstream DebugFile;
+  static bool Debug;
+
+  FORM* Form;
+};
+
+#endif // cmCursesForm_h
diff --git a/Source/CursesDialog/cmCursesLabelWidget.cxx b/Source/CursesDialog/cmCursesLabelWidget.cxx
new file mode 100644
index 0000000..1dfd4ce
--- /dev/null
+++ b/Source/CursesDialog/cmCursesLabelWidget.cxx
@@ -0,0 +1,26 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesLabelWidget.h"
+
+#include "cmCursesWidget.h"
+
+cmCursesLabelWidget::cmCursesLabelWidget(int width, int height, int left,
+                                         int top, const std::string& name)
+  : cmCursesWidget(width, height, left, top)
+{
+  field_opts_off(this->Field, O_EDIT);
+  field_opts_off(this->Field, O_ACTIVE);
+  field_opts_off(this->Field, O_STATIC);
+  this->SetValue(name);
+}
+
+cmCursesLabelWidget::~cmCursesLabelWidget()
+{
+}
+
+bool cmCursesLabelWidget::HandleInput(int& /*key*/, cmCursesMainForm* /*fm*/,
+                                      WINDOW* /*w*/)
+{
+  // Static text. No input is handled here.
+  return false;
+}
diff --git a/Source/CursesDialog/cmCursesLabelWidget.h b/Source/CursesDialog/cmCursesLabelWidget.h
new file mode 100644
index 0000000..aab559b
--- /dev/null
+++ b/Source/CursesDialog/cmCursesLabelWidget.h
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesLabelWidget_h
+#define cmCursesLabelWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+
+#include <string>
+
+class cmCursesMainForm;
+
+class cmCursesLabelWidget : public cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesLabelWidget)
+
+public:
+  cmCursesLabelWidget(int width, int height, int left, int top,
+                      const std::string& name);
+  ~cmCursesLabelWidget() override;
+
+  // Description:
+  // Handle user input. Called by the container of this widget
+  // when this widget has focus. Returns true if the input was
+  // handled
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+};
+
+#endif // cmCursesLabelWidget_h
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx
new file mode 100644
index 0000000..9bd1c11
--- /dev/null
+++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx
@@ -0,0 +1,178 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesLongMessageForm.h"
+
+#include "cmCursesForm.h"
+#include "cmCursesMainForm.h"
+#include "cmCursesStandardIncludes.h"
+#include "cmVersion.h"
+
+#include <stdio.h>
+#include <string.h>
+
+inline int ctrl(int z)
+{
+  return (z & 037);
+}
+
+cmCursesLongMessageForm::cmCursesLongMessageForm(
+  std::vector<std::string> const& messages, const char* title)
+{
+  // Append all messages into on big string
+  std::vector<std::string>::const_iterator it;
+  for (it = messages.begin(); it != messages.end(); it++) {
+    this->Messages += (*it);
+    // Add one blank line after each message
+    this->Messages += "\n\n";
+  }
+  this->Title = title;
+  this->Fields[0] = nullptr;
+  this->Fields[1] = nullptr;
+}
+
+cmCursesLongMessageForm::~cmCursesLongMessageForm()
+{
+  if (this->Fields[0]) {
+    free_field(this->Fields[0]);
+  }
+}
+
+void cmCursesLongMessageForm::UpdateStatusBar()
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+
+  char bar[cmCursesMainForm::MAX_WIDTH];
+  size_t size = strlen(this->Title.c_str());
+  if (size >= cmCursesMainForm::MAX_WIDTH) {
+    size = cmCursesMainForm::MAX_WIDTH - 1;
+  }
+  strncpy(bar, this->Title.c_str(), size);
+  for (size_t i = size - 1; i < cmCursesMainForm::MAX_WIDTH; i++) {
+    bar[i] = ' ';
+  }
+  int width;
+  if (x < cmCursesMainForm::MAX_WIDTH) {
+    width = x;
+  } else {
+    width = cmCursesMainForm::MAX_WIDTH - 1;
+  }
+
+  bar[width] = '\0';
+
+  char version[cmCursesMainForm::MAX_WIDTH];
+  char vertmp[128];
+  sprintf(vertmp, "CMake Version %s", cmVersion::GetCMakeVersion());
+  size_t sideSpace = (width - strlen(vertmp));
+  for (size_t i = 0; i < sideSpace; i++) {
+    version[i] = ' ';
+  }
+  sprintf(version + sideSpace, "%s", vertmp);
+  version[width] = '\0';
+
+  char fmt_s[] = "%s";
+  curses_move(y - 4, 0);
+  attron(A_STANDOUT);
+  printw(fmt_s, bar);
+  attroff(A_STANDOUT);
+  curses_move(y - 3, 0);
+  printw(fmt_s, version);
+  pos_form_cursor(this->Form);
+}
+
+void cmCursesLongMessageForm::PrintKeys()
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
+    return;
+  }
+  char firstLine[512];
+  sprintf(firstLine, "Press [e] to exit help");
+
+  char fmt_s[] = "%s";
+  curses_move(y - 2, 0);
+  printw(fmt_s, firstLine);
+  pos_form_cursor(this->Form);
+}
+
+void cmCursesLongMessageForm::Render(int /*left*/, int /*top*/, int /*width*/,
+                                     int /*height*/)
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+
+  if (this->Form) {
+    unpost_form(this->Form);
+    free_form(this->Form);
+    this->Form = nullptr;
+  }
+
+  const char* msg = this->Messages.c_str();
+
+  curses_clear();
+
+  if (this->Fields[0]) {
+    free_field(this->Fields[0]);
+    this->Fields[0] = nullptr;
+  }
+
+  this->Fields[0] = new_field(y - 6, x - 2, 1, 1, 0, 0);
+
+  field_opts_off(this->Fields[0], O_STATIC);
+
+  this->Form = new_form(this->Fields);
+  post_form(this->Form);
+
+  int i = 0;
+  form_driver(this->Form, REQ_BEG_FIELD);
+  while (msg[i] != '\0' && i < 60000) {
+    if (msg[i] == '\n' && msg[i + 1] != '\0') {
+      form_driver(this->Form, REQ_NEW_LINE);
+    } else {
+      form_driver(this->Form, msg[i]);
+    }
+    i++;
+  }
+  form_driver(this->Form, REQ_BEG_FIELD);
+
+  this->UpdateStatusBar();
+  this->PrintKeys();
+  touchwin(stdscr);
+  refresh();
+}
+
+void cmCursesLongMessageForm::HandleInput()
+{
+  if (!this->Form) {
+    return;
+  }
+
+  char debugMessage[128];
+
+  for (;;) {
+    int key = getch();
+
+    sprintf(debugMessage, "Message widget handling input, key: %d", key);
+    cmCursesForm::LogMessage(debugMessage);
+
+    // quit
+    if (key == 'o' || key == 'e') {
+      break;
+    }
+    if (key == KEY_DOWN || key == ctrl('n')) {
+      form_driver(this->Form, REQ_SCR_FLINE);
+    } else if (key == KEY_UP || key == ctrl('p')) {
+      form_driver(this->Form, REQ_SCR_BLINE);
+    } else if (key == KEY_NPAGE || key == ctrl('d')) {
+      form_driver(this->Form, REQ_SCR_FPAGE);
+    } else if (key == KEY_PPAGE || key == ctrl('u')) {
+      form_driver(this->Form, REQ_SCR_BPAGE);
+    }
+
+    this->UpdateStatusBar();
+    this->PrintKeys();
+    touchwin(stdscr);
+    wrefresh(stdscr);
+  }
+}
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.h b/Source/CursesDialog/cmCursesLongMessageForm.h
new file mode 100644
index 0000000..2bcc15a
--- /dev/null
+++ b/Source/CursesDialog/cmCursesLongMessageForm.h
@@ -0,0 +1,49 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesLongMessageForm_h
+#define cmCursesLongMessageForm_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesForm.h"
+#include "cmCursesStandardIncludes.h"
+
+#include <string>
+#include <vector>
+
+class cmCursesLongMessageForm : public cmCursesForm
+{
+  CM_DISABLE_COPY(cmCursesLongMessageForm)
+
+public:
+  cmCursesLongMessageForm(std::vector<std::string> const& messages,
+                          const char* title);
+  ~cmCursesLongMessageForm() override;
+
+  // Description:
+  // Handle user input.
+  void HandleInput() override;
+
+  // Description:
+  // Display form. Use a window of size width x height, starting
+  // at top, left.
+  void Render(int left, int top, int width, int height) override;
+
+  // Description:
+  // This method should normally  called only by the form.
+  // The only exception is during a resize.
+  void PrintKeys();
+
+  // Description:
+  // This method should normally  called only by the form.
+  // The only exception is during a resize.
+  void UpdateStatusBar() override;
+
+protected:
+  std::string Messages;
+  std::string Title;
+
+  FIELD* Fields[2];
+};
+
+#endif // cmCursesLongMessageForm_h
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
new file mode 100644
index 0000000..dbd024d
--- /dev/null
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -0,0 +1,1127 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesMainForm.h"
+
+#include "cmAlgorithms.h"
+#include "cmCursesCacheEntryComposite.h"
+#include "cmCursesDummyWidget.h"
+#include "cmCursesForm.h"
+#include "cmCursesLabelWidget.h"
+#include "cmCursesLongMessageForm.h"
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesStringWidget.h"
+#include "cmCursesWidget.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmake.h"
+
+#include <algorithm>
+#include <stdio.h>
+#include <string.h>
+
+inline int ctrl(int z)
+{
+  return (z & 037);
+}
+
+cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
+                                   int initWidth)
+  : Args(args)
+  , InitialWidth(initWidth)
+{
+  this->NumberOfPages = 0;
+  this->Fields = nullptr;
+  this->Entries = nullptr;
+  this->AdvancedMode = false;
+  this->NumberOfVisibleEntries = 0;
+  this->OkToGenerate = false;
+  this->HelpMessage.push_back(
+    "Welcome to ccmake, curses based user interface for CMake.");
+  this->HelpMessage.push_back("");
+  this->HelpMessage.push_back(s_ConstHelpMessage);
+  this->CMakeInstance = new cmake(cmake::RoleProject);
+  this->CMakeInstance->SetCMakeEditCommand(
+    cmSystemTools::GetCMakeCursesCommand());
+
+  // create the arguments for the cmake object
+  std::string whereCMake = cmSystemTools::GetProgramPath(this->Args[0]);
+  whereCMake += "/cmake";
+  this->Args[0] = whereCMake;
+  this->CMakeInstance->SetArgs(this->Args);
+  this->SearchString = "";
+  this->OldSearchString = "";
+  this->SearchMode = false;
+}
+
+cmCursesMainForm::~cmCursesMainForm()
+{
+  if (this->Form) {
+    unpost_form(this->Form);
+    free_form(this->Form);
+    this->Form = nullptr;
+  }
+  delete[] this->Fields;
+
+  // Clean-up composites
+  if (this->Entries) {
+    cmDeleteAll(*this->Entries);
+  }
+  delete this->Entries;
+  if (this->CMakeInstance) {
+    delete this->CMakeInstance;
+    this->CMakeInstance = nullptr;
+  }
+}
+
+// See if a cache entry is in the list of entries in the ui.
+bool cmCursesMainForm::LookForCacheEntry(const std::string& key)
+{
+  if (!this->Entries) {
+    return false;
+  }
+
+  std::vector<cmCursesCacheEntryComposite*>::iterator it;
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+    if (key == (*it)->Key) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Create new cmCursesCacheEntryComposite entries from the cache
+void cmCursesMainForm::InitializeUI()
+{
+  // Create a vector of cmCursesCacheEntryComposite's
+  // which contain labels, entries and new entry markers
+  std::vector<cmCursesCacheEntryComposite*>* newEntries =
+    new std::vector<cmCursesCacheEntryComposite*>;
+  std::vector<std::string> cacheKeys =
+    this->CMakeInstance->GetState()->GetCacheEntryKeys();
+  newEntries->reserve(cacheKeys.size());
+
+  // Count non-internal and non-static entries
+  int count = 0;
+
+  for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+       it != cacheKeys.end(); ++it) {
+    cmStateEnums::CacheEntryType t =
+      this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+    if (t != cmStateEnums::INTERNAL && t != cmStateEnums::STATIC &&
+        t != cmStateEnums::UNINITIALIZED) {
+      ++count;
+    }
+  }
+
+  int entrywidth = this->InitialWidth - 35;
+
+  cmCursesCacheEntryComposite* comp;
+  if (count == 0) {
+    // If cache is empty, display a label saying so and a
+    // dummy entry widget (does not respond to input)
+    comp = new cmCursesCacheEntryComposite("EMPTY CACHE", 30, 30);
+    comp->Entry = new cmCursesDummyWidget(1, 1, 1, 1);
+    newEntries->push_back(comp);
+  } else {
+    // Create the composites.
+
+    // First add entries which are new
+    for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+         it != cacheKeys.end(); ++it) {
+      std::string key = *it;
+      cmStateEnums::CacheEntryType t =
+        this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+      if (t == cmStateEnums::INTERNAL || t == cmStateEnums::STATIC ||
+          t == cmStateEnums::UNINITIALIZED) {
+        continue;
+      }
+
+      if (!this->LookForCacheEntry(key)) {
+        newEntries->push_back(new cmCursesCacheEntryComposite(
+          key, this->CMakeInstance, true, 30, entrywidth));
+        this->OkToGenerate = false;
+      }
+    }
+
+    // then add entries which are old
+    for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+         it != cacheKeys.end(); ++it) {
+      std::string key = *it;
+      cmStateEnums::CacheEntryType t =
+        this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+      if (t == cmStateEnums::INTERNAL || t == cmStateEnums::STATIC ||
+          t == cmStateEnums::UNINITIALIZED) {
+        continue;
+      }
+
+      if (this->LookForCacheEntry(key)) {
+        newEntries->push_back(new cmCursesCacheEntryComposite(
+          key, this->CMakeInstance, false, 30, entrywidth));
+      }
+    }
+  }
+
+  // Clean old entries
+  if (this->Entries) {
+    cmDeleteAll(*this->Entries);
+  }
+  delete this->Entries;
+  this->Entries = newEntries;
+
+  // Compute fields from composites
+  this->RePost();
+}
+
+void cmCursesMainForm::RePost()
+{
+  // Create the fields to be passed to the form.
+  if (this->Form) {
+    unpost_form(this->Form);
+    free_form(this->Form);
+    this->Form = nullptr;
+  }
+  delete[] this->Fields;
+  if (this->AdvancedMode) {
+    this->NumberOfVisibleEntries = this->Entries->size();
+  } else {
+    // If normal mode, count only non-advanced entries
+    this->NumberOfVisibleEntries = 0;
+    std::vector<cmCursesCacheEntryComposite*>::iterator it;
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+      const char* existingValue =
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
+      bool advanced =
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
+        continue;
+      }
+      this->NumberOfVisibleEntries++;
+    }
+  }
+  // there is always one even if it is the dummy one
+  if (this->NumberOfVisibleEntries == 0) {
+    this->NumberOfVisibleEntries = 1;
+  }
+  // Assign the fields: 3 for each entry: label, new entry marker
+  // ('*' or ' ') and entry widget
+  this->Fields = new FIELD*[3 * this->NumberOfVisibleEntries + 1];
+  size_t cc;
+  for (cc = 0; cc < 3 * this->NumberOfVisibleEntries + 1; cc++) {
+    this->Fields[cc] = nullptr;
+  }
+
+  // Assign fields
+  int j = 0;
+  std::vector<cmCursesCacheEntryComposite*>::iterator it;
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+    const char* existingValue =
+      this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
+    bool advanced =
+      this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+        (*it)->GetValue(), "ADVANCED");
+    if (!existingValue || (!this->AdvancedMode && advanced)) {
+      continue;
+    }
+    this->Fields[3 * j] = (*it)->Label->Field;
+    this->Fields[3 * j + 1] = (*it)->IsNewLabel->Field;
+    this->Fields[3 * j + 2] = (*it)->Entry->Field;
+    j++;
+  }
+  // if no cache entries there should still be one dummy field
+  if (j == 0) {
+    it = this->Entries->begin();
+    this->Fields[0] = (*it)->Label->Field;
+    this->Fields[1] = (*it)->IsNewLabel->Field;
+    this->Fields[2] = (*it)->Entry->Field;
+    this->NumberOfVisibleEntries = 1;
+  }
+  // Has to be null terminated.
+  this->Fields[3 * this->NumberOfVisibleEntries] = nullptr;
+}
+
+void cmCursesMainForm::Render(int left, int top, int width, int height)
+{
+
+  if (this->Form) {
+    FIELD* currentField = current_field(this->Form);
+    cmCursesWidget* cw =
+      reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
+    // If in edit mode, get out of it
+    if (cw->GetType() == cmStateEnums::STRING ||
+        cw->GetType() == cmStateEnums::PATH ||
+        cw->GetType() == cmStateEnums::FILEPATH) {
+      cmCursesStringWidget* sw = static_cast<cmCursesStringWidget*>(cw);
+      sw->SetInEdit(false);
+    }
+    // Delete the previous form
+    unpost_form(this->Form);
+    free_form(this->Form);
+    this->Form = nullptr;
+  }
+
+  // Wrong window size
+  if (width < cmCursesMainForm::MIN_WIDTH || width < this->InitialWidth ||
+      height < cmCursesMainForm::MIN_HEIGHT) {
+    return;
+  }
+
+  // Leave room for toolbar
+  height -= 7;
+
+  if (this->AdvancedMode) {
+    this->NumberOfVisibleEntries = this->Entries->size();
+  } else {
+    // If normal, display only non-advanced entries
+    this->NumberOfVisibleEntries = 0;
+    std::vector<cmCursesCacheEntryComposite*>::iterator it;
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+      const char* existingValue =
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
+      bool advanced =
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
+        continue;
+      }
+      this->NumberOfVisibleEntries++;
+    }
+  }
+
+  // Re-adjust the fields according to their place
+  this->NumberOfPages = 1;
+  if (height > 0) {
+    bool isNewPage;
+    int i = 0;
+    std::vector<cmCursesCacheEntryComposite*>::iterator it;
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+      const char* existingValue =
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
+      bool advanced =
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
+        continue;
+      }
+      int row = (i % height) + 1;
+      int page = (i / height) + 1;
+      isNewPage = (page > 1) && (row == 1);
+
+      if (isNewPage) {
+        this->NumberOfPages++;
+      }
+      (*it)->Label->Move(left, top + row - 1, isNewPage);
+      (*it)->IsNewLabel->Move(left + 32, top + row - 1, false);
+      (*it)->Entry->Move(left + 33, top + row - 1, false);
+      (*it)->Entry->SetPage(this->NumberOfPages);
+      i++;
+    }
+  }
+
+  // Post the form
+  this->Form = new_form(this->Fields);
+  post_form(this->Form);
+  // Update toolbar
+  this->UpdateStatusBar();
+  this->PrintKeys();
+
+  touchwin(stdscr);
+  refresh();
+}
+
+void cmCursesMainForm::PrintKeys(int process /* = 0 */)
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+  if (x < cmCursesMainForm::MIN_WIDTH || x < this->InitialWidth ||
+      y < cmCursesMainForm::MIN_HEIGHT) {
+    return;
+  }
+
+  // Give the current widget (if it exists), a chance to print keys
+  cmCursesWidget* cw = nullptr;
+  if (this->Form) {
+    FIELD* currentField = current_field(this->Form);
+    cw = reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
+  }
+
+  char fmt_s[] = "%s";
+  if (cw == nullptr || !cw->PrintKeys()) {
+    char firstLine[512] = "";
+    char secondLine[512] = "";
+    char thirdLine[512] = "";
+    if (process) {
+      memset(firstLine, ' ', 68);
+      memset(secondLine, ' ', 68);
+      memset(thirdLine, ' ', 68);
+    } else {
+      if (this->OkToGenerate) {
+        sprintf(firstLine,
+                "Press [c] to configure       Press [g] to generate and exit");
+      } else {
+        sprintf(firstLine,
+                "Press [c] to configure                                     ");
+      }
+      {
+        const char* toggleKeyInstruction =
+          "Press [t] to toggle advanced mode (Currently %s)";
+        sprintf(thirdLine, toggleKeyInstruction,
+                this->AdvancedMode ? "On" : "Off");
+      }
+      sprintf(secondLine, "Press [h] for help           "
+                          "Press [q] to quit without generating");
+    }
+
+    curses_move(y - 4, 0);
+    char fmt[512] =
+      "Press [enter] to edit option Press [d] to delete an entry";
+    if (process) {
+      memset(fmt, ' ', 27);
+    }
+    printw(fmt_s, fmt);
+    curses_move(y - 3, 0);
+    printw(fmt_s, firstLine);
+    curses_move(y - 2, 0);
+    printw(fmt_s, secondLine);
+    curses_move(y - 1, 0);
+    printw(fmt_s, thirdLine);
+  }
+
+  if (cw) {
+    char pageLine[512] = "";
+    sprintf(pageLine, "Page %d of %d", cw->GetPage(), this->NumberOfPages);
+    curses_move(0, 65 - static_cast<unsigned int>(strlen(pageLine)) - 1);
+    printw(fmt_s, pageLine);
+  }
+
+  pos_form_cursor(this->Form);
+}
+
+// Print the key of the current entry and the CMake version
+// on the status bar. Designed for a width of 80 chars.
+void cmCursesMainForm::UpdateStatusBar(const char* message)
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+  // If window size is too small, display error and return
+  if (x < cmCursesMainForm::MIN_WIDTH || x < this->InitialWidth ||
+      y < cmCursesMainForm::MIN_HEIGHT) {
+    curses_clear();
+    curses_move(0, 0);
+    char fmt[] = "Window is too small. A size of at least %dx%d is required.";
+    printw(fmt, (cmCursesMainForm::MIN_WIDTH < this->InitialWidth
+                   ? this->InitialWidth
+                   : cmCursesMainForm::MIN_WIDTH),
+           cmCursesMainForm::MIN_HEIGHT);
+    touchwin(stdscr);
+    wrefresh(stdscr);
+    return;
+  }
+
+  // Get the key of the current entry
+  FIELD* cur = current_field(this->Form);
+  int findex = field_index(cur);
+  cmCursesWidget* lbl = nullptr;
+  if (findex >= 0) {
+    lbl = reinterpret_cast<cmCursesWidget*>(
+      field_userptr(this->Fields[findex - 2]));
+  }
+  char help[128] = "";
+  const char* curField = "";
+  if (lbl) {
+    curField = lbl->GetValue();
+
+    // Get the help string of the current entry
+    // and add it to the help string
+    const char* existingValue =
+      this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
+    if (existingValue) {
+      const char* hs = this->CMakeInstance->GetState()->GetCacheEntryProperty(
+        curField, "HELPSTRING");
+      if (hs) {
+        strncpy(help, hs, 127);
+        help[127] = '\0';
+      } else {
+        help[0] = 0;
+      }
+    } else {
+      sprintf(help, " ");
+    }
+  }
+
+  // Join the key, help string and pad with spaces
+  // (or truncate) as necessary
+  char bar[cmCursesMainForm::MAX_WIDTH];
+  size_t curFieldLen = strlen(curField);
+  size_t helpLen = strlen(help);
+
+  size_t width = std::min<size_t>(x, cmCursesMainForm::MAX_WIDTH);
+
+  if (message) {
+    curField = message;
+    curFieldLen = strlen(message);
+    strncpy(bar, curField, width);
+    if (curFieldLen < width) {
+      memset(bar + curFieldLen, ' ', width - curFieldLen);
+    }
+  } else {
+    strncpy(bar, curField, width);
+    if (curFieldLen < width) {
+      bar[curFieldLen] = ':';
+      bar[curFieldLen + 1] = ' ';
+      strncpy(bar + curFieldLen + 2, help, width - curFieldLen - 2);
+      if (curFieldLen + helpLen + 2 < width) {
+        memset(bar + curFieldLen + helpLen + 2, ' ',
+               width - curFieldLen + helpLen + 2);
+      }
+    }
+  }
+
+  bar[width] = '\0';
+
+  // Display CMake version info on the next line
+  // We want to display this on the right
+  char version[cmCursesMainForm::MAX_WIDTH];
+  char vertmp[128];
+  sprintf(vertmp, "CMake Version %s", cmVersion::GetCMakeVersion());
+  size_t sideSpace = (width - strlen(vertmp));
+  memset(version, ' ', sideSpace);
+  sprintf(version + sideSpace, "%s", vertmp);
+  version[width] = '\0';
+
+  // Now print both lines
+  char fmt_s[] = "%s";
+  curses_move(y - 5, 0);
+  attron(A_STANDOUT);
+  printw(fmt_s, bar);
+  attroff(A_STANDOUT);
+  curses_move(y - 4, 0);
+  printw(fmt_s, version);
+  pos_form_cursor(this->Form);
+}
+
+void cmCursesMainForm::UpdateProgress(const char* msg, float prog, void* vp)
+{
+  cmCursesMainForm* cm = static_cast<cmCursesMainForm*>(vp);
+  if (!cm) {
+    return;
+  }
+  char tmp[1024];
+  const char* cmsg = tmp;
+  if (prog >= 0) {
+    sprintf(tmp, "%s %i%%", msg, static_cast<int>(100 * prog));
+  } else {
+    cmsg = msg;
+  }
+  cm->UpdateStatusBar(cmsg);
+  cm->PrintKeys(1);
+  curses_move(1, 1);
+  touchwin(stdscr);
+  refresh();
+}
+
+int cmCursesMainForm::Configure(int noconfigure)
+{
+  int xi, yi;
+  getmaxyx(stdscr, yi, xi);
+
+  curses_move(1, 1);
+  this->UpdateStatusBar("Configuring, please wait...");
+  this->PrintKeys(1);
+  touchwin(stdscr);
+  refresh();
+  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress,
+                                           this);
+
+  // always save the current gui values to disk
+  this->FillCacheManagerFromUI();
+  this->CMakeInstance->SaveCache(
+    this->CMakeInstance->GetHomeOutputDirectory());
+  this->LoadCache(nullptr);
+
+  // Get rid of previous errors
+  this->Errors = std::vector<std::string>();
+
+  // run the generate process
+  this->OkToGenerate = true;
+  int retVal;
+  if (noconfigure) {
+    retVal = this->CMakeInstance->DoPreConfigureChecks();
+    this->OkToGenerate = false;
+    if (retVal > 0) {
+      retVal = 0;
+    }
+  } else {
+    retVal = this->CMakeInstance->Configure();
+  }
+  this->CMakeInstance->SetProgressCallback(nullptr, nullptr);
+
+  keypad(stdscr, true); /* Use key symbols as KEY_DOWN */
+
+  if (retVal != 0 || !this->Errors.empty()) {
+    // see if there was an error
+    if (cmSystemTools::GetErrorOccuredFlag()) {
+      this->OkToGenerate = false;
+    }
+    int xx, yy;
+    getmaxyx(stdscr, yy, xx);
+    cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(
+      this->Errors, cmSystemTools::GetErrorOccuredFlag()
+        ? "Errors occurred during the last pass."
+        : "CMake produced the following output.");
+    // reset error condition
+    cmSystemTools::ResetErrorOccuredFlag();
+    CurrentForm = msgs;
+    msgs->Render(1, 1, xx, yy);
+    msgs->HandleInput();
+    // If they typed the wrong source directory, we report
+    // an error and exit
+    if (retVal == -2) {
+      return retVal;
+    }
+    CurrentForm = this;
+    this->Render(1, 1, xx, yy);
+  }
+
+  this->InitializeUI();
+  this->Render(1, 1, xi, yi);
+
+  return 0;
+}
+
+int cmCursesMainForm::Generate()
+{
+  int xi, yi;
+  getmaxyx(stdscr, yi, xi);
+
+  curses_move(1, 1);
+  this->UpdateStatusBar("Generating, please wait...");
+  this->PrintKeys(1);
+  touchwin(stdscr);
+  refresh();
+  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress,
+                                           this);
+
+  // Get rid of previous errors
+  this->Errors = std::vector<std::string>();
+
+  // run the generate process
+  int retVal = this->CMakeInstance->Generate();
+
+  this->CMakeInstance->SetProgressCallback(nullptr, nullptr);
+  keypad(stdscr, true); /* Use key symbols as KEY_DOWN */
+
+  if (retVal != 0 || !this->Errors.empty()) {
+    // see if there was an error
+    if (cmSystemTools::GetErrorOccuredFlag()) {
+      this->OkToGenerate = false;
+    }
+    // reset error condition
+    cmSystemTools::ResetErrorOccuredFlag();
+    int xx, yy;
+    getmaxyx(stdscr, yy, xx);
+    const char* title = "Messages during last pass.";
+    if (cmSystemTools::GetErrorOccuredFlag()) {
+      title = "Errors occurred during the last pass.";
+    }
+    cmCursesLongMessageForm* msgs =
+      new cmCursesLongMessageForm(this->Errors, title);
+    CurrentForm = msgs;
+    msgs->Render(1, 1, xx, yy);
+    msgs->HandleInput();
+    // If they typed the wrong source directory, we report
+    // an error and exit
+    if (retVal == -2) {
+      return retVal;
+    }
+    CurrentForm = this;
+    this->Render(1, 1, xx, yy);
+  }
+
+  this->InitializeUI();
+  this->Render(1, 1, xi, yi);
+
+  return 0;
+}
+
+void cmCursesMainForm::AddError(const char* message, const char* /*unused*/)
+{
+  this->Errors.push_back(message);
+}
+
+void cmCursesMainForm::RemoveEntry(const char* value)
+{
+  if (!value) {
+    return;
+  }
+
+  std::vector<cmCursesCacheEntryComposite*>::iterator it;
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+    const char* val = (*it)->GetValue();
+    if (val && !strcmp(value, val)) {
+      this->CMakeInstance->UnwatchUnusedCli(value);
+      this->Entries->erase(it);
+      break;
+    }
+  }
+}
+
+// copy from the list box to the cache manager
+void cmCursesMainForm::FillCacheManagerFromUI()
+{
+  size_t size = this->Entries->size();
+  for (size_t i = 0; i < size; i++) {
+    std::string cacheKey = (*this->Entries)[i]->Key;
+    const char* existingValue =
+      this->CMakeInstance->GetState()->GetCacheEntryValue(cacheKey);
+    if (existingValue) {
+      std::string oldValue = existingValue;
+      std::string newValue = (*this->Entries)[i]->Entry->GetValue();
+      std::string fixedOldValue;
+      std::string fixedNewValue;
+      cmStateEnums::CacheEntryType t =
+        this->CMakeInstance->GetState()->GetCacheEntryType(cacheKey);
+      this->FixValue(t, oldValue, fixedOldValue);
+      this->FixValue(t, newValue, fixedNewValue);
+
+      if (!(fixedOldValue == fixedNewValue)) {
+        // The user has changed the value.  Mark it as modified.
+        this->CMakeInstance->GetState()->SetCacheEntryBoolProperty(
+          cacheKey, "MODIFIED", true);
+        this->CMakeInstance->GetState()->SetCacheEntryValue(cacheKey,
+                                                            fixedNewValue);
+      }
+    }
+  }
+}
+
+void cmCursesMainForm::FixValue(cmStateEnums::CacheEntryType type,
+                                const std::string& in, std::string& out) const
+{
+  out = in.substr(0, in.find_last_not_of(' ') + 1);
+  if (type == cmStateEnums::PATH || type == cmStateEnums::FILEPATH) {
+    cmSystemTools::ConvertToUnixSlashes(out);
+  }
+  if (type == cmStateEnums::BOOL) {
+    if (cmSystemTools::IsOff(out.c_str())) {
+      out = "OFF";
+    } else {
+      out = "ON";
+    }
+  }
+}
+
+void cmCursesMainForm::HandleInput()
+{
+  int x = 0, y = 0;
+
+  if (!this->Form) {
+    return;
+  }
+
+  FIELD* currentField;
+  cmCursesWidget* currentWidget;
+
+  char debugMessage[128];
+
+  for (;;) {
+    this->UpdateStatusBar();
+    this->PrintKeys();
+    if (this->SearchMode) {
+      std::string searchstr = "Search: " + this->SearchString;
+      this->UpdateStatusBar(searchstr.c_str());
+      this->PrintKeys(1);
+      curses_move(y - 5, static_cast<unsigned int>(searchstr.size()));
+      // curses_move(1,1);
+      touchwin(stdscr);
+      refresh();
+    }
+    int key = getch();
+
+    getmaxyx(stdscr, y, x);
+    // If window too small, handle 'q' only
+    if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
+      // quit
+      if (key == 'q') {
+        break;
+      }
+      continue;
+    }
+
+    currentField = current_field(this->Form);
+    currentWidget =
+      reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
+
+    bool widgetHandled = false;
+
+    if (this->SearchMode) {
+      if (key == 10 || key == KEY_ENTER) {
+        this->SearchMode = false;
+        if (!this->SearchString.empty()) {
+          this->JumpToCacheEntry(this->SearchString.c_str());
+          this->OldSearchString = this->SearchString;
+        }
+        this->SearchString = "";
+      }
+      /*
+      else if ( key == KEY_ESCAPE )
+        {
+        this->SearchMode = false;
+        }
+      */
+      else if ((key >= 'a' && key <= 'z') || (key >= 'A' && key <= 'Z') ||
+               (key >= '0' && key <= '9') || (key == '_')) {
+        if (this->SearchString.size() <
+            static_cast<std::string::size_type>(x - 10)) {
+          this->SearchString += static_cast<char>(key);
+        }
+      } else if (key == ctrl('h') || key == KEY_BACKSPACE || key == KEY_DC) {
+        if (!this->SearchString.empty()) {
+          this->SearchString.resize(this->SearchString.size() - 1);
+        }
+      }
+    } else if (currentWidget && !this->SearchMode) {
+      // Ask the current widget if it wants to handle input
+      widgetHandled = currentWidget->HandleInput(key, this, stdscr);
+      if (widgetHandled) {
+        this->OkToGenerate = false;
+        this->UpdateStatusBar();
+        this->PrintKeys();
+      }
+    }
+    if ((!currentWidget || !widgetHandled) && !this->SearchMode) {
+      // If the current widget does not want to handle input,
+      // we handle it.
+      sprintf(debugMessage, "Main form handling input, key: %d", key);
+      cmCursesForm::LogMessage(debugMessage);
+      // quit
+      if (key == 'q') {
+        break;
+      }
+      // if not end of page, next field otherwise next page
+      // each entry consists of fields: label, isnew, value
+      // therefore, the label field for the prev. entry is index-5
+      // and the label field for the next entry is index+1
+      // (index always corresponds to the value field)
+      // scroll down with arrow down, ctrl+n (emacs binding), or j (vim
+      // binding)
+      if (key == KEY_DOWN || key == ctrl('n') || key == 'j') {
+        FIELD* cur = current_field(this->Form);
+        size_t findex = field_index(cur);
+        if (findex == 3 * this->NumberOfVisibleEntries - 1) {
+          continue;
+        }
+        if (new_page(this->Fields[findex + 1])) {
+          form_driver(this->Form, REQ_NEXT_PAGE);
+        } else {
+          form_driver(this->Form, REQ_NEXT_FIELD);
+        }
+      }
+      // if not beginning of page, previous field, otherwise previous page
+      // each entry consists of fields: label, isnew, value
+      // therefore, the label field for the prev. entry is index-5
+      // and the label field for the next entry is index+1
+      // (index always corresponds to the value field)
+      // scroll down with arrow up, ctrl+p (emacs binding), or k (vim binding)
+      else if (key == KEY_UP || key == ctrl('p') || key == 'k') {
+        FIELD* cur = current_field(this->Form);
+        int findex = field_index(cur);
+        if (findex == 2) {
+          continue;
+        }
+        if (new_page(this->Fields[findex - 2])) {
+          form_driver(this->Form, REQ_PREV_PAGE);
+          set_current_field(this->Form, this->Fields[findex - 3]);
+        } else {
+          form_driver(this->Form, REQ_PREV_FIELD);
+        }
+      }
+      // pg down
+      else if (key == KEY_NPAGE || key == ctrl('d')) {
+        form_driver(this->Form, REQ_NEXT_PAGE);
+      }
+      // pg up
+      else if (key == KEY_PPAGE || key == ctrl('u')) {
+        form_driver(this->Form, REQ_PREV_PAGE);
+      }
+      // configure
+      else if (key == 'c') {
+        this->Configure();
+      }
+      // display help
+      else if (key == 'h') {
+        getmaxyx(stdscr, y, x);
+
+        FIELD* cur = current_field(this->Form);
+        int findex = field_index(cur);
+        cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
+        const char* curField = lbl->GetValue();
+        const char* helpString = nullptr;
+
+        const char* existingValue =
+          this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
+        if (existingValue) {
+          helpString = this->CMakeInstance->GetState()->GetCacheEntryProperty(
+            curField, "HELPSTRING");
+        }
+        if (helpString) {
+          char* message = new char
+            [strlen(curField) + strlen(helpString) +
+             strlen(
+               "Current option is: \n Help string for this option is: \n") +
+             10];
+          sprintf(
+            message,
+            "Current option is: %s\nHelp string for this option is: %s\n",
+            curField, helpString);
+          this->HelpMessage[1] = message;
+          delete[] message;
+        } else {
+          this->HelpMessage[1] = "";
+        }
+
+        cmCursesLongMessageForm* msgs =
+          new cmCursesLongMessageForm(this->HelpMessage, "Help.");
+        CurrentForm = msgs;
+        msgs->Render(1, 1, x, y);
+        msgs->HandleInput();
+        CurrentForm = this;
+        this->Render(1, 1, x, y);
+        set_current_field(this->Form, cur);
+      }
+      // display last errors
+      else if (key == 'l') {
+        getmaxyx(stdscr, y, x);
+        cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(
+          this->Errors, "Errors occurred during the last pass.");
+        CurrentForm = msgs;
+        msgs->Render(1, 1, x, y);
+        msgs->HandleInput();
+        CurrentForm = this;
+        this->Render(1, 1, x, y);
+      } else if (key == '/') {
+        this->SearchMode = true;
+        this->UpdateStatusBar("Search");
+        this->PrintKeys(1);
+        touchwin(stdscr);
+        refresh();
+      } else if (key == 'n') {
+        if (!this->OldSearchString.empty()) {
+          this->JumpToCacheEntry(this->OldSearchString.c_str());
+        }
+      }
+      // switch advanced on/off
+      else if (key == 't') {
+        if (this->AdvancedMode) {
+          this->AdvancedMode = false;
+        } else {
+          this->AdvancedMode = true;
+        }
+        getmaxyx(stdscr, y, x);
+        this->RePost();
+        this->Render(1, 1, x, y);
+      }
+      // generate and exit
+      else if (key == 'g') {
+        if (this->OkToGenerate) {
+          this->Generate();
+          break;
+        }
+      }
+      // delete cache entry
+      else if (key == 'd' && this->NumberOfVisibleEntries) {
+        this->OkToGenerate = false;
+        FIELD* cur = current_field(this->Form);
+        size_t findex = field_index(cur);
+
+        // make the next or prev. current field after deletion
+        // each entry consists of fields: label, isnew, value
+        // therefore, the label field for the prev. entry is findex-5
+        // and the label field for the next entry is findex+1
+        // (findex always corresponds to the value field)
+        FIELD* nextCur;
+        if (findex == 2) {
+          nextCur = nullptr;
+        } else if (findex == 3 * this->NumberOfVisibleEntries - 1) {
+          nextCur = this->Fields[findex - 5];
+        } else {
+          nextCur = this->Fields[findex + 1];
+        }
+
+        // Get the label widget
+        // each entry consists of fields: label, isnew, value
+        // therefore, the label field for the is findex-2
+        // (findex always corresponds to the value field)
+        cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
+        if (lbl) {
+          this->CMakeInstance->GetState()->RemoveCacheEntry(lbl->GetValue());
+
+          std::string nextVal;
+          if (nextCur) {
+            nextVal =
+              (reinterpret_cast<cmCursesWidget*>(field_userptr(nextCur))
+                 ->GetValue());
+          }
+
+          getmaxyx(stdscr, y, x);
+          this->RemoveEntry(lbl->GetValue());
+          this->RePost();
+          this->Render(1, 1, x, y);
+
+          if (nextCur) {
+            // make the next or prev. current field after deletion
+            nextCur = nullptr;
+            std::vector<cmCursesCacheEntryComposite*>::iterator it;
+            for (it = this->Entries->begin(); it != this->Entries->end();
+                 ++it) {
+              if (nextVal == (*it)->Key) {
+                nextCur = (*it)->Entry->Field;
+              }
+            }
+
+            if (nextCur) {
+              set_current_field(this->Form, nextCur);
+            }
+          }
+        }
+      }
+    }
+
+    touchwin(stdscr);
+    wrefresh(stdscr);
+  }
+}
+
+int cmCursesMainForm::LoadCache(const char* /*unused*/)
+
+{
+  int r = this->CMakeInstance->LoadCache();
+  if (r < 0) {
+    return r;
+  }
+  this->CMakeInstance->SetCacheArgs(this->Args);
+  this->CMakeInstance->PreLoadCMakeFiles();
+  return r;
+}
+
+void cmCursesMainForm::JumpToCacheEntry(const char* astr)
+{
+  std::string str;
+  if (astr) {
+    str = cmSystemTools::LowerCase(astr);
+  }
+
+  if (str.empty()) {
+    return;
+  }
+  FIELD* cur = current_field(this->Form);
+  int start_index = field_index(cur);
+  int findex = start_index;
+  for (;;) {
+    if (!str.empty()) {
+      cmCursesWidget* lbl = nullptr;
+      if (findex >= 0) {
+        lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
+      }
+      if (lbl) {
+        const char* curField = lbl->GetValue();
+        if (curField) {
+          std::string cfld = cmSystemTools::LowerCase(curField);
+          if (cfld.find(str) != std::string::npos && findex != start_index) {
+            break;
+          }
+        }
+      }
+    }
+    if (size_t(findex) >= 3 * this->NumberOfVisibleEntries - 1) {
+      set_current_field(this->Form, this->Fields[2]);
+    } else if (new_page(this->Fields[findex + 1])) {
+      form_driver(this->Form, REQ_NEXT_PAGE);
+    } else {
+      form_driver(this->Form, REQ_NEXT_FIELD);
+    }
+    /*
+    char buffer[1024];
+    sprintf(buffer, "Line: %d != %d / %d\n", findex, idx,
+    this->NumberOfVisibleEntries);
+    touchwin(stdscr);
+    refresh();
+    this->UpdateStatusBar( buffer );
+    usleep(100000);
+    */
+    cur = current_field(this->Form);
+    findex = field_index(cur);
+    if (findex == start_index) {
+      break;
+    }
+  }
+}
+
+const char* cmCursesMainForm::s_ConstHelpMessage =
+  "CMake is used to configure and generate build files for software projects. "
+  "The basic steps for configuring a project with ccmake are as follows:\n\n"
+  "1. Run ccmake in the directory where you want the object and executable "
+  "files to be placed (build directory). If the source directory is not the "
+  "same as this build directory, you have to specify it as an argument on the "
+  "command line.\n\n"
+  "2. When ccmake is run, it will read the configuration files and display "
+  "the current build options. "
+  "If you have run CMake before and have updated the configuration files "
+  "since then, any new entries will be displayed on top and will be marked "
+  "with a *. "
+  "On the other hand, the first time you run ccmake, all build options will "
+  "be new and will be marked as such. "
+  "At this point, you can modify any options (see keys below) you want to "
+  "change. "
+  "When you are satisfied with your changes, press 'c' to have CMake process "
+  "the configuration files. "
+  "Please note that changing some options may cause new ones to appear. These "
+  "will be shown on top and will be marked with *. "
+  "Repeat this procedure until you are satisfied with all the options and "
+  "there are no new entries. "
+  "At this point, a new command will appear: G)enerate and Exit. You can now "
+  "hit 'g' to have CMake generate all the build files (i.e. makefiles or "
+  "project files) and exit. "
+  "At any point during the process, you can exit ccmake with 'q'. However, "
+  "this will not generate/change any build files.\n\n"
+  "ccmake KEYS:\n\n"
+  "Navigation: "
+  "You can use the arrow keys and page up, down to navigate the options. "
+  "Alternatively, you can use the following keys: \n"
+  " C-n or j : next option\n"
+  " C-p or k : previous options\n"
+  " C-d : down one page\n"
+  " C-u : up one page\n\n"
+  "Editing options: "
+  "To change an option  press enter or return. If the current options is a "
+  "boolean, this will toggle its value. "
+  "Otherwise, ccmake will enter edit mode. Alternatively, you can toggle "
+  "a bool variable by pressing space, and enter edit mode with i."
+  "In this mode you can edit an option using arrow keys and backspace. "
+  "Alternatively, you can use the following keys:\n"
+  " C-b : back one character\n"
+  " C-f : forward one character\n"
+  " C-a : go to the beginning of the field\n"
+  " C-e : go to the end of the field\n"
+  " C-d : delete previous character\n"
+  " C-k : kill the rest of the field\n"
+  " Esc : Restore field (discard last changes)\n"
+  " Enter : Leave edit mode\n"
+  "Commands:\n"
+  " q : quit ccmake without generating build files\n"
+  " h : help, shows this screen\n"
+  " c : process the configuration files with the current options\n"
+  " g : generate build files and exit, only available when there are no "
+  "new options and no errors have been detected during last configuration.\n"
+  " l : shows last errors\n"
+  " d : delete an option\n"
+  " t : toggles advanced mode. In normal mode, only the most important "
+  "options are shown. In advanced mode, all options are shown. We recommend "
+  "using normal mode unless you are an expert.\n"
+  " / : search for a variable name.\n";
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
new file mode 100644
index 0000000..7f5b3ca
--- /dev/null
+++ b/Source/CursesDialog/cmCursesMainForm.h
@@ -0,0 +1,160 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesMainForm_h
+#define cmCursesMainForm_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesForm.h"
+#include "cmCursesStandardIncludes.h"
+#include "cmStateTypes.h"
+
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+class cmCursesCacheEntryComposite;
+class cmake;
+
+/** \class cmCursesMainForm
+ * \brief The main page of ccmake
+ *
+ * cmCursesMainForm is the main page of ccmake.
+ */
+class cmCursesMainForm : public cmCursesForm
+{
+  CM_DISABLE_COPY(cmCursesMainForm)
+
+public:
+  cmCursesMainForm(std::vector<std::string> const& args, int initwidth);
+  ~cmCursesMainForm() override;
+
+  /**
+   * Set the widgets which represent the cache entries.
+   */
+  void InitializeUI();
+
+  /**
+   * Handle user input.
+   */
+  void HandleInput() override;
+
+  /**
+   * Display form. Use a window of size width x height, starting
+   * at top, left.
+   */
+  void Render(int left, int top, int width, int height) override;
+
+  /**
+   * Returns true if an entry with the given key is in the
+   * list of current composites.
+   */
+  bool LookForCacheEntry(const std::string& key);
+
+  enum
+  {
+    MIN_WIDTH = 65,
+    MIN_HEIGHT = 6,
+    IDEAL_WIDTH = 80,
+    MAX_WIDTH = 512
+  };
+
+  /**
+   * This method should normally be called only by the form.  The only
+   * exception is during a resize. The optional argument specifies the
+   * string to be displayed in the status bar.
+   */
+  void UpdateStatusBar() override { this->UpdateStatusBar(nullptr); }
+  virtual void UpdateStatusBar(const char* message);
+
+  /**
+   * Display current commands and their keys on the toolbar.  This
+   * method should normally called only by the form.  The only
+   * exception is during a resize. If the optional argument process is
+   * specified and is either 1 (configure) or 2 (generate), then keys
+   * will be displayed accordingly.
+   */
+  void PrintKeys(int process = 0);
+
+  /**
+   * During a CMake run, an error handle should add errors
+   * to be displayed afterwards.
+   */
+  void AddError(const char* message, const char* title) override;
+
+  /**
+   * Used to do a configure. If argument is specified, it does only the check
+   * and not configure.
+   */
+  int Configure(int noconfigure = 0);
+
+  /**
+   * Used to generate
+   */
+  int Generate();
+
+  /**
+   * Used by main program
+   */
+  int LoadCache(const char* dir);
+
+  /**
+   * Progress callback
+   */
+  static void UpdateProgressOld(const char* msg, float prog, void*);
+  static void UpdateProgress(const char* msg, float prog, void*);
+
+protected:
+  // Copy the cache values from the user interface to the actual
+  // cache.
+  void FillCacheManagerFromUI();
+  // Fix formatting of values to a consistent form.
+  void FixValue(cmStateEnums::CacheEntryType type, const std::string& in,
+                std::string& out) const;
+  // Re-post the existing fields. Used to toggle between
+  // normal and advanced modes. Render() should be called
+  // afterwards.
+  void RePost();
+  // Remove an entry from the interface and the cache.
+  void RemoveEntry(const char* value);
+
+  // Jump to the cache entry whose name matches the string.
+  void JumpToCacheEntry(const char* str);
+
+  // Copies of cache entries stored in the user interface
+  std::vector<cmCursesCacheEntryComposite*>* Entries;
+  // Errors produced during last run of cmake
+  std::vector<std::string> Errors;
+  // Command line argumens to be passed to cmake each time
+  // it is run
+  std::vector<std::string> Args;
+  // Message displayed when user presses 'h'
+  // It is: Welcome + info about current entry + common help
+  std::vector<std::string> HelpMessage;
+
+  // Common help
+  static const char* s_ConstHelpMessage;
+
+  // Fields displayed. Includes labels, new entry markers, entries
+  FIELD** Fields;
+  // Where is source of current project
+  std::string WhereSource;
+  // Where is cmake executable
+  std::string WhereCMake;
+  // Number of entries shown (depends on mode -normal or advanced-)
+  size_t NumberOfVisibleEntries;
+  bool AdvancedMode;
+  // Did the iteration converge (no new entries) ?
+  bool OkToGenerate;
+  // Number of pages displayed
+  int NumberOfPages;
+
+  int InitialWidth;
+  cmake* CMakeInstance;
+
+  std::string SearchString;
+  std::string OldSearchString;
+  bool SearchMode;
+};
+
+#endif // cmCursesMainForm_h
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.cxx b/Source/CursesDialog/cmCursesOptionsWidget.cxx
new file mode 100644
index 0000000..a8c4933
--- /dev/null
+++ b/Source/CursesDialog/cmCursesOptionsWidget.cxx
@@ -0,0 +1,84 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesOptionsWidget.h"
+
+#include "cmCursesWidget.h"
+#include "cmStateTypes.h"
+
+#define ctrl(z) ((z)&037)
+
+cmCursesOptionsWidget::cmCursesOptionsWidget(int width, int height, int left,
+                                             int top)
+  : cmCursesWidget(width, height, left, top)
+{
+  this->Type = cmStateEnums::BOOL; // this is a bit of a hack
+  // there is no option type, and string type causes ccmake to cast
+  // the widget into a string widget at some point.  BOOL is safe for
+  // now.
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
+}
+
+bool cmCursesOptionsWidget::HandleInput(int& key, cmCursesMainForm* /*fm*/,
+                                        WINDOW* w)
+{
+  switch (key) {
+    case 10: // 10 == enter
+    case KEY_ENTER:
+      this->NextOption();
+      touchwin(w);
+      wrefresh(w);
+      return true;
+    case KEY_LEFT:
+    case ctrl('b'):
+      touchwin(w);
+      wrefresh(w);
+      this->PreviousOption();
+      return true;
+    case KEY_RIGHT:
+    case ctrl('f'):
+      this->NextOption();
+      touchwin(w);
+      wrefresh(w);
+      return true;
+    default:
+      return false;
+  }
+}
+
+void cmCursesOptionsWidget::AddOption(std::string const& option)
+{
+  this->Options.push_back(option);
+}
+
+void cmCursesOptionsWidget::NextOption()
+{
+  this->CurrentOption++;
+  if (this->CurrentOption > this->Options.size() - 1) {
+    this->CurrentOption = 0;
+  }
+  this->SetValue(this->Options[this->CurrentOption]);
+}
+void cmCursesOptionsWidget::PreviousOption()
+{
+  if (this->CurrentOption == 0) {
+    this->CurrentOption = this->Options.size() - 1;
+  } else {
+    this->CurrentOption--;
+  }
+  this->SetValue(this->Options[this->CurrentOption]);
+}
+
+void cmCursesOptionsWidget::SetOption(const std::string& value)
+{
+  this->CurrentOption = 0; // default to 0 index
+  this->SetValue(value);
+  int index = 0;
+  for (auto const& opt : this->Options) {
+    if (opt == value) {
+      this->CurrentOption = index;
+    }
+    index++;
+  }
+}
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.h b/Source/CursesDialog/cmCursesOptionsWidget.h
new file mode 100644
index 0000000..3e50e2d
--- /dev/null
+++ b/Source/CursesDialog/cmCursesOptionsWidget.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesOptionsWidget_h
+#define cmCursesOptionsWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+
+#include <string>
+#include <vector>
+
+class cmCursesMainForm;
+
+class cmCursesOptionsWidget : public cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesOptionsWidget)
+
+public:
+  cmCursesOptionsWidget(int width, int height, int left, int top);
+
+  // Description:
+  // Handle user input. Called by the container of this widget
+  // when this widget has focus. Returns true if the input was
+  // handled.
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+  void SetOption(const std::string&);
+  void AddOption(std::string const&);
+  void NextOption();
+  void PreviousOption();
+
+protected:
+  std::vector<std::string> Options;
+  std::vector<std::string>::size_type CurrentOption;
+};
+
+#endif // cmCursesOptionsWidget_h
diff --git a/Source/CursesDialog/cmCursesPathWidget.cxx b/Source/CursesDialog/cmCursesPathWidget.cxx
new file mode 100644
index 0000000..05c3279
--- /dev/null
+++ b/Source/CursesDialog/cmCursesPathWidget.cxx
@@ -0,0 +1,81 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesPathWidget.h"
+
+#include "cmCursesMainForm.h"
+#include "cmCursesStringWidget.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+
+#include <vector>
+
+cmCursesPathWidget::cmCursesPathWidget(int width, int height, int left,
+                                       int top)
+  : cmCursesStringWidget(width, height, left, top)
+{
+  this->Type = cmStateEnums::PATH;
+  this->Cycle = false;
+  this->CurrentIndex = 0;
+}
+
+void cmCursesPathWidget::OnType(int& key, cmCursesMainForm* fm, WINDOW* w)
+{
+  this->Cycle = false;
+  this->CurrentIndex = 0;
+  this->LastGlob = "";
+  this->cmCursesStringWidget::OnType(key, fm, w);
+}
+
+void cmCursesPathWidget::OnTab(cmCursesMainForm* fm, WINDOW* w)
+{
+  if (!this->GetString()) {
+    return;
+  }
+  FORM* form = fm->GetForm();
+  form_driver(form, REQ_NEXT_FIELD);
+  form_driver(form, REQ_PREV_FIELD);
+  std::string cstr = this->GetString();
+  cstr = cstr.substr(0, cstr.find_last_not_of(" \t\n\r") + 1);
+  if (this->LastString != cstr) {
+    this->Cycle = false;
+    this->CurrentIndex = 0;
+    this->LastGlob = "";
+  }
+  std::string glob;
+  if (this->Cycle) {
+    glob = this->LastGlob;
+  } else {
+    glob = cstr + "*";
+  }
+  std::vector<std::string> dirs;
+
+  cmSystemTools::SimpleGlob(glob, dirs,
+                            (this->Type == cmStateEnums::PATH ? -1 : 0));
+  if (this->CurrentIndex < dirs.size()) {
+    cstr = dirs[this->CurrentIndex];
+  }
+  if (cstr[cstr.size() - 1] == '*') {
+    cstr = cstr.substr(0, cstr.size() - 1);
+  }
+
+  if (cmSystemTools::FileIsDirectory(cstr)) {
+    cstr += "/";
+  }
+
+  this->SetString(cstr);
+  touchwin(w);
+  wrefresh(w);
+  form_driver(form, REQ_END_FIELD);
+  this->LastGlob = glob;
+  this->LastString = cstr;
+  this->Cycle = true;
+  this->CurrentIndex++;
+  if (this->CurrentIndex >= dirs.size()) {
+    this->CurrentIndex = 0;
+  }
+}
+
+void cmCursesPathWidget::OnReturn(cmCursesMainForm* fm, WINDOW* w)
+{
+  this->cmCursesStringWidget::OnReturn(fm, w);
+}
diff --git a/Source/CursesDialog/cmCursesPathWidget.h b/Source/CursesDialog/cmCursesPathWidget.h
new file mode 100644
index 0000000..bfa0ea3
--- /dev/null
+++ b/Source/CursesDialog/cmCursesPathWidget.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesPathWidget_h
+#define cmCursesPathWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesStringWidget.h"
+
+#include <string>
+
+class cmCursesMainForm;
+
+class cmCursesPathWidget : public cmCursesStringWidget
+{
+  CM_DISABLE_COPY(cmCursesPathWidget)
+
+public:
+  cmCursesPathWidget(int width, int height, int left, int top);
+
+  /**
+   * This method is called when different keys are pressed. The
+   * subclass can have a special implementation handler for this.
+   */
+  void OnTab(cmCursesMainForm* fm, WINDOW* w) override;
+  void OnReturn(cmCursesMainForm* fm, WINDOW* w) override;
+  void OnType(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+
+protected:
+  std::string LastString;
+  std::string LastGlob;
+  bool Cycle;
+  std::string::size_type CurrentIndex;
+};
+
+#endif // cmCursesPathWidget_h
diff --git a/Source/CursesDialog/cmCursesStandardIncludes.h b/Source/CursesDialog/cmCursesStandardIncludes.h
new file mode 100644
index 0000000..332d2af
--- /dev/null
+++ b/Source/CursesDialog/cmCursesStandardIncludes.h
@@ -0,0 +1,32 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesStandardIncludes_h
+#define cmCursesStandardIncludes_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#if defined(__hpux)
+#define _BOOL_DEFINED
+#include <sys/time.h>
+#endif
+
+#include <form.h>
+
+// on some machines move erase and clear conflict with stl
+// so remove them from the namespace
+inline void curses_move(unsigned int x, unsigned int y)
+{
+  move(x, y);
+}
+
+inline void curses_clear()
+{
+  erase();
+  clearok(stdscr, TRUE);
+}
+
+#undef move
+#undef erase
+#undef clear
+
+#endif // cmCursesStandardIncludes_h
diff --git a/Source/CursesDialog/cmCursesStringWidget.cxx b/Source/CursesDialog/cmCursesStringWidget.cxx
new file mode 100644
index 0000000..5e2a329
--- /dev/null
+++ b/Source/CursesDialog/cmCursesStringWidget.cxx
@@ -0,0 +1,209 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesStringWidget.h"
+
+#include "cmCursesForm.h"
+#include "cmCursesMainForm.h"
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+#include "cmStateTypes.h"
+
+#include <stdio.h>
+#include <string.h>
+
+inline int ctrl(int z)
+{
+  return (z & 037);
+}
+
+cmCursesStringWidget::cmCursesStringWidget(int width, int height, int left,
+                                           int top)
+  : cmCursesWidget(width, height, left, top)
+{
+  this->InEdit = false;
+  this->Type = cmStateEnums::STRING;
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
+}
+
+void cmCursesStringWidget::OnTab(cmCursesMainForm* /*unused*/,
+                                 WINDOW* /*unused*/)
+{
+  // FORM* form = fm->GetForm();
+}
+
+void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW* /*unused*/)
+{
+  FORM* form = fm->GetForm();
+  if (this->InEdit) {
+    cmCursesForm::LogMessage("String widget leaving edit.");
+    this->InEdit = false;
+    fm->PrintKeys();
+    delete[] this->OriginalString;
+    // trick to force forms to update the field buffer
+    form_driver(form, REQ_NEXT_FIELD);
+    form_driver(form, REQ_PREV_FIELD);
+    this->Done = true;
+  } else {
+    cmCursesForm::LogMessage("String widget entering edit.");
+    this->InEdit = true;
+    fm->PrintKeys();
+    char* buf = field_buffer(this->Field, 0);
+    this->OriginalString = new char[strlen(buf) + 1];
+    strcpy(this->OriginalString, buf);
+  }
+}
+
+void cmCursesStringWidget::OnType(int& key, cmCursesMainForm* fm,
+                                  WINDOW* /*unused*/)
+{
+  form_driver(fm->GetForm(), key);
+}
+
+bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm,
+                                       WINDOW* w)
+{
+  int x, y;
+
+  FORM* form = fm->GetForm();
+  // when not in edit mode, edit mode is entered by pressing enter or i (vim
+  // binding)
+  // 10 == enter
+  if (!this->InEdit && (key != 10 && key != KEY_ENTER && key != 'i')) {
+    return false;
+  }
+
+  this->OriginalString = nullptr;
+  this->Done = false;
+
+  char debugMessage[128];
+
+  // <Enter> is used to change edit mode (like <Esc> in vi).
+  while (!this->Done) {
+    sprintf(debugMessage, "String widget handling input, key: %d", key);
+    cmCursesForm::LogMessage(debugMessage);
+
+    fm->PrintKeys();
+
+    getmaxyx(stdscr, y, x);
+    // If window too small, handle 'q' only
+    if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
+      // quit
+      if (key == 'q') {
+        return false;
+      }
+      key = getch();
+      continue;
+    }
+
+    // If resize occurred during edit, move out of edit mode
+    if (!this->InEdit && (key != 10 && key != KEY_ENTER && key != 'i')) {
+      return false;
+    }
+    // enter edit with return and i (vim binding)
+    if (!this->InEdit && (key == 10 || key == KEY_ENTER || key == 'i')) {
+      this->OnReturn(fm, w);
+    }
+    // leave edit with return (but not i -- not a toggle)
+    else if (this->InEdit && (key == 10 || key == KEY_ENTER)) {
+      this->OnReturn(fm, w);
+    } else if (key == KEY_DOWN || key == ctrl('n') || key == KEY_UP ||
+               key == ctrl('p') || key == KEY_NPAGE || key == ctrl('d') ||
+               key == KEY_PPAGE || key == ctrl('u')) {
+      this->InEdit = false;
+      delete[] this->OriginalString;
+      // trick to force forms to update the field buffer
+      form_driver(form, REQ_NEXT_FIELD);
+      form_driver(form, REQ_PREV_FIELD);
+      return false;
+    }
+    // esc
+    else if (key == 27) {
+      if (this->InEdit) {
+        this->InEdit = false;
+        fm->PrintKeys();
+        this->SetString(this->OriginalString);
+        delete[] this->OriginalString;
+        touchwin(w);
+        wrefresh(w);
+        return true;
+      }
+    } else if (key == 9) {
+      this->OnTab(fm, w);
+    } else if (key == KEY_LEFT || key == ctrl('b')) {
+      form_driver(form, REQ_PREV_CHAR);
+    } else if (key == KEY_RIGHT || key == ctrl('f')) {
+      form_driver(form, REQ_NEXT_CHAR);
+    } else if (key == ctrl('k')) {
+      form_driver(form, REQ_CLR_EOL);
+    } else if (key == ctrl('a') || key == KEY_HOME) {
+      form_driver(form, REQ_BEG_FIELD);
+    } else if (key == ctrl('e') || key == KEY_END) {
+      form_driver(form, REQ_END_FIELD);
+    } else if (key == 127 || key == KEY_BACKSPACE) {
+      FIELD* cur = current_field(form);
+      form_driver(form, REQ_DEL_PREV);
+      if (current_field(form) != cur) {
+        set_current_field(form, cur);
+      }
+    } else if (key == ctrl('d') || key == KEY_DC) {
+      form_driver(form, REQ_DEL_CHAR);
+    } else {
+      this->OnType(key, fm, w);
+    }
+    if (!this->Done) {
+      touchwin(w);
+      wrefresh(w);
+
+      key = getch();
+    }
+  }
+  return true;
+}
+
+void cmCursesStringWidget::SetString(const std::string& value)
+{
+  this->SetValue(value);
+}
+
+const char* cmCursesStringWidget::GetString()
+{
+  return this->GetValue();
+}
+
+const char* cmCursesStringWidget::GetValue()
+{
+  return field_buffer(this->Field, 0);
+}
+
+bool cmCursesStringWidget::PrintKeys()
+{
+  int x, y;
+  getmaxyx(stdscr, y, x);
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
+    return false;
+  }
+  if (this->InEdit) {
+    char fmt_s[] = "%s";
+    char firstLine[512];
+    // Clean the toolbar
+    memset(firstLine, ' ', sizeof(firstLine));
+    firstLine[511] = '\0';
+    curses_move(y - 4, 0);
+    printw(fmt_s, firstLine);
+    curses_move(y - 3, 0);
+    printw(fmt_s, firstLine);
+    curses_move(y - 2, 0);
+    printw(fmt_s, firstLine);
+    curses_move(y - 1, 0);
+    printw(fmt_s, firstLine);
+
+    curses_move(y - 3, 0);
+    printw(fmt_s, "Editing option, press [enter] to confirm");
+    curses_move(y - 2, 0);
+    printw(fmt_s, "                press [esc] to cancel");
+    return true;
+  }
+  return false;
+}
diff --git a/Source/CursesDialog/cmCursesStringWidget.h b/Source/CursesDialog/cmCursesStringWidget.h
new file mode 100644
index 0000000..90310f6
--- /dev/null
+++ b/Source/CursesDialog/cmCursesStringWidget.h
@@ -0,0 +1,71 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesStringWidget_h
+#define cmCursesStringWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmCursesWidget.h"
+
+#include <string>
+
+class cmCursesMainForm;
+
+/** \class cmCursesStringWidget
+ * \brief A simple entry widget.
+ *
+ * cmCursesStringWdiget is a simple text entry widget.
+ */
+
+class cmCursesStringWidget : public cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesStringWidget)
+
+public:
+  cmCursesStringWidget(int width, int height, int left, int top);
+
+  /**
+   * Handle user input. Called by the container of this widget
+   * when this widget has focus. Returns true if the input was
+   * handled.
+   */
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) override;
+
+  /**
+   * Set/Get the string.
+   */
+  void SetString(const std::string& value);
+  const char* GetString();
+  const char* GetValue() override;
+
+  /**
+   * Set/Get InEdit flag. Can be used to tell the widget to leave
+   * edit mode (in case of a resize for example).
+   */
+  void SetInEdit(bool inedit) { this->InEdit = inedit; }
+  bool GetInEdit() { return this->InEdit; }
+
+  /**
+   * This method is called when different keys are pressed. The
+   * subclass can have a special implementation handler for this.
+   */
+  virtual void OnTab(cmCursesMainForm* fm, WINDOW* w);
+  virtual void OnReturn(cmCursesMainForm* fm, WINDOW* w);
+  virtual void OnType(int& key, cmCursesMainForm* fm, WINDOW* w);
+
+  /**
+   * If there are any, print the widget specific commands
+   * in the toolbar and return true. Otherwise, return false
+   * and the parent widget will print.
+   */
+  bool PrintKeys() override;
+
+protected:
+  // true if the widget is in edit mode
+  bool InEdit;
+  char* OriginalString;
+  bool Done;
+};
+
+#endif // cmCursesStringWidget_h
diff --git a/Source/CursesDialog/cmCursesWidget.cxx b/Source/CursesDialog/cmCursesWidget.cxx
new file mode 100644
index 0000000..cc07411
--- /dev/null
+++ b/Source/CursesDialog/cmCursesWidget.cxx
@@ -0,0 +1,44 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCursesWidget.h"
+
+cmCursesWidget::cmCursesWidget(int width, int height, int left, int top)
+{
+  this->Field = new_field(height, width, top, left, 0, 0);
+  set_field_userptr(this->Field, reinterpret_cast<char*>(this));
+  field_opts_off(this->Field, O_AUTOSKIP);
+  this->Page = 0;
+}
+
+cmCursesWidget::~cmCursesWidget()
+{
+  if (this->Field) {
+    free_field(this->Field);
+    this->Field = nullptr;
+  }
+}
+
+void cmCursesWidget::Move(int x, int y, bool isNewPage)
+{
+  if (!this->Field) {
+    return;
+  }
+
+  move_field(this->Field, y, x);
+  if (isNewPage) {
+    set_new_page(this->Field, true);
+  } else {
+    set_new_page(this->Field, false);
+  }
+}
+
+void cmCursesWidget::SetValue(const std::string& value)
+{
+  this->Value = value;
+  set_field_buffer(this->Field, 0, const_cast<char*>(value.c_str()));
+}
+
+const char* cmCursesWidget::GetValue()
+{
+  return this->Value.c_str();
+}
diff --git a/Source/CursesDialog/cmCursesWidget.h b/Source/CursesDialog/cmCursesWidget.h
new file mode 100644
index 0000000..a44c5e6
--- /dev/null
+++ b/Source/CursesDialog/cmCursesWidget.h
@@ -0,0 +1,71 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCursesWidget_h
+#define cmCursesWidget_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCursesStandardIncludes.h"
+#include "cmStateTypes.h"
+
+#include <string>
+
+class cmCursesMainForm;
+
+class cmCursesWidget
+{
+  CM_DISABLE_COPY(cmCursesWidget)
+
+public:
+  cmCursesWidget(int width, int height, int left, int top);
+  virtual ~cmCursesWidget();
+
+  /**
+   * Handle user input. Called by the container of this widget
+   * when this widget has focus. Returns true if the input was
+   * handled
+   */
+  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) = 0;
+
+  /**
+   * Change the position of the widget. Set isNewPage to true
+   * if this widget marks the beginning of a new page.
+   */
+  virtual void Move(int x, int y, bool isNewPage);
+
+  /**
+   * Set/Get the value (setting the value also changes the contents
+   * of the field buffer).
+   */
+  virtual void SetValue(const std::string& value);
+  virtual const char* GetValue();
+
+  /**
+   * Get the type of the widget (STRING, PATH etc...)
+   */
+  cmStateEnums::CacheEntryType GetType() { return this->Type; }
+
+  /**
+   * If there are any, print the widget specific commands
+   * in the toolbar and return true. Otherwise, return false
+   * and the parent widget will print.
+   */
+  virtual bool PrintKeys() { return false; }
+
+  /**
+   * Set/Get the page this widget is in.
+   */
+  void SetPage(int page) { this->Page = page; }
+  int GetPage() { return this->Page; }
+
+  friend class cmCursesMainForm;
+
+protected:
+  cmStateEnums::CacheEntryType Type;
+  std::string Value;
+  FIELD* Field;
+  // The page in the main form this widget is in
+  int Page;
+};
+
+#endif // cmCursesWidget_h
diff --git a/Source/CursesDialog/form/.NoDartCoverage b/Source/CursesDialog/form/.NoDartCoverage
new file mode 100644
index 0000000..3c99729
--- /dev/null
+++ b/Source/CursesDialog/form/.NoDartCoverage
@@ -0,0 +1 @@
+# do not do coverage in this directory
diff --git a/Source/CursesDialog/form/.gitattributes b/Source/CursesDialog/form/.gitattributes
new file mode 100644
index 0000000..62d728c
--- /dev/null
+++ b/Source/CursesDialog/form/.gitattributes
@@ -0,0 +1 @@
+* -format.clang-format
diff --git a/Source/CursesDialog/form/CMakeLists.txt b/Source/CursesDialog/form/CMakeLists.txt
new file mode 100644
index 0000000..b468f5b
--- /dev/null
+++ b/Source/CursesDialog/form/CMakeLists.txt
@@ -0,0 +1,61 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+project(CMAKE_FORM)
+
+configure_file(cmFormConfigure.h.in "${CMAKE_CURRENT_BINARY_DIR}/cmFormConfigure.h")
+
+add_library(cmForm
+             fld_arg.c
+             fld_attr.c
+             fld_current.c
+             fld_def.c
+             fld_dup.c
+             fld_ftchoice.c
+             fld_ftlink.c
+             fld_info.c
+             fld_just.c
+             fld_link.c
+             fld_max.c
+             fld_move.c
+             fld_newftyp.c
+             fld_opts.c
+             fld_pad.c
+             fld_page.c
+             fld_stat.c
+             fld_type.c
+             fld_user.c
+             frm_cursor.c
+             frm_data.c
+             frm_def.c
+             frm_driver.c
+             frm_hook.c
+             frm_opts.c
+             frm_page.c
+             frm_post.c
+             frm_req_name.c
+             frm_scale.c
+             frm_sub.c
+             frm_user.c
+             frm_win.c
+             fty_alnum.c
+             fty_alpha.c
+             fty_enum.c
+             fty_int.c
+             fty_ipv4.c
+             fty_num.c
+             fty_regex.c
+   )
+
+target_include_directories(cmForm
+  PUBLIC
+    ${CURSES_INCLUDE_PATH}
+    ${CMAKE_FORM_BINARY_DIR}
+    ${CMAKE_FORM_SOURCE_DIR}
+  )
+
+target_link_libraries(cmForm ${CURSES_LIBRARY})
+
+if(CURSES_EXTRA_LIBRARY)
+  target_link_libraries(cmForm ${CURSES_EXTRA_LIBRARY})
+endif()
diff --git a/Source/CursesDialog/form/READ.ME b/Source/CursesDialog/form/READ.ME
new file mode 100644
index 0000000..dd91693
--- /dev/null
+++ b/Source/CursesDialog/form/READ.ME
@@ -0,0 +1,15 @@
+This is a clone of the form library that is available with typical
+System V curses implementations (ETI).
+
+It is modelled after the documentation that comes for this library with
+a 386 based SVR4 implementation (ESIX).  
+
+The development environment was and is an ELF based Linux system.
+
+For things that still need doing, see the TO-DO file in the top-level 
+directory.
+
+Juergen Pfeifer
+
+eMail: juergen.pfeifer@gmx.net
+
diff --git a/Source/CursesDialog/form/cmFormConfigure.h.in b/Source/CursesDialog/form/cmFormConfigure.h.in
new file mode 100644
index 0000000..511c525
--- /dev/null
+++ b/Source/CursesDialog/form/cmFormConfigure.h.in
@@ -0,0 +1,11 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef CMFORMCONFIGURE_H
+#define CMFORMCONFIGURE_H
+
+#cmakedefine CURSES_HAVE_CURSES_H
+#cmakedefine CURSES_HAVE_NCURSES_H
+#cmakedefine CURSES_HAVE_NCURSES_NCURSES_H
+#cmakedefine CURSES_HAVE_NCURSES_CURSES_H
+
+#endif
diff --git a/Source/CursesDialog/form/eti.h b/Source/CursesDialog/form/eti.h
new file mode 100644
index 0000000..cc1c830
--- /dev/null
+++ b/Source/CursesDialog/form/eti.h
@@ -0,0 +1,52 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#ifndef _ETI_ERRNO_H_
+#define _ETI_ERRNO_H_
+
+#define	E_OK			(0)
+#define	E_SYSTEM_ERROR	 	(-1)
+#define	E_BAD_ARGUMENT	 	(-2)
+#define	E_POSTED	 	(-3)
+#define	E_CONNECTED	 	(-4)
+#define	E_BAD_STATE	 	(-5)
+#define	E_NO_ROOM	 	(-6)
+#define	E_NOT_POSTED		(-7)
+#define	E_UNKNOWN_COMMAND	(-8)
+#define	E_NO_MATCH		(-9)
+#define	E_NOT_SELECTABLE	(-10)
+#define	E_NOT_CONNECTED	        (-11)
+#define	E_REQUEST_DENIED	(-12)
+#define	E_INVALID_FIELD	        (-13)
+#define	E_CURRENT		(-14)
+
+#endif
diff --git a/Source/CursesDialog/form/fld_arg.c b/Source/CursesDialog/form/fld_arg.c
new file mode 100644
index 0000000..91ad79f
--- /dev/null
+++ b/Source/CursesDialog/form/fld_arg.c
@@ -0,0 +1,91 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_fieldtype_arg(
+|                            FIELDTYPE *typ,
+|                            void * (* const make_arg)(va_list *),
+|                            void * (* const copy_arg)(const void *),
+|                            void   (* const free_arg)(void *) )
+|   
+|   Description   :  Connects to the type additional arguments necessary
+|                    for a set_field_type call. The various function pointer
+|                    arguments are:
+|                       make_arg : allocates a structure for the field
+|                                  specific parameters.
+|                       copy_arg : duplicate the structure created by
+|                                  make_arg
+|                       free_arg : Release the memory allocated by make_arg
+|                                  or copy_arg
+|
+|                    At least make_arg must be non-NULL.
+|                    You may pass NULL for copy_arg and free_arg if your
+|                    make_arg function doesn't allocate memory and your
+|                    arg fits into the storage for a (void*).
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid argument
++--------------------------------------------------------------------------*/
+int set_fieldtype_arg(FIELDTYPE * typ,
+		      void * (* const make_arg)(va_list *),
+		      void * (* const copy_arg)(const void *),
+		      void   (* const free_arg)(void *))
+{
+  if ( !typ || !make_arg )
+    RETURN(E_BAD_ARGUMENT);
+
+  typ->status |= _HAS_ARGS;
+  typ->makearg = make_arg;
+  typ->copyarg = copy_arg;
+  typ->freearg = free_arg;
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  void *field_arg(const FIELD *field)
+|   
+|   Description   :  Retrieve pointer to the fields argument structure.
+|
+|   Return Values :  Pointer to structure or NULL if none is defined.
++--------------------------------------------------------------------------*/
+void *field_arg(const FIELD * field)
+{
+  return Normalize_Field(field)->arg;
+}
+
+/* fld_arg.c ends here */
diff --git a/Source/CursesDialog/form/fld_attr.c b/Source/CursesDialog/form/fld_attr.c
new file mode 100644
index 0000000..35ea903
--- /dev/null
+++ b/Source/CursesDialog/form/fld_attr.c
@@ -0,0 +1,110 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+MODULE_ID("$Id$")
+
+/*----------------------------------------------------------------------------
+  Field-Attribute manipulation routines
+  --------------------------------------------------------------------------*/
+/* "Template" macro to generate a function to set a fields attribute */
+#define GEN_FIELD_ATTR_SET_FCT( name ) \
+int set_field_ ## name (FIELD * field, chtype attr)\
+{\
+   int res = E_BAD_ARGUMENT;\
+   if ( attr==A_NORMAL || ((attr & A_ATTRIBUTES)==attr) )\
+     {\
+       Normalize_Field( field );\
+       if ((field -> name) != attr)\
+         {\
+           field -> name = attr;\
+           res = _nc_Synchronize_Attributes( field );\
+         }\
+       else\
+       res = E_OK;\
+     }\
+   RETURN(res);\
+}
+
+/* "Template" macro to generate a function to get a fields attribute */
+#define GEN_FIELD_ATTR_GET_FCT( name ) \
+chtype field_ ## name (const FIELD * field)\
+{\
+   return ( A_ATTRIBUTES & (Normalize_Field( field ) -> name) );\
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_fore(FIELD *field, chtype attr)
+|   
+|   Description   :  Sets the foreground of the field used to display the
+|                    field contents.
+|
+|   Return Values :  E_OK             - success
+|                    E_BAD_ARGUMENT   - invalid attributes
+|                    E_SYSTEM_ERROR   - system error
++--------------------------------------------------------------------------*/
+GEN_FIELD_ATTR_SET_FCT( fore )
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  chtype field_fore(const FIELD *)
+|   
+|   Description   :  Retrieve fields foreground attribute
+|
+|   Return Values :  The foreground attribute
++--------------------------------------------------------------------------*/
+GEN_FIELD_ATTR_GET_FCT( fore )
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_back(FIELD *field, chtype attr)
+|   
+|   Description   :  Sets the background of the field used to display the
+|                    fields extend.
+|
+|   Return Values :  E_OK             - success
+|                    E_BAD_ARGUMENT   - invalid attributes
+|                    E_SYSTEM_ERROR   - system error
++--------------------------------------------------------------------------*/
+GEN_FIELD_ATTR_SET_FCT( back )
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform
+|   Function      :  chtype field_back(const 
+|   
+|   Description   :  Retrieve fields background attribute
+|
+|   Return Values :  The background attribute
++--------------------------------------------------------------------------*/
+GEN_FIELD_ATTR_GET_FCT( back )
+
+/* fld_attr.c ends here */
diff --git a/Source/CursesDialog/form/fld_current.c b/Source/CursesDialog/form/fld_current.c
new file mode 100644
index 0000000..d4b1254
--- /dev/null
+++ b/Source/CursesDialog/form/fld_current.c
@@ -0,0 +1,124 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_current_field(FORM  * form,FIELD * field)
+|   
+|   Description   :  Set the current field of the form to the specified one.
+|
+|   Return Values :  E_OK              - success
+|                    E_BAD_ARGUMENT    - invalid form or field pointer
+|                    E_REQUEST_DENIED  - field not selectable
+|                    E_BAD_STATE       - called from a hook routine
+|                    E_INVALID_FIELD   - current field can't be left
+|                    E_SYSTEM_ERROR    - system error
++--------------------------------------------------------------------------*/
+int set_current_field(FORM  * form, FIELD * field)
+{
+  int err = E_OK;
+
+  if ( !form || !field )
+    RETURN(E_BAD_ARGUMENT);
+
+  if ( (form != field->form) || Field_Is_Not_Selectable(field) )
+    RETURN(E_REQUEST_DENIED);
+
+  if (!(form->status & _POSTED))
+    {
+      form->current = field;
+      form->curpage = field->page;
+  }
+  else
+    {
+      if (form->status & _IN_DRIVER) 
+	err = E_BAD_STATE;
+      else
+	{
+	  if (form->current != field)
+	    {
+	      if (!_nc_Internal_Validation(form)) 
+	       err = E_INVALID_FIELD;
+	      else
+		{
+		  Call_Hook(form,fieldterm);
+		  if (field->page != form->curpage)
+		    {
+		      Call_Hook(form,formterm);
+		      err = _nc_Set_Form_Page(form,field->page,field);
+		      Call_Hook(form,forminit);
+		    } 
+		  else 
+		    {
+		      err = _nc_Set_Current_Field(form,field);
+		    }
+		  Call_Hook(form,fieldinit);
+		  _nc_Refresh_Current_Field(form);
+		}
+	    }
+	}
+    }
+  RETURN(err);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD *current_field(const FORM * form)
+|   
+|   Description   :  Return the current field.
+|
+|   Return Values :  Pointer to the current field.
++--------------------------------------------------------------------------*/
+FIELD *current_field(const FORM * form)
+{
+  return Normalize_Form(form)->current;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_index(const FIELD * field)
+|   
+|   Description   :  Return the index of the field in the field-array of
+|                    the form.
+|
+|   Return Values :  >= 0   : field index
+|                    -1     : fieldpointer invalid or field not connected
++--------------------------------------------------------------------------*/
+int field_index(const FIELD * field)
+{
+  return ( (field && field->form) ? field->index : -1 );
+}
+
+/* fld_current.c ends here */
diff --git a/Source/CursesDialog/form/fld_def.c b/Source/CursesDialog/form/fld_def.c
new file mode 100644
index 0000000..00da3b4
--- /dev/null
+++ b/Source/CursesDialog/form/fld_def.c
@@ -0,0 +1,346 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/* this can't be readonly */
+static FIELD default_field = {
+  0,                       /* status */
+  0,                       /* rows   */
+  0,                       /* cols   */
+  0,                       /* frow   */
+  0,                       /* fcol   */
+  0,                       /* drows  */
+  0,                       /* dcols  */
+  0,                       /* maxgrow*/
+  0,                       /* nrow   */
+  0,                       /* nbuf   */
+  NO_JUSTIFICATION,        /* just   */
+  0,                       /* page   */
+  0,                       /* index  */
+  (int)' ',                /* pad    */
+  A_NORMAL,                /* fore   */
+  A_NORMAL,                /* back   */
+  ALL_FIELD_OPTS,          /* opts   */
+  (FIELD *)0,              /* snext  */
+  (FIELD *)0,              /* sprev  */
+  (FIELD *)0,              /* link   */
+  (FORM *)0,               /* form   */
+  (FIELDTYPE *)0,          /* type   */
+  (char *)0,               /* arg    */ 
+  (char *)0,               /* buf    */
+  (char *)0                /* usrptr */
+};
+
+FIELD *_nc_Default_Field = &default_field;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  TypeArgument *_nc_Make_Argument(
+|                              const FIELDTYPE *typ,
+|                              va_list *ap,
+|                              int *err )
+|   
+|   Description   :  Create an argument structure for the specified type.
+|                    Use the type-dependent argument list to construct
+|                    it.
+|
+|   Return Values :  Pointer to argument structure. Maybe NULL.
+|                    In case of an error in *err an errorcounter is increased. 
++--------------------------------------------------------------------------*/
+TypeArgument*
+_nc_Make_Argument(const FIELDTYPE *typ, va_list *ap, int *err)
+{
+  TypeArgument *res = (TypeArgument *)0; 
+  TypeArgument *p;
+
+  if (typ && (typ->status & _HAS_ARGS))
+    {
+      assert(err && ap);
+      if (typ->status & _LINKED_TYPE)
+	{
+	  p = (TypeArgument *)malloc(sizeof(TypeArgument));
+	  if (p) 
+	    {
+	      p->left  = _nc_Make_Argument(typ->left ,ap,err);
+	      p->right = _nc_Make_Argument(typ->right,ap,err);
+	      return p;
+	    }
+	  else
+	    *err += 1;
+      } else 
+	{
+	  assert(typ->makearg != 0);
+	  if ( !(res=(TypeArgument *)typ->makearg(ap)) ) 
+	    *err += 1;
+	}
+    }
+  return res;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  TypeArgument *_nc_Copy_Argument(const FIELDTYPE *typ,
+|                                                    const TypeArgument *argp,
+|                                                    int *err )
+|   
+|   Description   :  Create a copy of an argument structure for the specified 
+|                    type.
+|
+|   Return Values :  Pointer to argument structure. Maybe NULL.
+|                    In case of an error in *err an errorcounter is increased. 
++--------------------------------------------------------------------------*/
+TypeArgument*
+_nc_Copy_Argument(const FIELDTYPE *typ,
+		  const TypeArgument *argp, int *err)
+{
+  TypeArgument *res = (TypeArgument *)0;
+  TypeArgument *p;
+
+  if ( typ && (typ->status & _HAS_ARGS) )
+    {
+      assert(err && argp);
+      if (typ->status & _LINKED_TYPE)
+	{
+	  p = (TypeArgument *)malloc(sizeof(TypeArgument));
+	  if (p)
+	    {
+	      p->left  = _nc_Copy_Argument(typ,argp->left ,err);
+	      p->right = _nc_Copy_Argument(typ,argp->right,err);
+	      return p;
+	    }
+	  *err += 1;
+      } 
+      else 
+	{
+	  if (typ->copyarg)
+	    {
+	      if (!(res = (TypeArgument *)(typ->copyarg((const void *)argp)))) 
+		*err += 1;
+	    }
+	  else
+	    res = (TypeArgument *)argp;
+	}
+    }
+  return res;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  void _nc_Free_Argument(const FIELDTYPE *typ,
+|                                           TypeArgument * argp )
+|   
+|   Description   :  Release memory associated with the argument structure
+|                    for the given fieldtype.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+void
+_nc_Free_Argument(const FIELDTYPE * typ, TypeArgument * argp)
+{
+  if (!typ || !(typ->status & _HAS_ARGS)) 
+    return;
+  
+  if (typ->status & _LINKED_TYPE)
+    {
+      assert(argp != 0);
+      _nc_Free_Argument(typ->left ,argp->left );
+      _nc_Free_Argument(typ->right,argp->right);
+      free(argp);
+    } 
+  else 
+    {
+      if (typ->freearg)
+	typ->freearg((void *)argp);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool _nc_Copy_Type( FIELD *dst, FIELD const *src )
+|   
+|   Description   :  Copy argument structure of field src to field dst
+|
+|   Return Values :  TRUE       - copy worked
+|                    FALSE      - error occurred
++--------------------------------------------------------------------------*/
+bool
+_nc_Copy_Type(FIELD *dst, FIELD const *src)
+{
+  int err = 0;
+
+  assert(dst && src);
+
+  dst->type = src->type;
+  dst->arg  = (void *)_nc_Copy_Argument(src->type,(TypeArgument *)(src->arg),&err);
+
+  if (err)
+    {
+      _nc_Free_Argument(dst->type,(TypeArgument *)(dst->arg));
+      dst->type = (FIELDTYPE *)0;
+      dst->arg  = (void *)0;
+      return FALSE;
+    }
+  else
+    {
+      if (dst->type) 
+	dst->type->ref++;
+      return TRUE;
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  void _nc_Free_Type( FIELD *field )
+|   
+|   Description   :  Release Argument structure for this field
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+void
+_nc_Free_Type(FIELD *field)
+{
+  assert(field != 0);
+  if (field->type) 
+    field->type->ref--;
+  _nc_Free_Argument(field->type,(TypeArgument *)(field->arg));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD *new_field( int rows, int cols, 
+|                                      int frow, int fcol,
+|                                      int nrow, int nbuf )
+|   
+|   Description   :  Create a new field with this many 'rows' and 'cols',
+|                    starting at 'frow/fcol' in the subwindow of the form.
+|                    Allocate 'nrow' off-screen rows and 'nbuf' additional
+|                    buffers. If an error occurs, errno is set to
+|                    
+|                    E_BAD_ARGUMENT - invalid argument
+|                    E_SYSTEM_ERROR - system error
+|
+|   Return Values :  Pointer to the new field or NULL if failure.
++--------------------------------------------------------------------------*/
+FIELD *new_field(int rows, int cols, int frow, int fcol, int nrow, int nbuf)
+{
+  FIELD *New_Field = (FIELD *)0;
+  int err = E_BAD_ARGUMENT;
+
+  if (rows>0  && 
+      cols>0  && 
+      frow>=0 && 
+      fcol>=0 && 
+      nrow>=0 && 
+      nbuf>=0 &&
+      ((err = E_SYSTEM_ERROR) != 0) && /* trick: this resets the default error */
+      (New_Field=(FIELD *)malloc(sizeof(FIELD))) )
+    {
+      *New_Field       = default_field;
+      New_Field->rows  = rows;
+      New_Field->cols  = cols;
+      New_Field->drows = rows + nrow;
+      New_Field->dcols = cols;
+      New_Field->frow  = frow;
+      New_Field->fcol  = fcol;
+      New_Field->nrow  = nrow;
+      New_Field->nbuf  = nbuf;
+      New_Field->link  = New_Field;
+
+      if (_nc_Copy_Type(New_Field,&default_field))
+	{
+	  size_t len;
+
+	  len = Total_Buffer_Size(New_Field);
+	  if ((New_Field->buf = (char *)malloc(len)))
+	    {
+	      /* Prefill buffers with blanks and insert terminating zeroes
+		 between buffers */
+	      int i;
+
+	      memset(New_Field->buf,' ',len);
+	      for(i=0;i<=New_Field->nbuf;i++)
+		{
+		  New_Field->buf[(New_Field->drows*New_Field->cols+1)*(i+1)-1]
+		    = '\0';
+		}
+	      return New_Field;
+	    }
+	}
+    }
+
+  if (New_Field) 
+    free_field(New_Field);
+  
+  SET_ERROR( err );
+  return (FIELD *)0;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int free_field( FIELD *field )
+|   
+|   Description   :  Frees the storage allocated for the field.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid field pointer
+|                    E_CONNECTED    - field is connected
++--------------------------------------------------------------------------*/
+int free_field(FIELD * field)
+{
+  if (!field) 
+    RETURN(E_BAD_ARGUMENT);
+
+  if (field->form)
+    RETURN(E_CONNECTED);
+  
+  if (field == field->link)
+    {
+      if (field->buf) 
+	free(field->buf);
+    }
+  else 
+    {
+      FIELD *f;
+
+      for(f=field;f->link != field;f = f->link) 
+	{}
+      f->link = field->link;
+    }
+  _nc_Free_Type(field);
+  free(field);
+  RETURN(E_OK);
+}
+
+/* fld_def.c ends here */
diff --git a/Source/CursesDialog/form/fld_dup.c b/Source/CursesDialog/form/fld_dup.c
new file mode 100644
index 0000000..1c5301d
--- /dev/null
+++ b/Source/CursesDialog/form/fld_dup.c
@@ -0,0 +1,97 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD *dup_field(FIELD *field, int frow, int fcol)
+|   
+|   Description   :  Duplicates the field at the specified position. All
+|                    field attributes and the buffers are copied.
+|                    If an error occurs, errno is set to
+|                    
+|                    E_BAD_ARGUMENT - invalid argument
+|                    E_SYSTEM_ERROR - system error
+|
+|   Return Values :  Pointer to the new field or NULL if failure
++--------------------------------------------------------------------------*/
+FIELD *dup_field(FIELD * field, int frow, int fcol)
+{
+  FIELD *New_Field = (FIELD *)0;
+  int err = E_BAD_ARGUMENT;
+
+  if (field && (frow>=0) && (fcol>=0) && 
+      ((err=E_SYSTEM_ERROR) != 0) && /* trick : this resets the default error */
+      (New_Field=(FIELD *)malloc(sizeof(FIELD))) )
+    {
+      *New_Field         = *_nc_Default_Field;
+      New_Field->frow    = frow;
+      New_Field->fcol    = fcol;
+      New_Field->link    = New_Field;
+      New_Field->rows    = field->rows;
+      New_Field->cols    = field->cols;
+      New_Field->nrow    = field->nrow;
+      New_Field->drows   = field->drows;
+      New_Field->dcols   = field->dcols;
+      New_Field->maxgrow = field->maxgrow;
+      New_Field->nbuf    = field->nbuf;
+      New_Field->just    = field->just;
+      New_Field->fore    = field->fore;
+      New_Field->back    = field->back;
+      New_Field->pad     = field->pad;
+      New_Field->opts    = field->opts;
+      New_Field->usrptr  = field->usrptr;
+
+      if (_nc_Copy_Type(New_Field,field))
+	{
+	  size_t len;
+
+	  len = Total_Buffer_Size(New_Field);
+	  if ( (New_Field->buf=(char *)malloc(len)) )
+	    {
+	      memcpy(New_Field->buf,field->buf,len);
+	      return New_Field;
+	    }
+	}
+    }
+
+  if (New_Field) 
+    free_field(New_Field);
+
+  SET_ERROR(err);
+  return (FIELD *)0;
+}
+
+/* fld_dup.c ends here */
diff --git a/Source/CursesDialog/form/fld_ftchoice.c b/Source/CursesDialog/form/fld_ftchoice.c
new file mode 100644
index 0000000..bb37073
--- /dev/null
+++ b/Source/CursesDialog/form/fld_ftchoice.c
@@ -0,0 +1,62 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_fieldtype_choice(
+|                          FIELDTYPE *typ,
+|                          bool (* const next_choice)(FIELD *,const void *),
+|                          bool (* const prev_choice)(FIELD *,const void *))
+|
+|   Description   :  Define implementation of enumeration requests.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid arguments
++--------------------------------------------------------------------------*/
+int set_fieldtype_choice(FIELDTYPE * typ,
+			 bool (* const next_choice) (FIELD *,const void *),
+			 bool (* const prev_choice) (FIELD *,const void *))
+{
+  if ( !typ || !next_choice || !prev_choice ) 
+    RETURN(E_BAD_ARGUMENT);
+
+  typ->status |= _HAS_CHOICE;
+  typ->next = next_choice;
+  typ->prev = prev_choice;
+  RETURN(E_OK);
+}
+
+/* fld_ftchoice.c ends here */
diff --git a/Source/CursesDialog/form/fld_ftlink.c b/Source/CursesDialog/form/fld_ftlink.c
new file mode 100644
index 0000000..e98a4ca
--- /dev/null
+++ b/Source/CursesDialog/form/fld_ftlink.c
@@ -0,0 +1,83 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELDTYPE *link_fieldtype(
+|                                FIELDTYPE *type1,
+|                                FIELDTYPE *type2)
+|   
+|   Description   :  Create a new fieldtype built from the two given types.
+|                    They are connected by an logical 'OR'.
+|                    If an error occurs, errno is set to                    
+|                       E_BAD_ARGUMENT  - invalid arguments
+|                       E_SYSTEM_ERROR  - system error (no memory)
+|
+|   Return Values :  Fieldtype pointer or NULL if error occurred.
++--------------------------------------------------------------------------*/
+FIELDTYPE *link_fieldtype(FIELDTYPE * type1, FIELDTYPE * type2)
+{
+  FIELDTYPE *nftyp = (FIELDTYPE *)0;
+
+  if ( type1 && type2 )
+    {
+      nftyp = (FIELDTYPE *)malloc(sizeof(FIELDTYPE));
+      if (nftyp)
+	{
+	  *nftyp = *_nc_Default_FieldType;
+	  nftyp->status |= _LINKED_TYPE;
+	  if ((type1->status & _HAS_ARGS) || (type2->status & _HAS_ARGS) )
+	    nftyp->status |= _HAS_ARGS;
+	  if ((type1->status & _HAS_CHOICE) || (type2->status & _HAS_CHOICE) )
+	    nftyp->status |= _HAS_CHOICE;
+	  nftyp->left  = type1;
+	  nftyp->right = type2; 
+	  type1->ref++;
+	  type2->ref++;
+	}
+      else
+	{
+	  SET_ERROR( E_SYSTEM_ERROR );
+	}
+    }
+  else
+    {
+      SET_ERROR( E_BAD_ARGUMENT );
+    }
+  return nftyp;
+}
+
+/* fld_ftlink.c ends here */
diff --git a/Source/CursesDialog/form/fld_info.c b/Source/CursesDialog/form/fld_info.c
new file mode 100644
index 0000000..1ba92c8
--- /dev/null
+++ b/Source/CursesDialog/form/fld_info.c
@@ -0,0 +1,91 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_info(const FIELD *field,
+|                                   int *rows, int *cols,
+|                                   int *frow, int *fcol,
+|                                   int *nrow, int *nbuf)
+|   
+|   Description   :  Retrieve infos about the fields creation parameters.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid field pointer
++--------------------------------------------------------------------------*/
+int field_info(const FIELD *field,
+	       int *rows, int *cols, 
+	       int *frow, int *fcol, 
+	       int *nrow, int *nbuf)
+{
+  if (!field) 
+    RETURN(E_BAD_ARGUMENT);
+
+  if (rows) *rows = field->rows;
+  if (cols) *cols = field->cols;
+  if (frow) *frow = field->frow;
+  if (fcol) *fcol = field->fcol;
+  if (nrow) *nrow = field->nrow;
+  if (nbuf) *nbuf = field->nbuf;
+  RETURN(E_OK);
+}
+	
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int dynamic_field_info(const FIELD *field,
+|                                           int *drows, int *dcols,
+|                                           int *maxgrow)
+|   
+|   Description   :  Retrieve information about a dynamic fields current
+|                    dynamic parameters.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid argument
++--------------------------------------------------------------------------*/
+int dynamic_field_info(const FIELD *field,
+		       int *drows, int *dcols, int *maxgrow)
+{
+  if (!field)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (drows)   *drows   = field->drows;
+  if (dcols)   *dcols   = field->dcols;
+  if (maxgrow) *maxgrow = field->maxgrow;
+
+  RETURN(E_OK);
+}
+
+/* fld_info.c ends here */
diff --git a/Source/CursesDialog/form/fld_just.c b/Source/CursesDialog/form/fld_just.c
new file mode 100644
index 0000000..7015654
--- /dev/null
+++ b/Source/CursesDialog/form/fld_just.c
@@ -0,0 +1,81 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_just(FIELD *field, int just)
+|   
+|   Description   :  Set the fields type of justification.
+|
+|   Return Values :  E_OK            - success
+|                    E_BAD_ARGUMENT  - one of the arguments was incorrect
+|                    E_SYSTEM_ERROR  - system error
++--------------------------------------------------------------------------*/
+int set_field_just(FIELD * field, int just)
+{
+  int res = E_BAD_ARGUMENT;
+
+  if ((just==NO_JUSTIFICATION)  ||
+      (just==JUSTIFY_LEFT)	||
+      (just==JUSTIFY_CENTER)	||
+      (just==JUSTIFY_RIGHT)	)
+    {
+      Normalize_Field( field );
+      if (field->just != just)
+	{
+	  field->just = just;
+	  res = _nc_Synchronize_Attributes( field );
+	}
+      else
+	res = E_OK;
+    }
+  RETURN(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_just( const FIELD *field )
+|   
+|   Description   :  Retrieve the fields type of justification
+|
+|   Return Values :  The justification type.
++--------------------------------------------------------------------------*/
+int field_just(const FIELD * field)
+{
+  return Normalize_Field( field )->just;
+}
+
+/* fld_just.c ends here */
diff --git a/Source/CursesDialog/form/fld_link.c b/Source/CursesDialog/form/fld_link.c
new file mode 100644
index 0000000..164f51b
--- /dev/null
+++ b/Source/CursesDialog/form/fld_link.c
@@ -0,0 +1,90 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD *link_field(FIELD *field, int frow, int fcol)  
+|   
+|   Description   :  Duplicates the field at the specified position. The
+|                    new field shares its buffers with the original one,
+|                    the attributes are independent.
+|                    If an error occurs, errno is set to
+|                    
+|                    E_BAD_ARGUMENT - invalid argument
+|                    E_SYSTEM_ERROR - system error
+|
+|   Return Values :  Pointer to the new field or NULL if failure
++--------------------------------------------------------------------------*/
+FIELD *link_field(FIELD * field, int frow, int fcol)
+{
+  FIELD *New_Field = (FIELD *)0;
+  int err = E_BAD_ARGUMENT;
+
+  if (field && (frow>=0) && (fcol>=0) &&
+      ((err=E_SYSTEM_ERROR) != 0) && /* trick: this resets the default error */
+      (New_Field = (FIELD *)malloc(sizeof(FIELD))) )
+    {
+      *New_Field        = *_nc_Default_Field;
+      New_Field->frow   = frow;
+      New_Field->fcol   = fcol;
+      New_Field->link   = field->link;
+      field->link       = New_Field;
+      New_Field->buf    = field->buf;
+      New_Field->rows   = field->rows;
+      New_Field->cols   = field->cols;
+      New_Field->nrow   = field->nrow;
+      New_Field->nbuf   = field->nbuf;
+      New_Field->drows  = field->drows;
+      New_Field->dcols  = field->dcols;
+      New_Field->maxgrow= field->maxgrow;
+      New_Field->just   = field->just;
+      New_Field->fore   = field->fore;
+      New_Field->back   = field->back;
+      New_Field->pad    = field->pad;
+      New_Field->opts   = field->opts;
+      New_Field->usrptr = field->usrptr;
+      if (_nc_Copy_Type(New_Field,field)) 
+	return New_Field;
+    }
+
+  if (New_Field) 
+    free_field(New_Field);
+
+  SET_ERROR( err );
+  return (FIELD *)0;
+}
+
+/* fld_link.c ends here */
diff --git a/Source/CursesDialog/form/fld_max.c b/Source/CursesDialog/form/fld_max.c
new file mode 100644
index 0000000..cca8dc5
--- /dev/null
+++ b/Source/CursesDialog/form/fld_max.c
@@ -0,0 +1,74 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_max_field(FIELD *field, int maxgrow)
+|   
+|   Description   :  Set the maximum growth for a dynamic field. If maxgrow=0
+|                    the field may grow to any possible size.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid argument
++--------------------------------------------------------------------------*/
+int set_max_field(FIELD *field, int maxgrow)
+{
+  if (!field || (maxgrow<0))
+    RETURN(E_BAD_ARGUMENT);
+  else
+    {
+      bool single_line_field = Single_Line_Field(field);
+
+      if (maxgrow>0)
+	{
+	  if (( single_line_field && (maxgrow < field->dcols)) ||
+	      (!single_line_field && (maxgrow < field->drows)))
+	    RETURN(E_BAD_ARGUMENT);
+	}
+      field->maxgrow = maxgrow;
+      field->status &= ~_MAY_GROW;
+      if (!(field->opts & O_STATIC))
+	{
+	  if ((maxgrow==0) ||
+	      ( single_line_field && (field->dcols < maxgrow)) ||
+	      (!single_line_field && (field->drows < maxgrow)))
+	    field->status |= _MAY_GROW;
+	}
+    }
+  RETURN(E_OK);
+}
+		  
+/* fld_max.c ends here */
diff --git a/Source/CursesDialog/form/fld_move.c b/Source/CursesDialog/form/fld_move.c
new file mode 100644
index 0000000..2293477
--- /dev/null
+++ b/Source/CursesDialog/form/fld_move.c
@@ -0,0 +1,62 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int move_field(FIELD *field,int frow, int fcol)
+|   
+|   Description   :  Moves the disconnected field to the new location in
+|                    the forms subwindow.
+|
+|   Return Values :  E_OK            - success
+|                    E_BAD_ARGUMENT  - invalid argument passed
+|                    E_CONNECTED     - field is connected
++--------------------------------------------------------------------------*/
+int move_field(FIELD *field, int frow, int fcol)
+{
+  if ( !field || (frow<0) || (fcol<0) ) 
+    RETURN(E_BAD_ARGUMENT);
+
+  if (field->form) 
+    RETURN(E_CONNECTED);
+
+  field->frow = frow;
+  field->fcol = fcol;
+  RETURN(E_OK);
+}
+
+/* fld_move.c ends here */
+
diff --git a/Source/CursesDialog/form/fld_newftyp.c b/Source/CursesDialog/form/fld_newftyp.c
new file mode 100644
index 0000000..b839f19
--- /dev/null
+++ b/Source/CursesDialog/form/fld_newftyp.c
@@ -0,0 +1,125 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+static FIELDTYPE const default_fieldtype = {
+  0,                   /* status                                      */
+  0L,                  /* reference count                             */
+  (FIELDTYPE *)0,      /* pointer to left  operand                    */
+  (FIELDTYPE *)0,      /* pointer to right operand                    */
+  NULL,                /* makearg function                            */
+  NULL,                /* copyarg function                            */
+  NULL,                /* freearg function                            */
+  NULL,                /* field validation function                   */
+  NULL,                /* Character check function                    */
+  NULL,                /* enumerate next function                     */
+  NULL                 /* enumerate previous function                 */
+};
+
+const FIELDTYPE* _nc_Default_FieldType = &default_fieldtype;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELDTYPE *new_fieldtype(
+|                       bool (* const field_check)(FIELD *,const void *),
+|                       bool (* const char_check) (int, const void *) ) 
+|   
+|   Description   :  Create a new fieldtype. The application programmer must
+|                    write a field_check and a char_check function and give
+|                    them as input to this call.
+|                    If an error occurs, errno is set to                    
+|                       E_BAD_ARGUMENT  - invalid arguments
+|                       E_SYSTEM_ERROR  - system error (no memory)
+|
+|   Return Values :  Fieldtype pointer or NULL if error occurred
++--------------------------------------------------------------------------*/
+FIELDTYPE *new_fieldtype(
+ bool (* const field_check)(FIELD *,const void *),
+ bool (* const char_check) (int,const void *) )
+{
+  FIELDTYPE *nftyp = (FIELDTYPE *)0;
+  
+  if ( (field_check) || (char_check) )
+    {
+      nftyp = (FIELDTYPE *)malloc(sizeof(FIELDTYPE));
+      if (nftyp)
+	{
+	  *nftyp = default_fieldtype;
+	  nftyp->fcheck = field_check;
+	  nftyp->ccheck = char_check;
+	}
+      else
+	{
+	  SET_ERROR( E_SYSTEM_ERROR );
+	}
+    }
+  else
+    {
+      SET_ERROR( E_BAD_ARGUMENT );
+    }
+  return nftyp;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int free_fieldtype(FIELDTYPE *typ)
+|   
+|   Description   :  Release the memory associated with this fieldtype.
+|
+|   Return Values :  E_OK            - success
+|                    E_CONNECTED     - there are fields referencing the type
+|                    E_BAD_ARGUMENT  - invalid fieldtype pointer
++--------------------------------------------------------------------------*/
+int free_fieldtype(FIELDTYPE *typ)
+{
+  if (!typ)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (typ->ref!=0)
+    RETURN(E_CONNECTED);
+
+  if (typ->status & _RESIDENT)
+    RETURN(E_CONNECTED);
+
+  if (typ->status & _LINKED_TYPE)
+    {
+      if (typ->left ) typ->left->ref--;
+      if (typ->right) typ->right->ref--;
+    }
+  free(typ);
+  RETURN(E_OK);
+}
+
+/* fld_newftyp.c ends here */
diff --git a/Source/CursesDialog/form/fld_opts.c b/Source/CursesDialog/form/fld_opts.c
new file mode 100644
index 0000000..234634b
--- /dev/null
+++ b/Source/CursesDialog/form/fld_opts.c
@@ -0,0 +1,124 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*----------------------------------------------------------------------------
+  Field-Options manipulation routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_opts(FIELD *field, Field_Options opts)
+|   
+|   Description   :  Turns on the named options for this field and turns
+|                    off all the remaining options.
+|
+|   Return Values :  E_OK            - success
+|                    E_CURRENT       - the field is the current field
+|                    E_BAD_ARGUMENT  - invalid options
+|                    E_SYSTEM_ERROR  - system error
++--------------------------------------------------------------------------*/
+int set_field_opts(FIELD * field, Field_Options opts)
+{
+  int res = E_BAD_ARGUMENT;
+  opts &= ALL_FIELD_OPTS;
+  if (!(opts & ~ALL_FIELD_OPTS))
+    res = _nc_Synchronize_Options( Normalize_Field(field), opts );
+  RETURN(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Field_Options field_opts(const FIELD *field)
+|   
+|   Description   :  Retrieve the fields options.
+|
+|   Return Values :  The options.
++--------------------------------------------------------------------------*/
+Field_Options field_opts(const FIELD * field)
+{
+  return ALL_FIELD_OPTS & Normalize_Field( field )->opts;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_opts_on(FIELD *field, Field_Options opts)
+|   
+|   Description   :  Turns on the named options for this field and all the 
+|                    remaining options are unchanged.
+|
+|   Return Values :  E_OK            - success
+|                    E_CURRENT       - the field is the current field
+|                    E_BAD_ARGUMENT  - invalid options
+|                    E_SYSTEM_ERROR  - system error
++--------------------------------------------------------------------------*/
+int field_opts_on(FIELD * field, Field_Options opts)
+{
+  int res = E_BAD_ARGUMENT;
+
+  opts &= ALL_FIELD_OPTS;
+  if (!(opts & ~ALL_FIELD_OPTS))
+    {
+      Normalize_Field( field );
+      res = _nc_Synchronize_Options( field, field->opts | opts );
+    }
+  RETURN(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_opts_off(FIELD *field, Field_Options opts)
+|   
+|   Description   :  Turns off the named options for this field and all the 
+|                    remaining options are unchanged.
+|
+|   Return Values :  E_OK            - success
+|                    E_CURRENT       - the field is the current field
+|                    E_BAD_ARGUMENT  - invalid options
+|                    E_SYSTEM_ERROR  - system error
++--------------------------------------------------------------------------*/
+int field_opts_off(FIELD  * field, Field_Options opts)
+{
+  int res = E_BAD_ARGUMENT;
+
+  opts &= ALL_FIELD_OPTS;
+  if (!(opts & ~ALL_FIELD_OPTS))
+    {
+      Normalize_Field( field );
+      res = _nc_Synchronize_Options( field, field->opts & ~opts );
+    }
+  RETURN(res);
+}	
+
+/* fld_opts.c ends here */
diff --git a/Source/CursesDialog/form/fld_pad.c b/Source/CursesDialog/form/fld_pad.c
new file mode 100644
index 0000000..4598340
--- /dev/null
+++ b/Source/CursesDialog/form/fld_pad.c
@@ -0,0 +1,78 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_pad(FIELD *field, int ch)
+|   
+|   Description   :  Set the pad character used to fill the field. This must
+|                    be a printable character.
+|
+|   Return Values :  E_OK           - success
+|                    E_BAD_ARGUMENT - invalid field pointer or pad character
+|                    E_SYSTEM_ERROR - system error
++--------------------------------------------------------------------------*/
+int set_field_pad(FIELD  * field, int ch)
+{
+  int res = E_BAD_ARGUMENT;
+
+  Normalize_Field( field );
+  if (isprint((unsigned char)ch))
+    {
+      if (field->pad != ch)
+	{
+	  field->pad = ch;
+	  res = _nc_Synchronize_Attributes( field );
+	}
+      else
+	res = E_OK;
+    }
+  RETURN(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_pad(const FIELD *field)
+|   
+|   Description   :  Retrieve the fields pad character.
+|
+|   Return Values :  The pad character.
++--------------------------------------------------------------------------*/
+int field_pad(const FIELD * field)
+{
+  return Normalize_Field( field )->pad;
+}
+
+/* fld_pad.c ends here */
diff --git a/Source/CursesDialog/form/fld_page.c b/Source/CursesDialog/form/fld_page.c
new file mode 100644
index 0000000..408e712
--- /dev/null
+++ b/Source/CursesDialog/form/fld_page.c
@@ -0,0 +1,76 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_new_page(FIELD *field, bool new_page_flag)
+|   
+|   Description   :  Marks the field as the beginning of a new page of 
+|                    the form.
+|
+|   Return Values :  E_OK         - success
+|                    E_CONNECTED  - field is connected
++--------------------------------------------------------------------------*/
+int set_new_page(FIELD * field, bool new_page_flag)
+{
+  Normalize_Field(field);
+  if (field->form) 
+    RETURN(E_CONNECTED);
+
+  if (new_page_flag) 
+    field->status |= _NEWPAGE;
+  else
+    field->status &= ~_NEWPAGE;
+
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool new_page(const FIELD *field)
+|   
+|   Description   :  Retrieve the info whether or not the field starts a
+|                    new page on the form.
+|
+|   Return Values :  TRUE  - field starts a new page
+|                    FALSE - field doesn't start a new page
++--------------------------------------------------------------------------*/
+bool new_page(const FIELD * field)
+{
+  return (Normalize_Field(field)->status & _NEWPAGE)  ? TRUE : FALSE;
+}
+
+/* fld_page.c ends here */
diff --git a/Source/CursesDialog/form/fld_stat.c b/Source/CursesDialog/form/fld_stat.c
new file mode 100644
index 0000000..ee6831b
--- /dev/null
+++ b/Source/CursesDialog/form/fld_stat.c
@@ -0,0 +1,73 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_status(FIELD *field, bool status)
+|   
+|   Description   :  Set or clear the 'changed' indication flag for that
+|                    fields primary buffer.
+|
+|   Return Values :  E_OK            - success
++--------------------------------------------------------------------------*/
+int set_field_status(FIELD * field, bool status)
+{
+  Normalize_Field( field );
+
+  if (status)
+    field->status |= _CHANGED;
+  else
+    field->status &= ~_CHANGED;
+
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool field_status(const FIELD *field)
+|   
+|   Description   :  Retrieve the value of the 'changed' indication flag
+|                    for that fields primary buffer. 
+|
+|   Return Values :  TRUE  - buffer has been changed
+|                    FALSE - buffer has not been changed
++--------------------------------------------------------------------------*/
+bool field_status(const FIELD * field)
+{
+  return ((Normalize_Field(field)->status & _CHANGED) ? TRUE : FALSE);
+}
+
+/* fld_stat.c ends here */
diff --git a/Source/CursesDialog/form/fld_type.c b/Source/CursesDialog/form/fld_type.c
new file mode 100644
index 0000000..6c9def2
--- /dev/null
+++ b/Source/CursesDialog/form/fld_type.c
@@ -0,0 +1,51 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELDTYPE *field_type(const FIELD *field)
+|   
+|   Description   :  Retrieve the associated fieldtype for this field.
+|
+|   Return Values :  Pointer to fieldtype of NULL if none is defined.
++--------------------------------------------------------------------------*/
+FIELDTYPE *field_type(const FIELD * field)
+{
+  return Normalize_Field(field)->type;
+}
+
+/* fld_type.c ends here */
diff --git a/Source/CursesDialog/form/fld_user.c b/Source/CursesDialog/form/fld_user.c
new file mode 100644
index 0000000..3287b5b
--- /dev/null
+++ b/Source/CursesDialog/form/fld_user.c
@@ -0,0 +1,67 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_userptr(FIELD *field, void *usrptr)
+|   
+|   Description   :  Set the pointer that is reserved in any field to store
+|                    application relevant information
+|
+|   Return Values :  E_OK         - on success
++--------------------------------------------------------------------------*/
+int set_field_userptr(FIELD * field, void  *usrptr)
+{
+  Normalize_Field( field )->usrptr = usrptr;
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  void *field_userptr(const FIELD *field)
+|   
+|   Description   :  Return the pointer that is reserved in any field to
+|                    store application relevant information.
+|
+|   Return Values :  Value of pointer. If no such pointer has been set,
+|                    NULL is returned
++--------------------------------------------------------------------------*/
+void *field_userptr(const FIELD *field)
+{
+  return Normalize_Field( field )->usrptr;
+}
+
+/* fld_user.c ends here */
diff --git a/Source/CursesDialog/form/form.h b/Source/CursesDialog/form/form.h
new file mode 100644
index 0000000..39ed75a
--- /dev/null
+++ b/Source/CursesDialog/form/form.h
@@ -0,0 +1,407 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#ifndef FORM_H
+#define FORM_H
+
+#include "cmFormConfigure.h"
+
+/* figure out which curses.h to include */
+# if defined(CURSES_HAVE_NCURSES_H)
+#  include <ncurses.h>
+# elif defined(CURSES_HAVE_NCURSES_NCURSES_H)
+#  include <ncurses/ncurses.h>
+# elif defined(CURSES_HAVE_NCURSES_CURSES_H)
+#  include <ncurses/curses.h>
+# else
+#  if defined(__hpux)
+#   if defined(_XOPEN_SOURCE_EXTENDED)
+#    define HAVE__XOPEN_SOURCE_EXTENDED
+#   else
+#    define _XOPEN_SOURCE_EXTENDED
+#   endif
+#  endif
+#  include <curses.h>
+#  if defined(__hpux) && !defined(HAVE__XOPEN_SOURCE_EXTENDED)
+#   undef _XOPEN_SOURCE_EXTENDED
+#  endif
+# endif
+
+#include <eti.h>
+#include <stdarg.h>
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+typedef int Form_Options;
+typedef int Field_Options;
+
+        /**********
+        *  _PAGE  *
+        **********/
+
+typedef struct {
+  short pmin;     /* index of first field on page            */
+  short pmax;     /* index of last field on page             */
+  short smin;     /* index of top leftmost field on page     */
+  short smax;     /* index of bottom rightmost field on page */
+} _PAGE;
+
+        /**********
+        *  FIELD  *
+        **********/
+
+typedef struct fieldnode {
+  unsigned short        status;   /* flags                      */
+  short                 rows;     /* size in rows               */
+  short                 cols;     /* size in cols               */
+  short                 frow;     /* first row                  */
+  short                 fcol;     /* first col                  */
+  int                   drows;    /* dynamic rows               */
+  int                   dcols;    /* dynamic cols               */
+  int                   maxgrow;  /* maximum field growth       */
+  int                   nrow;     /* offscreen rows             */
+  short                 nbuf;     /* additional buffers         */
+  short                 just;     /* justification              */
+  short                 page;     /* page on form               */
+  short                 index;    /* into form -> field         */
+  int                   pad;      /* pad character              */
+  chtype                fore;     /* foreground attribute       */
+  chtype                back;     /* background attribute       */
+  Field_Options         opts;     /* options                    */
+  struct fieldnode *    snext;    /* sorted order pointer       */
+  struct fieldnode *    sprev;    /* sorted order pointer       */
+  struct fieldnode *    link;     /* linked field chain         */
+  struct formnode *     form;     /* containing form            */
+  struct typenode *     type;     /* field type                 */
+  void *                arg;      /* argument for type          */
+  char *                buf;      /* field buffers              */
+  void *                usrptr;   /* user pointer               */
+} FIELD;
+
+        /**************
+        *  FIELDTYPE  *
+        **************/
+
+typedef struct typenode {
+  unsigned short        status;                /* flags                */
+  long                  ref;                   /* reference count      */
+  struct typenode *     left;                  /* ptr to operand for | */
+  struct typenode *     right;                 /* ptr to operand for | */
+
+  void* (*makearg)(va_list *);                 /* make fieldtype arg   */
+  void* (*copyarg)(const void *);              /* copy fieldtype arg   */
+  void  (*freearg)(void *);                    /* free fieldtype arg   */
+
+  bool  (*fcheck)(FIELD *,const void *);       /* field validation     */
+  bool  (*ccheck)(int,const void *);           /* character validation */
+
+  bool  (*next)(FIELD *,const void *);         /* enumerate next value */
+  bool  (*prev)(FIELD *,const void *);         /* enumerate prev value */
+
+} FIELDTYPE;
+
+        /*********
+        *  FORM  *
+        *********/
+
+typedef struct formnode {
+  unsigned short        status;   /* flags                      */
+  short                 rows;     /* size in rows               */
+  short                 cols;     /* size in cols               */
+  int                   currow;   /* current row in field window*/
+  int                   curcol;   /* current col in field window*/
+  int                   toprow;   /* in scrollable field window */
+  int                   begincol; /* in horiz. scrollable field */
+  short                 maxfield; /* number of fields           */
+  short                 maxpage;  /* number of pages            */
+  short                 curpage;  /* index into page            */
+  Form_Options          opts;     /* options                    */
+  WINDOW *              win;      /* window                     */
+  WINDOW *              sub;      /* subwindow                  */
+  WINDOW *              w;        /* window for current field   */
+  FIELD **              field;    /* field [maxfield]           */
+  FIELD *               current;  /* current field              */
+  _PAGE *               page;     /* page [maxpage]             */
+  void *                usrptr;   /* user pointer               */
+
+  void                  (*forminit)(struct formnode *);
+  void                  (*formterm)(struct formnode *);
+  void                  (*fieldinit)(struct formnode *);
+  void                  (*fieldterm)(struct formnode *);
+
+} FORM;
+
+typedef void (*Form_Hook)(FORM *);
+
+        /***************************
+        *  miscellaneous #defines  *
+        ***************************/
+
+/* field justification */
+#define NO_JUSTIFICATION        (0)
+#define JUSTIFY_LEFT            (1)
+#define JUSTIFY_CENTER          (2)
+#define JUSTIFY_RIGHT           (3)
+
+/* field options */
+#define O_VISIBLE               (0x0001)
+#define O_ACTIVE                (0x0002)
+#define O_PUBLIC                (0x0004)
+#define O_EDIT                  (0x0008)
+#define O_WRAP                  (0x0010)
+#define O_BLANK                 (0x0020)
+#define O_AUTOSKIP              (0x0040)
+#define O_NULLOK                (0x0080)
+#define O_PASSOK                (0x0100)
+#define O_STATIC                (0x0200)
+
+/* form options */
+#define O_NL_OVERLOAD           (0x0001)
+#define O_BS_OVERLOAD           (0x0002)
+
+/* form driver commands */
+#define REQ_NEXT_PAGE    (KEY_MAX + 1)  /* move to next page            */
+#define REQ_PREV_PAGE    (KEY_MAX + 2)  /* move to previous page        */
+#define REQ_FIRST_PAGE   (KEY_MAX + 3)  /* move to first page           */
+#define REQ_LAST_PAGE    (KEY_MAX + 4)  /* move to last page            */
+
+#define REQ_NEXT_FIELD   (KEY_MAX + 5)  /* move to next field           */
+#define REQ_PREV_FIELD   (KEY_MAX + 6)  /* move to previous field       */
+#define REQ_FIRST_FIELD  (KEY_MAX + 7)  /* move to first field          */
+#define REQ_LAST_FIELD   (KEY_MAX + 8)  /* move to last field           */
+#define REQ_SNEXT_FIELD  (KEY_MAX + 9)  /* move to sorted next field    */
+#define REQ_SPREV_FIELD  (KEY_MAX + 10) /* move to sorted prev field    */
+#define REQ_SFIRST_FIELD (KEY_MAX + 11) /* move to sorted first field   */
+#define REQ_SLAST_FIELD  (KEY_MAX + 12) /* move to sorted last field    */
+#define REQ_LEFT_FIELD   (KEY_MAX + 13) /* move to left to field        */
+#define REQ_RIGHT_FIELD  (KEY_MAX + 14) /* move to right to field       */
+#define REQ_UP_FIELD     (KEY_MAX + 15) /* move to up to field          */
+#define REQ_DOWN_FIELD   (KEY_MAX + 16) /* move to down to field        */
+
+#define REQ_NEXT_CHAR    (KEY_MAX + 17) /* move to next char in field   */
+#define REQ_PREV_CHAR    (KEY_MAX + 18) /* move to prev char in field   */
+#define REQ_NEXT_LINE    (KEY_MAX + 19) /* move to next line in field   */
+#define REQ_PREV_LINE    (KEY_MAX + 20) /* move to prev line in field   */
+#define REQ_NEXT_WORD    (KEY_MAX + 21) /* move to next word in field   */
+#define REQ_PREV_WORD    (KEY_MAX + 22) /* move to prev word in field   */
+#define REQ_BEG_FIELD    (KEY_MAX + 23) /* move to first char in field  */
+#define REQ_END_FIELD    (KEY_MAX + 24) /* move after last char in fld  */
+#define REQ_BEG_LINE     (KEY_MAX + 25) /* move to beginning of line    */
+#define REQ_END_LINE     (KEY_MAX + 26) /* move after last char in line */
+#define REQ_LEFT_CHAR    (KEY_MAX + 27) /* move left in field           */
+#define REQ_RIGHT_CHAR   (KEY_MAX + 28) /* move right in field          */
+#define REQ_UP_CHAR      (KEY_MAX + 29) /* move up in field             */
+#define REQ_DOWN_CHAR    (KEY_MAX + 30) /* move down in field           */
+
+#define REQ_NEW_LINE     (KEY_MAX + 31) /* insert/overlay new line      */
+#define REQ_INS_CHAR     (KEY_MAX + 32) /* insert blank char at cursor  */
+#define REQ_INS_LINE     (KEY_MAX + 33) /* insert blank line at cursor  */
+#define REQ_DEL_CHAR     (KEY_MAX + 34) /* delete char at cursor        */
+#define REQ_DEL_PREV     (KEY_MAX + 35) /* delete char before cursor    */
+#define REQ_DEL_LINE     (KEY_MAX + 36) /* delete line at cursor        */
+#define REQ_DEL_WORD     (KEY_MAX + 37) /* delete line at cursor        */
+#define REQ_CLR_EOL      (KEY_MAX + 38) /* clear to end of line         */
+#define REQ_CLR_EOF      (KEY_MAX + 39) /* clear to end of field        */
+#define REQ_CLR_FIELD    (KEY_MAX + 40) /* clear entire field           */
+#define REQ_OVL_MODE     (KEY_MAX + 41) /* begin overlay mode           */
+#define REQ_INS_MODE     (KEY_MAX + 42) /* begin insert mode            */
+#define REQ_SCR_FLINE    (KEY_MAX + 43) /* scroll field forward a line  */
+#define REQ_SCR_BLINE    (KEY_MAX + 44) /* scroll field backward a line */
+#define REQ_SCR_FPAGE    (KEY_MAX + 45) /* scroll field forward a page  */
+#define REQ_SCR_BPAGE    (KEY_MAX + 46) /* scroll field backward a page */
+#define REQ_SCR_FHPAGE   (KEY_MAX + 47) /* scroll field forward  half page */
+#define REQ_SCR_BHPAGE   (KEY_MAX + 48) /* scroll field backward half page */
+#define REQ_SCR_FCHAR    (KEY_MAX + 49) /* horizontal scroll char          */
+#define REQ_SCR_BCHAR    (KEY_MAX + 50) /* horizontal scroll char          */
+#define REQ_SCR_HFLINE   (KEY_MAX + 51) /* horizontal scroll line          */
+#define REQ_SCR_HBLINE   (KEY_MAX + 52) /* horizontal scroll line          */
+#define REQ_SCR_HFHALF   (KEY_MAX + 53) /* horizontal scroll half line     */
+#define REQ_SCR_HBHALF   (KEY_MAX + 54) /* horizontal scroll half line     */
+
+#define REQ_VALIDATION   (KEY_MAX + 55) /* validate field               */
+#define REQ_NEXT_CHOICE  (KEY_MAX + 56) /* display next field choice    */
+#define REQ_PREV_CHOICE  (KEY_MAX + 57) /* display prev field choice    */
+
+#define MIN_FORM_COMMAND (KEY_MAX + 1)  /* used by form_driver          */
+#define MAX_FORM_COMMAND (KEY_MAX + 57) /* used by form_driver          */
+
+#if defined(MAX_COMMAND)
+#  if (MAX_FORM_COMMAND > MAX_COMMAND)
+#    error Something is wrong -- MAX_FORM_COMMAND is greater than MAX_COMMAND
+#  elif (MAX_COMMAND != (KEY_MAX + 128))
+#    error Something is wrong -- MAX_COMMAND is already inconsistently defined.
+#  endif
+#else
+#  define MAX_COMMAND (KEY_MAX + 128)
+#endif
+
+        /*************************
+        *  standard field types  *
+        *************************/
+extern FIELDTYPE *TYPE_ALPHA,
+                 *TYPE_ALNUM,
+                 *TYPE_ENUM,
+                 *TYPE_INTEGER,
+                 *TYPE_NUMERIC,
+                 *TYPE_REGEXP;
+
+        /************************************
+        *  built-in additional field types  *
+        *  They are not defined in SVr4     *
+        ************************************/
+extern FIELDTYPE *TYPE_IPV4;      /* Internet IP Version 4 address */
+
+        /*********************** 
+        *   Default objects    *
+        ***********************/ 
+extern FORM  *_nc_Default_Form;
+extern FIELD *_nc_Default_Field;
+
+
+        /***********************
+        *  FIELDTYPE routines  *
+        ***********************/
+extern FIELDTYPE 
+                *new_fieldtype(
+                    bool (* const field_check)(FIELD *,const void *),
+                    bool (* const char_check)(int,const void *)),
+                *link_fieldtype(FIELDTYPE *,FIELDTYPE *);
+
+extern int      free_fieldtype(FIELDTYPE *),
+                set_fieldtype_choice (FIELDTYPE *,
+                    bool (* const next_choice)(FIELD *,const void *),
+                    bool (* const prev_choice)(FIELD *,const void *));
+
+        /*******************
+        *  FIELD routines  *
+        *******************/
+extern FIELD    *new_field(int,int,int,int,int,int),
+                *dup_field(FIELD *,int,int),
+                *link_field(FIELD *,int,int);
+
+extern int      free_field(FIELD *),
+                field_info(const FIELD *,int *,int *,int *,int *,int *,int *),
+                dynamic_field_info(const FIELD *,int *,int *,int *),
+                set_max_field( FIELD *,int),
+                move_field(FIELD *,int,int),
+                set_field_type(FIELD *,FIELDTYPE *,...),
+                set_new_page(FIELD *,bool),
+                set_field_just(FIELD *,int),
+                field_just(const FIELD *),
+                set_field_fore(FIELD *,chtype),
+                set_field_back(FIELD *,chtype),
+                set_field_pad(FIELD *,int),
+                field_pad(const FIELD *),
+                set_field_buffer(FIELD *,int,const char *),
+                set_field_status(FIELD *,bool),
+                set_field_userptr(FIELD *, void *),
+                set_field_opts(FIELD *,Field_Options),
+                field_opts_on(FIELD *,Field_Options),
+                field_opts_off(FIELD *,Field_Options);
+
+extern chtype   field_fore(const FIELD *),
+                field_back(const FIELD *);
+
+extern bool     new_page(const FIELD *),
+                field_status(const FIELD *);
+
+extern void     *field_arg(const FIELD *);
+
+extern void     *field_userptr(const FIELD *);
+
+extern FIELDTYPE
+                *field_type(const FIELD *);
+
+extern char*    field_buffer(const FIELD *,int);
+
+extern Field_Options  
+                field_opts(const FIELD *);
+
+        /******************
+        *  FORM routines  *
+        ******************/
+extern FORM     *new_form(FIELD **);
+
+extern FIELD    **form_fields(const FORM *),
+                *current_field(const FORM *);
+
+extern WINDOW   *form_win(const FORM *),
+                *form_sub(const FORM *);
+
+extern Form_Hook
+                form_init(const FORM *),
+                form_term(const FORM *),
+                field_init(const FORM *),
+                field_term(const FORM *);
+
+extern int      free_form(FORM *),
+                set_form_fields(FORM *,FIELD **),
+                field_count(const FORM *),
+                set_form_win(FORM *,WINDOW *),
+                set_form_sub(FORM *,WINDOW *),
+                set_current_field(FORM *,FIELD *),
+                field_index(const FIELD *),
+                set_form_page(FORM *,int),
+                form_page(const FORM *),
+                scale_form(const FORM *,int *,int *),
+                set_form_init(FORM *,Form_Hook),
+                set_form_term(FORM *,Form_Hook),
+                set_field_init(FORM *,Form_Hook),
+                set_field_term(FORM *,Form_Hook),
+                post_form(FORM *),
+                unpost_form(FORM *),
+                pos_form_cursor(FORM *),
+                form_driver(FORM *,int),
+                set_form_userptr(FORM *,void *),
+                set_form_opts(FORM *,Form_Options),
+                form_opts_on(FORM *,Form_Options),
+                form_opts_off(FORM *,Form_Options),
+                form_request_by_name(const char *);
+
+extern const char
+                *form_request_name(int);
+
+extern void     *form_userptr(const FORM *);
+
+extern Form_Options
+                form_opts(const FORM *);
+
+extern bool     data_ahead(const FORM *),
+                data_behind(const FORM *);
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif  /* FORM_H */
diff --git a/Source/CursesDialog/form/form.priv.h b/Source/CursesDialog/form/form.priv.h
new file mode 100644
index 0000000..6e00af6
--- /dev/null
+++ b/Source/CursesDialog/form/form.priv.h
@@ -0,0 +1,128 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "mf_common.h"
+#include "form.h"
+
+/* form  status values */
+#define _OVLMODE         (0x04) /* Form is in overlay mode                */
+#define _WINDOW_MODIFIED (0x10) /* Current field window has been modified */
+#define _FCHECK_REQUIRED (0x20) /* Current field needs validation         */
+
+/* field status values */
+#define _CHANGED         (0x01) /* Field has been changed                 */
+#define _NEWTOP          (0x02) /* Vertical scrolling occurred             */
+#define _NEWPAGE         (0x04) /* field begins new page of form          */
+#define _MAY_GROW        (0x08) /* dynamic field may still grow           */
+
+/* fieldtype status values */
+#define _LINKED_TYPE     (0x01) /* Type is a linked type                  */
+#define _HAS_ARGS        (0x02) /* Type has arguments                     */
+#define _HAS_CHOICE      (0x04) /* Type has choice methods                */
+#define _RESIDENT        (0x08) /* Type is builtin                        */
+
+/* This are the field options required to be a selectable field in field
+   navigation requests */
+#define O_SELECTABLE (O_ACTIVE | O_VISIBLE)
+
+/* If form is NULL replace form argument by default-form */
+#define Normalize_Form(form)  ((form)=(form)?(form):_nc_Default_Form)
+
+/* If field is NULL replace field argument by default-field */
+#define Normalize_Field(field)  ((field)=(field)?(field):_nc_Default_Field)
+
+/* Retrieve forms window */
+#define Get_Form_Window(form) \
+  ((form)->sub?(form)->sub:((form)->win?(form)->win:stdscr))
+
+/* Calculate the size for a single buffer for this field */
+#define Buffer_Length(field) ((field)->drows * (field)->dcols)
+
+/* Calculate the total size of all buffers for this field */
+#define Total_Buffer_Size(field) \
+   ( (Buffer_Length(field) + 1) * (1+(field)->nbuf) )
+
+/* Logic to determine whether or not a field is single lined */
+#define Single_Line_Field(field) \
+   (((field)->rows + (field)->nrow) == 1)
+
+/* Logic to determine whether or not a field is selectable */
+#define Field_Is_Selectable(f)     (((f)->opts & O_SELECTABLE)==O_SELECTABLE)
+#define Field_Is_Not_Selectable(f) (((f)->opts & O_SELECTABLE)!=O_SELECTABLE)
+
+typedef struct typearg {
+  struct typearg *left;
+  struct typearg *right;
+} TypeArgument;
+
+/* This is a dummy request code (normally invalid) to be used internally
+   with the form_driver() routine to position to the first active field
+   on the form
+*/
+#define FIRST_ACTIVE_MAGIC (-291056)
+
+#define ALL_FORM_OPTS  (                \
+                        O_NL_OVERLOAD  |\
+                        O_BS_OVERLOAD   )
+
+#define ALL_FIELD_OPTS (           \
+                        O_VISIBLE |\
+                        O_ACTIVE  |\
+                        O_PUBLIC  |\
+                        O_EDIT    |\
+                        O_WRAP    |\
+                        O_BLANK   |\
+                        O_AUTOSKIP|\
+                        O_NULLOK  |\
+                        O_PASSOK  |\
+                        O_STATIC   )
+
+
+#define C_BLANK ' '
+#define is_blank(c) ((c)==C_BLANK)
+
+extern const FIELDTYPE* _nc_Default_FieldType;
+
+extern TypeArgument* _nc_Make_Argument(const FIELDTYPE*,va_list*,int*);
+extern TypeArgument *_nc_Copy_Argument(const FIELDTYPE*,const TypeArgument*, int*);
+extern void _nc_Free_Argument(const FIELDTYPE*,TypeArgument*);
+extern bool _nc_Copy_Type(FIELD*, FIELD const *);
+extern void _nc_Free_Type(FIELD *);
+
+extern int _nc_Synchronize_Attributes(FIELD*);
+extern int _nc_Synchronize_Options(FIELD*,Field_Options);
+extern int _nc_Set_Form_Page(FORM*,int,FIELD*);
+extern int _nc_Refresh_Current_Field(FORM*);
+extern FIELD* _nc_First_Active_Field(FORM*);
+extern bool _nc_Internal_Validation(FORM*);
+extern int _nc_Set_Current_Field(FORM*,FIELD*);
+extern int _nc_Position_Form_Cursor(FORM*);
diff --git a/Source/CursesDialog/form/frm_cursor.c b/Source/CursesDialog/form/frm_cursor.c
new file mode 100644
index 0000000..6c311fe
--- /dev/null
+++ b/Source/CursesDialog/form/frm_cursor.c
@@ -0,0 +1,66 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int pos_form_cursor(FORM * form)
+|   
+|   Description   :  Moves the form window cursor to the location required
+|                    by the form driver to resume form processing. This may
+|                    be needed after the application calls a curses library
+|                    I/O routine that modifies the cursor position.
+|
+|   Return Values :  E_OK                      - Success
+|                    E_SYSTEM_ERROR            - System error.
+|                    E_BAD_ARGUMENT            - Invalid form pointer
+|                    E_NOT_POSTED              - Form is not posted
++--------------------------------------------------------------------------*/
+int pos_form_cursor(FORM * form)
+{
+  int res;
+
+  if (!form)
+   res = E_BAD_ARGUMENT;
+  else
+    {
+      if (!(form->status & _POSTED))
+        res = E_NOT_POSTED;
+      else
+	res = _nc_Position_Form_Cursor(form);
+    }
+  RETURN(res);
+}
+
+/* frm_cursor.c ends here */
diff --git a/Source/CursesDialog/form/frm_data.c b/Source/CursesDialog/form/frm_data.c
new file mode 100644
index 0000000..fb62ab8
--- /dev/null
+++ b/Source/CursesDialog/form/frm_data.c
@@ -0,0 +1,183 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+extern int winnstr(WINDOW *, char *, int);
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool data_behind(const FORM *form)
+|   
+|   Description   :  Check for off-screen data behind. This is nearly trivial
+|                    becose the begin of a field is fixed.
+|
+|   Return Values :  TRUE   - there are off-screen data behind
+|                    FALSE  - there are no off-screen data behind
++--------------------------------------------------------------------------*/
+bool data_behind(const FORM *form)
+{
+  bool result = FALSE;
+
+  if (form && (form->status & _POSTED) && form->current)
+    {
+      FIELD *field;
+
+      field = form->current;
+      if (!Single_Line_Field(field))
+	{
+	  result = (form->toprow==0) ? FALSE : TRUE;
+	}
+      else
+	{
+	  result = (form->begincol==0) ? FALSE : TRUE;
+	}
+    }
+  return(result);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static char * After_Last_Non_Pad_Position(
+|                                    char *buffer,
+|                                    int len,
+|                                    int pad)
+|   
+|   Description   :  Find the last position in the buffer that doesn't
+|                    contain a padding character.
+|
+|   Return Values :  The pointer to this position 
++--------------------------------------------------------------------------*/
+INLINE 
+static char * After_Last_Non_Pad_Position(char *buffer, int len, int pad)
+{
+  char *end = buffer + len;
+
+  assert(buffer && len>=0);
+  while ( (buffer < end) && (*(end-1)==pad) )
+    end--;
+
+  return end;
+}
+
+#define SMALL_BUFFER_SIZE (80)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool data_ahead(const FORM *form)
+|   
+|   Description   :  Check for off-screen data ahead. This is more difficult
+|                    because a dynamic field has a variable end. 
+|
+|   Return Values :  TRUE   - there are off-screen data ahead
+|                    FALSE  - there are no off-screen data ahead
++--------------------------------------------------------------------------*/
+bool data_ahead(const FORM *form)
+{
+  bool result = FALSE;
+
+  if (form && (form->status & _POSTED) && form->current)
+    {
+      static char buffer[SMALL_BUFFER_SIZE + 1];
+      FIELD *field;
+      bool large_buffer;
+      bool cursor_moved = FALSE;
+      char *bp;
+      char *found_content;
+      int pos;
+
+      field = form->current;
+      assert(form->w != 0);
+
+      large_buffer = (field->cols > SMALL_BUFFER_SIZE);
+      if (large_buffer)
+	bp = (char *)malloc((size_t)(field->cols) + 1);
+      else
+	bp = buffer;
+
+      assert(bp != 0);
+      
+      if (Single_Line_Field(field))
+	{
+	  int check_len;
+
+	  pos = form->begincol + field->cols;
+	  while (pos < field->dcols)
+	    {
+	      check_len = field->dcols - pos;
+	      if ( check_len >= field->cols )
+		check_len = field->cols;
+	      cursor_moved = TRUE;
+	      wmove(form->w,0,pos);
+	      winnstr(form->w,bp,check_len);
+	      found_content = 
+		After_Last_Non_Pad_Position(bp,check_len,field->pad);
+	      if (found_content==bp)
+		  pos += field->cols;		  
+	      else
+		{
+		  result = TRUE;
+		  break;
+		}
+	    }
+	}
+      else
+	{
+	  pos = form->toprow + field->rows;
+	  while (pos < field->drows)
+	    {
+	      cursor_moved = TRUE;
+	      wmove(form->w,pos,0);
+	      pos++;
+	      winnstr(form->w,bp,field->cols);
+	      found_content = 
+		After_Last_Non_Pad_Position(bp,field->cols,field->pad);
+	      if (found_content!=bp)
+		{
+		  result = TRUE;
+		  break;
+		}
+	    }
+	}
+
+      if (large_buffer)
+	free(bp);
+
+      if (cursor_moved)
+	wmove(form->w,form->currow,form->curcol);
+    }
+  return(result);
+}
+
+/* frm_data.c ends here */
diff --git a/Source/CursesDialog/form/frm_def.c b/Source/CursesDialog/form/frm_def.c
new file mode 100644
index 0000000..645b3ba
--- /dev/null
+++ b/Source/CursesDialog/form/frm_def.c
@@ -0,0 +1,376 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/* this can't be readonly */
+static FORM default_form = {
+  0,                                    /* status     */
+  0,                                    /* rows       */
+  0,                                    /* cols       */
+  0,                                    /* currow     */
+  0,                                    /* curcol     */
+  0,                                    /* toprow     */
+  0,                                    /* begincol   */
+  -1,                                   /* maxfield   */
+  -1,                                   /* maxpage    */
+  -1,                                   /* curpage    */
+  ALL_FORM_OPTS,                        /* opts       */
+  (WINDOW *)0,                          /* win        */
+  (WINDOW *)0,                          /* sub        */
+  (WINDOW *)0,                          /* w          */
+  (FIELD **)0,                          /* field      */
+  (FIELD *)0,                           /* current    */
+  (_PAGE *)0,                           /* page       */
+  (char *)0,                            /* usrptr     */
+  NULL,			                /* forminit   */
+  NULL,                                 /* formterm   */
+  NULL,                                 /* fieldinit  */
+  NULL                                  /* fieldterm  */
+};
+
+FORM *_nc_Default_Form = &default_form;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Insert_Field_By_Position(
+|                                     FIELD *new_field, 
+|                                     FIELD *head )
+|   
+|   Description   :  Insert new_field into sorted fieldlist with head "head"
+|                    and return new head of sorted fieldlist. Sorting
+|                    criteria is (row,column). This is a circular list.
+|
+|   Return Values :  New head of sorted fieldlist
++--------------------------------------------------------------------------*/
+static FIELD *Insert_Field_By_Position(FIELD *newfield, FIELD *head)
+{
+  FIELD *current, *newhead;
+  
+  assert(newfield != 0);
+
+  if (!head)
+    { /* empty list is trivial */
+      newhead = newfield->snext = newfield->sprev = newfield;
+    }
+  else
+    {
+      newhead = current = head;
+      while((current->frow < newfield->frow) || 
+	    ((current->frow==newfield->frow) && 
+	     (current->fcol < newfield->fcol)) )
+	{
+	  current = current->snext;
+	  if (current==head)
+	    { /* We cycled through. Reset head to indicate that */
+	      head = (FIELD *)0;
+	      break;
+	    }
+	}
+      /* we leave the loop with current pointing to the field after newfield*/
+      newfield->snext	 = current;
+      newfield->sprev	 = current->sprev;
+      newfield->snext->sprev = newfield;
+      newfield->sprev->snext = newfield;
+      if (current==head) 
+	newhead = newfield;
+    }
+  return(newhead);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Disconnect_Fields(FORM *form)
+|   
+|   Description   :  Break association between form and array of fields.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Disconnect_Fields( FORM * form )
+{
+  if (form->field)
+    {
+      FIELD **fields;
+
+      for(fields=form->field;*fields;fields++)
+	{
+	  if (form == (*fields)->form) 
+	    (*fields)->form = (FORM *)0;
+	}
+      
+      form->rows = form->cols = 0;
+      form->maxfield = form->maxpage = -1;
+      form->field = (FIELD **)0;
+      if (form->page) 
+	free(form->page);
+      form->page = (_PAGE *)0;
+    }	
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Connect_Fields(FORM *form, FIELD **fields)
+|   
+|   Description   :  Set association between form and array of fields.
+|
+|   Return Values :  E_OK            - no error
+|                    E_CONNECTED     - a field is already connected
+|                    E_BAD_ARGUMENT  - Invalid form pointer or field array
+|                    E_SYSTEM_ERROR  - not enough memory
++--------------------------------------------------------------------------*/
+static int Connect_Fields(FORM  * form, FIELD ** fields)
+{
+  int field_cnt, j;
+  int page_nr;
+  int maximum_row_in_field, maximum_col_in_field;
+  _PAGE *pg;
+  
+  assert(form != 0);
+
+  form->field    = fields;
+  form->maxfield = 0;
+  form->maxpage  = 0;
+
+  if (!fields)
+    RETURN(E_OK);
+  
+  page_nr = 0;
+  /* store formpointer in fields and count pages */
+  for(field_cnt=0;fields[field_cnt];field_cnt++)
+    {
+      if (fields[field_cnt]->form) 
+	RETURN(E_CONNECTED);
+      if ( field_cnt==0 || 
+	  (fields[field_cnt]->status & _NEWPAGE)) 
+	page_nr++;
+      fields[field_cnt]->form = form;
+    }	
+  if (field_cnt==0)
+    RETURN(E_BAD_ARGUMENT);
+  
+  /* allocate page structures */
+  if ( (pg = (_PAGE *)malloc(page_nr * sizeof(_PAGE))) != (_PAGE *)0 )
+    {
+      form->page = pg;
+    }
+  else
+    RETURN(E_SYSTEM_ERROR);
+  
+  /* Cycle through fields and calculate page boundaries as well as
+     size of the form */
+  for(j=0;j<field_cnt;j++)
+    {
+      if (j==0) 
+	pg->pmin = j;
+      else
+	{
+	  if (fields[j]->status & _NEWPAGE)
+	    {
+	      pg->pmax = j-1;
+	      pg++;
+	      pg->pmin = j;
+	    }
+	}
+      
+      maximum_row_in_field = fields[j]->frow + fields[j]->rows;
+      maximum_col_in_field = fields[j]->fcol + fields[j]->cols;
+      
+      if (form->rows < maximum_row_in_field) 
+	form->rows = maximum_row_in_field;
+      if (form->cols < maximum_col_in_field) 
+	form->cols = maximum_col_in_field;
+    }
+  
+  pg->pmax       = field_cnt-1;
+  form->maxfield = field_cnt;
+  form->maxpage  = page_nr; 
+  
+  /* Sort fields on form pages */
+  for(page_nr = 0;page_nr < form->maxpage; page_nr++)
+    {
+      FIELD *fld = (FIELD *)0;
+      for(j = form->page[page_nr].pmin;j <= form->page[page_nr].pmax;j++)
+	{
+	  fields[j]->index = j;
+	  fields[j]->page  = page_nr;
+	  fld = Insert_Field_By_Position(fields[j],fld);
+	}
+      form->page[page_nr].smin = fld->index;
+      form->page[page_nr].smax = fld->sprev->index;
+    }
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Associate_Fields(FORM *form, FIELD **fields)
+|   
+|   Description   :  Set association between form and array of fields. 
+|                    If there are fields, position to first active field.
+|
+|   Return Values :  E_OK            - success
+|                    any other       - error occurred
++--------------------------------------------------------------------------*/
+INLINE static int Associate_Fields(FORM  *form, FIELD **fields)
+{
+  int res = Connect_Fields(form,fields);
+  if (res == E_OK)
+    {
+      if (form->maxpage>0)
+	{
+	  form->curpage = 0;
+	  form_driver(form,FIRST_ACTIVE_MAGIC);
+	}
+      else
+	{
+	  form->curpage = -1;
+	  form->current = (FIELD *)0;
+	} 
+    }
+  return(res);
+}
+			    
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FORM *new_form( FIELD **fields )
+|   
+|   Description   :  Create new form with given array of fields.
+|
+|   Return Values :  Pointer to form. NULL if error occurred.
++--------------------------------------------------------------------------*/
+FORM *new_form(FIELD ** fields)
+{	
+  int err = E_SYSTEM_ERROR;
+
+  FORM *form = (FORM *)malloc(sizeof(FORM));
+  
+  if (form)
+    {
+      *form = *_nc_Default_Form;
+      if ((err=Associate_Fields(form,fields))!=E_OK)
+	{
+	  free_form(form);
+	  form = (FORM *)0;
+	}
+    }
+
+  if (!form)
+    SET_ERROR(err);
+  
+  return(form);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int free_form( FORM *form )
+|   
+|   Description   :  Release internal memory associated with form.
+|
+|   Return Values :  E_OK           - no error
+|                    E_BAD_ARGUMENT - invalid form pointer
+|                    E_POSTED       - form is posted
++--------------------------------------------------------------------------*/
+int free_form(FORM * form)
+{
+  if ( !form )	
+    RETURN(E_BAD_ARGUMENT);
+
+  if ( form->status & _POSTED)  
+    RETURN(E_POSTED);
+  
+  Disconnect_Fields( form );
+  if (form->page) 
+    free(form->page);
+  free(form);
+  
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_fields( FORM *form, FIELD **fields )
+|   
+|   Description   :  Set a new association of an array of fields to a form
+|
+|   Return Values :  E_OK              - no error
+|                    E_BAD_ARGUMENT    - invalid form pointer
+|                    E_POSTED          - form is posted
++--------------------------------------------------------------------------*/
+int set_form_fields(FORM  * form, FIELD ** fields)
+{
+  FIELD **old;
+  int res;
+  
+  if ( !form )	
+    RETURN(E_BAD_ARGUMENT);
+
+  if ( form->status & _POSTED )	
+    RETURN(E_POSTED);
+  
+  old = form->field;
+  Disconnect_Fields( form );
+  
+  if( (res = Associate_Fields( form, fields )) != E_OK )
+    Connect_Fields( form, old );
+  
+  RETURN(res);
+}
+	
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD **form_fields( const FORM *form )
+|   
+|   Description   :  Retrieve array of fields
+|
+|   Return Values :  Pointer to field array
++--------------------------------------------------------------------------*/
+FIELD **form_fields(const FORM * form)
+{
+  return (Normalize_Form( form )->field);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int field_count( const FORM *form )
+|   
+|   Description   :  Retrieve number of fields
+|
+|   Return Values :  Number of fields, -1 if none are defined
++--------------------------------------------------------------------------*/
+int field_count(const FORM * form)
+{
+  return (Normalize_Form( form )->maxfield);
+}
+
+/* frm_def.c ends here */
diff --git a/Source/CursesDialog/form/frm_driver.c b/Source/CursesDialog/form/frm_driver.c
new file mode 100644
index 0000000..e4e72aa
--- /dev/null
+++ b/Source/CursesDialog/form/frm_driver.c
@@ -0,0 +1,3883 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+/* AIX seems to define this */
+#undef lines
+#undef columns
+
+MODULE_ID("$Id$")
+
+/* These declarations are missing from curses.h on some platforms.  */
+extern int winnstr(WINDOW *, char *, int);
+#if defined(__DECCXX_VER) || (defined(__GNUC__) && defined(__osf__))
+extern int waddnstr(WINDOW *,const char *const,int);
+extern void wbkgdset(WINDOW *,chtype);
+#ifndef untouchwin
+extern int untouchwin(WINDOW *);
+#endif
+extern void wcursyncup(WINDOW *);
+extern int copywin(const WINDOW*,WINDOW*,int,int,int,int,int,int,int);
+extern bool is_linetouched(WINDOW *,int);
+extern void wsyncup(WINDOW *);
+extern WINDOW *derwin(WINDOW *,int,int,int,int);
+extern int winsnstr(WINDOW *, const char *,int);
+extern int winsdelln(WINDOW *,int);
+#endif
+
+/*----------------------------------------------------------------------------
+  This is the core module of the form library. It contains the majority
+  of the driver routines as well as the form_driver function. 
+
+  Essentially this module is nearly the whole library. This is because
+  all the functions in this module depends on some others in the module,
+  so it makes no sense to split them into separate files because they
+  will always be linked together. The only acceptable concern is turnaround
+  time for this module, but now we have all Pentiums or Riscs, so what!
+
+  The driver routines are grouped into nine generic categories:
+
+   a)   Page Navigation            ( all functions prefixed by PN_ )
+        The current page of the form is left and some new page is
+        entered.
+   b)   Inter-Field Navigation     ( all functions prefixed by FN_ )
+        The current field of the form is left and some new field is
+        entered.
+   c)   Intra-Field Navigation     ( all functions prefixed by IFN_ )
+        The current position in the current field is changed. 
+   d)   Vertical Scrolling         ( all functions prefixed by VSC_ )
+        Esseantially this is a specialization of Intra-Field navigation.
+        It has to check for a multi-line field.
+   e)   Horizontal Scrolling       ( all functions prefixed by HSC_ )
+        Esseantially this is a specialization of Intra-Field navigation.
+        It has to check for a single-line field.
+   f)   Field Editing              ( all functions prefixed by FE_ )
+        The content of the current field is changed
+   g)   Edit Mode requests         ( all functions prefixed by EM_ )
+        Switching between insert and overlay mode
+   h)   Field-Validation requests  ( all functions prefixed by FV_ )
+        Perform verifications of the field.
+   i)   Choice requests            ( all functions prefixed by CR_ )
+        Requests to enumerate possible field values
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Some remarks on the placements of assert() macros :
+  I use them only on "strategic" places, i.e. top level entries where
+  I want to make sure that things are set correctly. Throughout subordinate
+  routines I omit them mostly.
+  --------------------------------------------------------------------------*/
+
+/*
+Some options that may effect compatibility in behavior to SVr4 forms,
+but they are here to allow a more intuitive and user friendly behaviour of
+our form implementation. This doesn't affect the API, so we feel it is
+uncritical.
+
+The initial implementation tries to stay very close with the behaviour
+of the original SVr4 implementation, although in some areas it is quite
+clear that this isn't the most appropriate way. As far as possible this
+sources will allow you to build a forms lib that behaves quite similar
+to SVr4, but now and in the future we will give you better options. 
+Perhaps at some time we will make this configurable at runtime.
+*/
+
+/* Implement a more user-friendly previous/next word behaviour */
+#define FRIENDLY_PREV_NEXT_WORD (1)
+/* Fix the wrong behaviour for forms with all fields inactive */
+#define FIX_FORM_INACTIVE_BUG (1)
+/* Allow dynamic field growth also when navigating past the end */
+#define GROW_IF_NAVIGATE (1)
+
+/*----------------------------------------------------------------------------
+  Forward references to some internally used static functions
+  --------------------------------------------------------------------------*/
+static int Inter_Field_Navigation ( int (* const fct) (FORM *), FORM * form );
+static int FN_Next_Field (FORM * form);
+static int FN_Previous_Field (FORM * form);
+static int FE_New_Line(FORM *);
+static int FE_Delete_Previous(FORM *);
+
+/*----------------------------------------------------------------------------
+  Macro Definitions.
+
+  Some Remarks on that: I use the convention to use UPPERCASE for constants
+  defined by Macros. If I provide a macro as a kind of inline routine to
+  provide some logic, I use my Upper_Lower case style.
+  --------------------------------------------------------------------------*/
+
+/* Calculate the position of a single row in a field buffer */
+#define Position_Of_Row_In_Buffer(field,row) ((row)*(field)->dcols)
+
+/* Calculate start address for the fields buffer# N */
+#define Address_Of_Nth_Buffer(field,N) \
+  ((field)->buf + (N)*(1+Buffer_Length(field)))
+
+/* Calculate the start address of the row in the fields specified buffer# N */
+#define Address_Of_Row_In_Nth_Buffer(field,N,row) \
+  (Address_Of_Nth_Buffer(field,N) + Position_Of_Row_In_Buffer(field,row))
+
+/* Calculate the start address of the row in the fields primary buffer */
+#define Address_Of_Row_In_Buffer(field,row) \
+  Address_Of_Row_In_Nth_Buffer(field,0,row)
+
+/* Calculate the start address of the row in the forms current field
+   buffer# N */
+#define Address_Of_Current_Row_In_Nth_Buffer(form,N) \
+   Address_Of_Row_In_Nth_Buffer((form)->current,N,(form)->currow)
+
+/* Calculate the start address of the row in the forms current field
+   primary buffer */
+#define Address_Of_Current_Row_In_Buffer(form) \
+   Address_Of_Current_Row_In_Nth_Buffer(form,0)
+
+/* Calculate the address of the cursor in the forms current field
+   primary buffer */
+#define Address_Of_Current_Position_In_Nth_Buffer(form,N) \
+   (Address_Of_Current_Row_In_Nth_Buffer(form,N) + (form)->curcol)
+
+/* Calculate the address of the cursor in the forms current field
+   buffer# N */
+#define Address_Of_Current_Position_In_Buffer(form) \
+  Address_Of_Current_Position_In_Nth_Buffer(form,0)
+
+/* Logic to decide whether or not a field is actually a field with
+   vertical or horizontal scrolling */
+#define Is_Scroll_Field(field)          \
+   (((field)->drows > (field)->rows) || \
+    ((field)->dcols > (field)->cols))
+
+/* Logic to decide whether or not a field needs to have an individual window
+   instead of a derived window because it contains invisible parts.
+   This is true for non-public fields and for scrollable fields. */
+#define Has_Invisible_Parts(field)     \
+  (!((field)->opts & O_PUBLIC)      || \
+   Is_Scroll_Field(field))
+
+/* Logic to decide whether or not a field needs justification */
+#define Justification_Allowed(field)        \
+   (((field)->just != NO_JUSTIFICATION)  && \
+    (Single_Line_Field(field))           && \
+    (((field)->dcols == (field)->cols)   && \
+    ((field)->opts & O_STATIC))             )
+
+/* Logic to determine whether or not a dynamic field may still grow */
+#define Growable(field) ((field)->status & _MAY_GROW)
+
+/* Macro to set the attributes for a fields window */
+#define Set_Field_Window_Attributes(field,win) \
+(  wbkgdset((win),(chtype)((field)->pad | (field)->back)), \
+   wattrset((win),(field)->fore) )
+
+/* Logic to decide whether or not a field really appears on the form */
+#define Field_Really_Appears(field)         \
+  ((field->form)                          &&\
+   (field->form->status & _POSTED)        &&\
+   (field->opts & O_VISIBLE)              &&\
+   (field->page == field->form->curpage))
+
+/* Logic to determine whether or not we are on the first position in the
+   current field */
+#define First_Position_In_Current_Field(form) \
+  (((form)->currow==0) && ((form)->curcol==0))
+
+
+#define Minimum(a,b) (((a)<=(b)) ? (a) : (b))
+#define Maximum(a,b) (((a)>=(b)) ? (a) : (b))
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static char *Get_Start_Of_Data(char * buf, int blen)
+|   
+|   Description   :  Return pointer to first non-blank position in buffer.
+|                    If buffer is empty return pointer to buffer itself.
+|
+|   Return Values :  Pointer to first non-blank position in buffer
++--------------------------------------------------------------------------*/
+INLINE static char *Get_Start_Of_Data(char * buf, int blen)
+{
+  char *p   = buf;
+  char *end = &buf[blen];
+
+  assert(buf && blen>=0);
+  while( (p < end) && is_blank(*p) ) 
+    p++;
+  return( (p==end) ? buf : p );
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static char *After_End_Of_Data(char * buf, int blen)
+|   
+|   Description   :  Return pointer after last non-blank position in buffer.
+|                    If buffer is empty, return pointer to buffer itself.
+|
+|   Return Values :  Pointer to position after last non-blank position in 
+|                    buffer.
++--------------------------------------------------------------------------*/
+INLINE static char *After_End_Of_Data(char * buf,int blen)
+{
+  char *p   = &buf[blen];
+  
+  assert(buf && blen>=0);
+  while( (p>buf) && is_blank(p[-1]) ) 
+    p--;
+  return( p );
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static char *Get_First_Whitespace_Character(
+|                                     char * buf, int   blen)
+|   
+|   Description   :  Position to the first whitespace character.
+|
+|   Return Values :  Pointer to first whitespace character in buffer.
++--------------------------------------------------------------------------*/
+INLINE static char *Get_First_Whitespace_Character(char * buf, int blen)
+{
+  char *p   = buf;
+  char *end = &p[blen];
+  
+  assert(buf && blen>=0);
+  while( (p < end) && !is_blank(*p)) 
+    p++;
+  return( (p==end) ? buf : p );
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static char *After_Last_Whitespace_Character(
+|                                     char * buf, int blen)
+|   
+|   Description   :  Get the position after the last whitespace character.
+|
+|   Return Values :  Pointer to position after last whitespace character in 
+|                    buffer.
++--------------------------------------------------------------------------*/
+INLINE static char *After_Last_Whitespace_Character(char * buf, int blen)
+{
+  char *p   = &buf[blen];
+  
+  assert(buf && blen>=0);
+  while( (p>buf) && !is_blank(p[-1]) ) 
+    p--;
+  return( p );
+}
+
+/* Set this to 1 to use the div_t version. This is a good idea if your
+   compiler has an intrinsic div() support. Unfortunately GNU-C has it
+   not yet. 
+   N.B.: This only works if form->curcol follows immediately form->currow
+         and both are of type int. 
+*/
+#define USE_DIV_T (0)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Adjust_Cursor_Position(
+|                                       FORM * form, const char * pos)
+|   
+|   Description   :  Set current row and column of the form to values 
+|                    corresponding to the buffer position.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+INLINE static void Adjust_Cursor_Position(FORM * form, const char * pos)
+{
+  FIELD *field;
+  int idx;
+
+  field = form->current;
+  assert( pos >= field->buf && field->dcols > 0);
+  idx = (int)( pos - field->buf );
+#if USE_DIV_T
+  *((div_t *)&(form->currow)) = div(idx,field->dcols);
+#else
+  form->currow = idx / field->dcols;
+  form->curcol = idx - field->cols * form->currow;
+#endif  
+  if ( field->drows < form->currow )
+    form->currow = 0;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Buffer_To_Window(
+|                                      const FIELD  * field,
+|                                      WINDOW * win)
+|   
+|   Description   :  Copy the buffer to the window. If its a multiline
+|                    field, the buffer is split to the lines of the
+|                    window without any editing.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Buffer_To_Window(const FIELD  * field, WINDOW * win)
+{
+  int width, height;
+  int len;
+  int row;
+  char *pBuffer;
+
+  assert(win && field);
+
+  getmaxyx(win, height, width);
+
+  for(row=0, pBuffer=field->buf; 
+      row < height; 
+      row++, pBuffer += width )
+    {
+      if ((len = (int)( After_End_Of_Data( pBuffer, width ) - pBuffer )) > 0)
+        {
+          wmove( win, row, 0 );
+          waddnstr( win, pBuffer, len );
+        }
+    }   
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Window_To_Buffer(
+|                                          WINDOW * win,
+|                                          FIELD  * field)
+|   
+|   Description   :  Copy the content of the window into the buffer.
+|                    The multiple lines of a window are simply
+|                    concatenated into the buffer. Pad characters in
+|                    the window will be replaced by blanks in the buffer.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Window_To_Buffer(WINDOW * win, FIELD  * field)
+{
+  int pad;
+  int len = 0;
+  char *p;
+  int row, height, width;
+  
+  assert(win && field && field->buf );
+
+  pad = field->pad;
+  p = field->buf;
+  getmaxyx(win, height, width);
+
+  for(row=0; (row < height) && (row < field->drows); row++ )
+    {
+      wmove( win, row, 0 );
+      len += winnstr( win, p+len, field->dcols );
+    }
+  p[len] = '\0';
+
+  /* replace visual padding character by blanks in buffer */
+  if (pad != C_BLANK)
+    {
+      int i;
+      for(i=0; i<len; i++, p++)
+        {
+          if (*p==pad) 
+            *p = C_BLANK;
+        }
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Synchronize_Buffer(FORM * form)
+|   
+|   Description   :  If there was a change, copy the content of the
+|                    window into the buffer, so the buffer is synchronized
+|                    with the windows content. We have to indicate that the
+|                    buffer needs validation due to the change.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+INLINE static void Synchronize_Buffer(FORM * form)
+{
+  if (form->status & _WINDOW_MODIFIED)
+    {
+      form->status &= ~_WINDOW_MODIFIED;
+      form->status |=  _FCHECK_REQUIRED;
+      Window_To_Buffer(form->w,form->current);
+      wmove(form->w,form->currow,form->curcol);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Field_Grown( FIELD *field, int amount)
+|   
+|   Description   :  This function is called for growable dynamic fields
+|                    only. It has to increase the buffers and to allocate
+|                    a new window for this field.
+|                    This function has the side effect to set a new
+|                    field-buffer pointer, the dcols and drows values
+|                    as well as a new current Window for the field.
+|
+|   Return Values :  TRUE     - field successfully increased
+|                    FALSE    - there was some error
++--------------------------------------------------------------------------*/
+static bool Field_Grown(FIELD * field, int amount)
+{
+  bool result = FALSE;
+
+  if (field && Growable(field))
+    {
+      bool single_line_field = Single_Line_Field(field);
+      int old_buflen = Buffer_Length(field);
+      int new_buflen;
+      int old_dcols = field->dcols;
+      int old_drows = field->drows;
+      char *oldbuf  = field->buf;
+      char *newbuf;
+
+      int growth;
+      FORM *form = field->form;
+      bool need_visual_update = ((form != (FORM *)0)      &&
+                                 (form->status & _POSTED) &&
+                                 (form->current==field));
+      
+      if (need_visual_update)
+        Synchronize_Buffer(form);
+      
+      if (single_line_field)
+        {
+          growth = field->cols * amount;
+          if (field->maxgrow)
+            growth = Minimum(field->maxgrow - field->dcols,growth);
+          field->dcols += growth;
+          if (field->dcols == field->maxgrow)
+            field->status &= ~_MAY_GROW;
+        }
+      else
+        {
+          growth = (field->rows + field->nrow) * amount;
+          if (field->maxgrow)
+            growth = Minimum(field->maxgrow - field->drows,growth);
+          field->drows += growth;
+          if (field->drows == field->maxgrow)
+            field->status &= ~_MAY_GROW;
+        }
+      /* drows, dcols changed, so we get really the new buffer length */
+      new_buflen = Buffer_Length(field);
+      newbuf=(char *)malloc((size_t)Total_Buffer_Size(field));
+      if (!newbuf)
+        { /* restore to previous state */
+          field->dcols = old_dcols;
+          field->drows = old_drows;
+          if (( single_line_field && (field->dcols!=field->maxgrow)) ||
+              (!single_line_field && (field->drows!=field->maxgrow)))
+            field->status |= _MAY_GROW;
+          return FALSE;
+        }
+      else
+        { /* Copy all the buffers. This is the reason why we can't
+             just use realloc().
+             */
+          int i;
+          char *old_bp;
+          char *new_bp;
+          
+          field->buf = newbuf;
+          for(i=0;i<=field->nbuf;i++)
+            {
+              new_bp = Address_Of_Nth_Buffer(field,i);
+              old_bp = oldbuf + i*(1+old_buflen);
+              memcpy(new_bp,old_bp,(size_t)old_buflen);
+              if (new_buflen > old_buflen)
+                memset(new_bp + old_buflen,C_BLANK,
+                       (size_t)(new_buflen - old_buflen));
+              *(new_bp + new_buflen) = '\0';
+            }
+
+          if (need_visual_update)
+            {         
+              WINDOW *new_window = newpad(field->drows,field->dcols);
+              if (!new_window)
+                { /* restore old state */
+                  field->dcols = old_dcols;
+                  field->drows = old_drows;
+                  field->buf   = oldbuf;
+                  if (( single_line_field              && 
+                        (field->dcols!=field->maxgrow)) ||
+                      (!single_line_field              && 
+                       (field->drows!=field->maxgrow)))
+                    field->status |= _MAY_GROW;
+                  free( newbuf );
+                  return FALSE;
+                }
+              assert(form!=(FORM *)0);
+              delwin(form->w);
+              form->w = new_window;
+              Set_Field_Window_Attributes(field,form->w);
+              werase(form->w);
+              Buffer_To_Window(field,form->w);
+              untouchwin(form->w);
+              wmove(form->w,form->currow,form->curcol);
+            }
+
+          free(oldbuf);
+          /* reflect changes in linked fields */
+          if (field != field->link)
+            {
+              FIELD *linked_field;
+              for(linked_field = field->link;
+                  linked_field!= field;
+                  linked_field = linked_field->link)
+                {
+                  linked_field->buf   = field->buf;
+                  linked_field->drows = field->drows;
+                  linked_field->dcols = field->dcols;
+                }
+            }
+          result = TRUE;
+        }       
+    }
+  return(result);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Position_Form_Cursor(FORM * form)
+|   
+|   Description   :  Position the cursor in the window for the current
+|                    field to be in sync. with the currow and curcol 
+|                    values.
+|
+|   Return Values :  E_OK              - success
+|                    E_BAD_ARGUMENT    - invalid form pointer
+|                    E_SYSTEM_ERROR    - form has no current field or
+|                                        field-window
++--------------------------------------------------------------------------*/
+int
+_nc_Position_Form_Cursor(FORM * form)
+{
+  FIELD  *field;
+  WINDOW *formwin;
+  
+  if (!form)
+    return(E_BAD_ARGUMENT);
+
+  if (!form->w || !form->current) 
+    return(E_SYSTEM_ERROR);
+
+  field    = form->current;
+  formwin  = Get_Form_Window(form);
+
+  wmove( form->w, form->currow, form->curcol );
+  if ( Has_Invisible_Parts(field) )
+    {
+      /* in this case fieldwin isn't derived from formwin, so we have
+         to move the cursor in formwin by hand... */
+      wmove(formwin,
+            field->frow + form->currow - form->toprow,
+            field->fcol + form->curcol - form->begincol);
+      wcursyncup(formwin);
+    }
+  else 
+    wcursyncup(form->w);
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Refresh_Current_Field(FORM * form)
+|   
+|   Description   :  Propagate the changes in the fields window to the
+|                    window of the form.
+|
+|   Return Values :  E_OK              - on success
+|                    E_BAD_ARGUMENT    - invalid form pointer
+|                    E_SYSTEM_ERROR    - general error
++--------------------------------------------------------------------------*/
+int
+_nc_Refresh_Current_Field(FORM * form)
+{
+  WINDOW *formwin;
+  FIELD  *field;
+
+  if (!form)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (!form->w || !form->current) 
+    RETURN(E_SYSTEM_ERROR);
+
+  field    = form->current;
+  formwin  = Get_Form_Window(form);
+
+  if (field->opts & O_PUBLIC)
+    {
+      if (Is_Scroll_Field(field))
+        {
+          /* Again, in this case the fieldwin isn't derived from formwin,
+             so we have to perform a copy operation. */
+          if (Single_Line_Field(field))
+            { /* horizontal scrolling */
+              if (form->curcol < form->begincol)
+                  form->begincol = form->curcol;
+              else
+                {
+                  if (form->curcol >= (form->begincol + field->cols))
+                      form->begincol = form->curcol - field->cols + 1;
+                }
+              copywin(form->w,
+                      formwin,
+                      0,
+                      form->begincol,
+                      field->frow,
+                      field->fcol,
+                      field->frow,
+                      field->cols + field->fcol - 1,
+                      0);
+            }
+          else
+            { /* A multiline, i.e. vertical scrolling field */
+              int row_after_bottom,first_modified_row,first_unmodified_row;
+
+              if (field->drows > field->rows)
+                {
+                  row_after_bottom = form->toprow + field->rows;
+                  if (form->currow < form->toprow)
+                    {
+                      form->toprow = form->currow;
+                      field->status |= _NEWTOP;
+                    }
+                  if (form->currow >= row_after_bottom)
+                    {
+                      form->toprow = form->currow - field->rows + 1;
+                      field->status |= _NEWTOP;
+                    }
+                  if (field->status & _NEWTOP)
+                    { /* means we have to copy whole range */
+                      first_modified_row = form->toprow;
+                      first_unmodified_row = first_modified_row + field->rows;
+                      field->status &= ~_NEWTOP;
+                    }
+                  else 
+                    { /* we try to optimize : finding the range of touched
+                         lines */
+                      first_modified_row = form->toprow;
+                      while(first_modified_row < row_after_bottom)
+                        {
+                          if (is_linetouched(form->w,first_modified_row)) 
+                            break;
+                          first_modified_row++;
+                        }
+                      first_unmodified_row = first_modified_row;
+                      while(first_unmodified_row < row_after_bottom)
+                        {
+                          if (!is_linetouched(form->w,first_unmodified_row)) 
+                            break;
+                          first_unmodified_row++;
+                        }
+                    }
+                }
+              else
+                {
+                  first_modified_row   = form->toprow;
+                  first_unmodified_row = first_modified_row + field->rows;
+                }
+              if (first_unmodified_row != first_modified_row)
+                copywin(form->w,
+                        formwin,
+                        first_modified_row,
+                        0,
+                        field->frow + first_modified_row - form->toprow,
+                        field->fcol,
+                        field->frow + first_unmodified_row - form->toprow - 1,
+                        field->cols + field->fcol - 1,
+                        0);
+            }
+          wsyncup(formwin);
+        }
+      else
+        { /* if the field-window is simply a derived window, i.e. contains
+             no invisible parts, the whole thing is trivial 
+          */
+          wsyncup(form->w);
+        }
+    }
+  untouchwin(form->w);
+  return _nc_Position_Form_Cursor(form);
+}
+        
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Perform_Justification(
+|                                        FIELD  * field,
+|                                        WINDOW * win)
+|   
+|   Description   :  Output field with requested justification 
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Perform_Justification(FIELD  * field, WINDOW * win)
+{
+  char *bp;
+  int len;
+  int col  = 0;
+
+  bp  = Get_Start_Of_Data(field->buf,Buffer_Length(field));
+  len = (int)(After_End_Of_Data(field->buf,Buffer_Length(field)) - bp);
+
+  if (len>0)
+    {
+      assert(win && (field->drows == 1) && (field->dcols == field->cols));
+
+      switch(field->just)
+        {
+        case JUSTIFY_LEFT:
+          break;
+        case JUSTIFY_CENTER:
+          col = (field->cols - len)/2;
+          break;
+        case JUSTIFY_RIGHT:
+          col = field->cols - len;
+          break;
+        default:
+          break;
+        }
+
+      wmove(win,0,col);
+      waddnstr(win,bp,len);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Undo_Justification(
+|                                     FIELD  * field,
+|                                     WINDOW * win)
+|   
+|   Description   :  Display field without any justification, i.e.
+|                    left justified
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Undo_Justification(FIELD  * field, WINDOW * win)
+{
+  char *bp;
+  int len;
+
+  bp  = Get_Start_Of_Data(field->buf,Buffer_Length(field));
+  len = (int)(After_End_Of_Data(field->buf,Buffer_Length(field))-bp);
+
+  if (len>0)
+    {
+      assert(win != 0);
+      wmove(win,0,0);
+      waddnstr(win,bp,len);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Char(
+|                                           FIELDTYPE * typ,
+|                                           int ch,
+|                                           TypeArgument *argp)
+|   
+|   Description   :  Perform a single character check for character ch
+|                    according to the fieldtype instance.  
+|
+|   Return Values :  TRUE             - Character is valid
+|                    FALSE            - Character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Char(FIELDTYPE * typ, int ch, TypeArgument *argp)
+{
+  if (typ) 
+    {
+      if (typ->status & _LINKED_TYPE)
+        {
+          assert(argp != 0);
+          return(
+            Check_Char(typ->left ,ch,argp->left ) ||
+            Check_Char(typ->right,ch,argp->right) );
+        } 
+      else 
+        {
+          if (typ->ccheck)
+            return typ->ccheck(ch,(void *)argp);
+        }
+    }
+  return (isprint((unsigned char)ch) ? TRUE : FALSE);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Display_Or_Erase_Field(
+|                                           FIELD * field,
+|                                           bool bEraseFlag)
+|   
+|   Description   :  Create a subwindow for the field and display the
+|                    buffer contents (apply justification if required)
+|                    or simply erase the field.
+|
+|   Return Values :  E_OK           - on success
+|                    E_SYSTEM_ERROR - some error (typical no memory)
++--------------------------------------------------------------------------*/
+static int Display_Or_Erase_Field(FIELD * field, bool bEraseFlag)
+{
+  WINDOW *win;
+  WINDOW *fwin;
+
+  if (!field)
+    return E_SYSTEM_ERROR;
+
+  fwin = Get_Form_Window(field->form);
+  win  = derwin(fwin,
+                field->rows,field->cols,field->frow,field->fcol);
+
+  if (!win) 
+    return E_SYSTEM_ERROR;
+  else
+    {
+      if (field->opts & O_VISIBLE)
+        Set_Field_Window_Attributes(field,win);
+      else
+        {
+#if defined(__LSB_VERSION__)
+        /* getattrs() would be handy, but it is not part of LSB 4.0 */
+        attr_t fwinAttrs;
+        short  fwinPair;
+        wattr_get(fwin, &fwinAttrs, &fwinPair, 0);
+        wattr_set(win, fwinAttrs, fwinPair, 0);
+#else
+        wattrset(win,getattrs(fwin));
+#endif
+        }
+      werase(win);
+    }
+
+  if (!bEraseFlag)
+    {
+      if (field->opts & O_PUBLIC)
+        {
+          if (Justification_Allowed(field))
+            Perform_Justification(field,win);
+          else
+            Buffer_To_Window(field,win);
+        }
+      field->status &= ~_NEWTOP;
+    }
+  wsyncup(win);
+  delwin(win);
+  return E_OK;
+}
+
+/* Macros to preset the bEraseFlag */
+#define Display_Field(field) Display_Or_Erase_Field(field,FALSE)
+#define Erase_Field(field)   Display_Or_Erase_Field(field,TRUE)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Synchronize_Field(FIELD * field)
+|   
+|   Description   :  Synchronize the windows content with the value in
+|                    the buffer.
+|
+|   Return Values :  E_OK                - success
+|                    E_BAD_ARGUMENT      - invalid field pointer 
+|                    E_SYSTEM_ERROR      - some severe basic error
++--------------------------------------------------------------------------*/
+static int Synchronize_Field(FIELD * field)
+{
+  FORM *form;
+  int res = E_OK;
+
+  if (!field)
+    return(E_BAD_ARGUMENT);
+
+  if (((form=field->form) != (FORM *)0)
+      && Field_Really_Appears(field))
+    {
+      if (field == form->current)
+        { 
+          form->currow  = form->curcol = form->toprow = form->begincol = 0;
+          werase(form->w);
+      
+          if ( (field->opts & O_PUBLIC) && Justification_Allowed(field) )
+            Undo_Justification( field, form->w );
+          else
+            Buffer_To_Window( field, form->w );
+          
+          field->status |= _NEWTOP;
+          res = _nc_Refresh_Current_Field( form );
+        }
+      else
+        res = Display_Field( field );
+    }
+  field->status |= _CHANGED;
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Synchronize_Linked_Fields(FIELD * field)
+|   
+|   Description   :  Propagate the Synchronize_Field function to all linked
+|                    fields. The first error that occurs in the sequence
+|                    of updates is the returnvalue.
+|
+|   Return Values :  E_OK                - success
+|                    E_BAD_ARGUMENT      - invalid field pointer 
+|                    E_SYSTEM_ERROR      - some severe basic error
++--------------------------------------------------------------------------*/
+static int Synchronize_Linked_Fields(FIELD * field)
+{
+  FIELD *linked_field;
+  int res = E_OK;
+  int syncres;
+
+  if (!field)
+    return(E_BAD_ARGUMENT);
+
+  if (!field->link)
+    return(E_SYSTEM_ERROR);
+
+  for(linked_field = field->link; 
+      linked_field!= field;
+      linked_field = linked_field->link )
+    {
+      if (((syncres=Synchronize_Field(linked_field)) != E_OK) &&
+          (res==E_OK))
+        res = syncres;
+    }
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Synchronize_Attributes(FIELD * field)
+|   
+|   Description   :  If a fields visual attributes have changed, this
+|                    routine is called to propagate those changes to the
+|                    screen.  
+|
+|   Return Values :  E_OK             - success
+|                    E_BAD_ARGUMENT   - invalid field pointer
+|                    E_SYSTEM_ERROR   - some severe basic error
++--------------------------------------------------------------------------*/
+int _nc_Synchronize_Attributes(FIELD * field)
+{
+  FORM *form;
+  int res = E_OK;
+  WINDOW *formwin;
+
+  if (!field)
+    return(E_BAD_ARGUMENT);
+
+  if (((form=field->form) != (FORM *)0)
+      && Field_Really_Appears(field))
+    {    
+      if (form->current==field)
+        {
+          Synchronize_Buffer(form);
+          Set_Field_Window_Attributes(field,form->w);
+          werase(form->w);
+          if (field->opts & O_PUBLIC)
+            {
+              if (Justification_Allowed(field))
+                Undo_Justification(field,form->w);
+              else 
+                Buffer_To_Window(field,form->w);
+            }
+          else 
+            {
+              formwin = Get_Form_Window(form); 
+              copywin(form->w,formwin,
+                      0,0,
+                      field->frow,field->fcol,
+                      field->rows-1,field->cols-1,0);
+              wsyncup(formwin);
+              Buffer_To_Window(field,form->w);
+              field->status |= _NEWTOP; /* fake refresh to paint all */
+              _nc_Refresh_Current_Field(form);
+            }
+        }
+      else 
+        {
+          res = Display_Field(field);
+        }
+    }
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Synchronize_Options(FIELD * field,
+|                                                Field_Options newopts)
+|   
+|   Description   :  If a fields options have changed, this routine is
+|                    called to propagate these changes to the screen and
+|                    to really change the behaviour of the field.
+|
+|   Return Values :  E_OK                - success
+|                    E_BAD_ARGUMENT      - invalid field pointer 
+|                    E_SYSTEM_ERROR      - some severe basic error
++--------------------------------------------------------------------------*/
+int
+_nc_Synchronize_Options(FIELD *field, Field_Options newopts)
+{
+  Field_Options oldopts;
+  Field_Options changed_opts;
+  FORM *form;
+  int res = E_OK;
+
+  if (!field)
+    return(E_BAD_ARGUMENT);
+
+  oldopts      = field->opts;
+  changed_opts = oldopts ^ newopts;
+  field->opts  = newopts;
+  form         = field->form;
+
+  if (form)
+    {
+      if (form->current == field)
+        {
+          field->opts = oldopts;
+          return(E_CURRENT);
+        }
+
+      if (form->status & _POSTED)
+        {
+          if (form->curpage == field->page)
+            {
+              if (changed_opts & O_VISIBLE)
+                {
+                  if (newopts & O_VISIBLE)
+                    res = Display_Field(field);
+                  else
+                    res = Erase_Field(field);
+                }
+              else
+                {
+                  if ((changed_opts & O_PUBLIC) &&
+                      (newopts & O_VISIBLE))
+                    res = Display_Field(field);
+                }
+            }
+        }
+    }
+
+  if (changed_opts & O_STATIC)
+    {
+      bool single_line_field = Single_Line_Field(field);
+      int res2 = E_OK;
+
+      if (newopts & O_STATIC)
+        { /* the field becomes now static */
+          field->status &= ~_MAY_GROW;
+          /* if actually we have no hidden columns, justification may
+             occur again */
+          if (single_line_field                 &&
+              (field->cols == field->dcols)     &&
+              (field->just != NO_JUSTIFICATION) &&
+              Field_Really_Appears(field))
+            {
+              res2 = Display_Field(field);
+            }
+        }
+      else
+        { /* field is no longer static */
+          if ((field->maxgrow==0) ||
+              ( single_line_field && (field->dcols < field->maxgrow)) ||
+              (!single_line_field && (field->drows < field->maxgrow)))
+            {
+              field->status |= _MAY_GROW;
+              /* a field with justification now changes its behaviour,
+                 so we must redisplay it */
+              if (single_line_field                 &&
+                  (field->just != NO_JUSTIFICATION) &&
+                  Field_Really_Appears(field))
+                {
+                  res2 = Display_Field(field);
+                }        
+            }     
+        }
+      if (res2 != E_OK)
+        res = res2;
+    }
+
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Set_Current_Field(FORM  * form,
+|                                              FIELD * newfield)
+|   
+|   Description   :  Make the newfield the new current field.
+|
+|   Return Values :  E_OK                - success
+|                    E_BAD_ARGUMENT      - invalid form or field pointer 
+|                    E_SYSTEM_ERROR      - some severe basic error
++--------------------------------------------------------------------------*/
+int
+_nc_Set_Current_Field(FORM  *form, FIELD *newfield)
+{
+  FIELD  *field;
+  WINDOW *new_window;
+
+  if (!form || !newfield || !form->current || (newfield->form!=form))
+    return(E_BAD_ARGUMENT);
+
+  if ( (form->status & _IN_DRIVER) )
+    return(E_BAD_STATE);
+
+  if (!(form->field))
+    return(E_NOT_CONNECTED);
+
+  field = form->current;
+ 
+  if ((field!=newfield) || 
+      !(form->status & _POSTED))
+    {
+      if ((form->w) && 
+          (field->opts & O_VISIBLE) &&
+          (field->form->curpage == field->page))
+        {
+          _nc_Refresh_Current_Field(form);
+          if (field->opts & O_PUBLIC)
+            {
+              if (field->drows > field->rows)
+                {
+                  if (form->toprow==0)
+                    field->status &= ~_NEWTOP;
+                  else 
+                    field->status |= _NEWTOP;
+                } 
+              else 
+                {
+                  if (Justification_Allowed(field))
+                    {
+                      Window_To_Buffer(form->w,field);
+                      werase(form->w);
+                      Perform_Justification(field,form->w);
+                      wsyncup(form->w);
+                    }
+                }
+            }
+          delwin(form->w);
+        }
+      
+      field = newfield;
+
+      if (Has_Invisible_Parts(field))
+        new_window = newpad(field->drows,field->dcols);
+      else 
+        new_window = derwin(Get_Form_Window(form),
+                            field->rows,field->cols,field->frow,field->fcol);
+
+      if (!new_window) 
+        return(E_SYSTEM_ERROR);
+
+      form->current = field;
+      form->w       = new_window;
+      form->status &= ~_WINDOW_MODIFIED;
+      Set_Field_Window_Attributes(field,form->w);
+
+      if (Has_Invisible_Parts(field))
+        {
+          werase(form->w);
+          Buffer_To_Window(field,form->w);
+        } 
+      else 
+        {
+          if (Justification_Allowed(field))
+            {
+              werase(form->w);
+              Undo_Justification(field,form->w);
+              wsyncup(form->w);
+            }
+        }
+
+      untouchwin(form->w);
+    }
+
+  form->currow = form->curcol = form->toprow = form->begincol = 0;
+  return(E_OK);
+}
+
+/*----------------------------------------------------------------------------
+  Intra-Field Navigation routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Next_Character(FORM * form)
+|   
+|   Description   :  Move to the next character in the field. In a multiline
+|                    field this wraps at the end of the line.
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - at the rightmost position
++--------------------------------------------------------------------------*/
+static int IFN_Next_Character(FORM * form)
+{
+  FIELD *field = form->current;
+  
+  if ((++(form->curcol))==field->dcols)
+    {
+      if ((++(form->currow))==field->drows)
+        {
+#if GROW_IF_NAVIGATE
+          if (!Single_Line_Field(field) && Field_Grown(field,1)) {
+            form->curcol = 0;
+            return(E_OK);
+          }
+#endif
+          form->currow--;
+#if GROW_IF_NAVIGATE
+          if (Single_Line_Field(field) && Field_Grown(field,1))
+            return(E_OK);
+#endif
+          form->curcol--;
+          return(E_REQUEST_DENIED);
+        }
+      form->curcol = 0;
+    }
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Previous_Character(FORM * form)
+|   
+|   Description   :  Move to the previous character in the field. In a 
+|                    multiline field this wraps and the beginning of the 
+|                    line.
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - at the leftmost position
++--------------------------------------------------------------------------*/
+static int IFN_Previous_Character(FORM * form)
+{
+  if ((--(form->curcol))<0)
+    {
+      if ((--(form->currow))<0)
+        {
+          form->currow++;
+          form->curcol++;
+          return(E_REQUEST_DENIED);
+        }
+      form->curcol = form->current->dcols - 1;
+    }
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Next_Line(FORM * form)
+|   
+|   Description   :  Move to the beginning of the next line in the field
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - at the last line
++--------------------------------------------------------------------------*/
+static int IFN_Next_Line(FORM * form)
+{
+  FIELD *field = form->current;
+
+  if ((++(form->currow))==field->drows)
+    {
+#if GROW_IF_NAVIGATE
+      if (!Single_Line_Field(field) && Field_Grown(field,1))
+        return(E_OK);
+#endif
+      form->currow--;
+      return(E_REQUEST_DENIED);
+    }
+  form->curcol = 0;
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Previous_Line(FORM * form)
+|   
+|   Description   :  Move to the beginning of the previous line in the field
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - at the first line
++--------------------------------------------------------------------------*/
+static int IFN_Previous_Line(FORM * form)
+{
+  if ( (--(form->currow)) < 0 )
+    {
+      form->currow++;
+      return(E_REQUEST_DENIED);
+    }
+  form->curcol = 0;
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Next_Word(FORM * form)
+|   
+|   Description   :  Move to the beginning of the next word in the field.
+|
+|   Return Values :  E_OK             - success
+|                    E_REQUEST_DENIED - there is no next word
++--------------------------------------------------------------------------*/
+static int IFN_Next_Word(FORM * form)
+{
+  FIELD *field = form->current;
+  char  *bp    = Address_Of_Current_Position_In_Buffer(form);
+  char  *s;
+  char  *t;
+
+  /* We really need access to the data, so we have to synchronize */
+  Synchronize_Buffer(form);
+
+  /* Go to the first whitespace after the current position (including
+     current position). This is then the startpoint to look for the
+    next non-blank data */
+  s = Get_First_Whitespace_Character(bp,Buffer_Length(field) -
+                                     (int)(bp - field->buf));
+
+  /* Find the start of the next word */
+  t = Get_Start_Of_Data(s,Buffer_Length(field) -
+                        (int)(s - field->buf));
+#if !FRIENDLY_PREV_NEXT_WORD
+  if (s==t) 
+    return(E_REQUEST_DENIED);
+  else
+#endif
+    {
+      Adjust_Cursor_Position(form,t);
+      return(E_OK);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Previous_Word(FORM * form)
+|   
+|   Description   :  Move to the beginning of the previous word in the field.
+|
+|   Return Values :  E_OK             - success
+|                    E_REQUEST_DENIED - there is no previous word
++--------------------------------------------------------------------------*/
+static int IFN_Previous_Word(FORM * form)
+{
+  FIELD *field = form->current;
+  char  *bp    = Address_Of_Current_Position_In_Buffer(form);
+  char  *s;
+  char  *t;
+  bool  again = FALSE;
+
+  /* We really need access to the data, so we have to synchronize */
+  Synchronize_Buffer(form);
+
+  s = After_End_Of_Data(field->buf,(int)(bp-field->buf));
+  /* s points now right after the last non-blank in the buffer before bp.
+     If bp was in a word, s equals bp. In this case we must find the last
+     whitespace in the buffer before bp and repeat the game to really find
+     the previous word! */
+  if (s==bp)
+    again = TRUE;
+  
+  /* And next call now goes backward to look for the last whitespace
+     before that, pointing right after this, so it points to the begin
+     of the previous word. 
+  */
+  t = After_Last_Whitespace_Character(field->buf,(int)(s - field->buf));
+#if !FRIENDLY_PREV_NEXT_WORD
+  if (s==t) 
+    return(E_REQUEST_DENIED);
+#endif
+  if (again)
+    { /* and do it again, replacing bp by t */
+      s = After_End_Of_Data(field->buf,(int)(t - field->buf));
+      t = After_Last_Whitespace_Character(field->buf,(int)(s - field->buf));
+#if !FRIENDLY_PREV_NEXT_WORD
+      if (s==t) 
+        return(E_REQUEST_DENIED);
+#endif
+    }
+  Adjust_Cursor_Position(form,t);
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Beginning_Of_Field(FORM * form)
+|   
+|   Description   :  Place the cursor at the first non-pad character in
+|                    the field. 
+|
+|   Return Values :  E_OK             - success            
++--------------------------------------------------------------------------*/
+static int IFN_Beginning_Of_Field(FORM * form)
+{
+  FIELD *field = form->current;
+
+  Synchronize_Buffer(form);
+  Adjust_Cursor_Position(form,
+                 Get_Start_Of_Data(field->buf,Buffer_Length(field)));
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_End_Of_Field(FORM * form)
+|   
+|   Description   :  Place the cursor after the last non-pad character in
+|                    the field. If the field occupies the last position in
+|                    the buffer, the cursos is positioned on the last 
+|                    character.
+|
+|   Return Values :  E_OK              - success
++--------------------------------------------------------------------------*/
+static int IFN_End_Of_Field(FORM * form)
+{
+  FIELD *field = form->current;
+  char *pos;
+
+  Synchronize_Buffer(form);
+  pos = After_End_Of_Data(field->buf,Buffer_Length(field));
+  if (pos==(field->buf + Buffer_Length(field)))
+    pos--;
+  Adjust_Cursor_Position(form,pos);
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Beginning_Of_Line(FORM * form)
+|   
+|   Description   :  Place the cursor on the first non-pad character in
+|                    the current line of the field.
+|
+|   Return Values :  E_OK         - success
++--------------------------------------------------------------------------*/
+static int IFN_Beginning_Of_Line(FORM * form)
+{
+  FIELD *field = form->current;
+
+  Synchronize_Buffer(form);
+  Adjust_Cursor_Position(form,
+                 Get_Start_Of_Data(Address_Of_Current_Row_In_Buffer(form),
+                                   field->dcols));
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_End_Of_Line(FORM * form)
+|   
+|   Description   :  Place the cursor after the last non-pad character in the
+|                    current line of the field. If the field occupies the 
+|                    last column in the line, the cursor is positioned on the
+|                    last character of the line.
+|
+|   Return Values :  E_OK        - success
++--------------------------------------------------------------------------*/
+static int IFN_End_Of_Line(FORM * form)
+{
+  FIELD *field = form->current;
+  char *pos;
+  char *bp;
+
+  Synchronize_Buffer(form);
+  bp  = Address_Of_Current_Row_In_Buffer(form); 
+  pos = After_End_Of_Data(bp,field->dcols);
+  if (pos == (bp + field->dcols))
+    pos--;
+  Adjust_Cursor_Position(form,pos);
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Left_Character(FORM * form)
+|   
+|   Description   :  Move one character to the left in the current line.
+|                    This doesn't cycle.  
+|
+|   Return Values :  E_OK             - success
+|                    E_REQUEST_DENIED - already in first column
++--------------------------------------------------------------------------*/
+static int IFN_Left_Character(FORM * form)
+{
+  if ( (--(form->curcol)) < 0 )
+    {
+      form->curcol++;
+      return(E_REQUEST_DENIED);
+    }
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Right_Character(FORM * form)
+|   
+|   Description   :  Move one character to the right in the current line.
+|                    This doesn't cycle.
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - already in last column
++--------------------------------------------------------------------------*/
+static int IFN_Right_Character(FORM * form)
+{
+  if ( (++(form->curcol)) == form->current->dcols )
+    {
+#if GROW_IF_NAVIGATE
+      FIELD *field = form->current;
+      if (Single_Line_Field(field) && Field_Grown(field,1))
+        return(E_OK);
+#endif
+      --(form->curcol);
+      return(E_REQUEST_DENIED);
+    }
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Up_Character(FORM * form)
+|   
+|   Description   :  Move one line up. This doesn't cycle through the lines
+|                    of the field.
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - already in last column
++--------------------------------------------------------------------------*/
+static int IFN_Up_Character(FORM * form)
+{
+  if ( (--(form->currow)) < 0 )
+    {
+      form->currow++;
+      return(E_REQUEST_DENIED);
+    }
+  return(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int IFN_Down_Character(FORM * form)
+|   
+|   Description   :  Move one line down. This doesn't cycle through the
+|                    lines of the field.
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - already in last column
++--------------------------------------------------------------------------*/
+static int IFN_Down_Character(FORM * form)
+{
+  FIELD *field = form->current;
+
+  if ( (++(form->currow)) == field->drows )
+    {
+#if GROW_IF_NAVIGATE
+      if (!Single_Line_Field(field) && Field_Grown(field,1))
+        return(E_OK);
+#endif
+      --(form->currow);
+      return(E_REQUEST_DENIED);
+    }
+  return(E_OK);
+}
+/*----------------------------------------------------------------------------
+  END of Intra-Field Navigation routines 
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Vertical scrolling helper routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Generic(FORM *form, int lines)
+|
+|   Description   :  Scroll multi-line field forward (lines>0) or
+|                    backward (lines<0) this many lines.
+|
+|   Return Values :  E_OK              - success 
+|                    E_REQUEST_DENIED  - can't scroll
++--------------------------------------------------------------------------*/
+static int VSC_Generic(FORM *form, int lines)
+{
+  FIELD *field = form->current;
+  int res = E_REQUEST_DENIED;
+  int rows_to_go = (lines > 0 ? lines : -lines);
+
+  if (lines > 0)
+    {
+      if ( (rows_to_go + form->toprow) > (field->drows - field->rows) )
+        rows_to_go = (field->drows - field->rows - form->toprow);
+
+      if (rows_to_go > 0)
+        {
+          form->currow += rows_to_go;
+          form->toprow += rows_to_go;
+          res = E_OK;
+        }
+    }
+  else
+    {
+      if (rows_to_go > form->toprow)
+        rows_to_go = form->toprow;
+      
+      if (rows_to_go > 0)
+        {
+          form->currow -= rows_to_go;
+          form->toprow -= rows_to_go;
+          res = E_OK;
+        }
+    }
+  return(res);
+}
+/*----------------------------------------------------------------------------
+  End of Vertical scrolling helper routines
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Vertical scrolling routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Vertical_Scrolling(
+|                                           int (* const fct) (FORM *),
+|                                           FORM * form)
+|   
+|   Description   :  Performs the generic vertical scrolling routines. 
+|                    This has to check for a multi-line field and to set
+|                    the _NEWTOP flag if scrolling really occurred.
+|
+|   Return Values :  Propagated error code from low-level driver calls
++--------------------------------------------------------------------------*/
+static int Vertical_Scrolling(int (* const fct) (FORM *), FORM * form)
+{
+  int res = E_REQUEST_DENIED;
+
+  if (!Single_Line_Field(form->current))
+    {
+      res = fct(form);
+      if (res == E_OK)
+        form->current->status |= _NEWTOP;
+    }
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Line_Forward(FORM * form)
+|   
+|   Description   :  Scroll multi-line field forward a line
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data ahead
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Line_Forward(FORM * form)
+{
+  return VSC_Generic(form,1);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Line_Backward(FORM * form)
+|   
+|   Description   :  Scroll multi-line field backward a line
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data behind
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Line_Backward(FORM * form)
+{
+  return VSC_Generic(form,-1);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Page_Forward(FORM * form)
+|   
+|   Description   :  Scroll a multi-line field forward a page
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - no data ahead
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Page_Forward(FORM * form)
+{
+  return VSC_Generic(form,form->current->rows);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Half_Page_Forward(FORM * form)
+|   
+|   Description   :  Scroll a multi-line field forward half a page
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - no data ahead
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Half_Page_Forward(FORM * form)
+{
+  return VSC_Generic(form,(form->current->rows + 1)/2);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Page_Backward(FORM * form)
+|   
+|   Description   :  Scroll a multi-line field backward a page
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - no data behind
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Page_Backward(FORM * form)
+{
+  return VSC_Generic(form, -(form->current->rows));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int VSC_Scroll_Half_Page_Backward(FORM * form)
+|   
+|   Description   :  Scroll a multi-line field backward half a page
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - no data behind
++--------------------------------------------------------------------------*/
+static int VSC_Scroll_Half_Page_Backward(FORM * form)
+{
+  return VSC_Generic(form, -((form->current->rows + 1)/2));
+}
+/*----------------------------------------------------------------------------
+  End of Vertical scrolling routines
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Horizontal scrolling helper routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Generic(FORM *form, int columns)
+|
+|   Description   :  Scroll single-line field forward (columns>0) or
+|                    backward (columns<0) this many columns.
+|
+|   Return Values :  E_OK              - success 
+|                    E_REQUEST_DENIED  - can't scroll
++--------------------------------------------------------------------------*/
+static int HSC_Generic(FORM *form, int columns)
+{
+  FIELD *field = form->current;
+  int res = E_REQUEST_DENIED;
+  int cols_to_go = (columns > 0 ? columns : -columns);
+
+  if (columns > 0)
+    {
+      if ((cols_to_go + form->begincol) > (field->dcols - field->cols))
+        cols_to_go = field->dcols - field->cols - form->begincol;
+      
+      if (cols_to_go > 0)
+        {
+          form->curcol   += cols_to_go;
+          form->begincol += cols_to_go;
+          res = E_OK;
+        }
+    }
+  else
+    {
+      if ( cols_to_go > form->begincol )
+        cols_to_go = form->begincol;
+
+      if (cols_to_go > 0)
+        {
+          form->curcol   -= cols_to_go;
+          form->begincol -= cols_to_go;
+          res = E_OK;
+        }
+    }
+  return(res);
+}
+/*----------------------------------------------------------------------------
+  End of Horizontal scrolling helper routines
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Horizontal scrolling routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Horizontal_Scrolling(
+|                                          int (* const fct) (FORM *),
+|                                          FORM * form)
+|   
+|   Description   :  Performs the generic horizontal scrolling routines. 
+|                    This has to check for a single-line field.
+|
+|   Return Values :  Propagated error code from low-level driver calls
++--------------------------------------------------------------------------*/
+static int Horizontal_Scrolling(int (* const fct) (FORM *), FORM * form)
+{
+  if (Single_Line_Field(form->current))
+    return fct(form);
+  else
+    return(E_REQUEST_DENIED);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Scroll_Char_Forward(FORM * form)
+|   
+|   Description   :  Scroll single-line field forward a character
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data ahead
++--------------------------------------------------------------------------*/
+static int HSC_Scroll_Char_Forward(FORM *form)
+{
+  return HSC_Generic(form,1);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Scroll_Char_Backward(FORM * form)
+|   
+|   Description   :  Scroll single-line field backward a character
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data behind
++--------------------------------------------------------------------------*/
+static int HSC_Scroll_Char_Backward(FORM *form)
+{
+  return HSC_Generic(form,-1);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Horizontal_Line_Forward(FORM* form)
+|   
+|   Description   :  Scroll single-line field forward a line
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data ahead
++--------------------------------------------------------------------------*/
+static int HSC_Horizontal_Line_Forward(FORM * form)
+{
+  return HSC_Generic(form,form->current->cols);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Horizontal_Half_Line_Forward(FORM* form)
+|   
+|   Description   :  Scroll single-line field forward half a line
+|
+|   Return Values :  E_OK               - success
+|                    E_REQUEST_DENIED   - no data ahead
++--------------------------------------------------------------------------*/
+static int HSC_Horizontal_Half_Line_Forward(FORM * form)
+{
+  return HSC_Generic(form,(form->current->cols + 1)/2);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Horizontal_Line_Backward(FORM* form)
+|   
+|   Description   :  Scroll single-line field backward a line
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data behind
++--------------------------------------------------------------------------*/
+static int HSC_Horizontal_Line_Backward(FORM * form)
+{
+  return HSC_Generic(form,-(form->current->cols));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int HSC_Horizontal_Half_Line_Backward(FORM* form)
+|   
+|   Description   :  Scroll single-line field backward half a line
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - no data behind
++--------------------------------------------------------------------------*/
+static int HSC_Horizontal_Half_Line_Backward(FORM * form)
+{
+  return HSC_Generic(form,-((form->current->cols + 1)/2));
+}
+
+/*----------------------------------------------------------------------------
+  End of Horizontal scrolling routines
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for Field Editing
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Is_There_Room_For_A_Line(FORM * form)
+|   
+|   Description   :  Check whether or not there is enough room in the
+|                    buffer to enter a whole line.
+|
+|   Return Values :  TRUE   - there is enough space
+|                    FALSE  - there is not enough space
++--------------------------------------------------------------------------*/
+INLINE static bool Is_There_Room_For_A_Line(FORM * form)
+{
+  FIELD *field = form->current;
+  char *begin_of_last_line, *s;
+  
+  Synchronize_Buffer(form);
+  begin_of_last_line = Address_Of_Row_In_Buffer(field,(field->drows-1));
+  s  = After_End_Of_Data(begin_of_last_line,field->dcols);
+  return ((s==begin_of_last_line) ? TRUE : FALSE);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
+|   
+|   Description   :  Checks whether or not there is room for a new character
+|                    in the current line.
+|
+|   Return Values :  TRUE    - there is room
+|                    FALSE   - there is not enough room (line full)
++--------------------------------------------------------------------------*/
+INLINE static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
+{
+  int last_char_in_line;
+
+  wmove(form->w,form->currow,form->current->dcols-1);
+  last_char_in_line  = (int)(winch(form->w) & A_CHARTEXT);
+  wmove(form->w,form->currow,form->curcol);
+  return (((last_char_in_line == form->current->pad) ||
+           is_blank(last_char_in_line)) ? TRUE : FALSE);
+}
+
+#define There_Is_No_Room_For_A_Char_In_Line(f) \
+  !Is_There_Room_For_A_Char_In_Line(f)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Insert_String(
+|                                             FORM * form,
+|                                             int row,
+|                                             char *txt,
+|                                             int  len )
+|   
+|   Description   :  Insert the 'len' characters beginning at pointer 'txt'
+|                    into the 'row' of the 'form'. The insertion occurs
+|                    on the beginning of the row, all other characters are
+|                    moved to the right. After the text a pad character will 
+|                    be inserted to separate the text from the rest. If
+|                    necessary the insertion moves characters on the next
+|                    line to make place for the requested insertion string.
+|
+|   Return Values :  E_OK              - success 
+|                    E_REQUEST_DENIED  -
+|                    E_SYSTEM_ERROR    - system error
++--------------------------------------------------------------------------*/
+static int Insert_String(FORM *form, int row, char *txt, int len)
+{ 
+  FIELD  *field    = form->current;
+  char *bp         = Address_Of_Row_In_Buffer(field,row);
+  int datalen      = (int)(After_End_Of_Data(bp,field->dcols) - bp);
+  int freelen      = field->dcols - datalen;
+  int requiredlen  = len+1;
+  char *split;
+  int result = E_REQUEST_DENIED;
+  char *Space;
+
+  Space = (char*)malloc(2*sizeof(char));
+  strcpy(Space, " ");
+
+  if (freelen >= requiredlen)
+    {
+      wmove(form->w,row,0);
+      winsnstr(form->w,txt,len);
+      wmove(form->w,row,len);
+      winsnstr(form->w,Space,1);
+      free(Space);
+      return E_OK;
+    }
+  else
+    { /* we have to move characters on the next line. If we are on the
+         last line this may work, if the field is growable */
+      if ((row == (field->drows - 1)) && Growable(field))
+        {
+          if (!Field_Grown(field,1))
+            {
+            free(Space);
+            return(E_SYSTEM_ERROR);
+            }
+          /* !!!Side-Effect : might be changed due to growth!!! */
+          bp = Address_Of_Row_In_Buffer(field,row); 
+        }
+
+      if (row < (field->drows - 1)) 
+        { 
+          split = After_Last_Whitespace_Character(bp,
+                    (int)(Get_Start_Of_Data(bp + field->dcols - requiredlen ,
+                                            requiredlen) - bp));
+          /* split points now to the first character of the portion of the
+             line that must be moved to the next line */
+          datalen = (int)(split-bp); /* + freelen has to stay on this line   */
+          freelen = field->dcols - (datalen + freelen); /* for the next line */
+
+          if ((result=Insert_String(form,row+1,split,freelen))==E_OK) 
+            {
+              wmove(form->w,row,datalen);
+              wclrtoeol(form->w);
+              wmove(form->w,row,0);
+              winsnstr(form->w,txt,len);
+              wmove(form->w,row,len);
+              winsnstr(form->w,Space,1);
+              free(Space);
+              return E_OK;
+            }
+        }
+      free(Space);
+      return(result);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Wrapping_Not_Necessary_Or_Wrapping_Ok(
+|                                             FORM * form)
+|   
+|   Description   :  If a character has been entered into a field, it may
+|                    be that wrapping has to occur. This routine checks
+|                    whether or not wrapping is required and if so, performs
+|                    the wrapping.
+|
+|   Return Values :  E_OK              - no wrapping required or wrapping
+|                                        was successful
+|                    E_REQUEST_DENIED  -
+|                    E_SYSTEM_ERROR    - some system error
++--------------------------------------------------------------------------*/
+static int Wrapping_Not_Necessary_Or_Wrapping_Ok(FORM * form)
+{
+  FIELD  *field = form->current;
+  int result = E_REQUEST_DENIED;
+  bool Last_Row = ((field->drows - 1) == form->currow);
+
+  if ( (field->opts & O_WRAP)                     &&  /* wrapping wanted     */
+      (!Single_Line_Field(field))                 &&  /* must be multi-line  */
+      (There_Is_No_Room_For_A_Char_In_Line(form)) &&  /* line is full        */
+      (!Last_Row || Growable(field))               )  /* there are more lines*/
+    {
+      char *bp;
+      char *split;
+      int chars_to_be_wrapped;
+      int chars_to_remain_on_line;
+      if (Last_Row)
+        { /* the above logic already ensures, that in this case the field
+             is growable */
+          if (!Field_Grown(field,1))
+            return E_SYSTEM_ERROR;
+        }
+      bp = Address_Of_Current_Row_In_Buffer(form);
+      Window_To_Buffer(form->w,field);
+      split = After_Last_Whitespace_Character(bp,field->dcols);
+      /* split points to the first character of the sequence to be brought
+         on the next line */
+      chars_to_remain_on_line = (int)(split - bp);
+      chars_to_be_wrapped     = field->dcols - chars_to_remain_on_line;
+      if (chars_to_remain_on_line > 0)
+        {
+          if ((result=Insert_String(form,form->currow+1,split,
+                                    chars_to_be_wrapped)) == E_OK)
+            {
+              wmove(form->w,form->currow,chars_to_remain_on_line);
+              wclrtoeol(form->w);
+              if (form->curcol >= chars_to_remain_on_line)
+                {
+                  form->currow++;
+                  form->curcol -= chars_to_remain_on_line;
+                }
+              return E_OK;
+            }
+        }
+      else
+        return E_OK;
+      if (result!=E_OK)
+        {
+          wmove(form->w,form->currow,form->curcol);
+          wdelch(form->w);
+          Window_To_Buffer(form->w,field);
+          result = E_REQUEST_DENIED;
+        }
+    }
+  else
+    result = E_OK; /* wrapping was not necessary */
+  return(result);
+}
+
+/*----------------------------------------------------------------------------
+  Field Editing routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Field_Editing(
+|                                    int (* const fct) (FORM *),
+|                                    FORM * form)
+|   
+|   Description   :  Generic routine for field editing requests. The driver
+|                    routines are only called for editable fields, the
+|                    _WINDOW_MODIFIED flag is set if editing occurred.
+|                    This is somewhat special due to the overload semantics
+|                    of the NEW_LINE and DEL_PREV requests.
+|
+|   Return Values :  Error code from low level drivers.
++--------------------------------------------------------------------------*/
+static int Field_Editing(int (* const fct) (FORM *), FORM * form)
+{
+  int res = E_REQUEST_DENIED;
+
+  /* We have to deal here with the specific case of the overloaded 
+     behaviour of New_Line and Delete_Previous requests.
+     They may end up in navigational requests if we are on the first
+     character in a field. But navigation is also allowed on non-
+     editable fields.
+  */ 
+  if ((fct==FE_Delete_Previous)            && 
+      (form->opts & O_BS_OVERLOAD)         &&
+      First_Position_In_Current_Field(form) )
+    {
+      res = Inter_Field_Navigation(FN_Previous_Field,form);
+    }
+  else
+    {
+      if (fct==FE_New_Line)
+        {
+          if ((form->opts & O_NL_OVERLOAD)         &&
+              First_Position_In_Current_Field(form))
+            {
+              res = Inter_Field_Navigation(FN_Next_Field,form);
+            }
+          else
+            /* FE_New_Line deals itself with the _WINDOW_MODIFIED flag */
+            res = fct(form);
+        }
+      else
+        {
+          /* From now on, everything must be editable */
+          if (form->current->opts & O_EDIT)
+            {
+              res = fct(form);
+              if (res==E_OK)
+                form->status |= _WINDOW_MODIFIED;
+            }
+        }
+    }
+  return res;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_New_Line(FORM * form)
+|   
+|   Description   :  Perform a new line request. This is rather complex
+|                    compared to other routines in this code due to the 
+|                    rather difficult to understand description in the
+|                    manuals.
+|
+|   Return Values :  E_OK               - success
+|                    E_REQUEST_DENIED   - new line not allowed
+|                    E_SYSTEM_ERROR     - system error
++--------------------------------------------------------------------------*/
+static int FE_New_Line(FORM * form)
+{
+  FIELD  *field = form->current;
+  char *bp, *t;
+  bool Last_Row = ((field->drows - 1)==form->currow);
+  
+  if (form->status & _OVLMODE) 
+    {
+      if (Last_Row && 
+          (!(Growable(field) && !Single_Line_Field(field))))
+        {
+          if (!(form->opts & O_NL_OVERLOAD))
+            return(E_REQUEST_DENIED);
+          wclrtoeol(form->w);
+          /* we have to set this here, although it is also
+             handled in the generic routine. The reason is,
+             that FN_Next_Field may fail, but the form is
+             definitively changed */
+          form->status |= _WINDOW_MODIFIED;
+          return Inter_Field_Navigation(FN_Next_Field,form);
+        }
+      else 
+        {
+          if (Last_Row && !Field_Grown(field,1))
+            { /* N.B.: due to the logic in the 'if', LastRow==TRUE
+                 means here that the field is growable and not
+                 a single-line field */
+              return(E_SYSTEM_ERROR);
+            }
+          wclrtoeol(form->w);
+          form->currow++;
+          form->curcol = 0;
+          form->status |= _WINDOW_MODIFIED;
+          return(E_OK);
+        }
+    }
+  else 
+    { /* Insert Mode */
+      if (Last_Row &&
+          !(Growable(field) && !Single_Line_Field(field)))
+        {
+          if (!(form->opts & O_NL_OVERLOAD))
+            return(E_REQUEST_DENIED);
+          return Inter_Field_Navigation(FN_Next_Field,form);
+        }
+      else 
+        {
+          bool May_Do_It = !Last_Row && Is_There_Room_For_A_Line(form);
+          
+          if (!(May_Do_It || Growable(field)))
+            return(E_REQUEST_DENIED);
+          if (!May_Do_It && !Field_Grown(field,1))
+            return(E_SYSTEM_ERROR);
+          
+          bp= Address_Of_Current_Position_In_Buffer(form);
+          t = After_End_Of_Data(bp,field->dcols - form->curcol);
+          wclrtoeol(form->w);
+          form->currow++;
+          form->curcol=0;
+          wmove(form->w,form->currow,form->curcol);
+          winsertln(form->w);
+          waddnstr(form->w,bp,(int)(t-bp));
+          form->status |= _WINDOW_MODIFIED;
+          return E_OK;
+        }
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Insert_Character(FORM * form)
+|   
+|   Description   :  Insert blank character at the cursor position
+|
+|   Return Values :  E_OK
+|                    E_REQUEST_DENIED
++--------------------------------------------------------------------------*/
+static int FE_Insert_Character(FORM * form)
+{
+  FIELD *field = form->current;
+  int result = E_REQUEST_DENIED;
+
+  if (Check_Char(field->type,(int)C_BLANK,(TypeArgument *)(field->arg)))
+    {
+      bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
+
+      if (There_Is_Room ||
+          ((Single_Line_Field(field) && Growable(field))))
+        {
+          if (!There_Is_Room && !Field_Grown(field,1))
+            result =  E_SYSTEM_ERROR;
+          else
+            {
+              winsch(form->w,(chtype)C_BLANK);
+              result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form);
+            }
+        }
+    }
+  return result;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Insert_Line(FORM * form)
+|   
+|   Description   :  Insert a blank line at the cursor position
+|
+|   Return Values :  E_OK               - success
+|                    E_REQUEST_DENIED   - line can not be inserted
++--------------------------------------------------------------------------*/
+static int FE_Insert_Line(FORM * form)
+{
+  FIELD *field = form->current;
+  int result = E_REQUEST_DENIED;
+
+  if (Check_Char(field->type,(int)C_BLANK,(TypeArgument *)(field->arg)))
+    {
+      bool Maybe_Done = (form->currow!=(field->drows-1)) && 
+                        Is_There_Room_For_A_Line(form);
+
+      if (!Single_Line_Field(field) &&
+          (Maybe_Done || Growable(field)))
+        {
+          if (!Maybe_Done && !Field_Grown(field,1))
+            result = E_SYSTEM_ERROR;
+          else
+            {
+              form->curcol = 0;
+              winsertln(form->w);
+              result = E_OK;
+            }
+        }
+    }
+  return result;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Delete_Character(FORM * form)
+|   
+|   Description   :  Delete character at the cursor position
+|
+|   Return Values :  E_OK    - success
++--------------------------------------------------------------------------*/
+static int FE_Delete_Character(FORM * form)
+{
+  wdelch(form->w);
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Delete_Previous(FORM * form)
+|   
+|   Description   :  Delete character before cursor. Again this is a rather
+|                    difficult piece compared to others due to the overloading
+|                    semantics of backspace.
+|                    N.B.: The case of overloaded BS on first field position
+|                          is already handled in the generic routine.
+|
+|   Return Values :  E_OK                - success
+|                    E_REQUEST_DENIED    - Character can't be deleted
++--------------------------------------------------------------------------*/
+static int FE_Delete_Previous(FORM * form)
+{
+  FIELD  *field = form->current;
+  
+  if (First_Position_In_Current_Field(form))
+    return E_REQUEST_DENIED;
+
+  if ( (--(form->curcol))<0 )
+    {
+      char *this_line, *prev_line, *prev_end, *this_end;
+      
+      form->curcol++;
+      if (form->status & _OVLMODE) 
+        return E_REQUEST_DENIED;
+      
+      prev_line = Address_Of_Row_In_Buffer(field,(form->currow-1));
+      this_line = Address_Of_Row_In_Buffer(field,(form->currow));
+      Synchronize_Buffer(form);
+      prev_end = After_End_Of_Data(prev_line,field->dcols);
+      this_end = After_End_Of_Data(this_line,field->dcols);
+      if ((int)(this_end-this_line) > 
+          (field->cols-(int)(prev_end-prev_line))) 
+        return E_REQUEST_DENIED;
+      wdeleteln(form->w);
+      Adjust_Cursor_Position(form,prev_end);
+      wmove(form->w,form->currow,form->curcol);
+      waddnstr(form->w,this_line,(int)(this_end-this_line));
+    } 
+  else 
+    {
+      wmove(form->w,form->currow,form->curcol);
+      wdelch(form->w);
+    }
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Delete_Line(FORM * form)
+|   
+|   Description   :  Delete line at cursor position.
+|
+|   Return Values :  E_OK  - success
++--------------------------------------------------------------------------*/
+static int FE_Delete_Line(FORM * form)
+{
+  form->curcol = 0;
+  wdeleteln(form->w);
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Delete_Word(FORM * form)
+|   
+|   Description   :  Delete word at cursor position
+|
+|   Return Values :  E_OK               - success
+|                    E_REQUEST_DENIED   - failure
++--------------------------------------------------------------------------*/
+static int FE_Delete_Word(FORM * form)
+{
+  FIELD  *field = form->current;
+  char   *bp = Address_Of_Current_Row_In_Buffer(form);
+  char   *ep = bp + field->dcols;
+  char   *cp = bp + form->curcol;
+  char *s;
+  
+  Synchronize_Buffer(form);
+  if (is_blank(*cp)) 
+    return E_REQUEST_DENIED; /* not in word */
+
+  /* move cursor to begin of word and erase to end of screen-line */
+  Adjust_Cursor_Position(form,
+                         After_Last_Whitespace_Character(bp,form->curcol)); 
+  wmove(form->w,form->currow,form->curcol);
+  wclrtoeol(form->w);
+
+  /* skip over word in buffer */
+  s = Get_First_Whitespace_Character(cp,(int)(ep-cp)); 
+  /* to begin of next word    */
+  s = Get_Start_Of_Data(s,(int)(ep - s));
+  if ( (s!=cp) && !is_blank(*s))
+    {
+      /* copy remaining line to window */
+      waddnstr(form->w,s,(int)(s - After_End_Of_Data(s,(int)(ep - s))));
+    }
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Clear_To_End_Of_Line(FORM * form)
+|   
+|   Description   :  Clear to end of current line.
+|
+|   Return Values :  E_OK   - success
++--------------------------------------------------------------------------*/
+static int FE_Clear_To_End_Of_Line(FORM * form)
+{
+  wclrtoeol(form->w);
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Clear_To_End_Of_Form(FORM * form)
+|   
+|   Description   :  Clear to end of form.
+|
+|   Return Values :  E_OK   - success
++--------------------------------------------------------------------------*/
+static int FE_Clear_To_End_Of_Form(FORM * form)
+{
+  wclrtobot(form->w);
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FE_Clear_Field(FORM * form)
+|   
+|   Description   :  Clear entire field.
+|
+|   Return Values :  E_OK   - success
++--------------------------------------------------------------------------*/
+static int FE_Clear_Field(FORM * form)
+{
+  form->currow = form->curcol = 0;
+  werase(form->w);
+  return E_OK;
+}
+/*----------------------------------------------------------------------------
+  END of Field Editing routines 
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Edit Mode routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int EM_Overlay_Mode(FORM * form)
+|   
+|   Description   :  Switch to overlay mode.
+|
+|   Return Values :  E_OK   - success
++--------------------------------------------------------------------------*/
+static int EM_Overlay_Mode(FORM * form)
+{
+  form->status |= _OVLMODE;
+  return E_OK;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int EM_Insert_Mode(FORM * form)
+|   
+|   Description   :  Switch to insert mode
+|
+|   Return Values :  E_OK   - success
++--------------------------------------------------------------------------*/
+static int EM_Insert_Mode(FORM * form)
+{
+  form->status &= ~_OVLMODE;
+  return E_OK;
+}
+
+/*----------------------------------------------------------------------------
+  END of Edit Mode routines 
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for Choice Requests
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Next_Choice(
+|                                            FIELDTYPE * typ,
+|                                            FIELD * field,
+|                                            TypeArgument *argp)
+|   
+|   Description   :  Get the next field choice. For linked types this is
+|                    done recursively.
+|
+|   Return Values :  TRUE    - next choice successfully retrieved
+|                    FALSE   - couldn't retrieve next choice
++--------------------------------------------------------------------------*/
+static bool Next_Choice(FIELDTYPE * typ, FIELD *field, TypeArgument *argp)
+{
+  if (!typ || !(typ->status & _HAS_CHOICE)) 
+    return FALSE;
+
+  if (typ->status & _LINKED_TYPE)
+    {
+      assert(argp != 0);
+      return(
+             Next_Choice(typ->left ,field,argp->left) ||
+             Next_Choice(typ->right,field,argp->right) );
+    } 
+  else
+    {
+      assert(typ->next != 0);
+      return typ->next(field,(void *)argp);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Previous_Choice(
+|                                                FIELDTYPE * typ,
+|                                                FIELD * field,
+|                                                TypeArgument *argp)
+|   
+|   Description   :  Get the previous field choice. For linked types this
+|                    is done recursively.
+|
+|   Return Values :  TRUE    - previous choice successfully retrieved
+|                    FALSE   - couldn't retrieve previous choice
++--------------------------------------------------------------------------*/
+static bool Previous_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
+{
+  if (!typ || !(typ->status & _HAS_CHOICE)) 
+    return FALSE;
+
+  if (typ->status & _LINKED_TYPE)
+    {
+      assert(argp != 0);
+      return(
+             Previous_Choice(typ->left ,field,argp->left) ||
+             Previous_Choice(typ->right,field,argp->right));
+    } 
+  else 
+    {
+      assert(typ->prev != 0);
+      return typ->prev(field,(void *)argp);
+    }
+}
+/*----------------------------------------------------------------------------
+  End of Helper routines for Choice Requests
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Routines for Choice Requests
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int CR_Next_Choice(FORM * form)
+|   
+|   Description   :  Get the next field choice.
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - next choice couldn't be retrieved
++--------------------------------------------------------------------------*/
+static int CR_Next_Choice(FORM * form)
+{
+  FIELD *field = form->current;
+  Synchronize_Buffer(form);
+  return ((Next_Choice(field->type,field,(TypeArgument *)(field->arg))) ? 
+          E_OK : E_REQUEST_DENIED);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int CR_Previous_Choice(FORM * form)
+|   
+|   Description   :  Get the previous field choice.
+|
+|   Return Values :  E_OK              - success
+|                    E_REQUEST_DENIED  - prev. choice couldn't be retrieved
++--------------------------------------------------------------------------*/
+static int CR_Previous_Choice(FORM * form)
+{
+  FIELD *field = form->current;
+  Synchronize_Buffer(form);
+  return ((Previous_Choice(field->type,field,(TypeArgument *)(field->arg))) ? 
+          E_OK : E_REQUEST_DENIED);
+}
+/*----------------------------------------------------------------------------
+  End of Routines for Choice Requests
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for Field Validations.
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Field(
+|                                            FIELDTYPE * typ,
+|                                            FIELD * field,
+|                                            TypeArgument * argp)
+|   
+|   Description   :  Check the field according to its fieldtype and its
+|                    actual arguments. For linked fieldtypes this is done
+|                    recursively.
+|
+|   Return Values :  TRUE       - field is valid
+|                    FALSE      - field is invalid.
++--------------------------------------------------------------------------*/
+static bool Check_Field(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
+{
+  if (typ)
+    {
+      if (field->opts & O_NULLOK)
+        {
+          char *bp = field->buf;
+          assert(bp != 0);
+          while(is_blank(*bp))
+            { bp++; }
+          if (*bp == '\0') 
+            return TRUE;
+        }
+
+      if (typ->status & _LINKED_TYPE)
+        {
+          assert(argp != 0);
+          return( 
+                 Check_Field(typ->left ,field,argp->left ) ||
+                 Check_Field(typ->right,field,argp->right) );
+        }
+      else 
+        {
+          if (typ->fcheck)
+            return typ->fcheck(field,(void *)argp);
+        }
+    }
+  return TRUE;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  bool _nc_Internal_Validation(FORM * form )
+|   
+|   Description   :  Validate the current field of the form.  
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+bool
+_nc_Internal_Validation(FORM *form)
+{
+  FIELD *field;
+
+  field = form->current; 
+  
+  Synchronize_Buffer(form);
+  if ((form->status & _FCHECK_REQUIRED) ||
+      (!(field->opts & O_PASSOK)))
+    {
+      if (!Check_Field(field->type,field,(TypeArgument *)(field->arg)))
+        return FALSE;
+      form->status  &= ~_FCHECK_REQUIRED;
+      field->status |= _CHANGED;
+      Synchronize_Linked_Fields(field);
+    }
+  return TRUE;
+}
+/*----------------------------------------------------------------------------
+  End of Helper routines for Field Validations.
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Routines for Field Validation.
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FV_Validation(FORM * form)
+|   
+|   Description   :  Validate the current field of the form.
+|
+|   Return Values :  E_OK             - field valid
+|                    E_INVALID_FIELD  - field not valid
++--------------------------------------------------------------------------*/
+static int FV_Validation(FORM * form)
+{
+  if (_nc_Internal_Validation(form))
+    return E_OK;
+  else
+    return E_INVALID_FIELD;
+}
+/*----------------------------------------------------------------------------
+  End of routines for Field Validation.
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for Inter-Field Navigation
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Next_Field_On_Page(FIELD * field)
+|   
+|   Description   :  Get the next field after the given field on the current 
+|                    page. The order of fields is the one defined by the
+|                    fields array. Only visible and active fields are
+|                    counted.
+|
+|   Return Values :  Pointer to the next field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Next_Field_On_Page(FIELD * field)
+{
+  FORM  *form = field->form;
+  FIELD **field_on_page = &form->field[field->index];
+  FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
+  FIELD **last_on_page  = &form->field[form->page[form->curpage].pmax];
+
+  do
+    {
+      field_on_page = 
+        (field_on_page==last_on_page) ? first_on_page : field_on_page + 1;
+      if (Field_Is_Selectable(*field_on_page))
+        break;
+    } while(field!=(*field_on_page));  
+  return(*field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  FIELD* _nc_First_Active_Field(FORM * form)
+|   
+|   Description   :  Get the first active field on the current page,
+|                    if there are such. If there are none, get the first
+|                    visible field on the page. If there are also none,
+|                    we return the first field on page and hope the best.
+|
+|   Return Values :  Pointer to calculated field.
++--------------------------------------------------------------------------*/
+FIELD*
+_nc_First_Active_Field(FORM * form)
+{
+  FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
+  FIELD *proposed = Next_Field_On_Page(*last_on_page);
+
+  if (proposed == *last_on_page)
+    { /* there might be the special situation, where there is no 
+         active and visible field on the current page. We then select
+         the first visible field on this readonly page
+      */
+      if (Field_Is_Not_Selectable(proposed))
+        {
+          FIELD **field = &form->field[proposed->index];
+          FIELD **first = &form->field[form->page[form->curpage].pmin];
+
+          do
+            {
+              field = (field==last_on_page) ? first : field + 1;
+              if (((*field)->opts & O_VISIBLE))
+                break;
+            } while(proposed!=(*field));
+          
+          proposed = *field;
+
+          if ((proposed == *last_on_page) && !(proposed->opts&O_VISIBLE))
+            { /* This means, there is also no visible field on the page.
+                 So we propose the first one and hope the very best... 
+                 Some very clever user has designed a readonly and invisible
+                 page on this form.
+               */
+              proposed = *first;
+            }
+        }
+    }
+  return(proposed);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Previous_Field_On_Page(FIELD * field)
+|   
+|   Description   :  Get the previous field before the given field on the 
+|                    current page. The order of fields is the one defined by 
+|                    the fields array. Only visible and active fields are
+|                    counted.
+|
+|   Return Values :  Pointer to the previous field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Previous_Field_On_Page(FIELD * field)
+{
+  FORM  *form   = field->form;
+  FIELD **field_on_page = &form->field[field->index];
+  FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
+  FIELD **last_on_page  = &form->field[form->page[form->curpage].pmax];
+  
+  do
+    {
+      field_on_page = 
+        (field_on_page==first_on_page) ? last_on_page : field_on_page - 1;
+      if (Field_Is_Selectable(*field_on_page))
+        break;
+    } while(field!=(*field_on_page));
+  
+  return (*field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Sorted_Next_Field(FIELD * field)
+|   
+|   Description   :  Get the next field after the given field on the current 
+|                    page. The order of fields is the one defined by the
+|                    (row,column) geometry, rows are major.
+|
+|   Return Values :  Pointer to the next field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Sorted_Next_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+
+  do
+    {
+      field_on_page = field_on_page->snext;
+      if (Field_Is_Selectable(field_on_page))
+        break;
+    } while(field_on_page!=field);
+  
+  return (field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Sorted_Previous_Field(FIELD * field)
+|   
+|   Description   :  Get the previous field before the given field on the 
+|                    current page. The order of fields is the one defined 
+|                    by the (row,column) geometry, rows are major.
+|
+|   Return Values :  Pointer to the previous field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Sorted_Previous_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+
+  do
+    {
+      field_on_page = field_on_page->sprev;
+      if (Field_Is_Selectable(field_on_page))
+        break;
+    } while(field_on_page!=field);
+  
+  return (field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Left_Neighbour_Field(FIELD * field)
+|   
+|   Description   :  Get the left neighbour of the field on the same line
+|                    and the same page. Cycles through the line.
+|
+|   Return Values :  Pointer to left neighbour field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Left_Neighbour_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+
+  /* For a field that has really a left neighbour, the while clause
+     immediately fails and the loop is left, positioned at the right
+     neighbour. Otherwise we cycle backwards through the sorted fieldlist
+     until we enter the same line (from the right end).
+  */
+  do
+    {
+      field_on_page = Sorted_Previous_Field(field_on_page);
+    } while(field_on_page->frow != field->frow);
+  
+  return (field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Right_Neighbour_Field(FIELD * field)
+|   
+|   Description   :  Get the right neighbour of the field on the same line
+|                    and the same page.
+|
+|   Return Values :  Pointer to right neighbour field.
++--------------------------------------------------------------------------*/
+INLINE static FIELD *Right_Neighbour_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+
+  /* See the comments on Left_Neighbour_Field to understand how it works */
+  do
+    {
+      field_on_page = Sorted_Next_Field(field_on_page);
+    } while(field_on_page->frow != field->frow);
+  
+  return (field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Upper_Neighbour_Field(FIELD * field)
+|   
+|   Description   :  Because of the row-major nature of sorting the fields,
+|                    its more difficult to define whats the upper neighbour
+|                    field really means. We define that it must be on a
+|                    'previous' line (cyclic order!) and is the rightmost
+|                    field laying on the left side of the given field. If
+|                    this set is empty, we take the first field on the line.
+|
+|   Return Values :  Pointer to the upper neighbour field.
++--------------------------------------------------------------------------*/
+static FIELD *Upper_Neighbour_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+  int frow = field->frow;
+  int fcol = field->fcol;
+
+  /* Walk back to the 'previous' line. The second term in the while clause
+     just guarantees that we stop if we cycled through the line because
+     there might be no 'previous' line if the page has just one line.
+  */
+  do
+    {
+      field_on_page = Sorted_Previous_Field(field_on_page);
+    } while(field_on_page->frow==frow && field_on_page->fcol!=fcol);
+  
+  if (field_on_page->frow!=frow)
+    { /* We really found a 'previous' line. We are positioned at the
+         rightmost field on this line */
+      frow = field_on_page->frow; 
+
+      /* We walk to the left as long as we are really right of the 
+         field. */
+      while(field_on_page->frow==frow && field_on_page->fcol>fcol)
+        field_on_page = Sorted_Previous_Field(field_on_page);
+
+      /* If we wrapped, just go to the right which is the first field on 
+         the row */
+      if (field_on_page->frow!=frow)
+        field_on_page = Sorted_Next_Field(field_on_page);
+    }
+  
+  return (field_on_page);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static FIELD *Down_Neighbour_Field(FIELD * field)
+|   
+|   Description   :  Because of the row-major nature of sorting the fields,
+|                    its more difficult to define whats the down neighbour
+|                    field really means. We define that it must be on a
+|                    'next' line (cyclic order!) and is the leftmost
+|                    field laying on the right side of the given field. If
+|                    this set is empty, we take the last field on the line.
+|
+|   Return Values :  Pointer to the upper neighbour field.
++--------------------------------------------------------------------------*/
+static FIELD *Down_Neighbour_Field(FIELD * field)
+{
+  FIELD *field_on_page = field;
+  int frow = field->frow;
+  int fcol = field->fcol;
+
+  /* Walk forward to the 'next' line. The second term in the while clause
+     just guarantees that we stop if we cycled through the line because
+     there might be no 'next' line if the page has just one line.
+  */
+  do
+    {
+      field_on_page = Sorted_Next_Field(field_on_page);
+    } while(field_on_page->frow==frow && field_on_page->fcol!=fcol);
+
+  if (field_on_page->frow!=frow)
+    { /* We really found a 'next' line. We are positioned at the rightmost
+         field on this line */
+      frow = field_on_page->frow;
+
+      /* We walk to the right as long as we are really left of the 
+         field. */
+      while(field_on_page->frow==frow && field_on_page->fcol<fcol)
+        field_on_page = Sorted_Next_Field(field_on_page);
+
+      /* If we wrapped, just go to the left which is the last field on 
+         the row */
+      if (field_on_page->frow!=frow)
+        field_on_page = Sorted_Previous_Field(field_on_page);
+    }
+  
+  return(field_on_page);
+}
+
+/*----------------------------------------------------------------------------
+  Inter-Field Navigation routines
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Inter_Field_Navigation(
+|                                           int (* const fct) (FORM *),
+|                                           FORM * form)
+|   
+|   Description   :  Generic behaviour for changing the current field, the
+|                    field is left and a new field is entered. So the field
+|                    must be validated and the field init/term hooks must
+|                    be called.
+|
+|   Return Values :  E_OK                - success
+|                    E_INVALID_FIELD     - field is invalid
+|                    some other          - error from subordinate call
++--------------------------------------------------------------------------*/
+static int Inter_Field_Navigation(int (* const fct) (FORM *),FORM *form)
+{
+  int res;
+
+  if (!_nc_Internal_Validation(form)) 
+    res = E_INVALID_FIELD;
+  else
+    {
+      Call_Hook(form,fieldterm);
+      res = fct(form);
+      Call_Hook(form,fieldinit);
+    }
+  return res;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Next_Field(FORM * form)
+|   
+|   Description   :  Move to the next field on the current page of the form
+|
+|   Return Values :  E_OK                 - success
+|                    != E_OK              - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Next_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Next_Field_On_Page(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Previous_Field(FORM * form)
+|   
+|   Description   :  Move to the previous field on the current page of the 
+|                    form
+|
+|   Return Values :  E_OK                 - success
+|                    != E_OK              - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Previous_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Previous_Field_On_Page(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_First_Field(FORM * form)
+|   
+|   Description   :  Move to the first field on the current page of the form
+|
+|   Return Values :  E_OK                 - success
+|                    != E_OK              - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_First_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+      Next_Field_On_Page(form->field[form->page[form->curpage].pmax]));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Last_Field(FORM * form)
+|   
+|   Description   :  Move to the last field on the current page of the form
+|
+|   Return Values :  E_OK                 - success
+|                    != E_OK              - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Last_Field(FORM * form)
+{
+  return 
+    _nc_Set_Current_Field(form,
+       Previous_Field_On_Page(form->field[form->page[form->curpage].pmin]));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Sorted_Next_Field(FORM * form)
+|   
+|   Description   :  Move to the sorted next field on the current page
+|                    of the form.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Sorted_Next_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Sorted_Next_Field(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Sorted_Previous_Field(FORM * form)
+|   
+|   Description   :  Move to the sorted previous field on the current page
+|                    of the form.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Sorted_Previous_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Sorted_Previous_Field(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Sorted_First_Field(FORM * form)
+|   
+|   Description   :  Move to the sorted first field on the current page
+|                    of the form.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Sorted_First_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+              Sorted_Next_Field(form->field[form->page[form->curpage].smax]));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Sorted_Last_Field(FORM * form)
+|   
+|   Description   :  Move to the sorted last field on the current page
+|                    of the form.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Sorted_Last_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+           Sorted_Previous_Field(form->field[form->page[form->curpage].smin]));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Left_Field(FORM * form)
+|   
+|   Description   :  Get the field on the left of the current field on the
+|                    same line and the same page. Cycles through the line.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Left_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Left_Neighbour_Field(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Right_Field(FORM * form)
+|   
+|   Description   :  Get the field on the right of the current field on the
+|                    same line and the same page. Cycles through the line.
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Right_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Right_Neighbour_Field(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Up_Field(FORM * form)
+|   
+|   Description   :  Get the upper neighbour of the current field. This
+|                    cycles through the page. See the comments of the
+|                    Upper_Neighbour_Field function to understand how
+|                    'upper' is defined. 
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Up_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Upper_Neighbour_Field(form->current));
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int FN_Down_Field(FORM * form)
+|   
+|   Description   :  Get the down neighbour of the current field. This
+|                    cycles through the page. See the comments of the
+|                    Down_Neighbour_Field function to understand how
+|                    'down' is defined. 
+|
+|   Return Values :  E_OK            - success
+|                    != E_OK         - error from subordinate call
++--------------------------------------------------------------------------*/
+static int FN_Down_Field(FORM * form)
+{
+  return _nc_Set_Current_Field(form,
+                               Down_Neighbour_Field(form->current));
+}
+/*----------------------------------------------------------------------------
+  END of Field Navigation routines 
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for Page Navigation
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int _nc_Set_Form_Page(FORM * form,
+|                                          int page,
+|                                          FIELD * field)
+|   
+|   Description   :  Make the given page nr. the current page and make
+|                    the given field the current field on the page. If
+|                    for the field NULL is given, make the first field on
+|                    the page the current field. The routine acts only
+|                    if the requested page is not the current page.
+|
+|   Return Values :  E_OK                - success
+|                    != E_OK             - error from subordinate call
++--------------------------------------------------------------------------*/
+int
+_nc_Set_Form_Page(FORM * form, int page, FIELD * field)
+{
+  int res = E_OK;
+
+  if ((form->curpage!=page))
+    {
+      FIELD *last_field, *field_on_page;
+
+      werase(Get_Form_Window(form));
+      form->curpage = page;
+      last_field = field_on_page = form->field[form->page[page].smin];
+      do
+        {
+          if (field_on_page->opts & O_VISIBLE)
+            if ((res=Display_Field(field_on_page))!=E_OK) 
+              return(res);
+          field_on_page = field_on_page->snext;
+        } while(field_on_page != last_field);
+
+      if (field)
+        res = _nc_Set_Current_Field(form,field);
+      else
+        /* N.B.: we don't encapsulate this by Inter_Field_Navigation(),
+           because this is already executed in a page navigation
+           context that contains field navigation 
+         */
+        res = FN_First_Field(form);
+    }
+  return(res);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Next_Page_Number(const FORM * form)
+|   
+|   Description   :  Calculate the page number following the current page
+|                    number. This cycles if the highest page number is
+|                    reached.  
+|
+|   Return Values :  The next page number
++--------------------------------------------------------------------------*/
+INLINE static int Next_Page_Number(const FORM * form)
+{
+  return (form->curpage + 1) % form->maxpage;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Previous_Page_Number(const FORM * form)
+|   
+|   Description   :  Calculate the page number before the current page
+|                    number. This cycles if the first page number is
+|                    reached.  
+|
+|   Return Values :  The previous page number
++--------------------------------------------------------------------------*/
+INLINE static int Previous_Page_Number(const FORM * form)
+{
+  return (form->curpage!=0 ? form->curpage - 1 : form->maxpage - 1);
+}
+
+/*----------------------------------------------------------------------------
+  Page Navigation routines 
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Page_Navigation(
+|                                               int (* const fct) (FORM *),
+|                                               FORM * form)
+|   
+|   Description   :  Generic behaviour for changing a page. This means
+|                    that the field is left and a new field is entered.
+|                    So the field must be validated and the field init/term
+|                    hooks must be called. Because also the page is changed,
+|                    the forms init/term hooks must be called also.
+|
+|   Return Values :  E_OK                - success
+|                    E_INVALID_FIELD     - field is invalid
+|                    some other          - error from subordinate call
++--------------------------------------------------------------------------*/
+static int Page_Navigation(int (* const fct) (FORM *), FORM * form)
+{
+  int res;
+
+  if (!_nc_Internal_Validation(form)) 
+    res = E_INVALID_FIELD;
+  else
+    {
+      Call_Hook(form,fieldterm);
+      Call_Hook(form,formterm);
+      res = fct(form);
+      Call_Hook(form,forminit);
+      Call_Hook(form,fieldinit);
+    }
+  return res;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int PN_Next_Page(FORM * form)
+|   
+|   Description   :  Move to the next page of the form
+|
+|   Return Values :  E_OK                - success
+|                    != E_OK             - error from subordinate call
++--------------------------------------------------------------------------*/
+static int PN_Next_Page(FORM * form)
+{ 
+  return _nc_Set_Form_Page(form,Next_Page_Number(form),(FIELD *)0);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int PN_Previous_Page(FORM * form)
+|   
+|   Description   :  Move to the previous page of the form
+|
+|   Return Values :  E_OK              - success
+|                    != E_OK           - error from subordinate call
++--------------------------------------------------------------------------*/
+static int PN_Previous_Page(FORM * form)
+{
+  return _nc_Set_Form_Page(form,Previous_Page_Number(form),(FIELD *)0);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int PN_First_Page(FORM * form)
+|   
+|   Description   :  Move to the first page of the form
+|
+|   Return Values :  E_OK              - success
+|                    != E_OK           - error from subordinate call
++--------------------------------------------------------------------------*/
+static int PN_First_Page(FORM * form)
+{
+  return _nc_Set_Form_Page(form,0,(FIELD *)0);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int PN_Last_Page(FORM * form)
+|   
+|   Description   :  Move to the last page of the form
+|
+|   Return Values :  E_OK              - success
+|                    != E_OK           - error from subordinate call
++--------------------------------------------------------------------------*/
+static int PN_Last_Page(FORM * form)
+{
+  return _nc_Set_Form_Page(form,form->maxpage-1,(FIELD *)0);
+}
+/*----------------------------------------------------------------------------
+  END of Field Navigation routines 
+  --------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+  Helper routines for the core form driver.
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Data_Entry(FORM * form,int c)
+|   
+|   Description   :  Enter character c into at the current position of the
+|                    current field of the form.
+|
+|   Return Values :  E_OK              -
+|                    E_REQUEST_DENIED  -
+|                    E_SYSTEM_ERROR    -
++--------------------------------------------------------------------------*/
+static int Data_Entry(FORM * form, int c)
+{
+  FIELD  *field = form->current;
+  int result = E_REQUEST_DENIED;
+
+  if ( (field->opts & O_EDIT) 
+#if FIX_FORM_INACTIVE_BUG
+       && (field->opts & O_ACTIVE) 
+#endif
+       )
+    {
+      if ( (field->opts & O_BLANK) &&
+           First_Position_In_Current_Field(form) &&
+           !(form->status & _FCHECK_REQUIRED) && 
+           !(form->status & _WINDOW_MODIFIED) )
+        werase(form->w);
+
+      if (form->status & _OVLMODE)
+        {
+          waddch(form->w,(chtype)c);
+        } 
+      else /* no _OVLMODE */ 
+        {
+          bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
+
+          if (!(There_Is_Room ||
+                ((Single_Line_Field(field) && Growable(field)))))
+              return E_REQUEST_DENIED;
+
+          if (!There_Is_Room && !Field_Grown(field,1))
+            return E_SYSTEM_ERROR;
+
+          winsch(form->w,(chtype)c);
+        }
+
+      if ((result=Wrapping_Not_Necessary_Or_Wrapping_Ok(form))==E_OK)
+        {
+          bool End_Of_Field= (((field->drows-1)==form->currow) &&
+                              ((field->dcols-1)==form->curcol));
+          form->status |= _WINDOW_MODIFIED;
+          if (End_Of_Field && !Growable(field) && (field->opts & O_AUTOSKIP))
+            result = Inter_Field_Navigation(FN_Next_Field,form);
+          else
+            {
+              if (End_Of_Field && Growable(field) && !Field_Grown(field,1))
+                result = E_SYSTEM_ERROR;
+              else
+                {
+                  IFN_Next_Character(form);
+                  result = E_OK;
+                }
+            }
+        }
+    }
+  return result;
+}
+
+/* Structure to describe the binding of a request code to a function.
+   The member keycode codes the request value as well as the generic
+   routine to use for the request. The code for the generic routine
+   is coded in the upper 16 Bits while the request code is coded in
+   the lower 16 bits. 
+
+   In terms of C++ you might think of a request as a class with a
+   virtual method "perform". The different types of request are
+   derived from this base class and overload (or not) the base class
+   implementation of perform.
+*/
+typedef struct {
+  int keycode;           /* must be at least 32 bit: hi:mode, lo: key */
+  int (*cmd)(FORM *);    /* low level driver routine for this key     */
+} Binding_Info;
+
+/* You may see this is the class-id of the request type class */
+#define ID_PN    (0x00000000)    /* Page navigation           */
+#define ID_FN    (0x00010000)    /* Inter-Field navigation    */
+#define ID_IFN   (0x00020000)    /* Intra-Field navigation    */
+#define ID_VSC   (0x00030000)    /* Vertical Scrolling        */
+#define ID_HSC   (0x00040000)    /* Horizontal Scrolling      */
+#define ID_FE    (0x00050000)    /* Field Editing             */
+#define ID_EM    (0x00060000)    /* Edit Mode                 */
+#define ID_FV    (0x00070000)    /* Field Validation          */
+#define ID_CH    (0x00080000)    /* Choice                    */
+#define ID_Mask  (0xffff0000)
+#define Key_Mask (0x0000ffff)
+#define ID_Shft  (16)
+
+/* This array holds all the Binding Infos */
+static const Binding_Info bindings[MAX_FORM_COMMAND - MIN_FORM_COMMAND + 1] = 
+{
+  { REQ_NEXT_PAGE    |ID_PN  ,PN_Next_Page},
+  { REQ_PREV_PAGE    |ID_PN  ,PN_Previous_Page},
+  { REQ_FIRST_PAGE   |ID_PN  ,PN_First_Page},
+  { REQ_LAST_PAGE    |ID_PN  ,PN_Last_Page},
+  
+  { REQ_NEXT_FIELD   |ID_FN  ,FN_Next_Field},
+  { REQ_PREV_FIELD   |ID_FN  ,FN_Previous_Field},
+  { REQ_FIRST_FIELD  |ID_FN  ,FN_First_Field},
+  { REQ_LAST_FIELD   |ID_FN  ,FN_Last_Field},
+  { REQ_SNEXT_FIELD  |ID_FN  ,FN_Sorted_Next_Field},
+  { REQ_SPREV_FIELD  |ID_FN  ,FN_Sorted_Previous_Field},
+  { REQ_SFIRST_FIELD |ID_FN  ,FN_Sorted_First_Field},
+  { REQ_SLAST_FIELD  |ID_FN  ,FN_Sorted_Last_Field},
+  { REQ_LEFT_FIELD   |ID_FN  ,FN_Left_Field},
+  { REQ_RIGHT_FIELD  |ID_FN  ,FN_Right_Field},
+  { REQ_UP_FIELD     |ID_FN  ,FN_Up_Field},
+  { REQ_DOWN_FIELD   |ID_FN  ,FN_Down_Field},
+  
+  { REQ_NEXT_CHAR    |ID_IFN ,IFN_Next_Character},
+  { REQ_PREV_CHAR    |ID_IFN ,IFN_Previous_Character},
+  { REQ_NEXT_LINE    |ID_IFN ,IFN_Next_Line},
+  { REQ_PREV_LINE    |ID_IFN ,IFN_Previous_Line},
+  { REQ_NEXT_WORD    |ID_IFN ,IFN_Next_Word},
+  { REQ_PREV_WORD    |ID_IFN ,IFN_Previous_Word},
+  { REQ_BEG_FIELD    |ID_IFN ,IFN_Beginning_Of_Field},
+  { REQ_END_FIELD    |ID_IFN ,IFN_End_Of_Field},
+  { REQ_BEG_LINE     |ID_IFN ,IFN_Beginning_Of_Line},
+  { REQ_END_LINE     |ID_IFN ,IFN_End_Of_Line},
+  { REQ_LEFT_CHAR    |ID_IFN ,IFN_Left_Character},
+  { REQ_RIGHT_CHAR   |ID_IFN ,IFN_Right_Character},
+  { REQ_UP_CHAR      |ID_IFN ,IFN_Up_Character},
+  { REQ_DOWN_CHAR    |ID_IFN ,IFN_Down_Character},
+  
+  { REQ_NEW_LINE     |ID_FE  ,FE_New_Line},
+  { REQ_INS_CHAR     |ID_FE  ,FE_Insert_Character},
+  { REQ_INS_LINE     |ID_FE  ,FE_Insert_Line},
+  { REQ_DEL_CHAR     |ID_FE  ,FE_Delete_Character},
+  { REQ_DEL_PREV     |ID_FE  ,FE_Delete_Previous},
+  { REQ_DEL_LINE     |ID_FE  ,FE_Delete_Line},
+  { REQ_DEL_WORD     |ID_FE  ,FE_Delete_Word},
+  { REQ_CLR_EOL      |ID_FE  ,FE_Clear_To_End_Of_Line},
+  { REQ_CLR_EOF      |ID_FE  ,FE_Clear_To_End_Of_Form},
+  { REQ_CLR_FIELD    |ID_FE  ,FE_Clear_Field},
+  
+  { REQ_OVL_MODE     |ID_EM  ,EM_Overlay_Mode},
+  { REQ_INS_MODE     |ID_EM  ,EM_Insert_Mode},
+  
+  { REQ_SCR_FLINE    |ID_VSC ,VSC_Scroll_Line_Forward},
+  { REQ_SCR_BLINE    |ID_VSC ,VSC_Scroll_Line_Backward},
+  { REQ_SCR_FPAGE    |ID_VSC ,VSC_Scroll_Page_Forward},
+  { REQ_SCR_BPAGE    |ID_VSC ,VSC_Scroll_Page_Backward},
+  { REQ_SCR_FHPAGE   |ID_VSC ,VSC_Scroll_Half_Page_Forward},
+  { REQ_SCR_BHPAGE   |ID_VSC ,VSC_Scroll_Half_Page_Backward},
+  
+  { REQ_SCR_FCHAR    |ID_HSC ,HSC_Scroll_Char_Forward},
+  { REQ_SCR_BCHAR    |ID_HSC ,HSC_Scroll_Char_Backward},
+  { REQ_SCR_HFLINE   |ID_HSC ,HSC_Horizontal_Line_Forward},
+  { REQ_SCR_HBLINE   |ID_HSC ,HSC_Horizontal_Line_Backward},
+  { REQ_SCR_HFHALF   |ID_HSC ,HSC_Horizontal_Half_Line_Forward},
+  { REQ_SCR_HBHALF   |ID_HSC ,HSC_Horizontal_Half_Line_Backward},
+  
+  { REQ_VALIDATION   |ID_FV  ,FV_Validation},
+
+  { REQ_NEXT_CHOICE  |ID_CH  ,CR_Next_Choice},
+  { REQ_PREV_CHOICE  |ID_CH  ,CR_Previous_Choice}
+};
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int form_driver(FORM * form,int  c)
+|   
+|   Description   :  This is the workhorse of the forms system. It checks
+|                    to determine whether the character c is a request or
+|                    data. If it is a request, the form driver executes
+|                    the request and returns the result. If it is data
+|                    (printable character), it enters the data into the
+|                    current position in the current field. If it is not
+|                    recognized, the form driver assumes it is an application
+|                    defined command and returns E_UNKNOWN_COMMAND.
+|                    Application defined command should be defined relative
+|                    to MAX_FORM_COMMAND, the maximum value of a request.
+|
+|   Return Values :  E_OK              - success
+|                    E_SYSTEM_ERROR    - system error
+|                    E_BAD_ARGUMENT    - an argument is incorrect
+|                    E_NOT_POSTED      - form is not posted
+|                    E_INVALID_FIELD   - field contents are invalid
+|                    E_BAD_STATE       - called from inside a hook routine
+|                    E_REQUEST_DENIED  - request failed
+|                    E_UNKNOWN_COMMAND - command not known
++--------------------------------------------------------------------------*/
+int form_driver(FORM * form, int  c)
+{
+  const Binding_Info* BI = (Binding_Info *)0;
+  int res = E_UNKNOWN_COMMAND;
+
+  if (!form)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (!(form->field))
+    RETURN(E_NOT_CONNECTED);
+  
+  assert(form->page != 0);
+  
+  if (c==FIRST_ACTIVE_MAGIC)
+    {
+      form->current = _nc_First_Active_Field(form);
+      return E_OK;
+    }
+  
+  assert(form->current && 
+         form->current->buf && 
+         (form->current->form == form)
+        );
+  
+  if ( form->status & _IN_DRIVER )
+    RETURN(E_BAD_STATE);
+
+  if ( !( form->status & _POSTED ) ) 
+    RETURN(E_NOT_POSTED);
+  
+  if ((c>=MIN_FORM_COMMAND && c<=MAX_FORM_COMMAND) &&
+      ((bindings[c-MIN_FORM_COMMAND].keycode & Key_Mask) == c))
+    BI = &(bindings[c-MIN_FORM_COMMAND]);
+  
+  if (BI)
+    {
+      typedef int (*Generic_Method)(int (* const)(FORM *),FORM *);
+      static const Generic_Method Generic_Methods[] = 
+        {
+          Page_Navigation,         /* overloaded to call field&form hooks */
+          Inter_Field_Navigation,  /* overloaded to call field hooks      */
+          NULL,                    /* Intra-Field is generic              */
+          Vertical_Scrolling,      /* Overloaded to check multi-line      */
+          Horizontal_Scrolling,    /* Overloaded to check single-line     */
+          Field_Editing,           /* Overloaded to mark modification     */
+          NULL,                    /* Edit Mode is generic                */
+          NULL,                    /* Field Validation is generic         */
+          NULL                     /* Choice Request is generic           */
+        };
+      size_t nMethods = (sizeof(Generic_Methods)/sizeof(Generic_Methods[0]));
+      size_t method   = ((BI->keycode & ID_Mask) >> ID_Shft) & 0xffff;
+      
+      if ( (method >= nMethods) || !(BI->cmd) )
+        res = E_SYSTEM_ERROR;
+      else
+        {
+          Generic_Method fct = Generic_Methods[method];
+          if (fct)
+            res = fct(BI->cmd,form);
+          else
+            res = (BI->cmd)(form);
+        }
+    } 
+  else 
+    {
+      if (!(c & (~(int)MAX_REGULAR_CHARACTER)) &&
+          isprint((unsigned char)c) &&                      
+          Check_Char(form->current->type,c,
+                     (TypeArgument *)(form->current->arg)))
+        res = Data_Entry(form,c);
+    }
+  _nc_Refresh_Current_Field(form);
+  RETURN(res);
+}
+
+/*----------------------------------------------------------------------------
+  Field-Buffer manipulation routines.
+  The effects of setting a buffer is tightly coupled to the core of the form
+  driver logic. This is especially true in the case of growable fields.
+  So I don't separate this into an own module. 
+  --------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_buffer(FIELD *field,
+|                                         int buffer, char *value)
+|   
+|   Description   :  Set the given buffer of the field to the given value.
+|                    Buffer 0 stores the displayed content of the field.
+|                    For dynamic fields this may grow the fieldbuffers if
+|                    the length of the value exceeds the current buffer
+|                    length. For buffer 0 only printable values are allowed.
+|                    For static fields, the value needs not to be zero ter-
+|                    minated. It is copied up to the length of the buffer.   
+|
+|   Return Values :  E_OK            - success
+|                    E_BAD_ARGUMENT  - invalid argument
+|                    E_SYSTEM_ERROR  - system error
++--------------------------------------------------------------------------*/
+int set_field_buffer(FIELD * field, int buffer, const char * value)
+{
+  char *s, *p;
+  int res = E_OK;
+  unsigned int len;
+
+  if ( !field || !value || ((buffer < 0)||(buffer > field->nbuf)) )
+    RETURN(E_BAD_ARGUMENT);
+
+  len  = Buffer_Length(field);
+
+  if (buffer==0)
+    {
+      const char *v;
+      unsigned int i = 0;
+
+      for(v=value; *v && (i<len); v++,i++)
+        {
+          if (!isprint((unsigned char)*v))
+            RETURN(E_BAD_ARGUMENT);
+        }
+    }
+
+  if (Growable(field))
+    {
+      /* for a growable field we must assume zero terminated strings, because
+         somehow we have to detect the length of what should be copied.
+      */
+      unsigned int vlen = strlen(value);
+      if (vlen > len)
+        {
+          if (!Field_Grown(field,
+                           (int)(1 + (vlen-len)/((field->rows+field->nrow)*field->cols))))
+            RETURN(E_SYSTEM_ERROR);
+
+          /* in this case we also have to check, whether or not the remaining
+             characters in value are also printable for buffer 0. */
+          if (buffer==0)
+            {
+              unsigned int i;
+          
+              for(i=len; i<vlen; i++)
+                if (!isprint((int)(value[i])))
+                  RETURN(E_BAD_ARGUMENT);
+            }
+          len = vlen;
+        }
+    }
+  
+  p   = Address_Of_Nth_Buffer(field,buffer);
+
+#if HAVE_MEMCCPY
+  s = memccpy(p,value,0,len);
+#else
+  for(s=(char *)value; *s && (s < (value+len)); s++)
+    p[s-value] = *s;
+  if (s < (value+len))
+    {
+      int off = s-value;
+      p[off] = *s++;
+      s = p + (s-value);
+    }
+  else 
+    s=(char *)0;
+#endif
+
+  if (s) 
+    { /* this means, value was null terminated and not greater than the
+         buffer. We have to pad with blanks. Please note that due to memccpy
+         logic s points after the terminating null. */
+      s--; /* now we point to the terminator. */
+      assert(len >= (unsigned int)(s-p));
+      if (len > (unsigned int)(s-p))
+        memset(s,C_BLANK,len-(unsigned int)(s-p));
+    }
+
+  if (buffer==0)
+    {
+      int syncres;
+      if (((syncres=Synchronize_Field( field ))!=E_OK) && 
+          (res==E_OK))
+        res = syncres;
+      if (((syncres=Synchronize_Linked_Fields(field ))!=E_OK) &&
+          (res==E_OK))
+        res = syncres;
+    }
+  RETURN(res);
+}               
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  char *field_buffer(const FIELD *field,int buffer)
+|   
+|   Description   :  Return the address of the buffer for the field.
+|
+|   Return Values :  Pointer to buffer or NULL if arguments were invalid.
++--------------------------------------------------------------------------*/
+char *field_buffer(const FIELD * field, int  buffer)
+{
+  if (field && (buffer >= 0) && (buffer <= field->nbuf))
+    return Address_Of_Nth_Buffer(field,buffer);
+  else
+    return (char *)0;
+}
+
+/* frm_driver.c ends here */
diff --git a/Source/CursesDialog/form/frm_hook.c b/Source/CursesDialog/form/frm_hook.c
new file mode 100644
index 0000000..eb654c4
--- /dev/null
+++ b/Source/CursesDialog/form/frm_hook.c
@@ -0,0 +1,140 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/* "Template" macro to generate function to set application specific hook */
+#define GEN_HOOK_SET_FUNCTION( typ, name ) \
+int set_ ## typ ## _ ## name (FORM *form, Form_Hook func)\
+{\
+   (Normalize_Form( form ) -> typ ## name) = func ;\
+   RETURN(E_OK);\
+}
+
+/* "Template" macro to generate function to get application specific hook */
+#define GEN_HOOK_GET_FUNCTION( typ, name ) \
+Form_Hook typ ## _ ## name ( const FORM *form )\
+{\
+   return ( Normalize_Form( form ) -> typ ## name );\
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_init(FORM *form, Form_Hook f)
+|   
+|   Description   :  Assigns an application defined initialization function
+|                    to be called when the form is posted and just after
+|                    the current field changes.
+|
+|   Return Values :  E_OK      - success
++--------------------------------------------------------------------------*/
+GEN_HOOK_SET_FUNCTION(field,init)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Form_Hook field_init(const FORM *form)
+|   
+|   Description   :  Retrieve field initialization routine address.
+|
+|   Return Values :  The address or NULL if no hook defined.
++--------------------------------------------------------------------------*/
+GEN_HOOK_GET_FUNCTION(field,init)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_field_term(FORM *form, Form_Hook f)
+|   
+|   Description   :  Assigns an application defined finalization function
+|                    to be called when the form is unposted and just before
+|                    the current field changes.
+|
+|   Return Values :  E_OK      - success
++--------------------------------------------------------------------------*/
+GEN_HOOK_SET_FUNCTION(field,term)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Form_Hook field_term(const FORM *form)
+|   
+|   Description   :  Retrieve field finalization routine address.
+|
+|   Return Values :  The address or NULL if no hook defined.
++--------------------------------------------------------------------------*/
+GEN_HOOK_GET_FUNCTION(field,term)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_init(FORM *form, Form_Hook f)
+|   
+|   Description   :  Assigns an application defined initialization function
+|                    to be called when the form is posted and just after
+|                    a page change.
+|
+|   Return Values :  E_OK       - success
++--------------------------------------------------------------------------*/
+GEN_HOOK_SET_FUNCTION(form,init)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Form_Hook form_init(const FORM *form)
+|   
+|   Description   :  Retrieve form initialization routine address.
+|
+|   Return Values :  The address or NULL if no hook defined.
++--------------------------------------------------------------------------*/
+GEN_HOOK_GET_FUNCTION(form,init)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_term(FORM *form, Form_Hook f)
+|   
+|   Description   :  Assigns an application defined finalization function
+|                    to be called when the form is unposted and just before
+|                    a page change.
+|
+|   Return Values :  E_OK       - success
++--------------------------------------------------------------------------*/
+GEN_HOOK_SET_FUNCTION(form,term)
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Form_Hook form_term(const FORM *form)
+|   
+|   Description   :  Retrieve form finalization routine address.
+|
+|   Return Values :  The address or NULL if no hook defined.
++--------------------------------------------------------------------------*/
+GEN_HOOK_GET_FUNCTION(form,term)
+
+/* frm_hook.c ends here */
diff --git a/Source/CursesDialog/form/frm_opts.c b/Source/CursesDialog/form/frm_opts.c
new file mode 100644
index 0000000..7bbeaa1
--- /dev/null
+++ b/Source/CursesDialog/form/frm_opts.c
@@ -0,0 +1,116 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_opts(FORM *form, Form_Options opts)
+|   
+|   Description   :  Turns on the named options and turns off all the
+|                    remaining options for that form.
+|
+|   Return Values :  E_OK              - success
+|                    E_BAD_ARGUMENT    - invalid options
++--------------------------------------------------------------------------*/
+int set_form_opts(FORM * form, Form_Options  opts)
+{
+  opts &= ALL_FORM_OPTS;
+  if (opts & ~ALL_FORM_OPTS)
+    RETURN(E_BAD_ARGUMENT);
+  else
+    {
+      Normalize_Form( form )->opts = opts;
+      RETURN(E_OK);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  Form_Options form_opts(const FORM *)
+|   
+|   Description   :  Retrieves the current form options.
+|
+|   Return Values :  The option flags.
++--------------------------------------------------------------------------*/
+Form_Options form_opts(const FORM * form)
+{
+  return (Normalize_Form(form)->opts & ALL_FORM_OPTS);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int form_opts_on(FORM *form, Form_Options opts)
+|   
+|   Description   :  Turns on the named options; no other options are 
+|                    changed.
+|
+|   Return Values :  E_OK            - success 
+|                    E_BAD_ARGUMENT  - invalid options
++--------------------------------------------------------------------------*/
+int form_opts_on(FORM * form, Form_Options opts)
+{
+  opts &= ALL_FORM_OPTS;
+  if (opts & ~ALL_FORM_OPTS)
+    RETURN(E_BAD_ARGUMENT);
+  else
+    {
+      Normalize_Form( form )->opts |= opts;	
+      RETURN(E_OK);
+    }
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int form_opts_off(FORM *form, Form_Options opts)
+|   
+|   Description   :  Turns off the named options; no other options are 
+|                    changed.
+|
+|   Return Values :  E_OK            - success 
+|                    E_BAD_ARGUMENT  - invalid options
++--------------------------------------------------------------------------*/
+int form_opts_off(FORM * form, Form_Options opts)
+{
+  opts &= ALL_FORM_OPTS;
+  if (opts & ~ALL_FORM_OPTS)
+    RETURN(E_BAD_ARGUMENT);
+  else
+    {
+      Normalize_Form(form)->opts &= ~opts;
+      RETURN(E_OK);
+    }
+}
+
+/* frm_opts.c ends here */
diff --git a/Source/CursesDialog/form/frm_page.c b/Source/CursesDialog/form/frm_page.c
new file mode 100644
index 0000000..842cbce
--- /dev/null
+++ b/Source/CursesDialog/form/frm_page.c
@@ -0,0 +1,100 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_page(FORM * form,int  page)
+|   
+|   Description   :  Set the page number of the form.
+|
+|   Return Values :  E_OK              - success
+|                    E_BAD_ARGUMENT    - invalid form pointer or page number
+|                    E_BAD_STATE       - called from a hook routine
+|                    E_INVALID_FIELD   - current field can't be left
+|                    E_SYSTEM_ERROR    - system error
++--------------------------------------------------------------------------*/
+int set_form_page(FORM * form, int page)
+{
+  int err = E_OK;
+
+  if ( !form || (page<0) || (page>=form->maxpage) )
+    RETURN(E_BAD_ARGUMENT);
+
+  if (!(form->status & _POSTED))
+    {
+      form->curpage = page;
+      form->current = _nc_First_Active_Field(form);
+  }
+  else
+    {
+      if (form->status & _IN_DRIVER) 
+	err = E_BAD_STATE;
+      else
+	{
+	  if (form->curpage != page)
+	    {
+	      if (!_nc_Internal_Validation(form)) 
+		err = E_INVALID_FIELD;
+	      else
+		{
+		  Call_Hook(form,fieldterm);
+		  Call_Hook(form,formterm);
+		  err = _nc_Set_Form_Page(form,page,(FIELD *)0);
+		  Call_Hook(form,forminit);
+		  Call_Hook(form,fieldinit);
+		  _nc_Refresh_Current_Field(form);
+		}
+	    }
+	}
+    }
+  RETURN(err);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int form_page(const FORM * form)
+|   
+|   Description   :  Return the current page of the form.
+|
+|   Return Values :  >= 0  : current page number
+|                    -1    : invalid form pointer
++--------------------------------------------------------------------------*/
+int form_page(const FORM * form)
+{
+  return Normalize_Form(form)->curpage;
+}
+
+/* frm_page.c ends here */
diff --git a/Source/CursesDialog/form/frm_post.c b/Source/CursesDialog/form/frm_post.c
new file mode 100644
index 0000000..924fe6a
--- /dev/null
+++ b/Source/CursesDialog/form/frm_post.c
@@ -0,0 +1,119 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int post_form(FORM * form)
+|   
+|   Description   :  Writes the form into its associated subwindow.
+|
+|   Return Values :  E_OK              - success
+|                    E_BAD_ARGUMENT    - invalid form pointer
+|                    E_POSTED          - form already posted
+|                    E_NOT_CONNECTED   - no fields connected to form
+|                    E_NO_ROOM         - form doesn't fit into subwindow
+|                    E_SYSTEM_ERROR    - system error
++--------------------------------------------------------------------------*/
+int post_form(FORM * form)
+{
+  WINDOW *formwin;
+  int err;
+  int page;
+  int height, width;
+
+  if (!form)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (form->status & _POSTED)   
+    RETURN(E_POSTED);
+
+  if (!(form->field))
+    RETURN(E_NOT_CONNECTED);
+  
+  formwin = Get_Form_Window(form);
+  getmaxyx(formwin, height, width);
+  if ((form->cols > width) || (form->rows > height))
+    RETURN(E_NO_ROOM);
+
+  /* reset form->curpage to an invald value. This forces Set_Form_Page
+     to do the page initialization which is required by post_form.
+  */
+  page = form->curpage;
+  form->curpage = -1;
+  if ((err = _nc_Set_Form_Page(form,page,form->current))!=E_OK)
+    RETURN(err);
+
+  form->status |= _POSTED;
+
+  Call_Hook(form,forminit);
+  Call_Hook(form,fieldinit);
+
+  _nc_Refresh_Current_Field(form);
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int unpost_form(FORM * form)
+|   
+|   Description   :  Erase form from its associated subwindow.
+|
+|   Return Values :  E_OK            - success
+|                    E_BAD_ARGUMENT  - invalid form pointer
+|                    E_NOT_POSTED    - form isn't posted
+|                    E_BAD_STATE     - called from a hook routine
++--------------------------------------------------------------------------*/
+int unpost_form(FORM * form)
+{
+  if (!form)
+    RETURN(E_BAD_ARGUMENT);
+
+  if (!(form->status & _POSTED)) 
+    RETURN(E_NOT_POSTED);
+
+  if (form->status & _IN_DRIVER) 
+    RETURN(E_BAD_STATE);
+
+  Call_Hook(form,fieldterm);
+  Call_Hook(form,formterm);
+
+  werase(Get_Form_Window(form));
+  delwin(form->w);
+  form->w = (WINDOW *)0;
+  form->status &= ~_POSTED;
+  RETURN(E_OK);
+}
+
+/* frm_post.c ends here */
diff --git a/Source/CursesDialog/form/frm_req_name.c b/Source/CursesDialog/form/frm_req_name.c
new file mode 100644
index 0000000..6fb9183
--- /dev/null
+++ b/Source/CursesDialog/form/frm_req_name.c
@@ -0,0 +1,163 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+/***************************************************************************
+* Module form_request_name                                                 *
+* Routines to handle external names of menu requests                       *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+static const char *request_names[ MAX_FORM_COMMAND - MIN_FORM_COMMAND + 1 ] = {
+  "NEXT_PAGE"	 ,
+  "PREV_PAGE"	 ,
+  "FIRST_PAGE"	 ,
+  "LAST_PAGE"	 ,
+
+  "NEXT_FIELD"	 ,
+  "PREV_FIELD"	 ,
+  "FIRST_FIELD"	 ,
+  "LAST_FIELD"	 ,
+  "SNEXT_FIELD"	 ,
+  "SPREV_FIELD"	 ,
+  "SFIRST_FIELD" ,
+  "SLAST_FIELD"	 ,
+  "LEFT_FIELD"	 ,
+  "RIGHT_FIELD"	 ,
+  "UP_FIELD"	 ,
+  "DOWN_FIELD"	 ,
+
+  "NEXT_CHAR"	 ,
+  "PREV_CHAR"	 ,
+  "NEXT_LINE"	 ,
+  "PREV_LINE"	 ,
+  "NEXT_WORD"	 ,
+  "PREV_WORD"	 ,
+  "BEG_FIELD"	 ,
+  "END_FIELD"	 ,
+  "BEG_LINE"	 ,
+  "END_LINE"	 ,
+  "LEFT_CHAR"	 ,
+  "RIGHT_CHAR"	 ,
+  "UP_CHAR"	 ,
+  "DOWN_CHAR"	 ,
+
+  "NEW_LINE"	 ,
+  "INS_CHAR"	 ,
+  "INS_LINE"	 ,
+  "DEL_CHAR"	 ,
+  "DEL_PREV"	 ,
+  "DEL_LINE"	 ,
+  "DEL_WORD"	 ,
+  "CLR_EOL"	 ,
+  "CLR_EOF"	 ,
+  "CLR_FIELD"	 ,
+  "OVL_MODE"	 ,
+  "INS_MODE"	 ,
+  "SCR_FLINE"	 ,
+  "SCR_BLINE"	 ,
+  "SCR_FPAGE"	 ,
+  "SCR_BPAGE"	 ,
+  "SCR_FHPAGE"   ,
+  "SCR_BHPAGE"   ,
+  "SCR_FCHAR"    ,
+  "SCR_BCHAR"    ,
+  "SCR_HFLINE"   ,
+  "SCR_HBLINE"   ,
+  "SCR_HFHALF"   ,
+  "SCR_HBHALF"   ,
+
+  "VALIDATION"	 ,
+  "NEXT_CHOICE"	 ,
+  "PREV_CHOICE"	 
+};
+#define A_SIZE (sizeof(request_names)/sizeof(request_names[0]))
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  const char * form_request_name (int request);
+|   
+|   Description   :  Get the external name of a form request.
+|
+|   Return Values :  Pointer to name      - on success
+|                    NULL                 - on invalid request code
++--------------------------------------------------------------------------*/
+const char *form_request_name( int request )
+{
+  if ( (request < MIN_FORM_COMMAND) || (request > MAX_FORM_COMMAND) )
+    {
+      SET_ERROR (E_BAD_ARGUMENT);
+      return (const char *)0;
+    }
+  else
+    return request_names[ request - MIN_FORM_COMMAND ];
+}
+
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int form_request_by_name (const char *str);
+|   
+|   Description   :  Search for a request with this name.
+|
+|   Return Values :  Request Id       - on success
+|                    E_NO_MATCH       - request not found
++--------------------------------------------------------------------------*/
+int form_request_by_name( const char *str )
+{ 
+  /* because the table is so small, it doesn't really hurt
+     to run sequentially through it.
+  */
+  unsigned int i = 0;
+  char buf[16];
+  
+  if (str)
+    {
+      strncpy(buf,str,sizeof(buf));
+      while( (i<sizeof(buf)) && (buf[i] != '\0') )
+	{
+	  buf[i] = toupper((int)(buf[i]));
+	  i++;
+	}
+      
+      for (i=0; i < A_SIZE; i++)
+	{
+	  if (strncmp(request_names[i],buf,sizeof(buf))==0)
+	    return MIN_FORM_COMMAND + i;
+	} 
+    }
+  RETURN(E_NO_MATCH);
+}
+
+/* frm_req_name.c ends here */
diff --git a/Source/CursesDialog/form/frm_scale.c b/Source/CursesDialog/form/frm_scale.c
new file mode 100644
index 0000000..028e9e2
--- /dev/null
+++ b/Source/CursesDialog/form/frm_scale.c
@@ -0,0 +1,63 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int scale_form( const FORM *form, int *rows, int *cols )
+|   
+|   Description   :  Retrieve size of form
+|
+|   Return Values :  E_OK              - no error
+|                    E_BAD_ARGUMENT    - invalid form pointer
+|                    E_NOT_CONNECTED   - no fields connected to form
++--------------------------------------------------------------------------*/
+int scale_form(const FORM * form, int * rows, int * cols)
+{
+  if ( !form )
+    RETURN(E_BAD_ARGUMENT);
+
+  if ( !(form->field) )
+    RETURN(E_NOT_CONNECTED);
+  
+  if (rows) 
+    *rows = form->rows;
+  if (cols) 
+    *cols = form->cols;
+  
+  RETURN(E_OK);
+}
+
+/* frm_scale.c ends here */
diff --git a/Source/CursesDialog/form/frm_sub.c b/Source/CursesDialog/form/frm_sub.c
new file mode 100644
index 0000000..62dc613
--- /dev/null
+++ b/Source/CursesDialog/form/frm_sub.c
@@ -0,0 +1,69 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_sub(FORM *form, WINDOW *win)
+|   
+|   Description   :  Set the subwindow of the form to win. 
+|
+|   Return Values :  E_OK       - success
+|                    E_POSTED   - form is posted
++--------------------------------------------------------------------------*/
+int set_form_sub(FORM * form, WINDOW * win)
+{
+  if (form && (form->status & _POSTED))	
+    RETURN(E_POSTED);
+
+  Normalize_Form( form )->sub = win;
+  RETURN(E_OK);
+}	
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  WINDOW *form_sub(const FORM *)
+|   
+|   Description   :  Retrieve the window of the form.
+|
+|   Return Values :  The pointer to the Subwindow.
++--------------------------------------------------------------------------*/
+WINDOW *form_sub(const FORM * form)
+{
+  const FORM* f = Normalize_Form( form );
+  return Get_Form_Window(f);
+}
+
+/* frm_sub.c ends here */
diff --git a/Source/CursesDialog/form/frm_user.c b/Source/CursesDialog/form/frm_user.c
new file mode 100644
index 0000000..f38bbbb
--- /dev/null
+++ b/Source/CursesDialog/form/frm_user.c
@@ -0,0 +1,67 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_userptr(FORM *form, void *usrptr)
+|   
+|   Description   :  Set the pointer that is reserved in any form to store
+|                    application relevant information
+|
+|   Return Values :  E_OK         - on success
++--------------------------------------------------------------------------*/
+int set_form_userptr(FORM * form, void *usrptr)
+{
+  Normalize_Form(form)->usrptr = usrptr;
+  RETURN(E_OK);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  void *form_userptr(const FORM *form)
+|   
+|   Description   :  Return the pointer that is reserved in any form to
+|                    store application relevant information.
+|
+|   Return Values :  Value of pointer. If no such pointer has been set,
+|                    NULL is returned
++--------------------------------------------------------------------------*/
+void *form_userptr(const FORM * form)
+{
+  return Normalize_Form(form)->usrptr;
+}
+
+/* frm_user.c ends here */
diff --git a/Source/CursesDialog/form/frm_win.c b/Source/CursesDialog/form/frm_win.c
new file mode 100644
index 0000000..82d716f
--- /dev/null
+++ b/Source/CursesDialog/form/frm_win.c
@@ -0,0 +1,70 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  int set_form_win(FORM *form,WINDOW *win)
+|   
+|   Description   :  Set the window of the form to win. 
+|
+|   Return Values :  E_OK       - success
+|                    E_POSTED   - form is posted
++--------------------------------------------------------------------------*/
+int set_form_win(FORM * form, WINDOW * win)
+{
+  if (form && (form->status & _POSTED))	
+    RETURN(E_POSTED);
+
+  Normalize_Form( form )->win = win;
+  RETURN(E_OK);
+}	
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  WINDOW *form_win(const FORM *)
+|   
+|   Description   :  Retrieve the window of the form.
+|
+|   Return Values :  The pointer to the Window or stdscr if there is none.
++--------------------------------------------------------------------------*/
+WINDOW *form_win(const FORM * form)
+{
+  const FORM* f = Normalize_Form( form );
+  return (f->win ? f->win : stdscr);
+}
+
+/* frm_win.c ends here */
+
diff --git a/Source/CursesDialog/form/fty_alnum.c b/Source/CursesDialog/form/fty_alnum.c
new file mode 100644
index 0000000..6f3cfd4
--- /dev/null
+++ b/Source/CursesDialog/form/fty_alnum.c
@@ -0,0 +1,138 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+typedef struct {
+  int width;
+} alnumARG;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Make_AlphaNumeric_Type(va_list *ap)
+|   
+|   Description   :  Allocate structure for alphanumeric type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_AlphaNumeric_Type(va_list * ap)
+{
+  alnumARG *argp = (alnumARG *)malloc(sizeof(alnumARG));
+
+  if (argp)
+    argp->width = va_arg(*ap,int);
+
+  return ((void *)argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Copy_AlphaNumericType(const void *argp)
+|   
+|   Description   :  Copy structure for alphanumeric type argument.  
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_AlphaNumeric_Type(const void *argp)
+{
+  const alnumARG *ap = (const alnumARG *)argp;
+  alnumARG *result = (alnumARG *)malloc(sizeof(alnumARG));
+
+  if (result)
+    *result = *ap;
+
+  return ((void *)result);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Free_AlphaNumeric_Type(void *argp)
+|   
+|   Description   :  Free structure for alphanumeric type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_AlphaNumeric_Type(void * argp)
+{
+  if (argp) 
+    free(argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_AlphaNumeric_Field(
+|                                      FIELD *field,
+|                                      const void *argp)
+|   
+|   Description   :  Validate buffer content to be a valid alphanumeric value
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_AlphaNumeric_Field(FIELD * field, const void * argp)
+{
+  int width = ((const alnumARG *)argp)->width;
+  unsigned char *bp  = (unsigned char *)field_buffer(field,0);
+  int  l = -1;
+  unsigned char *s;
+
+  while(*bp && *bp==' ') 
+    bp++;
+  if (*bp)
+    {
+      s = bp;
+      while(*bp && isalnum(*bp)) 
+	bp++;
+      l = (int)(bp-s);
+      while(*bp && *bp==' ') 
+	bp++;
+    }
+  return ((*bp || (l < width)) ? FALSE : TRUE);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_AlphaNumeric_Character(
+|                                      int c, 
+|                                      const void *argp )
+|   
+|   Description   :  Check a character for the alphanumeric type.
+|
+|   Return Values :  TRUE  - character is valid
+|                    FALSE - character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_AlphaNumeric_Character(int c, const void * argp)
+{
+  argp=0; /* Silence unused parameter warning. */
+  return (isalnum(c) ? TRUE : FALSE);
+}
+
+static FIELDTYPE typeALNUM = {
+  _HAS_ARGS | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_AlphaNumeric_Type,
+  Copy_AlphaNumeric_Type,
+  Free_AlphaNumeric_Type,
+  Check_AlphaNumeric_Field,
+  Check_AlphaNumeric_Character,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_ALNUM = &typeALNUM;
+
+/* fty_alnum.c ends here */
diff --git a/Source/CursesDialog/form/fty_alpha.c b/Source/CursesDialog/form/fty_alpha.c
new file mode 100644
index 0000000..e4e9ceb
--- /dev/null
+++ b/Source/CursesDialog/form/fty_alpha.c
@@ -0,0 +1,139 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+typedef struct {
+  int width;
+} alphaARG;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Make_Alpha_Type(va_list *ap)
+|   
+|   Description   :  Allocate structure for alpha type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_Alpha_Type(va_list * ap)
+{
+  alphaARG *argp = (alphaARG *)malloc(sizeof(alphaARG));
+  if (argp)
+    {
+      argp->width = va_arg(*ap,int);
+    }
+  return ((void *)argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Copy_Alpha_Type(const void * argp)
+|   
+|   Description   :  Copy structure for alpha type argument.  
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_Alpha_Type(const void * argp)
+{
+  const alphaARG *ap = (const alphaARG *)argp;
+  alphaARG *result = (alphaARG *)malloc(sizeof(alphaARG));
+  
+  if (result)
+    {
+      *result = *ap;
+    }
+  return ((void *)result);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Free_Alpha_Type( void * argp )
+|   
+|   Description   :  Free structure for alpha type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_Alpha_Type(void * argp)
+{
+  if (argp) 
+    free(argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Alpha_Field(
+|                                      FIELD * field,
+|                                      const void * argp)
+|   
+|   Description   :  Validate buffer content to be a valid alpha value
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Alpha_Field(FIELD * field, const void * argp)
+{
+  int width = ((const alphaARG *)argp)->width;
+  unsigned char *bp  = (unsigned char *)field_buffer(field,0);
+  int  l = -1;
+  unsigned char *s;
+
+  while(*bp && *bp==' ') 
+    bp++;
+  if (*bp)
+    {
+      s = bp;
+      while(*bp && isalpha(*bp)) 
+	bp++;
+      l = (int)(bp-s);
+      while(*bp && *bp==' ') 
+	bp++;
+    }
+  return ((*bp || (l < width)) ? FALSE : TRUE);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Alpha_Character(
+|                                      int c,
+|                                      const void * argp)
+|   
+|   Description   :  Check a character for the alpha type.
+|
+|   Return Values :  TRUE  - character is valid
+|                    FALSE - character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Alpha_Character(int c, const void * argp)
+{
+  argp=0; /* Silence unused parameter warning.  */
+  return (isalpha(c) ? TRUE : FALSE);
+}
+
+static FIELDTYPE typeALPHA = {
+  _HAS_ARGS | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_Alpha_Type,
+  Copy_Alpha_Type,
+  Free_Alpha_Type,
+  Check_Alpha_Field,
+  Check_Alpha_Character,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_ALPHA = &typeALPHA;
+
+/* fty_alpha.c ends here */
diff --git a/Source/CursesDialog/form/fty_enum.c b/Source/CursesDialog/form/fty_enum.c
new file mode 100644
index 0000000..59058a9
--- /dev/null
+++ b/Source/CursesDialog/form/fty_enum.c
@@ -0,0 +1,295 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+typedef struct {
+  char **kwds;
+  int  count;
+  bool checkcase;
+  bool checkunique;
+} enumARG;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Make_Enum_Type( va_list * ap )
+|   
+|   Description   :  Allocate structure for enumeration type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_Enum_Type(va_list * ap)
+{
+  enumARG *argp = (enumARG *)malloc(sizeof(enumARG));
+
+  if (argp)
+    {
+      int cnt = 0;
+      char **kp = (char **)0;
+      int ccase, cunique;
+
+      argp->kwds        = va_arg(*ap,char **);
+      ccase             = va_arg(*ap,int);
+      cunique           = va_arg(*ap,int);
+      argp->checkcase   = ccase   ? TRUE : FALSE;
+      argp->checkunique = cunique ? TRUE : FALSE;
+
+      kp = argp->kwds;
+      while( kp && (*kp++) ) cnt++;
+      argp->count = cnt;
+    }
+  return (void *)argp;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Copy_Enum_Type( const void * argp )
+|   
+|   Description   :  Copy structure for enumeration type argument.  
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_Enum_Type(const void * argp)
+{
+  enumARG *result = (enumARG *)0;
+
+  if (argp)
+    {
+      const enumARG *ap = (const enumARG *)argp;
+
+      result = (enumARG *)malloc(sizeof(enumARG));
+      if (result)
+	*result = *ap;
+    }
+  return (void *)result;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Free_Enum_Type( void * argp )
+|   
+|   Description   :  Free structure for enumeration type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_Enum_Type(void * argp)
+{
+  if (argp) 
+    free(argp);
+}
+
+#define SKIP_SPACE(x) while(((*(x))!='\0') && (is_blank(*(x)))) (x)++
+#define NOMATCH 0
+#define PARTIAL 1
+#define EXACT   2
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static int Compare(const unsigned char * s,  
+|                                       const unsigned char * buf,
+|                                       bool  ccase )
+|   
+|   Description   :  Check whether or not the text in 'buf' matches the
+|                    text in 's', at least partial.
+|
+|   Return Values :  NOMATCH   - buffer doesn't match
+|                    PARTIAL   - buffer matches partially
+|                    EXACT     - buffer matches exactly
++--------------------------------------------------------------------------*/
+static int Compare(const unsigned char *s, const unsigned char *buf, 
+		   bool ccase)
+{
+  SKIP_SPACE(buf); /* Skip leading spaces in both texts */
+  SKIP_SPACE(s);
+
+  if (*buf=='\0')
+    {
+      return (((*s)!='\0') ? NOMATCH : EXACT);
+    } 
+  else 
+    {
+      if (ccase)
+	{
+	  while(*s++ == *buf)
+	    {
+	      if (*buf++=='\0') return EXACT;
+	    } 
+	} 
+      else 
+	{
+	  while(toupper(*s++)==toupper(*buf))
+	    {
+	      if (*buf++=='\0') return EXACT;
+	    }
+	}
+    }
+  /* At this location buf points to the first character where it no longer
+     matches with s. So if only blanks are following, we have a partial
+     match otherwise there is no match */
+  SKIP_SPACE(buf);
+  if (*buf) 
+    return NOMATCH;
+
+  /* If it happens that the reference buffer is at its end, the partial
+     match is actually an exact match. */
+  return ((s[-1]!='\0') ? PARTIAL : EXACT);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Enum_Field(
+|                                      FIELD * field,
+|                                      const void  * argp)
+|   
+|   Description   :  Validate buffer content to be a valid enumeration value
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Enum_Field(FIELD * field, const void  * argp)
+{
+  char **kwds       = ((const enumARG *)argp)->kwds;
+  bool ccase        = ((const enumARG *)argp)->checkcase;
+  bool unique       = ((const enumARG *)argp)->checkunique;
+  unsigned char *bp = (unsigned char *)field_buffer(field,0);
+  char *s, *t, *p;
+  int res;
+  
+  while( kwds && (s=(*kwds++)) )
+    {
+      if ((res=Compare((unsigned char *)s,bp,ccase))!=NOMATCH)
+	{
+	  p=t=s; /* t is at least a partial match */
+	  if ((unique && res!=EXACT)) 
+	    {
+	      while( kwds && (p = *kwds++) )
+		{
+		  if ((res=Compare((unsigned char *)p,bp,ccase))!=NOMATCH)
+		    {
+		      if (res==EXACT)
+			{
+			  t = p;
+			  break;
+			}
+		      else
+			t = (char *)0;
+		    }
+		}
+	    }	  
+	  if (t)
+	    {
+	      set_field_buffer(field,0,t);
+	      return TRUE;
+	    }
+	  if (!p)
+	    break;
+	}
+    }
+  return FALSE;
+}
+
+static const char *dummy[] = { (char *)0 };
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Next_Enum(FIELD * field,
+|                                          const void * argp)
+|   
+|   Description   :  Check for the next enumeration value
+|
+|   Return Values :  TRUE  - next value found and loaded
+|                    FALSE - no next value loaded
++--------------------------------------------------------------------------*/
+static bool Next_Enum(FIELD * field, const void * argp)
+{
+  const enumARG *args = (const enumARG *)argp;
+  char **kwds       = args->kwds;
+  bool ccase        = args->checkcase;
+  int cnt           = args->count;
+  unsigned char *bp = (unsigned char *)field_buffer(field,0);
+
+  if (kwds) {
+    while(cnt--)
+      {
+	if (Compare((unsigned char *)(*kwds++),bp,ccase)==EXACT) 
+	  break;
+      }
+    if (cnt<=0)
+      kwds = args->kwds;
+    if ((cnt>=0) || (Compare((const unsigned char *)dummy,bp,ccase)==EXACT))
+      {
+	set_field_buffer(field,0,*kwds);
+	return TRUE;
+      }
+  }
+  return FALSE;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Previous_Enum(
+|                                          FIELD * field,
+|                                          const void * argp)
+|   
+|   Description   :  Check for the previous enumeration value
+|
+|   Return Values :  TRUE  - previous value found and loaded
+|                    FALSE - no previous value loaded
++--------------------------------------------------------------------------*/
+static bool Previous_Enum(FIELD * field, const void * argp)
+{
+  const enumARG *args = (const enumARG *)argp;
+  int cnt       = args->count;
+  char **kwds   = &args->kwds[cnt-1];
+  bool ccase    = args->checkcase;
+  unsigned char *bp = (unsigned char *)field_buffer(field,0);
+
+  if (kwds) {
+    while(cnt--)
+      {
+	if (Compare((unsigned char *)(*kwds--),bp,ccase)==EXACT) 
+	  break;
+      }
+    
+    if (cnt<=0)
+      kwds  = &args->kwds[args->count-1];
+    
+    if ((cnt>=0) || (Compare((const unsigned char *)dummy,bp,ccase)==EXACT))
+      {
+	set_field_buffer(field,0,*kwds);
+	return TRUE;
+      }
+  }
+  return FALSE;
+}
+
+
+static FIELDTYPE typeENUM = {
+  _HAS_ARGS | _HAS_CHOICE | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_Enum_Type,
+  Copy_Enum_Type,
+  Free_Enum_Type,
+  Check_Enum_Field,
+  NULL,
+  Next_Enum,
+  Previous_Enum
+};
+
+FIELDTYPE* TYPE_ENUM = &typeENUM;
+
+/* fty_enum.c ends here */
diff --git a/Source/CursesDialog/form/fty_int.c b/Source/CursesDialog/form/fty_int.c
new file mode 100644
index 0000000..7107fcc
--- /dev/null
+++ b/Source/CursesDialog/form/fty_int.c
@@ -0,0 +1,161 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+typedef struct {
+  int precision;
+  long low;
+  long high;
+} integerARG;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Make_Integer_Type( va_list * ap )
+|   
+|   Description   :  Allocate structure for integer type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_Integer_Type(va_list * ap)
+{
+  integerARG *argp = (integerARG *)malloc(sizeof(integerARG));
+
+  if (argp)
+    {
+      argp->precision = va_arg(*ap,int);
+      argp->low       = va_arg(*ap,long);
+      argp->high      = va_arg(*ap,long);
+    }
+  return (void *)argp;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Copy_Integer_Type(const void * argp)
+|   
+|   Description   :  Copy structure for integer type argument.  
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_Integer_Type(const void * argp)
+{
+  const integerARG *ap = (const integerARG *)argp;
+  integerARG *result = (integerARG *)0;
+
+  if (argp)
+    {
+      result = (integerARG *)malloc(sizeof(integerARG));
+      if (result)
+	*result = *ap;
+    }
+  return (void *)result;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Free_Integer_Type(void * argp)
+|   
+|   Description   :  Free structure for integer type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_Integer_Type(void * argp)
+{
+  if (argp) 
+    free(argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Integer_Field(
+|                                                    FIELD * field,
+|                                                    const void * argp)
+|   
+|   Description   :  Validate buffer content to be a valid integer value
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Integer_Field(FIELD * field, const void * argp)
+{
+  const integerARG *argi = (const integerARG *)argp;
+  long low          = argi->low;
+  long high         = argi->high;
+  int prec          = argi->precision;
+  unsigned char *bp = (unsigned char *)field_buffer(field,0);
+  char *s           = (char *)bp;
+  long val;
+  char buf[100];
+
+  while( *bp && *bp==' ') bp++;
+  if (*bp)
+    {
+      if (*bp=='-') bp++;
+      while (*bp)
+	{
+	  if (!isdigit(*bp)) break;
+	  bp++;
+	}
+      while(*bp && *bp==' ') bp++;
+      if (*bp=='\0')
+	{
+	  val = atol(s);
+	  if (low<high)
+	    {
+	      if (val<low || val>high) return FALSE;
+	    }
+	  sprintf(buf,"%.*ld",(prec>0?prec:0),val);
+	  set_field_buffer(field,0,buf);
+	  return TRUE;
+	}
+    }
+  return FALSE;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Integer_Character(
+|                                      int c,
+|                                      const void * argp)
+|   
+|   Description   :  Check a character for the integer type.
+|
+|   Return Values :  TRUE  - character is valid
+|                    FALSE - character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Integer_Character(int c, const void * argp)
+{
+  argp=0; /* Silence unused parameter warning.  */
+  return ((isdigit(c) || (c=='-')) ? TRUE : FALSE);
+}
+
+static FIELDTYPE typeINTEGER = {
+  _HAS_ARGS | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_Integer_Type,
+  Copy_Integer_Type,
+  Free_Integer_Type,
+  Check_Integer_Field,
+  Check_Integer_Character,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_INTEGER = &typeINTEGER;
+
+/* fty_int.c ends here */
diff --git a/Source/CursesDialog/form/fty_ipv4.c b/Source/CursesDialog/form/fty_ipv4.c
new file mode 100644
index 0000000..c855af6
--- /dev/null
+++ b/Source/CursesDialog/form/fty_ipv4.c
@@ -0,0 +1,84 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Per Foreby, perf@efd.lth.se                                    *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_IPV4_Field(
+|                                      FIELD * field,
+|                                      const void * argp)
+|   
+|   Description   :  Validate buffer content to be a valid IP number (Ver. 4)
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_IPV4_Field(FIELD * field, const void * argp)
+{
+  char *bp = field_buffer(field,0);
+  int num = 0, len;
+  unsigned int d1=256, d2=256, d3=256, d4=256;
+
+  argp=0; /* Silence unused parameter warning.  */
+
+  if(isdigit((int)(*bp)))              /* Must start with digit */
+    {
+      num = sscanf(bp, "%u.%u.%u.%u%n", &d1, &d2, &d3, &d4, &len);
+      if (num == 4)
+        {
+          bp += len;            /* Make bp point to what sscanf() left */
+          while (*bp && isspace((int)(*bp)))
+            bp++;               /* Allow trailing whitespace */
+        }
+    }
+  return ((num != 4 || *bp || d1 > 255 || d2 > 255
+                           || d3 > 255 || d4 > 255) ? FALSE : TRUE);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_IPV4_Character(
+|                                      int c, 
+|                                      const void *argp )
+|   
+|   Description   :  Check a character for unsigned type or period.
+|
+|   Return Values :  TRUE  - character is valid
+|                    FALSE - character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_IPV4_Character(int c, const void * argp)
+{
+  argp=0; /* Silence unused parameter warning.  */
+  return ((isdigit(c) || (c=='.')) ? TRUE : FALSE);
+}
+
+static FIELDTYPE typeIPV4 = {
+  _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  NULL,
+  NULL,
+  NULL,
+  Check_IPV4_Field,
+  Check_IPV4_Character,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_IPV4 = &typeIPV4;
+
+/* fty_ipv4.c ends here */
diff --git a/Source/CursesDialog/form/fty_num.c b/Source/CursesDialog/form/fty_num.c
new file mode 100644
index 0000000..7809599
--- /dev/null
+++ b/Source/CursesDialog/form/fty_num.c
@@ -0,0 +1,192 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+#if HAVE_LOCALE_H
+#include <locale.h>
+#endif
+
+typedef struct {
+  int    precision;
+  double low;
+  double high;
+  struct lconv* L;
+} numericARG;
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Make_Numeric_Type(va_list * ap)
+|   
+|   Description   :  Allocate structure for numeric type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_Numeric_Type(va_list * ap)
+{
+  numericARG *argn = (numericARG *)malloc(sizeof(numericARG));
+
+  if (argn)
+    {
+      argn->precision = va_arg(*ap,int);
+      argn->low       = va_arg(*ap,double);
+      argn->high      = va_arg(*ap,double);
+#if HAVE_LOCALE_H
+      argn->L         = localeconv();
+#else
+      argn->L         = NULL;
+#endif
+    }
+  return (void *)argn;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void *Copy_Numeric_Type(const void * argp)
+|   
+|   Description   :  Copy structure for numeric type argument.  
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_Numeric_Type(const void * argp)
+{
+  const numericARG *ap = (const numericARG *)argp;
+  numericARG *result = (numericARG *)0;
+
+  if (argp)
+    {
+      result = (numericARG *)malloc(sizeof(numericARG));
+      if (result)
+	*result  = *ap;
+    }
+  return (void *)result;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static void Free_Numeric_Type(void * argp)
+|   
+|   Description   :  Free structure for numeric type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_Numeric_Type(void * argp)
+{
+  if (argp) 
+    free(argp);
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Numeric_Field(FIELD * field,
+|                                                    const void * argp)
+|   
+|   Description   :  Validate buffer content to be a valid numeric value
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Numeric_Field(FIELD * field, const void * argp)
+{
+  const numericARG *argn = (const numericARG *)argp;
+  double low          = argn->low;
+  double high         = argn->high;
+  int prec            = argn->precision;
+  unsigned char *bp   = (unsigned char *)field_buffer(field,0);
+  char *s             = (char *)bp;
+  double val          = 0.0;
+  char buf[64];
+
+  while(*bp && *bp==' ') bp++;
+  if (*bp)
+    {
+      if (*bp=='-' || *bp=='+')
+	bp++;
+      while(*bp)
+	{
+	  if (!isdigit(*bp)) break;
+	  bp++;
+	}
+      if (*bp==(
+#if HAVE_LOCALE_H
+		(L && L->decimal_point) ? *(L->decimal_point) :
+#endif
+		'.'))
+	{
+	  bp++;
+	  while(*bp)
+	    {
+	      if (!isdigit(*bp)) break;
+	      bp++;
+	    }
+	}
+      while(*bp && *bp==' ') bp++;
+      if (*bp=='\0')
+	{
+	  val = atof(s);
+	  if (low<high)
+	    {
+	      if (val<low || val>high) return FALSE;
+	    }
+	  sprintf(buf,"%.*f",(prec>0?prec:0),val);
+	  set_field_buffer(field,0,buf);
+	  return TRUE;
+	}
+    }
+  return FALSE;
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform  
+|   Function      :  static bool Check_Numeric_Character(
+|                                      int c,
+|                                      const void * argp)
+|   
+|   Description   :  Check a character for the numeric type.
+|
+|   Return Values :  TRUE  - character is valid
+|                    FALSE - character is invalid
++--------------------------------------------------------------------------*/
+static bool Check_Numeric_Character(int c, const void * argp)
+{
+  argp=0; /* Silence unused parameter warning.  */
+  return (isdigit(c)  || 
+	  c == '+'    || 
+	  c == '-'    || 
+	  c == (
+#if HAVE_LOCALE_H
+		(L && L->decimal_point) ? *(L->decimal_point) :
+#endif
+		'.')
+	  ) ? TRUE : FALSE;
+}
+
+static FIELDTYPE typeNUMERIC = {
+  _HAS_ARGS | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_Numeric_Type,
+  Copy_Numeric_Type,
+  Free_Numeric_Type,
+  Check_Numeric_Field,
+  Check_Numeric_Character,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_NUMERIC = &typeNUMERIC;
+
+/* fty_num.c ends here */
diff --git a/Source/CursesDialog/form/fty_regex.c b/Source/CursesDialog/form/fty_regex.c
new file mode 100644
index 0000000..f90e0c1
--- /dev/null
+++ b/Source/CursesDialog/form/fty_regex.c
@@ -0,0 +1,264 @@
+
+/*
+ * THIS CODE IS SPECIFICALLY EXEMPTED FROM THE NCURSES PACKAGE COPYRIGHT.
+ * You may freely copy it for use as a template for your own field types.
+ * If you develop a field type that might be of general use, please send
+ * it back to the ncurses maintainers for inclusion in the next version.
+ */
+/***************************************************************************
+*                                                                          *
+*  Author : Juergen Pfeifer, juergen.pfeifer@gmx.net                       *
+*                                                                          *
+***************************************************************************/
+
+#include "form.priv.h"
+
+MODULE_ID("$Id$")
+
+#if HAVE_REGEX_H_FUNCS	/* We prefer POSIX regex */
+#include <regex.h>
+
+typedef struct
+{
+  regex_t *pRegExp;
+  unsigned long *refCount;
+} RegExp_Arg;
+
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
+#undef RETURN
+static int reg_errno;
+
+static char *RegEx_Init(char *instring)
+{
+	reg_errno = 0;
+	return instring;
+}
+
+static char *RegEx_Error(int code)
+{
+	reg_errno = code;
+	return 0;
+}
+
+#define INIT 		char *sp = RegEx_Init(instring);
+#define GETC()		(*sp++)
+#define PEEKC()		(*sp)
+#define UNGETC(c)	(--sp)
+#define RETURN(c)	return(c)
+#define ERROR(c)	return RegEx_Error(c)
+
+#if HAVE_REGEXP_H_FUNCS
+#include <regexp.h>
+#else
+#include <regexpr.h>
+#endif
+
+typedef struct
+{
+  char *compiled_expression;
+  unsigned long *refCount;
+} RegExp_Arg;
+
+/* Maximum Length we allow for a compiled regular expression */
+#define MAX_RX_LEN   (2048)
+#define RX_INCREMENT (256)
+
+#endif
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform
+|   Function      :  static void *Make_RegularExpression_Type(va_list * ap)
+|
+|   Description   :  Allocate structure for regex type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error
++--------------------------------------------------------------------------*/
+static void *Make_RegularExpression_Type(va_list * ap)
+{
+#if HAVE_REGEX_H_FUNCS
+  char *rx = va_arg(*ap,char *);
+  RegExp_Arg *preg;
+
+  preg = (RegExp_Arg*)malloc(sizeof(RegExp_Arg));
+  if (preg)
+    {
+      if (((preg->pRegExp = (regex_t*)malloc(sizeof(regex_t))) != (regex_t*)0)
+       && !regcomp(preg->pRegExp,rx,
+		   (REG_EXTENDED | REG_NOSUB | REG_NEWLINE) ))
+	{
+	  preg->refCount = (unsigned long *)malloc(sizeof(unsigned long));
+	  *(preg->refCount) = 1;
+	}
+      else
+	{
+	  if (preg->pRegExp)
+	    free(preg->pRegExp);
+	  free(preg);
+	  preg = (RegExp_Arg*)0;
+	}
+    }
+  return((void *)preg);
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
+  char *rx = va_arg(*ap,char *);
+  RegExp_Arg *pArg;
+
+  pArg = (RegExp_Arg *)malloc(sizeof(RegExp_Arg));
+
+  if (pArg)
+    {
+      int blen = RX_INCREMENT;
+      pArg->compiled_expression = NULL;
+      pArg->refCount = (unsigned long *)malloc(sizeof(unsigned long));
+      *(pArg->refCount) = 1;
+
+      do {
+	char *buf = (char *)malloc(blen);
+	if (buf)
+	  {
+#if HAVE_REGEXP_H_FUNCS
+	    char *last_pos = compile (rx, buf, &buf[blen], '\0');
+#else /* HAVE_REGEXPR_H_FUNCS */
+	    char *last_pos = compile (rx, buf, &buf[blen]);
+#endif
+	    if (reg_errno)
+	      {
+		free(buf);
+		if (reg_errno==50)
+		  blen += RX_INCREMENT;
+		else
+		  {
+		    free(pArg);
+		    pArg = NULL;
+		    break;
+		  }
+	      }
+	    else
+	      {
+		pArg->compiled_expression = buf;
+		break;
+	      }
+	  }
+      } while( blen <= MAX_RX_LEN );
+    }
+  if (pArg && !pArg->compiled_expression)
+    {
+      free(pArg);
+      pArg = NULL;
+    }
+  return (void *)pArg;
+#else
+  ap=0; /* Silence unused parameter warning.  */
+  return 0;
+#endif
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform
+|   Function      :  static void *Copy_RegularExpression_Type(
+|                                      const void * argp)
+|
+|   Description   :  Copy structure for regex type argument.
+|
+|   Return Values :  Pointer to argument structure or NULL on error.
++--------------------------------------------------------------------------*/
+static void *Copy_RegularExpression_Type(const void * argp)
+{
+#if (HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS)
+  const RegExp_Arg *ap = (const RegExp_Arg *)argp;
+  const RegExp_Arg *result = (const RegExp_Arg *)0;
+
+  if (ap)
+    {
+      *(ap->refCount) += 1;
+      result = ap;
+    }
+  return (void *)result;
+#else
+  argp=0; /* Silence unused parameter warning.  */
+  return 0;
+#endif
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform
+|   Function      :  static void Free_RegularExpression_Type(void * argp)
+|
+|   Description   :  Free structure for regex type argument.
+|
+|   Return Values :  -
++--------------------------------------------------------------------------*/
+static void Free_RegularExpression_Type(void * argp)
+{
+#if HAVE_REGEX_H_FUNCS | HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
+  RegExp_Arg *ap = (RegExp_Arg *)argp;
+  if (ap)
+    {
+      if (--(*(ap->refCount)) == 0)
+	{
+#if HAVE_REGEX_H_FUNCS
+	  if (ap->pRegExp)
+	    {
+	      free(ap->refCount);
+	      regfree(ap->pRegExp);
+	    }
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
+	  if (ap->compiled_expression)
+	    {
+	      free(ap->refCount);
+	      free(ap->compiled_expression);
+	    }
+#endif
+	  free(ap);
+	}
+    }
+#else
+  argp=0; /* Silence unused parameter warning.  */
+#endif
+}
+
+/*---------------------------------------------------------------------------
+|   Facility      :  libnform
+|   Function      :  static bool Check_RegularExpression_Field(
+|                                      FIELD * field,
+|                                      const void  * argp)
+|
+|   Description   :  Validate buffer content to be a valid regular expression
+|
+|   Return Values :  TRUE  - field is valid
+|                    FALSE - field is invalid
++--------------------------------------------------------------------------*/
+static bool Check_RegularExpression_Field(FIELD * field, const void  * argp)
+{
+  bool match = FALSE;
+#if HAVE_REGEX_H_FUNCS
+  const RegExp_Arg *ap = (const RegExp_Arg*)argp;
+  if (ap && ap->pRegExp)
+    match = (regexec(ap->pRegExp,field_buffer(field,0),0,NULL,0) ? FALSE:TRUE);
+#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
+  RegExp_Arg *ap = (RegExp_Arg *)argp;
+  if (ap && ap->compiled_expression)
+    match = (step(field_buffer(field,0),ap->compiled_expression) ? TRUE:FALSE);
+#else
+  argp=0;  /* Silence unused parameter warning.  */
+  field=0; /* Silence unused parameter warning.  */
+#endif
+  return match;
+}
+
+static FIELDTYPE typeREGEXP = {
+  _HAS_ARGS | _RESIDENT,
+  1,                           /* this is mutable, so we can't be const */
+  (FIELDTYPE *)0,
+  (FIELDTYPE *)0,
+  Make_RegularExpression_Type,
+  Copy_RegularExpression_Type,
+  Free_RegularExpression_Type,
+  Check_RegularExpression_Field,
+  NULL,
+  NULL,
+  NULL
+};
+
+FIELDTYPE* TYPE_REGEXP = &typeREGEXP;
+
+/* fty_regex.c ends here */
diff --git a/Source/CursesDialog/form/llib-lform b/Source/CursesDialog/form/llib-lform
new file mode 100644
index 0000000..ac2ba43
--- /dev/null
+++ b/Source/CursesDialog/form/llib-lform
@@ -0,0 +1,694 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Thomas E. Dickey <dickey@clark.net> 1996,1997                   *
+ ****************************************************************************/
+/* LINTLIBRARY */
+
+/* ./fld_arg.c */
+
+#include "form.priv.h"
+
+#undef set_fieldtype_arg
+int	set_fieldtype_arg(
+		FIELDTYPE *typ, 
+		void	*(*const make_arg)(
+		va_list	*p1), 
+		void	*(*const copy_arg)(
+		const void *p1), 
+		void	(*const free_arg)(
+		void	*p1))
+		{ return(*(int *)0); }
+
+#undef field_arg
+void	*field_arg(
+		const FIELD *field)
+		{ return(*(void **)0); }
+
+/* ./fld_attr.c */
+
+#undef set_field_fore
+int	set_field_fore(
+		FIELD	*field, 
+		chtype	attr)
+		{ return(*(int *)0); }
+
+#undef field_fore
+chtype	field_fore(
+		const FIELD *field)
+		{ return(*(chtype *)0); }
+
+#undef set_field_back
+int	set_field_back(
+		FIELD	*field, 
+		chtype	attr)
+		{ return(*(int *)0); }
+
+#undef field_back
+chtype	field_back(
+		const FIELD *field)
+		{ return(*(chtype *)0); }
+
+/* ./fld_current.c */
+
+#undef set_current_field
+int	set_current_field(
+		FORM	*form, 
+		FIELD	*field)
+		{ return(*(int *)0); }
+
+#undef current_field
+FIELD	*current_field(
+		const FORM *form)
+		{ return(*(FIELD **)0); }
+
+#undef field_index
+int	field_index(
+		const FIELD *field)
+		{ return(*(int *)0); }
+
+/* ./fld_def.c */
+
+#undef _nc_Default_Field
+FIELD	*_nc_Default_Field;
+
+#undef _nc_Make_Argument
+TypeArgument *_nc_Make_Argument(
+		const FIELDTYPE *typ, 
+		va_list	*ap, 
+		int	*err)
+		{ return(*(TypeArgument **)0); }
+
+#undef _nc_Copy_Argument
+TypeArgument *_nc_Copy_Argument(
+		const FIELDTYPE *typ, 
+		const TypeArgument *argp, 
+		int	*err)
+		{ return(*(TypeArgument **)0); }
+
+#undef _nc_Free_Argument
+void	_nc_Free_Argument(
+		const FIELDTYPE *typ, 
+		TypeArgument *argp)
+		{ /* void */ }
+
+#undef _nc_Copy_Type
+bool	_nc_Copy_Type(
+		FIELD	*dst, 
+		FIELD const *src)
+		{ return(*(bool *)0); }
+
+#undef _nc_Free_Type
+void	_nc_Free_Type(
+		FIELD	*field)
+		{ /* void */ }
+
+#undef new_field
+FIELD	*new_field(
+		int	rows, 
+		int	cols, 
+		int	frow, 
+		int	fcol, 
+		int	nrow, 
+		int	nbuf)
+		{ return(*(FIELD **)0); }
+
+#undef free_field
+int	free_field(
+		FIELD	*field)
+		{ return(*(int *)0); }
+
+/* ./fld_dup.c */
+
+#undef dup_field
+FIELD	*dup_field(
+		FIELD	*field, 
+		int	frow, 
+		int	fcol)
+		{ return(*(FIELD **)0); }
+
+/* ./fld_ftchoice.c */
+
+#undef set_fieldtype_choice
+int	set_fieldtype_choice(
+		FIELDTYPE *typ, 
+		bool	(*const next_choice)(
+		FIELD	*p1, 
+		const void *p2), 
+		bool	(*const prev_choice)(
+		FIELD	*p1, 
+		const void *p2))
+		{ return(*(int *)0); }
+
+/* ./fld_ftlink.c */
+
+#undef link_fieldtype
+FIELDTYPE *link_fieldtype(
+		FIELDTYPE *type1, 
+		FIELDTYPE *type2)
+		{ return(*(FIELDTYPE **)0); }
+
+/* ./fld_info.c */
+
+#undef field_info
+int	field_info(
+		const FIELD *field, 
+		int	*rows, 
+		int	*cols, 
+		int	*frow, 
+		int	*fcol, 
+		int	*nrow, 
+		int	*nbuf)
+		{ return(*(int *)0); }
+
+#undef dynamic_field_info
+int	dynamic_field_info(
+		const FIELD *field, 
+		int	*drows, 
+		int	*dcols, 
+		int	*maxgrow)
+		{ return(*(int *)0); }
+
+/* ./fld_just.c */
+
+#undef set_field_just
+int	set_field_just(
+		FIELD	*field, 
+		int	just)
+		{ return(*(int *)0); }
+
+#undef field_just
+int	field_just(
+		const FIELD *field)
+		{ return(*(int *)0); }
+
+/* ./fld_link.c */
+
+#undef link_field
+FIELD	*link_field(
+		FIELD	*field, 
+		int	frow, 
+		int	fcol)
+		{ return(*(FIELD **)0); }
+
+/* ./fld_max.c */
+
+#undef set_max_field
+int	set_max_field(
+		FIELD	*field, 
+		int	maxgrow)
+		{ return(*(int *)0); }
+
+/* ./fld_move.c */
+
+#undef move_field
+int	move_field(
+		FIELD	*field, 
+		int	frow, 
+		int	fcol)
+		{ return(*(int *)0); }
+
+/* ./fld_newftyp.c */
+
+#undef _nc_Default_FieldType
+const FIELDTYPE *_nc_Default_FieldType = {0};
+
+#undef new_fieldtype
+FIELDTYPE *new_fieldtype(
+		bool	(*const field_check)(
+		FIELD	*p1, 
+		const void *p2), 
+		bool	(*const char_check)(
+		int	p1, 
+		const void *p2))
+		{ return(*(FIELDTYPE **)0); }
+
+#undef free_fieldtype
+int	free_fieldtype(
+		FIELDTYPE *typ)
+		{ return(*(int *)0); }
+
+/* ./fld_opts.c */
+
+#undef set_field_opts
+int	set_field_opts(
+		FIELD	*field, 
+		Field_Options opts)
+		{ return(*(int *)0); }
+
+#undef field_opts
+Field_Options field_opts(
+		const FIELD *field)
+		{ return(*(Field_Options *)0); }
+
+#undef field_opts_on
+int	field_opts_on(
+		FIELD	*field, 
+		Field_Options opts)
+		{ return(*(int *)0); }
+
+#undef field_opts_off
+int	field_opts_off(
+		FIELD	*field, 
+		Field_Options opts)
+		{ return(*(int *)0); }
+
+/* ./fld_pad.c */
+
+#undef set_field_pad
+int	set_field_pad(
+		FIELD	*field, 
+		int	ch)
+		{ return(*(int *)0); }
+
+#undef field_pad
+int	field_pad(
+		const FIELD *field)
+		{ return(*(int *)0); }
+
+/* ./fld_page.c */
+
+#undef set_new_page
+int	set_new_page(
+		FIELD	*field, 
+		bool	new_page_flag)
+		{ return(*(int *)0); }
+
+#undef new_page
+bool	new_page(
+		const FIELD *field)
+		{ return(*(bool *)0); }
+
+/* ./fld_stat.c */
+
+#undef set_field_status
+int	set_field_status(
+		FIELD	*field, 
+		bool	status)
+		{ return(*(int *)0); }
+
+#undef field_status
+bool	field_status(
+		const FIELD *field)
+		{ return(*(bool *)0); }
+
+/* ./fld_type.c */
+
+#undef set_field_type
+int	set_field_type(
+		FIELD	*field, 
+		FIELDTYPE *type, 
+		...)
+		{ return(*(int *)0); }
+
+#undef field_type
+FIELDTYPE *field_type(
+		const FIELD *field)
+		{ return(*(FIELDTYPE **)0); }
+
+/* ./fld_user.c */
+
+#undef set_field_userptr
+int	set_field_userptr(
+		FIELD	*field, 
+		void	*usrptr)
+		{ return(*(int *)0); }
+
+#undef field_userptr
+void	*field_userptr(
+		const FIELD *field)
+		{ return(*(void **)0); }
+
+/* ./frm_cursor.c */
+
+#undef pos_form_cursor
+int	pos_form_cursor(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+/* ./frm_data.c */
+
+#undef data_behind
+bool	data_behind(
+		const FORM *form)
+		{ return(*(bool *)0); }
+
+#undef data_ahead
+bool	data_ahead(
+		const FORM *form)
+		{ return(*(bool *)0); }
+
+/* ./frm_def.c */
+
+#undef _nc_Default_Form
+FORM	*_nc_Default_Form;
+
+#undef new_form
+FORM	*new_form(
+		FIELD	**fields)
+		{ return(*(FORM **)0); }
+
+#undef free_form
+int	free_form(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+#undef set_form_fields
+int	set_form_fields(
+		FORM	*form, 
+		FIELD	**fields)
+		{ return(*(int *)0); }
+
+#undef form_fields
+FIELD	**form_fields(
+		const FORM *form)
+		{ return(*(FIELD ***)0); }
+
+#undef field_count
+int	field_count(
+		const FORM *form)
+		{ return(*(int *)0); }
+
+/* ./frm_driver.c */
+
+#undef _nc_Position_Form_Cursor
+int	_nc_Position_Form_Cursor(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+#undef _nc_Refresh_Current_Field
+int	_nc_Refresh_Current_Field(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+#undef _nc_Synchronize_Attributes
+int	_nc_Synchronize_Attributes(
+		FIELD	*field)
+		{ return(*(int *)0); }
+
+#undef _nc_Synchronize_Options
+int	_nc_Synchronize_Options(
+		FIELD	*field, 
+		Field_Options newopts)
+		{ return(*(int *)0); }
+
+#undef _nc_Set_Current_Field
+int	_nc_Set_Current_Field(
+		FORM	*form, 
+		FIELD	*newfield)
+		{ return(*(int *)0); }
+
+#undef _nc_Internal_Validation
+bool	_nc_Internal_Validation(
+		FORM	*form)
+		{ return(*(bool *)0); }
+
+#undef _nc_First_Active_Field
+FIELD	*_nc_First_Active_Field(
+		FORM	*form)
+		{ return(*(FIELD **)0); }
+
+#undef _nc_Set_Form_Page
+int	_nc_Set_Form_Page(
+		FORM	*form, 
+		int	page, 
+		FIELD	*field)
+		{ return(*(int *)0); }
+
+typedef struct {
+  int keycode;           
+  int (*cmd)(FORM *);    
+} Binding_Info;
+
+#undef form_driver
+int	form_driver(
+		FORM	*form, 
+		int	c)
+		{ return(*(int *)0); }
+
+#undef set_field_buffer
+int	set_field_buffer(
+		FIELD	*field, 
+		int	buffer, 
+		const char *value)
+		{ return(*(int *)0); }
+
+#undef field_buffer
+char	*field_buffer(
+		const FIELD *field, 
+		int	buffer)
+		{ return(*(char **)0); }
+
+/* ./frm_hook.c */
+
+#undef set_field_init
+int	set_field_init(
+		FORM	*form, 
+		Form_Hook func)
+		{ return(*(int *)0); }
+
+#undef field_init
+Form_Hook field_init(
+		const FORM *form)
+		{ return(*(Form_Hook *)0); }
+
+#undef set_field_term
+int	set_field_term(
+		FORM	*form, 
+		Form_Hook func)
+		{ return(*(int *)0); }
+
+#undef field_term
+Form_Hook field_term(
+		const FORM *form)
+		{ return(*(Form_Hook *)0); }
+
+#undef set_form_init
+int	set_form_init(
+		FORM	*form, 
+		Form_Hook func)
+		{ return(*(int *)0); }
+
+#undef form_init
+Form_Hook form_init(
+		const FORM *form)
+		{ return(*(Form_Hook *)0); }
+
+#undef set_form_term
+int	set_form_term(
+		FORM	*form, 
+		Form_Hook func)
+		{ return(*(int *)0); }
+
+#undef form_term
+Form_Hook form_term(
+		const FORM *form)
+		{ return(*(Form_Hook *)0); }
+
+/* ./frm_opts.c */
+
+#undef set_form_opts
+int	set_form_opts(
+		FORM	*form, 
+		Form_Options opts)
+		{ return(*(int *)0); }
+
+#undef form_opts
+Form_Options form_opts(
+		const FORM *form)
+		{ return(*(Form_Options *)0); }
+
+#undef form_opts_on
+int	form_opts_on(
+		FORM	*form, 
+		Form_Options opts)
+		{ return(*(int *)0); }
+
+#undef form_opts_off
+int	form_opts_off(
+		FORM	*form, 
+		Form_Options opts)
+		{ return(*(int *)0); }
+
+/* ./frm_page.c */
+
+#undef set_form_page
+int	set_form_page(
+		FORM	*form, 
+		int	page)
+		{ return(*(int *)0); }
+
+#undef form_page
+int	form_page(
+		const FORM *form)
+		{ return(*(int *)0); }
+
+/* ./frm_post.c */
+
+#undef post_form
+int	post_form(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+#undef unpost_form
+int	unpost_form(
+		FORM	*form)
+		{ return(*(int *)0); }
+
+/* ./frm_req_name.c */
+
+#undef form_request_name
+const char *form_request_name(
+		int	request)
+		{ return(*(const char **)0); }
+
+#undef form_request_by_name
+int	form_request_by_name(
+		const char *str)
+		{ return(*(int *)0); }
+
+/* ./frm_scale.c */
+
+#undef scale_form
+int	scale_form(
+		const FORM *form, 
+		int	*rows, 
+		int	*cols)
+		{ return(*(int *)0); }
+
+/* ./frm_sub.c */
+
+#undef set_form_sub
+int	set_form_sub(
+		FORM	*form, 
+		WINDOW	*win)
+		{ return(*(int *)0); }
+
+#undef form_sub
+WINDOW	*form_sub(
+		const FORM *form)
+		{ return(*(WINDOW **)0); }
+
+/* ./frm_user.c */
+
+#undef set_form_userptr
+int	set_form_userptr(
+		FORM	*form, 
+		void	*usrptr)
+		{ return(*(int *)0); }
+
+#undef form_userptr
+void	*form_userptr(
+		const FORM *form)
+		{ return(*(void **)0); }
+
+/* ./frm_win.c */
+
+#undef set_form_win
+int	set_form_win(
+		FORM	*form, 
+		WINDOW	*win)
+		{ return(*(int *)0); }
+
+#undef form_win
+WINDOW	*form_win(
+		const FORM *form)
+		{ return(*(WINDOW **)0); }
+
+/* ./fty_alnum.c */
+
+typedef struct {
+  int width;
+} alnumARG;
+
+#undef TYPE_ALNUM
+FIELDTYPE *TYPE_ALNUM;
+
+/* ./fty_alpha.c */
+
+typedef struct {
+  int width;
+} alphaARG;
+
+#undef TYPE_ALPHA
+FIELDTYPE *TYPE_ALPHA;
+
+/* ./fty_enum.c */
+
+typedef struct {
+  char **kwds;
+  int  count;
+  bool checkcase;
+  bool checkunique;
+} enumARG;
+
+#undef TYPE_ENUM
+FIELDTYPE *TYPE_ENUM;
+
+/* ./fty_int.c */
+
+typedef struct {
+  int precision;
+  long low;
+  long high;
+} integerARG;
+
+#undef TYPE_INTEGER
+FIELDTYPE *TYPE_INTEGER;
+
+/* ./fty_ipv4.c */
+#undef TYPE_IPV4
+FIELDTYPE *TYPE_IPV4;
+
+/* ./fty_num.c */
+
+#include <locale.h>
+
+typedef struct {
+  int    precision;
+  double low;
+  double high;
+  struct lconv* L;
+} numericARG;
+
+#undef TYPE_NUMERIC
+FIELDTYPE *TYPE_NUMERIC;
+
+/* ./fty_regex.c */
+
+#include <regex.h>
+
+typedef struct
+{
+  regex_t *pRegExp;
+  unsigned long *refCount;
+} RegExp_Arg;
+
+#undef TYPE_REGEXP
+FIELDTYPE *TYPE_REGEXP;
diff --git a/Source/CursesDialog/form/mf_common.h b/Source/CursesDialog/form/mf_common.h
new file mode 100644
index 0000000..6b1e8fe
--- /dev/null
+++ b/Source/CursesDialog/form/mf_common.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+ * Copyright (c) 1998,2000 Free Software Foundation, Inc.                   *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer <juergen.pfeifer@gmx.net> 1995,1997            *
+ ****************************************************************************/
+
+/* Common internal header for menu and form library */
+
+#if HAVE_CONFIG_H
+#  include <ncurses_cfg.h>
+#endif
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#if DECL_ERRNO
+extern int errno;
+#endif
+
+/* in case of debug version we ignore the suppression of assertions */
+#ifdef TRACE
+#  ifdef NDEBUG
+#    undef NDEBUG
+#  endif
+#endif
+
+#include <nc_alloc.h>
+
+#if USE_RCS_IDS
+#define MODULE_ID(id) static const char Ident[] = id;
+#else
+#define MODULE_ID(id) /*nothing*/
+#endif
+
+
+/* Maximum regular 8-bit character code */
+#define MAX_REGULAR_CHARACTER (0xff)
+
+#define SET_ERROR(code) (errno=(code))
+#define GET_ERROR() (errno)
+#define RETURN(code) return( SET_ERROR(code) )
+
+/* The few common values in the status fields for menus and forms */
+#define _POSTED         (0x01)  /* menu or form is posted                  */
+#define _IN_DRIVER      (0x02)  /* menu or form is processing hook routine */
+
+/* Call object hook */
+#define Call_Hook( object, handler ) \
+   if ( (object) && ((object)->handler) )\
+   {\
+	(object)->status |= _IN_DRIVER;\
+	(object)->handler(object);\
+	(object)->status &= ~_IN_DRIVER;\
+   }
+
+#define INLINE
+
+#ifndef TRACE
+#  if CC_HAS_INLINE_FUNCS
+#    undef INLINE
+#    define INLINE inline
+#  endif
+#endif
diff --git a/Source/CursesDialog/form/nc_alloc.h b/Source/CursesDialog/form/nc_alloc.h
new file mode 100644
index 0000000..f49ea93
--- /dev/null
+++ b/Source/CursesDialog/form/nc_alloc.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+ * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Thomas E. Dickey <dickey@clark.net> 1996,1997                   *
+ ****************************************************************************/
+/* $Id$ */
+
+#ifndef NC_ALLOC_included
+#define NC_ALLOC_included 1
+
+#if HAVE_LIBDMALLOC
+#include <dmalloc.h>    /* Gray Watson's library */
+#else
+#undef  HAVE_LIBDMALLOC
+#define HAVE_LIBDMALLOC 0
+#endif
+
+#if HAVE_LIBDBMALLOC
+#include <dbmalloc.h>   /* Conor Cahill's library */
+#else
+#undef  HAVE_LIBDBMALLOC
+#define HAVE_LIBDBMALLOC 0
+#endif
+
+#ifndef NO_LEAKS
+#define NO_LEAKS 0
+#endif
+
+#if HAVE_LIBDBMALLOC || HAVE_LIBDMALLOC || NO_LEAKS
+#define HAVE_NC_FREEALL 1
+struct termtype;
+extern void _nc_free_and_exit(int) GCC_NORETURN;
+extern void _nc_free_tparm(void);
+extern void _nc_leaks_dump_entry(void);
+#define ExitProgram(code) _nc_free_and_exit(code)
+#endif
+
+#ifndef HAVE_NC_FREEALL
+#define HAVE_NC_FREEALL 0
+#endif
+
+#ifndef ExitProgram
+#define ExitProgram(code) return code
+#endif
+
+/* doalloc.c */
+extern void *_nc_doalloc(void *, size_t);
+#if !HAVE_STRDUP
+/* #define strdup _nc_strdup */
+extern char *_nc_strdup(const char *);
+#endif
+
+#define typeMalloc(type,elts) (type *)malloc((elts)*sizeof(type))
+#define typeCalloc(type,elts) (type *)calloc((elts),sizeof(type))
+#define typeRealloc(type,elts,ptr) (type *)_nc_doalloc(ptr, (elts)*sizeof(type))
+
+#endif /* NC_ALLOC_included */
diff --git a/Source/LexerParser/.clang-tidy b/Source/LexerParser/.clang-tidy
new file mode 100644
index 0000000..52b11bf
--- /dev/null
+++ b/Source/LexerParser/.clang-tidy
@@ -0,0 +1,6 @@
+---
+# We want to disable all checks for generated code.  However, clang-tidy will
+# assume we did not configure it correctly.  Just add one check that will never
+# be found.
+Checks: '-*,llvm-twine-local'
+...
diff --git a/Source/LexerParser/.gitattributes b/Source/LexerParser/.gitattributes
new file mode 100644
index 0000000..47eedfb
--- /dev/null
+++ b/Source/LexerParser/.gitattributes
@@ -0,0 +1,17 @@
+/cmCommandArgumentLexer.cxx        generated
+/cmCommandArgumentLexer.h          generated
+/cmCommandArgumentParser.cxx       generated
+/cmCommandArgumentParserTokens.h   generated
+/cmDependsJavaLexer.cxx            generated
+/cmDependsJavaLexer.h              generated
+/cmDependsJavaParser.cxx           generated
+/cmDependsJavaParserTokens.h       generated
+/cmExprLexer.cxx                   generated
+/cmExprLexer.h                     generated
+/cmExprParser.cxx                  generated
+/cmExprParserTokens.h              generated
+/cmFortranLexer.cxx                generated
+/cmFortranLexer.h                  generated
+/cmFortranParser.cxx               generated
+/cmFortranParserTokens.h           generated
+/cmListFileLexer.c                 generated
diff --git a/Source/LexerParser/cmCommandArgumentLexer.cxx b/Source/LexerParser/cmCommandArgumentLexer.cxx
new file mode 100644
index 0000000..6b4fc85
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentLexer.cxx
@@ -0,0 +1,2248 @@
+#include "cmStandardLexer.h"
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmCommandArgument_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmCommandArgument_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmCommandArgument_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmCommandArgument_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmCommandArgument_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmCommandArgument_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmCommandArgument_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmCommandArgument_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmCommandArgument_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmCommandArgument_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmCommandArgument_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmCommandArgument_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmCommandArgument_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmCommandArgument_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmCommandArgument_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmCommandArgument_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmCommandArgument_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmCommandArgument_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmCommandArgument_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmCommandArgument_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmCommandArgument_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmCommandArgument_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmCommandArgument_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmCommandArgument_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmCommandArgument_yylex_ALREADY_DEFINED
+#else
+#define yylex cmCommandArgument_yylex
+#endif
+
+#ifdef yyrestart
+#define cmCommandArgument_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmCommandArgument_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmCommandArgument_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmCommandArgument_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmCommandArgument_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmCommandArgument_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmCommandArgument_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmCommandArgument_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmCommandArgument_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmCommandArgument_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmCommandArgument_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmCommandArgument_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmCommandArgument_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmCommandArgument_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmCommandArgument_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmCommandArgument_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmCommandArgument_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmCommandArgument_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmCommandArgument_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmCommandArgument_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmCommandArgument_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmCommandArgument_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmCommandArgument_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmCommandArgument_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmCommandArgument_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmCommandArgument_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmCommandArgument_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmCommandArgument_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmCommandArgument_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmCommandArgument_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmCommandArgument_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmCommandArgument_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmCommandArgument_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmCommandArgument_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmCommandArgument_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmCommandArgument_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmCommandArgument_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmCommandArgument_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmCommandArgument_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmCommandArgument_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmCommandArgument_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmCommandArgument_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmCommandArgument_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmCommandArgument_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define cmCommandArgument_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 14
+#define YY_END_OF_BUFFER 15
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[30] =
+    {   0,
+        0,    0,    0,    0,    0,    0,   15,    9,   10,    7,
+        6,   14,   11,    5,   12,   13,    9,    0,    0,    4,
+        7,    0,    8,    2,    0,    3,    0,    1,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    3,    1,    1,    1,    1,
+        1,    1,    4,    1,    4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4,    4,    1,    1,    1,
+        1,    1,    1,    5,    4,    4,    4,    4,    6,    4,
+        4,    4,    4,    4,    4,    4,    4,    7,    4,    4,
+        4,    4,    4,    4,    4,    8,    4,    4,    4,    4,
+        1,    9,    1,    1,    4,    1,    4,    4,    4,    4,
+
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+        4,    4,   10,    1,   11,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[12] =
+    {   0,
+        1,    2,    3,    4,    3,    4,    4,    4,    3,    5,
+        3
+    } ;
+
+static const flex_int16_t yy_base[35] =
+    {   0,
+        0,    0,   31,   30,   29,   28,   36,    0,    6,   16,
+        0,   41,   41,   41,    0,   41,    0,   22,   22,   41,
+       18,   18,   41,   41,    7,   41,    4,   41,   41,   20,
+       21,   26,    9,   30
+    } ;
+
+static const flex_int16_t yy_def[35] =
+    {   0,
+       29,    1,    1,    1,    1,    1,   29,   30,   31,   32,
+       33,   29,   29,   29,   34,   29,   30,   31,   18,   29,
+       32,   33,   29,   29,   18,   29,   18,   29,    0,   29,
+       29,   29,   29,   29
+    } ;
+
+static const flex_int16_t yy_nxt[53] =
+    {   0,
+        8,    8,    9,   10,   11,   10,   10,   10,   12,   13,
+       14,   19,   22,   28,   27,   20,   17,   17,   17,   17,
+       17,   17,   26,   17,   18,   18,   21,   21,   25,   21,
+       23,   24,   23,   23,   23,   29,   16,   16,   15,   15,
+        7,   29,   29,   29,   29,   29,   29,   29,   29,   29,
+       29,   29
+    } ;
+
+static const flex_int16_t yy_chk[53] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    9,   33,   27,   25,    9,   10,   10,   21,   21,
+       30,   30,   22,   30,   31,   31,   32,   32,   19,   32,
+       34,   18,   34,   34,   34,    7,    6,    5,    4,    3,
+       29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
+       29,   29
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmCommandArgumentLexer.h -ocmCommandArgumentLexer.cxx cmCommandArgumentLexer.in.l
+
+Modify cmCommandArgumentLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmCommandArgumentLexer.h cmCommandArgumentLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmCommandArgumentLexer.h cmCommandArgumentLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCommandArgumentLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include "cmCommandArgumentParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmCommandArgumentParserTokens.h"
+
+static const char *DCURLYVariable = "${";
+static const char *RCURLYVariable = "}";
+static const char *ATVariable = "@";
+static const char *DOLLARVariable = "$";
+static const char *LCURLYVariable = "{";
+static const char *BSLASHVariable = "\\";
+
+/*--------------------------------------------------------------------------*/
+
+#define INITIAL 0
+#define ESCAPES 1
+#define NOESCAPES 2
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 30 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 41 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_ENVCURLY;
+}
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_NCURLY;
+}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_ATNAME;
+}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = DCURLYVariable;
+  return cal_DCURLY;
+}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = RCURLYVariable;
+  return cal_RCURLY;
+}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = ATVariable;
+  return cal_AT;
+}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return cal_NAME;
+}
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+{
+  if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) )
+    {
+    return cal_ERROR;
+    }
+  return cal_SYMBOL;
+}
+	YY_BREAK
+case 9:
+/* rule 9 can match eol */
+YY_RULE_SETUP
+{
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return cal_SYMBOL;
+}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+{
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = DOLLARVariable;
+  return cal_DOLLAR;
+}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+{
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = LCURLYVariable;
+  return cal_LCURLY;
+}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = BSLASHVariable;
+  return cal_BSLASH;
+}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+{
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = BSLASHVariable;
+  return cal_SYMBOL;
+}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(ESCAPES):
+case YY_STATE_EOF(NOESCAPES):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 30 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 30 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 29);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+/*--------------------------------------------------------------------------*/
+void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes)
+{
+  /* Hack into the internal flex-generated scanner to set the state.  */
+  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+  if(noEscapes) {
+    BEGIN(NOESCAPES);
+  } else {
+    BEGIN(ESCAPES);
+  }
+}
diff --git a/Source/LexerParser/cmCommandArgumentLexer.h b/Source/LexerParser/cmCommandArgumentLexer.h
new file mode 100644
index 0000000..5677513
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentLexer.h
@@ -0,0 +1,689 @@
+#ifndef cmCommandArgument_yyHEADER_H
+#define cmCommandArgument_yyHEADER_H 1
+#define cmCommandArgument_yyIN_HEADER 1
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmCommandArgument_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmCommandArgument_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmCommandArgument_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmCommandArgument_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmCommandArgument_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmCommandArgument_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmCommandArgument_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmCommandArgument_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmCommandArgument_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmCommandArgument_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmCommandArgument_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmCommandArgument_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmCommandArgument_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmCommandArgument_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmCommandArgument_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmCommandArgument_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmCommandArgument_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmCommandArgument_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmCommandArgument_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmCommandArgument_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmCommandArgument_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmCommandArgument_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmCommandArgument_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmCommandArgument_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmCommandArgument_yylex_ALREADY_DEFINED
+#else
+#define yylex cmCommandArgument_yylex
+#endif
+
+#ifdef yyrestart
+#define cmCommandArgument_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmCommandArgument_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmCommandArgument_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmCommandArgument_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmCommandArgument_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmCommandArgument_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmCommandArgument_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmCommandArgument_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmCommandArgument_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmCommandArgument_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmCommandArgument_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmCommandArgument_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmCommandArgument_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmCommandArgument_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmCommandArgument_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmCommandArgument_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmCommandArgument_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmCommandArgument_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmCommandArgument_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmCommandArgument_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmCommandArgument_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmCommandArgument_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmCommandArgument_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmCommandArgument_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmCommandArgument_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmCommandArgument_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmCommandArgument_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmCommandArgument_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmCommandArgument_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmCommandArgument_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmCommandArgument_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmCommandArgument_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmCommandArgument_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmCommandArgument_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmCommandArgument_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmCommandArgument_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmCommandArgument_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmCommandArgument_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmCommandArgument_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmCommandArgument_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmCommandArgument_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmCommandArgument_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmCommandArgument_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmCommandArgument_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define cmCommandArgument_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define ESCAPES 1
+#define NOESCAPES 2
+
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef cmCommandArgument_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef cmCommandArgument_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef cmCommandArgument_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef cmCommandArgument_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef cmCommandArgument_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef cmCommandArgument_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef cmCommandArgument_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef cmCommandArgument_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef cmCommandArgument_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef cmCommandArgument_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef cmCommandArgument_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef cmCommandArgument_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef cmCommandArgument_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef cmCommandArgument_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef cmCommandArgument_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef cmCommandArgument_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef cmCommandArgument_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef cmCommandArgument_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef cmCommandArgument_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef cmCommandArgument_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef cmCommandArgument_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef cmCommandArgument_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef cmCommandArgument_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef cmCommandArgument_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef cmCommandArgument_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef cmCommandArgument_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef cmCommandArgument_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef cmCommandArgument_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef cmCommandArgument_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef cmCommandArgument_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef cmCommandArgument_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef cmCommandArgument_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef cmCommandArgument_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef cmCommandArgument_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef cmCommandArgument_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef cmCommandArgument_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef cmCommandArgument_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef cmCommandArgument_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef cmCommandArgument_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef cmCommandArgument_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef cmCommandArgument_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef cmCommandArgument_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef cmCommandArgument_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef cmCommandArgument_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef cmCommandArgument_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef cmCommandArgument_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef cmCommandArgument_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef cmCommandArgument_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#undef cmCommandArgument_yyIN_HEADER
+#endif /* cmCommandArgument_yyHEADER_H */
diff --git a/Source/LexerParser/cmCommandArgumentLexer.in.l b/Source/LexerParser/cmCommandArgumentLexer.in.l
new file mode 100644
index 0000000..5927b9e
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentLexer.in.l
@@ -0,0 +1,147 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmCommandArgumentLexer.h -ocmCommandArgumentLexer.cxx cmCommandArgumentLexer.in.l
+
+Modify cmCommandArgumentLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmCommandArgumentLexer.h cmCommandArgumentLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmCommandArgumentLexer.h cmCommandArgumentLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCommandArgumentLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include "cmCommandArgumentParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmCommandArgumentParserTokens.h"
+
+static const char *DCURLYVariable = "${";
+static const char *RCURLYVariable = "}";
+static const char *ATVariable = "@";
+static const char *DOLLARVariable = "$";
+static const char *LCURLYVariable = "{";
+static const char *BSLASHVariable = "\\";
+
+/*--------------------------------------------------------------------------*/
+%}
+
+%option prefix="cmCommandArgument_yy"
+
+%option reentrant
+%option noyywrap
+%option nounput
+%pointer
+%s ESCAPES
+%s NOESCAPES
+
+%%
+
+\$ENV\{ {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_ENVCURLY;
+}
+
+\$[A-Za-z0-9/_.+-]+\{ {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_NCURLY;
+}
+
+@[A-Za-z0-9/_.+-]+@ {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
+  return cal_ATNAME;
+}
+
+"${" {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = DCURLYVariable;
+  return cal_DCURLY;
+}
+
+"}" {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = RCURLYVariable;
+  return cal_RCURLY;
+}
+
+"@" {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = ATVariable;
+  return cal_AT;
+}
+
+[A-Za-z0-9/_.+-]+ {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return cal_NAME;
+}
+
+<ESCAPES>\\. {
+  if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) )
+    {
+    return cal_ERROR;
+    }
+  return cal_SYMBOL;
+}
+
+[^\${}\\@]+ {
+  //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return cal_SYMBOL;
+}
+
+"$" {
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = DOLLARVariable;
+  return cal_DOLLAR;
+}
+
+"{" {
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = LCURLYVariable;
+  return cal_LCURLY;
+}
+
+<ESCAPES>"\\" {
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = BSLASHVariable;
+  return cal_BSLASH;
+}
+
+<NOESCAPES>"\\" {
+  //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  yylvalp->str = BSLASHVariable;
+  return cal_SYMBOL;
+}
+
+%%
+
+/*--------------------------------------------------------------------------*/
+void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes)
+{
+  /* Hack into the internal flex-generated scanner to set the state.  */
+  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+  if(noEscapes) {
+    BEGIN(NOESCAPES);
+  } else {
+    BEGIN(ESCAPES);
+  }
+}
diff --git a/Source/LexerParser/cmCommandArgumentParser.cxx b/Source/LexerParser/cmCommandArgumentParser.cxx
new file mode 100644
index 0000000..aed0826
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentParser.cxx
@@ -0,0 +1,1723 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names.  */
+#define yyparse         cmCommandArgument_yyparse
+#define yylex           cmCommandArgument_yylex
+#define yyerror         cmCommandArgument_yyerror
+#define yydebug         cmCommandArgument_yydebug
+#define yynerrs         cmCommandArgument_yynerrs
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "cmCommandArgumentParser.y" /* yacc.c:339  */
+
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmCommandArgument_yy --defines=cmCommandArgumentParserTokens.h -ocmCommandArgumentParser.cxx cmCommandArgumentParser.y
+
+Modify cmCommandArgumentParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string.h>
+
+#define yyGetParser (cmCommandArgument_yyget_extra(yyscanner))
+
+/* Make sure malloc and free are available on QNX.  */
+#ifdef __QNX__
+# include <malloc.h>
+#endif
+
+/* Make sure the parser uses standard memory allocation.  The default
+   generated parser malloc/free declarations do not work on all
+   platforms.  */
+#include <stdlib.h>
+#define YYMALLOC malloc
+#define YYFREE free
+
+/*-------------------------------------------------------------------------*/
+#include "cmCommandArgumentParserHelper.h" /* Interface to parser object.  */
+#include "cmCommandArgumentLexer.h"  /* Interface to lexer object.  */
+#include "cmCommandArgumentParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmCommandArgument_yyerror(yyscan_t yyscanner, const char* message);
+
+/* Configure the parser to support large input.  */
+#define YYMAXDEPTH 100000
+#define YYINITDEPTH 10000
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no
+                                    case. */
+# pragma warning (disable: 4244) /* loss of precision */
+# pragma warning (disable: 4702) /* unreachable code */
+#endif
+
+#line 131 "cmCommandArgumentParser.cxx" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "cmCommandArgumentParserTokens.h".  */
+#ifndef YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED
+# define YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmCommandArgument_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    cal_ENVCURLY = 258,
+    cal_NCURLY = 259,
+    cal_DCURLY = 260,
+    cal_DOLLAR = 261,
+    cal_LCURLY = 262,
+    cal_RCURLY = 263,
+    cal_NAME = 264,
+    cal_BSLASH = 265,
+    cal_SYMBOL = 266,
+    cal_AT = 267,
+    cal_ERROR = 268,
+    cal_ATNAME = 269
+  };
+#endif
+/* Tokens.  */
+#define cal_ENVCURLY 258
+#define cal_NCURLY 259
+#define cal_DCURLY 260
+#define cal_DOLLAR 261
+#define cal_LCURLY 262
+#define cal_RCURLY 263
+#define cal_NAME 264
+#define cal_BSLASH 265
+#define cal_SYMBOL 266
+#define cal_AT 267
+#define cal_ERROR 268
+#define cal_ATNAME 269
+
+/* Value type.  */
+
+
+
+int cmCommandArgument_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 204 "cmCommandArgumentParser.cxx" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  25
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   40
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  15
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  10
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  24
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  33
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   269
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,    96,    96,   102,   105,   110,   113,   118,   121,   126,
+     129,   132,   135,   138,   141,   146,   149,   152,   155,   160,
+     163,   168,   171,   176,   179
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "cal_ENVCURLY", "cal_NCURLY",
+  "cal_DCURLY", "\"$\"", "\"{\"", "\"}\"", "cal_NAME", "\"\\\\\"",
+  "cal_SYMBOL", "\"@\"", "cal_ERROR", "cal_ATNAME", "$accept", "Start",
+  "GoalWithOptionalBackSlash", "Goal", "String", "OuterText", "Variable",
+  "EnvVarName", "MultipleIds", "ID", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269
+};
+# endif
+
+#define YYPACT_NINF -3
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-3)))
+
+#define YYTABLE_NINF -1
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int8 yypact[] =
+{
+       0,    14,    26,    26,    -3,    -3,    -3,    -3,    -3,    -3,
+      -3,    10,    -3,     3,     0,    -3,    -3,    -3,    14,    -3,
+       7,    -3,    26,    13,    16,    -3,    -3,    -3,    -3,    -3,
+      -3,    -3,    -3
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       5,    21,    21,    21,    11,    12,    13,     9,    14,    10,
+      18,     0,     2,     3,     5,     7,     8,    23,    21,    24,
+       0,    19,    21,     0,     0,     1,     4,     6,    20,    15,
+      22,    16,    17
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+      -3,    -3,    -3,     8,    -3,    -3,     2,     9,    -2,    -3
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,    11,    12,    13,    14,    15,    19,    20,    21,    22
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_uint8 yytable[] =
+{
+      23,    24,    16,     1,     2,     3,     4,     5,     6,     7,
+      25,     8,     9,    26,    10,    29,    16,     1,     2,     3,
+      30,    31,    27,    17,    32,    18,     0,    28,    10,     1,
+       2,     3,     0,     0,     0,    17,     0,     0,     0,     0,
+      10
+};
+
+static const yytype_int8 yycheck[] =
+{
+       2,     3,     0,     3,     4,     5,     6,     7,     8,     9,
+       0,    11,    12,    10,    14,     8,    14,     3,     4,     5,
+      22,     8,    14,     9,     8,    11,    -1,    18,    14,     3,
+       4,     5,    -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,
+      14
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     3,     4,     5,     6,     7,     8,     9,    11,    12,
+      14,    16,    17,    18,    19,    20,    21,     9,    11,    21,
+      22,    23,    24,    23,    23,     0,    10,    18,    22,     8,
+      23,     8,     8
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    15,    16,    17,    17,    18,    18,    19,    19,    20,
+      20,    20,    20,    20,    20,    21,    21,    21,    21,    22,
+      22,    23,    23,    24,    24
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     1,     2,     0,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     3,     3,     3,     1,     1,
+       2,     0,     2,     1,     1
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (yyscanner, YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value, yyscanner); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  YYUSE (yyscanner);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              , yyscanner);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, yyscan_t yyscanner)
+{
+  YYUSE (yyvaluep);
+  YYUSE (yyscanner);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (yyscan_t yyscanner)
+{
+/* The lookahead symbol.  */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol.  */
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex (&yylval, yyscanner);
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 96 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = 0;
+    yyGetParser->SetResult((yyvsp[0].str));
+  }
+#line 1306 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 3:
+#line 102 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1314 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 4:
+#line 105 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str));
+  }
+#line 1322 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 5:
+#line 110 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = 0;
+  }
+#line 1330 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 6:
+#line 113 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str));
+  }
+#line 1338 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 7:
+#line 118 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1346 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 121 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1354 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 126 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1362 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 129 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1370 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 11:
+#line 132 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1378 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 12:
+#line 135 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1386 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 13:
+#line 138 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1394 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 14:
+#line 141 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1402 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 15:
+#line 146 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->ExpandSpecialVariable((yyvsp[-2].str), (yyvsp[-1].str));
+  }
+#line 1410 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 16:
+#line 149 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->ExpandSpecialVariable((yyvsp[-2].str), (yyvsp[-1].str));
+  }
+#line 1418 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 17:
+#line 152 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->ExpandVariable((yyvsp[-1].str));
+  }
+#line 1426 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 18:
+#line 155 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->ExpandVariableForAt((yyvsp[0].str));
+  }
+#line 1434 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 19:
+#line 160 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1442 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 20:
+#line 163 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[-1].str);
+  }
+#line 1450 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 21:
+#line 168 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = 0;
+  }
+#line 1458 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 22:
+#line 171 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str));
+  }
+#line 1466 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 23:
+#line 176 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1474 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 24:
+#line 179 "cmCommandArgumentParser.y" /* yacc.c:1646  */
+    {
+    (yyval.str) = (yyvsp[0].str);
+  }
+#line 1482 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+    break;
+
+
+#line 1486 "cmCommandArgumentParser.cxx" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (yyscanner, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yyscanner, yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, yyscanner);
+          yychar = YYEMPTY;
+        }
+    }
+
+#if 0
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+#endif
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (yyscanner, YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, yyscanner);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 184 "cmCommandArgumentParser.y" /* yacc.c:1906  */
+
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmCommandArgument_yyerror(yyscan_t yyscanner, const char* message)
+{
+  yyGetParser->Error(message);
+}
diff --git a/Source/LexerParser/cmCommandArgumentParser.y b/Source/LexerParser/cmCommandArgumentParser.y
new file mode 100644
index 0000000..55a88df
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentParser.y
@@ -0,0 +1,191 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmCommandArgument_yy --defines=cmCommandArgumentParserTokens.h -ocmCommandArgumentParser.cxx cmCommandArgumentParser.y
+
+Modify cmCommandArgumentParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string.h>
+
+#define yyGetParser (cmCommandArgument_yyget_extra(yyscanner))
+
+/* Make sure malloc and free are available on QNX.  */
+#ifdef __QNX__
+# include <malloc.h>
+#endif
+
+/* Make sure the parser uses standard memory allocation.  The default
+   generated parser malloc/free declarations do not work on all
+   platforms.  */
+#include <stdlib.h>
+#define YYMALLOC malloc
+#define YYFREE free
+
+/*-------------------------------------------------------------------------*/
+#include "cmCommandArgumentParserHelper.h" /* Interface to parser object.  */
+#include "cmCommandArgumentLexer.h"  /* Interface to lexer object.  */
+#include "cmCommandArgumentParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmCommandArgument_yyerror(yyscan_t yyscanner, const char* message);
+
+/* Configure the parser to support large input.  */
+#define YYMAXDEPTH 100000
+#define YYINITDEPTH 10000
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no
+                                    case. */
+# pragma warning (disable: 4244) /* loss of precision */
+# pragma warning (disable: 4702) /* unreachable code */
+#endif
+%}
+
+/* Generate a reentrant parser object.  */
+%define api.pure
+
+/* Configure the parser to use a lexer object.  */
+%lex-param   {yyscan_t yyscanner}
+%parse-param {yyscan_t yyscanner}
+
+%define parse.error verbose
+
+/*
+%union {
+  char* string;
+}
+*/
+
+/*-------------------------------------------------------------------------*/
+/* Tokens */
+%token cal_ENVCURLY
+%token cal_NCURLY
+%token cal_DCURLY
+%token cal_DOLLAR "$"
+%token cal_LCURLY "{"
+%token cal_RCURLY "}"
+%token cal_NAME
+%token cal_BSLASH "\\"
+%token cal_SYMBOL
+%token cal_AT     "@"
+%token cal_ERROR
+%token cal_ATNAME
+
+/*-------------------------------------------------------------------------*/
+/* grammar */
+%%
+
+
+Start:
+  GoalWithOptionalBackSlash {
+    $<str>$ = 0;
+    yyGetParser->SetResult($<str>1);
+  }
+
+GoalWithOptionalBackSlash:
+  Goal {
+    $<str>$ = $<str>1;
+  }
+| Goal cal_BSLASH {
+    $<str>$ = yyGetParser->CombineUnions($<str>1, $<str>2);
+  }
+
+Goal:
+  {
+    $<str>$ = 0;
+  }
+| String Goal {
+    $<str>$ = yyGetParser->CombineUnions($<str>1, $<str>2);
+  }
+
+String:
+  OuterText {
+    $<str>$ = $<str>1;
+  }
+| Variable {
+    $<str>$ = $<str>1;
+  }
+
+OuterText:
+  cal_NAME {
+    $<str>$ = $<str>1;
+  }
+| cal_AT {
+    $<str>$ = $<str>1;
+  }
+| cal_DOLLAR {
+    $<str>$ = $<str>1;
+  }
+| cal_LCURLY {
+    $<str>$ = $<str>1;
+  }
+| cal_RCURLY {
+    $<str>$ = $<str>1;
+  }
+| cal_SYMBOL {
+    $<str>$ = $<str>1;
+  }
+
+Variable:
+  cal_ENVCURLY EnvVarName cal_RCURLY {
+    $<str>$ = yyGetParser->ExpandSpecialVariable($<str>1, $<str>2);
+  }
+| cal_NCURLY MultipleIds cal_RCURLY {
+    $<str>$ = yyGetParser->ExpandSpecialVariable($<str>1, $<str>2);
+  }
+| cal_DCURLY MultipleIds cal_RCURLY {
+    $<str>$ = yyGetParser->ExpandVariable($<str>2);
+  }
+| cal_ATNAME {
+    $<str>$ = yyGetParser->ExpandVariableForAt($<str>1);
+  }
+
+EnvVarName:
+  MultipleIds {
+    $<str>$ = $<str>1;
+  }
+| cal_SYMBOL EnvVarName {
+    $<str>$ = $<str>1;
+  }
+
+MultipleIds:
+  {
+    $<str>$ = 0;
+  }
+| ID MultipleIds {
+    $<str>$ = yyGetParser->CombineUnions($<str>1, $<str>2);
+  }
+
+ID:
+  cal_NAME {
+    $<str>$ = $<str>1;
+  }
+| Variable {
+    $<str>$ = $<str>1;
+  }
+;
+
+%%
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmCommandArgument_yyerror(yyscan_t yyscanner, const char* message)
+{
+  yyGetParser->Error(message);
+}
diff --git a/Source/LexerParser/cmCommandArgumentParserTokens.h b/Source/LexerParser/cmCommandArgumentParserTokens.h
new file mode 100644
index 0000000..3172182
--- /dev/null
+++ b/Source/LexerParser/cmCommandArgumentParserTokens.h
@@ -0,0 +1,82 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED
+# define YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmCommandArgument_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    cal_ENVCURLY = 258,
+    cal_NCURLY = 259,
+    cal_DCURLY = 260,
+    cal_DOLLAR = 261,
+    cal_LCURLY = 262,
+    cal_RCURLY = 263,
+    cal_NAME = 264,
+    cal_BSLASH = 265,
+    cal_SYMBOL = 266,
+    cal_AT = 267,
+    cal_ERROR = 268,
+    cal_ATNAME = 269
+  };
+#endif
+/* Tokens.  */
+#define cal_ENVCURLY 258
+#define cal_NCURLY 259
+#define cal_DCURLY 260
+#define cal_DOLLAR 261
+#define cal_LCURLY 262
+#define cal_RCURLY 263
+#define cal_NAME 264
+#define cal_BSLASH 265
+#define cal_SYMBOL 266
+#define cal_AT 267
+#define cal_ERROR 268
+#define cal_ATNAME 269
+
+/* Value type.  */
+
+
+
+int cmCommandArgument_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED  */
diff --git a/Source/LexerParser/cmDependsJavaLexer.cxx b/Source/LexerParser/cmDependsJavaLexer.cxx
new file mode 100644
index 0000000..36cac61
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaLexer.cxx
@@ -0,0 +1,2813 @@
+#include "cmStandardLexer.h"
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmDependsJava_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmDependsJava_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmDependsJava_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmDependsJava_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmDependsJava_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmDependsJava_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmDependsJava_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmDependsJava_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmDependsJava_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmDependsJava_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmDependsJava_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmDependsJava_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmDependsJava_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmDependsJava_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmDependsJava_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmDependsJava_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmDependsJava_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmDependsJava_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmDependsJava_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmDependsJava_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmDependsJava_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmDependsJava_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmDependsJava_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmDependsJava_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmDependsJava_yylex_ALREADY_DEFINED
+#else
+#define yylex cmDependsJava_yylex
+#endif
+
+#ifdef yyrestart
+#define cmDependsJava_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmDependsJava_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmDependsJava_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmDependsJava_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmDependsJava_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmDependsJava_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmDependsJava_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmDependsJava_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmDependsJava_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmDependsJava_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmDependsJava_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmDependsJava_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmDependsJava_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmDependsJava_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmDependsJava_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmDependsJava_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmDependsJava_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmDependsJava_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmDependsJava_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmDependsJava_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmDependsJava_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmDependsJava_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmDependsJava_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmDependsJava_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmDependsJava_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmDependsJava_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmDependsJava_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmDependsJava_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmDependsJava_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmDependsJava_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmDependsJava_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmDependsJava_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmDependsJava_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmDependsJava_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmDependsJava_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmDependsJava_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmDependsJava_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmDependsJava_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmDependsJava_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmDependsJava_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmDependsJava_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmDependsJava_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmDependsJava_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmDependsJava_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define cmDependsJava_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 111
+#define YY_END_OF_BUFFER 112
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[327] =
+    {   0,
+        0,    0,    0,    0,    0,    0,  112,  110,  109,  109,
+       77,    4,   73,   94,   60,  110,   93,   92,  105,   99,
+       68,   89,   74,   71,   56,   56,   67,  103,   86,   75,
+       79,  102,  107,   64,   63,   65,  107,  107,  107,  107,
+      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
+      107,   70,   96,   69,  104,    3,    3,    6,  111,    5,
+       78,   95,   61,   62,    0,    0,  106,  101,  100,   91,
+       90,   57,    1,    0,   72,   57,   56,   57,    0,   56,
+        0,   88,   87,   76,   80,   81,  107,   66,  107,  107,
+      107,  107,  107,  107,  107,  107,  107,  107,   18,  107,
+
+      107,  107,  107,  107,  107,   26,  107,  107,  107,  107,
+      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
+      107,  107,  107,  107,  107,   97,   98,    2,   55,   55,
+        0,    0,    0,  108,   57,    0,   57,   58,   85,   82,
+       83,  107,  107,  107,  107,  107,  107,  107,  107,  107,
+      107,  107,  107,  107,  107,  107,  107,  107,   25,  107,
+      107,   30,  107,  107,   34,  107,  107,  107,  107,  107,
+      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
+      107,   50,  107,  107,  107,    0,    0,   58,   84,  107,
+      107,  107,  107,   11,   12,  107,   14,  107,  107,  107,
+
+      107,   20,  107,  107,  107,  107,  107,  107,  107,  107,
+       32,  107,   59,  107,  107,  107,  107,  107,  107,  107,
+      107,  107,  107,  107,   46,  107,  107,   54,   51,  107,
+      107,  107,  107,  107,   10,   13,   15,  107,  107,  107,
+      107,   22,   24,  107,  107,  107,  107,  107,  107,  107,
+      107,  107,  107,   40,  107,  107,   43,  107,  107,   47,
+      107,  107,   53,  107,    8,  107,  107,  107,   19,  107,
+      107,  107,   28,  107,  107,   33,  107,  107,  107,   38,
+       39,   41,  107,   44,  107,   48,  107,  107,  107,    9,
+      107,   17,   21,   23,  107,  107,  107,   35,   36,  107,
+
+      107,  107,  107,  107,    7,   16,  107,  107,  107,  107,
+       42,  107,  107,   52,  107,  107,   31,   37,  107,   49,
+       27,   29,  107,  107,   45,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    2,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    5,    1,    6,    7,    8,    9,   10,
+       11,   12,   13,   14,   15,   16,   17,   18,   19,   19,
+       19,   19,   19,   19,   19,   20,   20,   21,   22,   23,
+       24,   25,   26,    1,   27,   27,   27,   28,   29,   28,
+       30,   30,   30,   30,   30,   31,   30,   30,   30,   30,
+       30,   30,   30,   30,   30,   30,   30,   32,   30,   30,
+       33,   34,   35,   36,   30,    1,   37,   38,   39,   40,
+
+       41,   42,   43,   44,   45,   30,   46,   47,   48,   49,
+       50,   51,   30,   52,   53,   54,   55,   56,   57,   58,
+       59,   60,   61,   62,   63,   64,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[65] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    1,
+        1,    1,    1,    1,    1,    1,    1,    3,    3,    3,
+        1,    1,    1,    1,    1,    1,    3,    3,    3,    4,
+        4,    4,    1,    1,    1,    1,    3,    3,    3,    3,
+        3,    3,    4,    4,    4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+        1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[334] =
+    {   0,
+        0,    0,  401,  400,   62,   63,  411,  414,  414,  414,
+      386,  414,  414,  385,   61,  374,  414,  414,  383,   57,
+      414,   56,   54,   65,   74,   43,  414,  414,   55,  382,
+       59,  414,    0,  414,  414,  381,   38,   36,   60,   46,
+       51,   75,   69,  354,   82,   76,  362,   85,   56,  352,
+      357,  414,  100,  414,  414,  414,  383,  414,  414,  414,
+      414,  414,  414,  414,  390,  127,  414,  414,  414,  414,
+      414,  129,  414,  395,  414,  132,   95,  414,  165,  414,
+        0,  373,  414,  414,  414,  109,    0,  414,  343,  342,
+      344,  352,  338,  101,  354,  353,  340,  346,  332,  333,
+
+      331,  337,  334,  332,  329,    0,  329,  110,  330,  324,
+      320,  329,  336,   93,  336,  319,  322,   89,  320,  325,
+      320,  114,  131,  120,  323,  414,  414,  414,  414,  358,
+      170,  357,  362,  414,  173,  157,  176,  150,  414,  414,
+      340,  309,  321,  314,  323,  318,  317,  318,  304,  302,
+      300,  316,  314,  310,  309,  296,  311,  310,    0,  153,
+      292,  304,  301,  298,    0,  295,  295,  284,  285,  291,
+      282,  284,  281,  289,  292,  278,  292,  277,  279,  279,
+      286,    0,  286,  288,  277,  189,  314,  414,  414,  270,
+      269,  279,  273,    0,    0,  274,    0,  264,  271,  260,
+
+      267,    0,  264,  271,  264,  256,  268,  256,  270,  254,
+        0,  249,    0,  267,  266,  261,  256,  248,  245,  253,
+      258,  244,  256,  250,    0,  236,  239,    0,    0,  237,
+      249,  252,  234,  250,    0,    0,    0,  237,  238,  243,
+      243,  235,    0,  233,  226,  230,  236,  236,  233,  221,
+      235,  234,  223,    0,  232,  216,    0,  225,  216,  214,
+      221,  220,    0,  225,    0,  214,  207,  207,    0,  207,
+      200,  217,    0,  218,  219,    0,  214,  213,  199,    0,
+        0,    0,  210,    0,  201,    0,  209,  202,  194,    0,
+      206,    0,    0,    0,  197,  204,  205,    0,    0,  202,
+
+      191,  192,  191,  198,    0,    0,  163,  162,  170,  170,
+        0,  164,  152,    0,  152,  157,    0,    0,  127,    0,
+        0,    0,  115,   95,    0,  414,  218,  222,  226,  228,
+      232,   96,  235
+    } ;
+
+static const flex_int16_t yy_def[334] =
+    {   0,
+      326,    1,  327,  327,  328,  328,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  329,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,   25,  326,  326,  326,  326,
+      326,  326,  330,  326,  326,  326,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  329,  326,  326,  326,  326,
+      326,  326,  326,  331,  326,  326,   25,  326,  326,  326,
+      332,  326,  326,  326,  326,  326,  330,  326,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  326,  326,  326,  326,  326,
+      326,  333,  331,  326,  326,  326,  326,  332,  326,  326,
+      326,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  326,  333,  326,  326,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,    0,  326,  326,  326,  326,
+      326,  326,  326
+    } ;
+
+static const flex_int16_t yy_nxt[479] =
+    {   0,
+        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
+       18,   19,   20,   21,   22,   23,   24,   25,   26,   26,
+       27,   28,   29,   30,   31,   32,   33,   33,   33,   33,
+       33,   33,   34,    8,   35,   36,   37,   38,   39,   40,
+       41,   42,   33,   33,   43,   33,   44,   33,   45,   33,
+       46,   47,   48,   49,   33,   50,   51,   33,   33,   33,
+       52,   53,   54,   55,   59,   59,   60,   60,   63,   68,
+       70,   72,   72,   72,  326,   89,   73,   82,   83,   71,
+       69,   74,   85,   86,   64,   91,   98,   92,   75,   76,
+       90,   77,   77,   77,   93,   99,   94,  100,  138,  122,
+
+      326,   78,   79,   95,   80,   81,   96,  123,  101,   97,
+      106,  102,  113,   78,   79,   78,  107,  108,  110,  103,
+       80,  104,  111,  126,  105,  173,  326,  114,  117,  326,
+      115,   81,  140,  141,  325,  130,  112,  168,  118,  119,
+      174,  120,  169,  121,  131,  131,   72,   72,   72,  135,
+      135,  135,  326,  147,  148,  324,   78,   79,  178,   78,
+       79,  127,  161,  162,  183,  179,  184,  180,   78,   79,
+       78,   78,   79,   78,  137,  137,  137,  136,  129,  136,
+      188,  132,  137,  137,  137,  181,  323,  186,  186,  182,
+      135,  135,  135,  137,  137,  137,  188,  129,  322,  207,
+
+       78,   79,  208,   78,  321,  320,  186,  186,  319,  318,
+      317,  316,   78,   79,   78,   78,  315,   78,   56,   56,
+       56,   56,   58,   58,   58,   58,   65,   65,   65,   65,
+       87,   87,  133,  133,  133,  133,  187,  187,  314,  313,
+      312,  311,  310,  309,  308,  307,  306,  305,  304,  303,
+      302,  301,  300,  299,  298,  297,  296,  295,  294,  293,
+      292,  291,  290,  289,  288,  287,  286,  285,  284,  283,
+      282,  281,  280,  279,  278,  277,  276,  275,  274,  273,
+      272,  271,  270,  269,  268,  267,  266,  265,  264,  263,
+      262,  261,  260,  259,  258,  257,  256,  255,  254,  253,
+
+      252,  251,  250,  249,  248,  247,  246,  245,  244,  243,
+      242,  228,  241,  240,  239,  238,  237,  236,  235,  234,
+      233,  232,  129,  231,  230,  229,  228,  227,  226,  225,
+      224,  223,  222,  221,  220,  219,  218,  217,  216,  215,
+      214,  213,  212,  211,  210,  209,  206,  205,  204,  203,
+      202,  201,  200,  199,  198,  197,  196,  195,  194,  193,
+      192,  191,  190,  189,  134,  129,  129,  185,  177,  176,
+      175,  172,  171,  170,  167,  166,  165,  164,  163,  160,
+      159,  158,  157,  156,  155,  154,  153,  152,  151,  150,
+      149,  146,  145,  144,  143,  142,  139,  134,  129,  128,
+
+      125,  124,  116,  109,   88,   84,   67,   66,   62,   61,
+      326,   57,   57,    7,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326
+    } ;
+
+static const flex_int16_t yy_chk[479] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    5,    6,    5,    6,   15,   20,
+       22,   23,   23,   23,   26,   37,   24,   29,   29,   22,
+       20,   24,   31,   31,   15,   38,   40,   38,   24,   25,
+       37,   25,   25,   25,   38,   40,   39,   41,  332,   49,
+
+       26,   25,   25,   39,   25,   25,   39,   49,   41,   39,
+       43,   42,   46,   25,   25,   25,   43,   43,   45,   42,
+       25,   42,   45,   53,   42,  118,   77,   46,   48,   66,
+       46,   25,   86,   86,  324,   66,   45,  114,   48,   48,
+      118,   48,  114,   48,   66,   66,   72,   72,   72,   76,
+       76,   76,   77,   94,   94,  323,   72,   72,  122,   76,
+       76,   53,  108,  108,  124,  122,  124,  123,   72,   72,
+       72,   76,   76,   76,  136,  136,  136,   79,  131,   79,
+      138,   66,   79,   79,   79,  123,  319,  131,  131,  123,
+      135,  135,  135,  137,  137,  137,  138,  186,  316,  160,
+
+      135,  135,  160,  137,  315,  313,  186,  186,  312,  310,
+      309,  308,  135,  135,  135,  137,  307,  137,  327,  327,
+      327,  327,  328,  328,  328,  328,  329,  329,  329,  329,
+      330,  330,  331,  331,  331,  331,  333,  333,  304,  303,
+      302,  301,  300,  297,  296,  295,  291,  289,  288,  287,
+      285,  283,  279,  278,  277,  275,  274,  272,  271,  270,
+      268,  267,  266,  264,  262,  261,  260,  259,  258,  256,
+      255,  253,  252,  251,  250,  249,  248,  247,  246,  245,
+      244,  242,  241,  240,  239,  238,  234,  233,  232,  231,
+      230,  227,  226,  224,  223,  222,  221,  220,  219,  218,
+
+      217,  216,  215,  214,  212,  210,  209,  208,  207,  206,
+      205,  204,  203,  201,  200,  199,  198,  196,  193,  192,
+      191,  190,  187,  185,  184,  183,  181,  180,  179,  178,
+      177,  176,  175,  174,  173,  172,  171,  170,  169,  168,
+      167,  166,  164,  163,  162,  161,  158,  157,  156,  155,
+      154,  153,  152,  151,  150,  149,  148,  147,  146,  145,
+      144,  143,  142,  141,  133,  132,  130,  125,  121,  120,
+      119,  117,  116,  115,  113,  112,  111,  110,  109,  107,
+      105,  104,  103,  102,  101,  100,   99,   98,   97,   96,
+       95,   93,   92,   91,   90,   89,   82,   74,   65,   57,
+
+       51,   50,   47,   44,   36,   30,   19,   16,   14,   11,
+        7,    4,    3,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+      326,  326,  326,  326,  326,  326,  326,  326
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmDependsJavaLexer.h -ocmDependsJavaLexer.cxx cmDependsJavaLexer.in.l
+
+Modify cmDependsJavaLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmDependsJavaLexer.h cmDependsJavaLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmDependsJavaLexer.h cmDependsJavaLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmDependsJavaLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include <iostream>
+
+#include "cmDependsJavaParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmDependsJavaParserTokens.h"
+
+#define KEYWORD yylvalp->str = 0
+#define SYMBOL yylvalp->str = 0
+#define PRIMITIVE  yylvalp->str = 0
+
+/*--------------------------------------------------------------------------*/
+
+#define INITIAL 0
+#define comment 1
+#define string 2
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput ( int c, char *buf_ptr  , yyscan_t yyscanner);
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 327 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 414 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{ BEGIN(comment); }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+{ BEGIN(INITIAL); }
+	YY_BREAK
+case 3:
+/* rule 3 can match eol */
+YY_RULE_SETUP
+{}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+{ BEGIN(string); }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+{ BEGIN(INITIAL); return jp_STRINGLITERAL; }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+{}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+{ KEYWORD; return jp_ABSTRACT; }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+{ KEYWORD; return jp_ASSERT; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+{ KEYWORD; return jp_BOOLEAN_TYPE; }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+{ KEYWORD; return jp_BREAK; }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+{ KEYWORD; return jp_BYTE_TYPE; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{ KEYWORD; return jp_CASE; }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+{ KEYWORD; return jp_CATCH; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+{ KEYWORD; return jp_CHAR_TYPE; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+{ KEYWORD; return jp_CLASS; }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+{ KEYWORD; return jp_CONTINUE; }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+{ KEYWORD; return jp_DEFAULT; }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+{ KEYWORD; return jp_DO; }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+{ KEYWORD; return jp_DOUBLE_TYPE; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+{ KEYWORD; return jp_ELSE; }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+{ KEYWORD; return jp_EXTENDS; }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+{ KEYWORD; return jp_FINAL; }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+{ KEYWORD; return jp_FINALLY; }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+{ KEYWORD; return jp_FLOAT_TYPE; }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+{ KEYWORD; return jp_FOR; }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+{ KEYWORD; return jp_IF; }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+{ KEYWORD; return jp_IMPLEMENTS; }
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+{ KEYWORD; return jp_IMPORT; }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+{ KEYWORD; return jp_INSTANCEOF; }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+{ KEYWORD; return jp_INT_TYPE; }
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+{ KEYWORD; return jp_INTERFACE; }
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+{ KEYWORD; return jp_LONG_TYPE; }
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+{ KEYWORD; return jp_NATIVE; }
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+{ KEYWORD; return jp_NEW; }
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+{ KEYWORD; return jp_PACKAGE; }
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+{ KEYWORD; return jp_PRIVATE; }
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+{ KEYWORD; return jp_PROTECTED; }
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+{ KEYWORD; return jp_PUBLIC; }
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+{ KEYWORD; return jp_RETURN; }
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+{ KEYWORD; return jp_SHORT_TYPE; }
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+{ KEYWORD; return jp_STATIC; }
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+{ KEYWORD; return jp_STRICTFP; }
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+{ KEYWORD; return jp_SUPER; }
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+{ KEYWORD; return jp_SWITCH; }
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+{ KEYWORD; return jp_SYNCHRONIZED; }
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+{ KEYWORD; return jp_THIS; }
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+{ KEYWORD; return jp_THROW; }
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+{ KEYWORD; return jp_THROWS; }
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+{ KEYWORD; return jp_TRANSIENT; }
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+{ KEYWORD; return jp_TRY; }
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+{ KEYWORD; return jp_VOID; }
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+{ KEYWORD; return jp_VOLATILE; }
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+{ KEYWORD; return jp_WHILE; }
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_BOOLEANLITERAL; }
+	YY_BREAK
+case 55:
+/* rule 55 can match eol */
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_CHARACTERLITERAL; }
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_HEXINTEGERLITERAL; }
+	YY_BREAK
+case 59:
+YY_RULE_SETUP
+{ PRIMITIVE; return jp_NULLLITERAL; }
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+{ SYMBOL; return jp_AND; }
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+{ SYMBOL; return jp_ANDAND; }
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+{ SYMBOL; return jp_ANDEQUALS; }
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+{ SYMBOL; return jp_BRACKETEND; }
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+{ SYMBOL; return jp_BRACKETSTART; }
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+{ SYMBOL; return jp_CARROT; }
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+{ SYMBOL; return jp_CARROTEQUALS; }
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+{ SYMBOL; return jp_COLON; }
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+{ SYMBOL; return jp_COMMA; }
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+{ SYMBOL; return jp_CURLYEND; }
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+{ SYMBOL; return jp_CURLYSTART; }
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+{ SYMBOL; return jp_DIVIDE; }
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
+{ SYMBOL; return jp_DIVIDEEQUALS; }
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+{ SYMBOL; return jp_DOLLAR; }
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
+{ SYMBOL; return jp_DOT; }
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
+{ SYMBOL; return jp_EQUALS; }
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
+{ SYMBOL; return jp_EQUALSEQUALS; }
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
+{ SYMBOL; return jp_EXCLAMATION; }
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
+{ SYMBOL; return jp_EXCLAMATIONEQUALS; }
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GREATER; }
+	YY_BREAK
+case 80:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GTEQUALS; }
+	YY_BREAK
+case 81:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GTGT; }
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GTGTEQUALS; }
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GTGTGT; }
+	YY_BREAK
+case 84:
+YY_RULE_SETUP
+{ SYMBOL; return jp_GTGTGTEQUALS; }
+	YY_BREAK
+case 85:
+YY_RULE_SETUP
+{ SYMBOL; return jp_LESLESEQUALS; }
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
+{ SYMBOL; return jp_LESSTHAN; }
+	YY_BREAK
+case 87:
+YY_RULE_SETUP
+{ SYMBOL; return jp_LTEQUALS; }
+	YY_BREAK
+case 88:
+YY_RULE_SETUP
+{ SYMBOL; return jp_LTLT; }
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
+{ SYMBOL; return jp_MINUS; }
+	YY_BREAK
+case 90:
+YY_RULE_SETUP
+{ SYMBOL; return jp_MINUSEQUALS; }
+	YY_BREAK
+case 91:
+YY_RULE_SETUP
+{ SYMBOL; return jp_MINUSMINUS; }
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PAREEND; }
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PARESTART; }
+	YY_BREAK
+case 94:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PERCENT; }
+	YY_BREAK
+case 95:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PERCENTEQUALS; }
+	YY_BREAK
+case 96:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PIPE; }
+	YY_BREAK
+case 97:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PIPEEQUALS; }
+	YY_BREAK
+case 98:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PIPEPIPE; }
+	YY_BREAK
+case 99:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PLUS; }
+	YY_BREAK
+case 100:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PLUSEQUALS; }
+	YY_BREAK
+case 101:
+YY_RULE_SETUP
+{ SYMBOL; return jp_PLUSPLUS; }
+	YY_BREAK
+case 102:
+YY_RULE_SETUP
+{ SYMBOL; return jp_QUESTION; }
+	YY_BREAK
+case 103:
+YY_RULE_SETUP
+{ SYMBOL; return jp_SEMICOL; }
+	YY_BREAK
+case 104:
+YY_RULE_SETUP
+{ SYMBOL; return jp_TILDE; }
+	YY_BREAK
+case 105:
+YY_RULE_SETUP
+{ SYMBOL; return jp_TIMES; }
+	YY_BREAK
+case 106:
+YY_RULE_SETUP
+{ SYMBOL; return jp_TIMESEQUALS; }
+	YY_BREAK
+case 107:
+YY_RULE_SETUP
+{
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return jp_NAME;
+}
+	YY_BREAK
+case 108:
+/* rule 108 can match eol */
+YY_RULE_SETUP
+{ }
+	YY_BREAK
+case 109:
+/* rule 109 can match eol */
+YY_RULE_SETUP
+{ }
+	YY_BREAK
+case 110:
+YY_RULE_SETUP
+{
+  std::cerr << "Unknown character: " << yytext[0]
+    << " (" << (int)yytext[0] << ")" << std::endl;
+  yyextra->Error("Unknown character");
+  return jp_ERROR;
+}
+	YY_BREAK
+case 111:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(comment):
+case YY_STATE_EOF(string):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 327 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 327 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 326);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
+{
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    yy_cp = yyg->yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yyg->yy_hold_char;
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = yyg->yy_n_chars + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+	yyg->yytext_ptr = yy_bp;
+	yyg->yy_hold_char = *yy_cp;
+	yyg->yy_c_buf_p = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
diff --git a/Source/LexerParser/cmDependsJavaLexer.h b/Source/LexerParser/cmDependsJavaLexer.h
new file mode 100644
index 0000000..f1e87d2
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaLexer.h
@@ -0,0 +1,689 @@
+#ifndef cmDependsJava_yyHEADER_H
+#define cmDependsJava_yyHEADER_H 1
+#define cmDependsJava_yyIN_HEADER 1
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmDependsJava_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmDependsJava_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmDependsJava_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmDependsJava_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmDependsJava_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmDependsJava_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmDependsJava_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmDependsJava_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmDependsJava_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmDependsJava_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmDependsJava_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmDependsJava_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmDependsJava_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmDependsJava_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmDependsJava_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmDependsJava_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmDependsJava_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmDependsJava_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmDependsJava_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmDependsJava_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmDependsJava_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmDependsJava_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmDependsJava_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmDependsJava_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmDependsJava_yylex_ALREADY_DEFINED
+#else
+#define yylex cmDependsJava_yylex
+#endif
+
+#ifdef yyrestart
+#define cmDependsJava_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmDependsJava_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmDependsJava_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmDependsJava_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmDependsJava_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmDependsJava_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmDependsJava_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmDependsJava_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmDependsJava_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmDependsJava_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmDependsJava_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmDependsJava_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmDependsJava_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmDependsJava_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmDependsJava_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmDependsJava_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmDependsJava_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmDependsJava_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmDependsJava_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmDependsJava_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmDependsJava_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmDependsJava_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmDependsJava_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmDependsJava_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmDependsJava_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmDependsJava_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmDependsJava_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmDependsJava_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmDependsJava_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmDependsJava_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmDependsJava_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmDependsJava_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmDependsJava_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmDependsJava_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmDependsJava_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmDependsJava_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmDependsJava_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmDependsJava_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmDependsJava_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmDependsJava_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmDependsJava_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmDependsJava_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmDependsJava_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmDependsJava_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define cmDependsJava_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define comment 1
+#define string 2
+
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef cmDependsJava_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef cmDependsJava_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef cmDependsJava_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef cmDependsJava_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef cmDependsJava_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef cmDependsJava_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef cmDependsJava_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef cmDependsJava_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef cmDependsJava_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef cmDependsJava_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef cmDependsJava_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef cmDependsJava_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef cmDependsJava_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef cmDependsJava_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef cmDependsJava_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef cmDependsJava_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef cmDependsJava_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef cmDependsJava_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef cmDependsJava_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef cmDependsJava_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef cmDependsJava_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef cmDependsJava_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef cmDependsJava_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef cmDependsJava_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef cmDependsJava_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef cmDependsJava_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef cmDependsJava_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef cmDependsJava_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef cmDependsJava_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef cmDependsJava_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef cmDependsJava_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef cmDependsJava_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef cmDependsJava_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef cmDependsJava_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef cmDependsJava_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef cmDependsJava_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef cmDependsJava_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef cmDependsJava_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef cmDependsJava_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef cmDependsJava_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef cmDependsJava_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef cmDependsJava_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef cmDependsJava_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef cmDependsJava_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef cmDependsJava_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef cmDependsJava_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef cmDependsJava_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef cmDependsJava_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#undef cmDependsJava_yyIN_HEADER
+#endif /* cmDependsJava_yyHEADER_H */
diff --git a/Source/LexerParser/cmDependsJavaLexer.in.l b/Source/LexerParser/cmDependsJavaLexer.in.l
new file mode 100644
index 0000000..01a0fa3
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaLexer.in.l
@@ -0,0 +1,175 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmDependsJavaLexer.h -ocmDependsJavaLexer.cxx cmDependsJavaLexer.in.l
+
+Modify cmDependsJavaLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmDependsJavaLexer.h cmDependsJavaLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmDependsJavaLexer.h cmDependsJavaLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmDependsJavaLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include <iostream>
+
+#include "cmDependsJavaParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmDependsJavaParserTokens.h"
+
+#define KEYWORD yylvalp->str = 0
+#define SYMBOL yylvalp->str = 0
+#define PRIMITIVE  yylvalp->str = 0
+
+/*--------------------------------------------------------------------------*/
+%}
+
+%option prefix="cmDependsJava_yy"
+
+%option reentrant
+%option noyywrap
+%pointer
+
+%x comment
+%x string
+
+%%
+"/*" { BEGIN(comment); }
+<comment>"*/" { BEGIN(INITIAL); }
+<comment>.|\n {}
+
+\" { BEGIN(string); }
+<string>\" { BEGIN(INITIAL); return jp_STRINGLITERAL; }
+<string>. {}
+
+abstract { KEYWORD; return jp_ABSTRACT; }
+assert { KEYWORD; return jp_ASSERT; }
+boolean { KEYWORD; return jp_BOOLEAN_TYPE; }
+break { KEYWORD; return jp_BREAK; }
+byte { KEYWORD; return jp_BYTE_TYPE; }
+case { KEYWORD; return jp_CASE; }
+catch { KEYWORD; return jp_CATCH; }
+char { KEYWORD; return jp_CHAR_TYPE; }
+class { KEYWORD; return jp_CLASS; }
+continue { KEYWORD; return jp_CONTINUE; }
+default { KEYWORD; return jp_DEFAULT; }
+do { KEYWORD; return jp_DO; }
+double { KEYWORD; return jp_DOUBLE_TYPE; }
+else { KEYWORD; return jp_ELSE; }
+extends { KEYWORD; return jp_EXTENDS; }
+final { KEYWORD; return jp_FINAL; }
+finally { KEYWORD; return jp_FINALLY; }
+float { KEYWORD; return jp_FLOAT_TYPE; }
+for { KEYWORD; return jp_FOR; }
+if { KEYWORD; return jp_IF; }
+implements { KEYWORD; return jp_IMPLEMENTS; }
+import { KEYWORD; return jp_IMPORT; }
+instanceof { KEYWORD; return jp_INSTANCEOF; }
+int { KEYWORD; return jp_INT_TYPE; }
+interface { KEYWORD; return jp_INTERFACE; }
+long { KEYWORD; return jp_LONG_TYPE; }
+native { KEYWORD; return jp_NATIVE; }
+new { KEYWORD; return jp_NEW; }
+package { KEYWORD; return jp_PACKAGE; }
+private { KEYWORD; return jp_PRIVATE; }
+protected { KEYWORD; return jp_PROTECTED; }
+public { KEYWORD; return jp_PUBLIC; }
+return { KEYWORD; return jp_RETURN; }
+short { KEYWORD; return jp_SHORT_TYPE; }
+static { KEYWORD; return jp_STATIC; }
+strictfp { KEYWORD; return jp_STRICTFP; }
+super { KEYWORD; return jp_SUPER; }
+switch { KEYWORD; return jp_SWITCH; }
+synchronized { KEYWORD; return jp_SYNCHRONIZED; }
+this { KEYWORD; return jp_THIS; }
+throw { KEYWORD; return jp_THROW; }
+throws { KEYWORD; return jp_THROWS; }
+transient { KEYWORD; return jp_TRANSIENT; }
+try { KEYWORD; return jp_TRY; }
+void { KEYWORD; return jp_VOID; }
+volatile { KEYWORD; return jp_VOLATILE; }
+while { KEYWORD; return jp_WHILE; }
+
+(true|false) { PRIMITIVE; return jp_BOOLEANLITERAL; }
+\'([^\\]|\\.|\\u[0-9a-fA-F]*|\\[0-7]*)\' { PRIMITIVE; return jp_CHARACTERLITERAL; }
+(0|[0-9]+)[lL]? { PRIMITIVE; return jp_DECIMALINTEGERLITERAL; }
+([0-9]+\.[0-9]*|\.[0-9]+|[0-9]+)([eE][+\-]?[0-9]+)?[fFdD]? { PRIMITIVE; return jp_FLOATINGPOINTLITERAL; }
+0[xX][0-9a-fA-F]+[lL]? { PRIMITIVE; return jp_HEXINTEGERLITERAL; }
+null { PRIMITIVE; return jp_NULLLITERAL; }
+
+"&" { SYMBOL; return jp_AND; }
+"&&" { SYMBOL; return jp_ANDAND; }
+"&=" { SYMBOL; return jp_ANDEQUALS; }
+"\]" { SYMBOL; return jp_BRACKETEND; }
+"\[" { SYMBOL; return jp_BRACKETSTART; }
+"\^" { SYMBOL; return jp_CARROT; }
+"\^=" { SYMBOL; return jp_CARROTEQUALS; }
+":" { SYMBOL; return jp_COLON; }
+"," { SYMBOL; return jp_COMMA; }
+"}" { SYMBOL; return jp_CURLYEND; }
+"{" { SYMBOL; return jp_CURLYSTART; }
+"/" { SYMBOL; return jp_DIVIDE; }
+"/=" { SYMBOL; return jp_DIVIDEEQUALS; }
+"\$" { SYMBOL; return jp_DOLLAR; }
+"\." { SYMBOL; return jp_DOT; }
+"=" { SYMBOL; return jp_EQUALS; }
+"==" { SYMBOL; return jp_EQUALSEQUALS; }
+"\!" { SYMBOL; return jp_EXCLAMATION; }
+"\!=" { SYMBOL; return jp_EXCLAMATIONEQUALS; }
+">" { SYMBOL; return jp_GREATER; }
+">=" { SYMBOL; return jp_GTEQUALS; }
+">>" { SYMBOL; return jp_GTGT; }
+">>=" { SYMBOL; return jp_GTGTEQUALS; }
+">>>" { SYMBOL; return jp_GTGTGT; }
+">>>=" { SYMBOL; return jp_GTGTGTEQUALS; }
+"<<=" { SYMBOL; return jp_LESLESEQUALS; }
+"<" { SYMBOL; return jp_LESSTHAN; }
+"<=" { SYMBOL; return jp_LTEQUALS; }
+"<<" { SYMBOL; return jp_LTLT; }
+"-" { SYMBOL; return jp_MINUS; }
+"-=" { SYMBOL; return jp_MINUSEQUALS; }
+"--" { SYMBOL; return jp_MINUSMINUS; }
+"\)" { SYMBOL; return jp_PAREEND; }
+"\(" { SYMBOL; return jp_PARESTART; }
+"%" { SYMBOL; return jp_PERCENT; }
+"%=" { SYMBOL; return jp_PERCENTEQUALS; }
+"\|" { SYMBOL; return jp_PIPE; }
+"\|=" { SYMBOL; return jp_PIPEEQUALS; }
+"\|\|" { SYMBOL; return jp_PIPEPIPE; }
+"\+" { SYMBOL; return jp_PLUS; }
+"\+=" { SYMBOL; return jp_PLUSEQUALS; }
+"\+\+" { SYMBOL; return jp_PLUSPLUS; }
+"\?" { SYMBOL; return jp_QUESTION; }
+";" { SYMBOL; return jp_SEMICOL; }
+"\~" { SYMBOL; return jp_TILDE; }
+"\*" { SYMBOL; return jp_TIMES; }
+"\*=" { SYMBOL; return jp_TIMESEQUALS; }
+
+[a-z_A-Z][a-z_0-9A-Z]* {
+  yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
+  return jp_NAME;
+}
+
+\/\/.*\n { }
+[ \f\t\n\r] { }
+. {
+  std::cerr << "Unknown character: " << yytext[0]
+    << " (" << (int)yytext[0] << ")" << std::endl;
+  yyextra->Error("Unknown character");
+  return jp_ERROR;
+}
+
+%%
diff --git a/Source/LexerParser/cmDependsJavaParser.cxx b/Source/LexerParser/cmDependsJavaParser.cxx
new file mode 100644
index 0000000..bc45d45
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaParser.cxx
@@ -0,0 +1,6421 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names.  */
+#define yyparse         cmDependsJava_yyparse
+#define yylex           cmDependsJava_yylex
+#define yyerror         cmDependsJava_yyerror
+#define yydebug         cmDependsJava_yydebug
+#define yynerrs         cmDependsJava_yynerrs
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "cmDependsJavaParser.y" /* yacc.c:339  */
+
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmDependsJava_yy --defines=cmDependsJavaParserTokens.h -ocmDependsJavaParser.cxx cmDependsJavaParser.y
+
+Modify cmDependsJavaParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+
+#define yyGetParser (cmDependsJava_yyget_extra(yyscanner))
+
+/*-------------------------------------------------------------------------*/
+#include "cmDependsJavaParserHelper.h" /* Interface to parser object.  */
+#include "cmDependsJavaLexer.h"  /* Interface to lexer object.  */
+#include "cmDependsJavaParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message);
+
+#define YYMAXDEPTH 1000000
+
+
+#define jpCheckEmpty(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
+#define jpElementStart(cnt) yyGetParser->PrepareElement(&yyval)
+#define jpStoreClass(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no case. */
+#endif
+
+#line 120 "cmDependsJavaParser.cxx" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "cmDependsJavaParserTokens.h".  */
+#ifndef YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED
+# define YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmDependsJava_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    jp_ABSTRACT = 258,
+    jp_ASSERT = 259,
+    jp_BOOLEAN_TYPE = 260,
+    jp_BREAK = 261,
+    jp_BYTE_TYPE = 262,
+    jp_CASE = 263,
+    jp_CATCH = 264,
+    jp_CHAR_TYPE = 265,
+    jp_CLASS = 266,
+    jp_CONTINUE = 267,
+    jp_DEFAULT = 268,
+    jp_DO = 269,
+    jp_DOUBLE_TYPE = 270,
+    jp_ELSE = 271,
+    jp_EXTENDS = 272,
+    jp_FINAL = 273,
+    jp_FINALLY = 274,
+    jp_FLOAT_TYPE = 275,
+    jp_FOR = 276,
+    jp_IF = 277,
+    jp_IMPLEMENTS = 278,
+    jp_IMPORT = 279,
+    jp_INSTANCEOF = 280,
+    jp_INT_TYPE = 281,
+    jp_INTERFACE = 282,
+    jp_LONG_TYPE = 283,
+    jp_NATIVE = 284,
+    jp_NEW = 285,
+    jp_PACKAGE = 286,
+    jp_PRIVATE = 287,
+    jp_PROTECTED = 288,
+    jp_PUBLIC = 289,
+    jp_RETURN = 290,
+    jp_SHORT_TYPE = 291,
+    jp_STATIC = 292,
+    jp_STRICTFP = 293,
+    jp_SUPER = 294,
+    jp_SWITCH = 295,
+    jp_SYNCHRONIZED = 296,
+    jp_THIS = 297,
+    jp_THROW = 298,
+    jp_THROWS = 299,
+    jp_TRANSIENT = 300,
+    jp_TRY = 301,
+    jp_VOID = 302,
+    jp_VOLATILE = 303,
+    jp_WHILE = 304,
+    jp_BOOLEANLITERAL = 305,
+    jp_CHARACTERLITERAL = 306,
+    jp_DECIMALINTEGERLITERAL = 307,
+    jp_FLOATINGPOINTLITERAL = 308,
+    jp_HEXINTEGERLITERAL = 309,
+    jp_NULLLITERAL = 310,
+    jp_STRINGLITERAL = 311,
+    jp_NAME = 312,
+    jp_AND = 313,
+    jp_ANDAND = 314,
+    jp_ANDEQUALS = 315,
+    jp_BRACKETEND = 316,
+    jp_BRACKETSTART = 317,
+    jp_CARROT = 318,
+    jp_CARROTEQUALS = 319,
+    jp_COLON = 320,
+    jp_COMMA = 321,
+    jp_CURLYEND = 322,
+    jp_CURLYSTART = 323,
+    jp_DIVIDE = 324,
+    jp_DIVIDEEQUALS = 325,
+    jp_DOLLAR = 326,
+    jp_DOT = 327,
+    jp_EQUALS = 328,
+    jp_EQUALSEQUALS = 329,
+    jp_EXCLAMATION = 330,
+    jp_EXCLAMATIONEQUALS = 331,
+    jp_GREATER = 332,
+    jp_GTEQUALS = 333,
+    jp_GTGT = 334,
+    jp_GTGTEQUALS = 335,
+    jp_GTGTGT = 336,
+    jp_GTGTGTEQUALS = 337,
+    jp_LESLESEQUALS = 338,
+    jp_LESSTHAN = 339,
+    jp_LTEQUALS = 340,
+    jp_LTLT = 341,
+    jp_MINUS = 342,
+    jp_MINUSEQUALS = 343,
+    jp_MINUSMINUS = 344,
+    jp_PAREEND = 345,
+    jp_PARESTART = 346,
+    jp_PERCENT = 347,
+    jp_PERCENTEQUALS = 348,
+    jp_PIPE = 349,
+    jp_PIPEEQUALS = 350,
+    jp_PIPEPIPE = 351,
+    jp_PLUS = 352,
+    jp_PLUSEQUALS = 353,
+    jp_PLUSPLUS = 354,
+    jp_QUESTION = 355,
+    jp_SEMICOL = 356,
+    jp_TILDE = 357,
+    jp_TIMES = 358,
+    jp_TIMESEQUALS = 359,
+    jp_ERROR = 360
+  };
+#endif
+/* Tokens.  */
+#define jp_ABSTRACT 258
+#define jp_ASSERT 259
+#define jp_BOOLEAN_TYPE 260
+#define jp_BREAK 261
+#define jp_BYTE_TYPE 262
+#define jp_CASE 263
+#define jp_CATCH 264
+#define jp_CHAR_TYPE 265
+#define jp_CLASS 266
+#define jp_CONTINUE 267
+#define jp_DEFAULT 268
+#define jp_DO 269
+#define jp_DOUBLE_TYPE 270
+#define jp_ELSE 271
+#define jp_EXTENDS 272
+#define jp_FINAL 273
+#define jp_FINALLY 274
+#define jp_FLOAT_TYPE 275
+#define jp_FOR 276
+#define jp_IF 277
+#define jp_IMPLEMENTS 278
+#define jp_IMPORT 279
+#define jp_INSTANCEOF 280
+#define jp_INT_TYPE 281
+#define jp_INTERFACE 282
+#define jp_LONG_TYPE 283
+#define jp_NATIVE 284
+#define jp_NEW 285
+#define jp_PACKAGE 286
+#define jp_PRIVATE 287
+#define jp_PROTECTED 288
+#define jp_PUBLIC 289
+#define jp_RETURN 290
+#define jp_SHORT_TYPE 291
+#define jp_STATIC 292
+#define jp_STRICTFP 293
+#define jp_SUPER 294
+#define jp_SWITCH 295
+#define jp_SYNCHRONIZED 296
+#define jp_THIS 297
+#define jp_THROW 298
+#define jp_THROWS 299
+#define jp_TRANSIENT 300
+#define jp_TRY 301
+#define jp_VOID 302
+#define jp_VOLATILE 303
+#define jp_WHILE 304
+#define jp_BOOLEANLITERAL 305
+#define jp_CHARACTERLITERAL 306
+#define jp_DECIMALINTEGERLITERAL 307
+#define jp_FLOATINGPOINTLITERAL 308
+#define jp_HEXINTEGERLITERAL 309
+#define jp_NULLLITERAL 310
+#define jp_STRINGLITERAL 311
+#define jp_NAME 312
+#define jp_AND 313
+#define jp_ANDAND 314
+#define jp_ANDEQUALS 315
+#define jp_BRACKETEND 316
+#define jp_BRACKETSTART 317
+#define jp_CARROT 318
+#define jp_CARROTEQUALS 319
+#define jp_COLON 320
+#define jp_COMMA 321
+#define jp_CURLYEND 322
+#define jp_CURLYSTART 323
+#define jp_DIVIDE 324
+#define jp_DIVIDEEQUALS 325
+#define jp_DOLLAR 326
+#define jp_DOT 327
+#define jp_EQUALS 328
+#define jp_EQUALSEQUALS 329
+#define jp_EXCLAMATION 330
+#define jp_EXCLAMATIONEQUALS 331
+#define jp_GREATER 332
+#define jp_GTEQUALS 333
+#define jp_GTGT 334
+#define jp_GTGTEQUALS 335
+#define jp_GTGTGT 336
+#define jp_GTGTGTEQUALS 337
+#define jp_LESLESEQUALS 338
+#define jp_LESSTHAN 339
+#define jp_LTEQUALS 340
+#define jp_LTLT 341
+#define jp_MINUS 342
+#define jp_MINUSEQUALS 343
+#define jp_MINUSMINUS 344
+#define jp_PAREEND 345
+#define jp_PARESTART 346
+#define jp_PERCENT 347
+#define jp_PERCENTEQUALS 348
+#define jp_PIPE 349
+#define jp_PIPEEQUALS 350
+#define jp_PIPEPIPE 351
+#define jp_PLUS 352
+#define jp_PLUSEQUALS 353
+#define jp_PLUSPLUS 354
+#define jp_QUESTION 355
+#define jp_SEMICOL 356
+#define jp_TILDE 357
+#define jp_TIMES 358
+#define jp_TIMESEQUALS 359
+#define jp_ERROR 360
+
+/* Value type.  */
+
+
+
+int cmDependsJava_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 375 "cmDependsJavaParser.cxx" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  23
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   2215
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  106
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  158
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  351
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  575
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   360
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint16 yyrline[] =
+{
+       0,   179,   179,   188,   196,   204,   212,   220,   228,   237,
+     245,   254,   262,   271,   276,   281,   286,   291,   296,   301,
+     306,   312,   320,   329,   339,   348,   357,   365,   375,   381,
+     388,   395,   401,   408,   417,   427,   437,   446,   454,   463,
+     472,   478,   487,   493,   502,   508,   517,   529,   537,   546,
+     558,   571,   579,   587,   596,   604,   613,   613,   613,   614,
+     615,   615,   615,   615,   615,   615,   616,   619,   629,   638,
+     647,   656,   666,   672,   681,   690,   699,   707,   716,   725,
+     731,   740,   748,   756,   764,   773,   781,   790,   796,   804,
+     813,   821,   830,   839,   848,   856,   865,   873,   881,   890,
+     899,   909,   916,   926,   936,   943,   950,   953,   959,   969,
+     979,   989,   995,  1005,  1015,  1025,  1034,  1044,  1055,  1065,
+    1072,  1082,  1091,  1101,  1110,  1120,  1126,  1136,  1145,  1155,
+    1165,  1172,  1181,  1190,  1199,  1208,  1216,  1225,  1234,  1244,
+    1254,  1263,  1273,  1283,  1290,  1299,  1309,  1318,  1328,  1337,
+    1344,  1354,  1363,  1373,  1382,  1391,  1401,  1411,  1420,  1430,
+    1439,  1448,  1457,  1466,  1475,  1485,  1494,  1503,  1512,  1521,
+    1531,  1540,  1549,  1558,  1567,  1576,  1585,  1594,  1603,  1612,
+    1621,  1630,  1640,  1650,  1661,  1671,  1681,  1690,  1699,  1708,
+    1717,  1726,  1735,  1745,  1755,  1765,  1775,  1782,  1789,  1796,
+    1806,  1813,  1823,  1833,  1842,  1852,  1861,  1871,  1878,  1885,
+    1892,  1900,  1907,  1917,  1924,  1934,  1944,  1951,  1961,  1970,
+    1980,  1990,  1999,  2009,  2018,  2028,  2039,  2046,  2053,  2064,
+    2074,  2084,  2094,  2103,  2113,  2120,  2130,  2139,  2149,  2156,
+    2166,  2175,  2185,  2194,  2200,  2209,  2218,  2227,  2236,  2246,
+    2256,  2263,  2273,  2280,  2290,  2299,  2309,  2318,  2327,  2336,
+    2346,  2353,  2363,  2372,  2382,  2392,  2398,  2405,  2415,  2425,
+    2435,  2446,  2456,  2467,  2477,  2488,  2498,  2508,  2517,  2526,
+    2535,  2544,  2554,  2564,  2574,  2583,  2592,  2601,  2610,  2620,
+    2630,  2640,  2649,  2658,  2667,  2677,  2686,  2695,  2702,  2711,
+    2720,  2729,  2739,  2748,  2757,  2767,  2776,  2785,  2794,  2804,
+    2813,  2822,  2831,  2840,  2849,  2859,  2868,  2877,  2887,  2896,
+    2906,  2915,  2925,  2934,  2944,  2953,  2963,  2972,  2982,  2991,
+    3001,  3010,  3020,  3030,  3040,  3049,  3059,  3068,  3077,  3086,
+    3095,  3104,  3113,  3122,  3131,  3140,  3149,  3158,  3168,  3178,
+    3188,  3197
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "jp_ABSTRACT", "jp_ASSERT",
+  "jp_BOOLEAN_TYPE", "jp_BREAK", "jp_BYTE_TYPE", "jp_CASE", "jp_CATCH",
+  "jp_CHAR_TYPE", "jp_CLASS", "jp_CONTINUE", "jp_DEFAULT", "jp_DO",
+  "jp_DOUBLE_TYPE", "jp_ELSE", "jp_EXTENDS", "jp_FINAL", "jp_FINALLY",
+  "jp_FLOAT_TYPE", "jp_FOR", "jp_IF", "jp_IMPLEMENTS", "jp_IMPORT",
+  "jp_INSTANCEOF", "jp_INT_TYPE", "jp_INTERFACE", "jp_LONG_TYPE",
+  "jp_NATIVE", "jp_NEW", "jp_PACKAGE", "jp_PRIVATE", "jp_PROTECTED",
+  "jp_PUBLIC", "jp_RETURN", "jp_SHORT_TYPE", "jp_STATIC", "jp_STRICTFP",
+  "jp_SUPER", "jp_SWITCH", "jp_SYNCHRONIZED", "jp_THIS", "jp_THROW",
+  "jp_THROWS", "jp_TRANSIENT", "jp_TRY", "jp_VOID", "jp_VOLATILE",
+  "jp_WHILE", "jp_BOOLEANLITERAL", "jp_CHARACTERLITERAL",
+  "jp_DECIMALINTEGERLITERAL", "jp_FLOATINGPOINTLITERAL",
+  "jp_HEXINTEGERLITERAL", "jp_NULLLITERAL", "jp_STRINGLITERAL", "jp_NAME",
+  "jp_AND", "jp_ANDAND", "jp_ANDEQUALS", "jp_BRACKETEND",
+  "jp_BRACKETSTART", "jp_CARROT", "jp_CARROTEQUALS", "jp_COLON",
+  "jp_COMMA", "jp_CURLYEND", "jp_CURLYSTART", "jp_DIVIDE",
+  "jp_DIVIDEEQUALS", "jp_DOLLAR", "jp_DOT", "jp_EQUALS", "jp_EQUALSEQUALS",
+  "jp_EXCLAMATION", "jp_EXCLAMATIONEQUALS", "jp_GREATER", "jp_GTEQUALS",
+  "jp_GTGT", "jp_GTGTEQUALS", "jp_GTGTGT", "jp_GTGTGTEQUALS",
+  "jp_LESLESEQUALS", "jp_LESSTHAN", "jp_LTEQUALS", "jp_LTLT", "jp_MINUS",
+  "jp_MINUSEQUALS", "jp_MINUSMINUS", "jp_PAREEND", "jp_PARESTART",
+  "jp_PERCENT", "jp_PERCENTEQUALS", "jp_PIPE", "jp_PIPEEQUALS",
+  "jp_PIPEPIPE", "jp_PLUS", "jp_PLUSEQUALS", "jp_PLUSPLUS", "jp_QUESTION",
+  "jp_SEMICOL", "jp_TILDE", "jp_TIMES", "jp_TIMESEQUALS", "jp_ERROR",
+  "$accept", "Goal", "Literal", "IntegerLiteral", "Type", "PrimitiveType",
+  "ReferenceType", "ClassOrInterfaceType", "ClassType", "InterfaceType",
+  "ArrayType", "Name", "SimpleName", "Identifier", "QualifiedName",
+  "SimpleType", "CompilationUnit", "PackageDeclarationopt",
+  "ImportDeclarations", "TypeDeclarations", "PackageDeclaration",
+  "ImportDeclaration", "SingleTypeImportDeclaration",
+  "TypeImportOnDemandDeclaration", "TypeDeclaration", "Modifiers",
+  "Modifier", "ClassHeader", "ClassDeclaration", "Modifiersopt", "Super",
+  "Interfaces", "InterfaceTypeList", "ClassBody", "ClassBodyDeclarations",
+  "ClassBodyDeclaration", "ClassMemberDeclaration", "FieldDeclaration",
+  "VariableDeclarators", "VariableDeclarator", "VariableDeclaratorId",
+  "VariableInitializer", "MethodDeclaration", "MethodHeader", "Throwsopt",
+  "MethodDeclarator", "FormalParameterListopt", "FormalParameterList",
+  "FormalParameter", "Throws", "ClassTypeList", "MethodBody",
+  "StaticInitializer", "ConstructorDeclaration", "ConstructorDeclarator",
+  "ConstructorBody", "ExplicitConstructorInvocationopt",
+  "ExplicitConstructorInvocation", "InterfaceHeader",
+  "InterfaceDeclaration", "ExtendsInterfacesopt", "ExtendsInterfaces",
+  "InterfaceBody", "InterfaceMemberDeclarations",
+  "InterfaceMemberDeclaration", "ConstantDeclaration",
+  "AbstractMethodDeclaration", "Semicols", "ArrayInitializer",
+  "VariableInitializersOptional", "VariableInitializers", "Block",
+  "BlockStatementsopt", "BlockStatements", "BlockStatement",
+  "LocalVariableDeclarationStatement", "LocalVariableDeclaration",
+  "Statement", "StatementNoShortIf",
+  "StatementWithoutTrailingSubstatement", "EmptyStatement",
+  "LabeledStatement", "LabeledStatementNoShortIf", "ExpressionStatement",
+  "StatementExpression", "IfThenStatement", "IfThenElseStatement",
+  "IfThenElseStatementNoShortIf", "SwitchStatement", "SwitchBlock",
+  "SwitchLabelsopt", "SwitchBlockStatementGroups",
+  "SwitchBlockStatementGroup", "SwitchLabels", "SwitchLabel",
+  "WhileStatement", "WhileStatementNoShortIf", "DoStatement",
+  "ForStatement", "ForUpdateopt", "ForInitopt", "ForStatementNoShortIf",
+  "Expressionopt", "ForInit", "ForUpdate", "StatementExpressionList",
+  "AssertStatement", "BreakStatement", "Identifieropt",
+  "ContinueStatement", "ReturnStatement", "ThrowStatement",
+  "SynchronizedStatement", "TryStatement", "Catchesopt", "Catches",
+  "CatchClause", "Finally", "Primary", "PrimaryNoNewArray",
+  "ClassInstanceCreationExpression", "ClassBodyOpt", "ArgumentListopt",
+  "ArgumentList", "ArrayCreationExpression", "Dimsopt", "DimExprs",
+  "DimExpr", "Dims", "FieldAccess", "MethodInvocation", "ArrayAccess",
+  "PostfixExpression", "PostIncrementExpression",
+  "PostDecrementExpression", "UnaryExpression", "PreIncrementExpression",
+  "PreDecrementExpression", "UnaryExpressionNotPlusMinus",
+  "CastExpression", "MultiplicativeExpression", "AdditiveExpression",
+  "ShiftExpression", "RelationalExpression", "EqualityExpression",
+  "AndExpression", "ExclusiveOrExpression", "InclusiveOrExpression",
+  "ConditionalAndExpression", "ConditionalOrExpression",
+  "ConditionalExpression", "AssignmentExpression", "Assignment",
+  "LeftHandSide", "AssignmentOperator", "Expression", "ConstantExpression",
+  "New", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
+     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
+     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
+     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+     355,   356,   357,   358,   359,   360
+};
+# endif
+
+#define YYPACT_NINF -503
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-503)))
+
+#define YYTABLE_NINF -336
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int16 yypact[] =
+{
+     159,  1039,   236,  -503,  -503,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,   186,  -503,    56,  -503,
+    -503,  -503,   178,  -503,    35,  -503,    21,  -503,   248,  1039,
+     273,  -503,  -503,  -503,  -503,  -503,  -503,  -503,    78,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  2088,  -503,    32,  -503,    16,   245,  -503,    28,
+    -503,  -503,  1039,  1039,  -503,    80,   206,  -503,   129,   129,
+    1039,   221,   228,   194,  -503,  -503,   225,  -503,  -503,   234,
+     164,   206,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  1039,
+    -503,  1039,   233,  -503,  -503,   739,  -503,  -503,  -503,  -503,
+     -49,  -503,  -503,  -503,  1116,  -503,  -503,  1276,  -503,   129,
+     129,    40,  -503,  -503,  -503,   122,   212,   265,  -503,   215,
+    -503,  -503,   219,   739,  -503,   222,   224,  -503,  -503,  -503,
+    1820,   129,   129,  1627,   237,   238,  -503,  1820,   241,   239,
+     242,   283,  1820,   233,   266,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  1820,  1820,  1820,  -503,  -503,  -503,   129,   284,
+     476,   293,  2067,  -503,   349,  -503,   296,  1366,  -503,  -503,
+     264,  -503,  -503,  -503,  -503,  -503,   268,  -503,  -503,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,
+     294,   305,    72,  -503,  2070,    88,  2084,   121,   130,   148,
+    -503,  -503,  -503,  2111,  1039,   281,   133,   281,   -25,  -503,
+     126,   133,   314,   315,   315,   921,  1039,   308,  -503,  -503,
+    -503,  -503,   277,  -503,  1820,  1820,  1820,  1820,  1820,   317,
+     284,   545,  -503,  -503,   121,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,    73,   124,   163,    59,   196,   323,   319,   290,
+     324,    18,  -503,  -503,  -503,   -30,  -503,   285,   286,   242,
+     342,  1941,  1820,   291,  -503,   129,  1820,  1820,   129,   292,
+     385,  1820,    96,  -503,  -503,  -503,   310,  -503,  -503,   329,
+     387,  1085,     3,  1820,  1627,   129,  -503,  -503,  -503,  -503,
+     175,  1820,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,  1820,   339,   339,   311,
+     921,   343,  -503,   129,  -503,   344,  1766,  -503,  -503,   346,
+    1039,   313,   347,  -503,  -503,   353,  -503,   307,  -503,  -503,
+    -503,     6,   545,   326,  -503,  -503,  1820,  1820,  1820,  1820,
+    1820,  1820,  1820,  1820,  1039,  1820,  1820,  1820,  1820,  1820,
+    1820,  1820,  1820,  1820,  1820,  1820,  1820,  1820,  -503,  -503,
+    -503,   330,  2067,  -503,  -503,   327,  -503,   354,   334,  -503,
+     345,   335,   340,   348,  -503,   351,   416,   232,  -503,   356,
+    -503,  -503,   376,  -503,   357,   377,  -503,  -503,   329,  -503,
+     358,   390,  -503,  1085,   339,  -503,   154,   339,   154,  1820,
+     362,  -503,  -503,  -503,  1766,  -503,  -503,  -503,  -503,   129,
+    -503,  2088,  1039,  1456,  -503,   363,    70,    93,  1874,  -503,
+    -503,  -503,    73,    73,   124,   124,   124,  -503,   163,   163,
+     163,   163,    59,    59,   196,   323,   319,   290,   324,   383,
+     360,  1820,  1820,  1995,  1699,  1820,   386,   233,  1820,  2088,
+     233,  -503,  -503,  1627,  -503,  -503,  1820,  1820,  -503,   394,
+    -503,  -503,   315,  -503,  -503,  -503,   369,  -503,  -503,   396,
+     404,   410,  -503,  -503,    26,   113,  -503,   407,  1820,  1874,
+    -503,  1820,  -503,   391,   374,  -503,   393,   395,   397,   411,
+    -503,   466,   471,  -503,  -503,  -503,  -503,   399,  -503,  -503,
+    -503,   400,   401,  -503,  -503,  -503,   402,  -503,   206,  -503,
+    1766,  1820,  1820,  -503,  -503,  -503,  -503,   403,  1995,  1941,
+    1820,  1820,  1699,  1627,  -503,    34,  -503,   233,  -503,  -503,
+    -503,  -503,   405,   412,  -503,   413,  -503,   354,   406,   418,
+     421,  -503,  -503,  1820,   429,   430,  -503,  1186,  -503,  -503,
+     419,   422,  1627,  1820,  1699,  1699,  -503,   447,  -503,  -503,
+    1555,  -503,  -503,  -503,  -503,   423,   497,  -503,  -503,  1995,
+    1699,   432,  -503,  1699,  -503
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint16 yydefact[] =
+{
+      40,     0,     0,     2,    42,    41,    20,    13,    17,    19,
+      18,    15,    16,    14,    38,    31,     0,    37,     0,    28,
+      30,    29,     0,     1,    44,    32,     0,    46,     0,     0,
+      72,    43,    47,    48,    34,    35,    33,    36,     0,    60,
+      61,    62,    58,    57,    56,    59,    66,    63,    64,    65,
+      53,    45,    73,    54,     0,    51,     0,   125,    52,     0,
+      49,    55,     0,     0,    79,     0,     0,    68,     0,     0,
+       0,     0,   126,     0,    24,    74,    23,    25,    76,    75,
+      72,     0,    70,    69,    67,   123,   127,   130,   124,     0,
+      50,     0,    59,    78,    84,     0,    80,    81,    85,    86,
+       0,    82,    83,    71,    72,   128,    77,    72,   114,    38,
+       0,    11,    12,    21,    22,    23,    28,   101,    96,    97,
+     113,   129,   134,     0,   138,     0,   136,   131,   132,   133,
+       0,   226,   226,     0,     0,     0,   350,   216,     0,     0,
+      63,   243,     0,     0,     0,     5,     6,     9,     4,    10,
+       8,     7,     0,     0,     0,   182,   242,     3,     0,    22,
+     333,    30,    73,   155,     0,   170,     0,    72,   151,   153,
+       0,   154,   159,   171,   160,   172,     0,   161,   162,   173,
+     163,   174,   164,   181,   175,   176,   177,   179,   178,   180,
+     277,   240,   245,   241,   246,   247,   248,     0,   189,   190,
+     187,   188,   186,     0,     0,     0,   101,    92,     0,    88,
+      90,   101,     0,    26,    27,    72,     0,     0,   102,    98,
+     135,   140,   139,   137,     0,     0,     0,     0,     0,    37,
+       0,   278,   245,   247,   291,   280,   281,   298,   284,   285,
+     288,   294,   302,   305,   309,   315,   318,   320,   322,   324,
+     326,   328,   330,   348,   331,     0,   227,     0,     0,     0,
+       0,   213,     0,     0,   217,     0,     0,     0,     0,     0,
+     234,     0,   278,   246,   248,   290,     0,   289,    92,   158,
+       0,     0,     0,   252,     0,     0,   148,   152,   156,   185,
+       0,     0,   283,   282,   345,   346,   338,   336,   343,   344,
+     342,   341,   339,   347,   340,   337,     0,    37,    24,     0,
+      72,     0,   100,     0,    87,     0,     0,    99,   265,     0,
+       0,     0,   106,   107,   111,   110,   119,   115,   141,   293,
+     287,    37,   278,     0,   286,   292,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   223,   225,
+     228,     0,     0,   219,   221,     0,   214,   218,     0,   229,
+     268,     0,     0,   269,   230,     0,     0,   232,   236,     0,
+     244,   279,     0,   351,     0,   253,   254,   183,   157,   270,
+     267,     0,   332,     0,   260,   262,     0,   260,     0,   252,
+       0,   104,    89,    93,   143,    91,    95,    94,   266,     0,
+     117,    72,     0,    72,   116,     0,    26,    27,   244,   300,
+     301,   299,   304,   303,   307,   308,   306,   314,   311,   313,
+     310,   312,   316,   317,   319,   321,   323,   325,   327,     0,
+       0,     0,   216,     0,     0,   252,     0,     0,   252,    72,
+       0,   233,   237,     0,   275,   271,     0,   252,   276,     0,
+     256,   263,   261,   258,   257,   259,     0,   103,   146,     0,
+     144,   109,   108,   112,     0,   243,   120,     0,     0,     0,
+     296,     0,   224,     0,     0,   222,     0,     0,     0,    30,
+     193,     0,   159,   166,   167,   168,   169,     0,   200,   196,
+     231,     0,     0,   239,   207,   255,     0,   264,   250,   142,
+     145,   252,   252,   118,   295,   297,   329,     0,   211,   213,
+       0,     0,     0,     0,   273,   198,   274,     0,   272,   251,
+     249,   147,     0,     0,   209,     0,   212,   220,     0,     0,
+       0,   184,   194,     0,     0,     0,   201,    72,   203,   238,
+       0,     0,     0,   216,     0,     0,   349,     0,   206,   197,
+     202,   204,   122,   121,   210,     0,     0,   208,   205,   211,
+       0,     0,   195,     0,   215
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -503,  -503,  -503,  -503,   -85,     2,   181,   -41,  -198,   -45,
+     -87,    -1,   431,    14,  -503,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  -503,  -503,   448,   -81,   -47,  -503,     7,   -23,
+    -503,   462,  -503,   -64,  -503,  -503,  -503,   425,  -146,   217,
+     123,  -391,  -503,   427,  -101,   424,   230,  -503,  -360,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,   439,
+    -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -110,  -503,
+    -503,   -77,   138,   -12,  -163,  -503,  -250,   -13,  -421,  -414,
+    -503,  -503,  -503,  -503,  -252,  -503,  -503,  -503,  -503,  -503,
+    -503,  -503,  -503,  -503,     5,  -503,  -503,  -503,  -503,   -16,
+      36,  -503,  -418,  -503,  -503,  -502,  -503,  -503,   440,  -503,
+    -503,  -503,  -503,  -503,  -503,  -503,   179,  -503,  -503,  -503,
+     -54,  -503,  -341,  -503,  -503,  -149,   255,  -136,   102,   652,
+     101,   688,   145,   157,   201,   -98,   289,   338,  -384,  -503,
+     -59,   -58,   -92,   -57,   213,   226,   218,   223,   227,  -503,
+      95,   274,   350,  -503,  -503,   660,  -503,  -503
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+      -1,     2,   156,   157,   158,   229,   112,   113,    75,    78,
+     230,   231,    19,    20,    21,    22,     3,     4,    24,    30,
+       5,    31,    32,    33,    51,    52,    53,    54,   163,   164,
+      65,    66,    79,    67,    80,    96,    97,    98,   208,   209,
+     210,   405,    99,   100,   217,   206,   321,   322,   323,   218,
+     325,   119,   101,   102,   117,   327,   413,   476,    57,    58,
+      71,    72,    88,   104,   127,   128,   129,   222,   406,   469,
+     470,   165,   166,   167,   168,   169,   170,   171,   491,   172,
+     173,   174,   493,   175,   176,   177,   178,   494,   179,   499,
+     545,   525,   546,   547,   548,   180,   495,   181,   182,   535,
+     365,   496,   263,   366,   536,   367,   183,   184,   257,   185,
+     186,   187,   188,   189,   376,   377,   378,   451,   190,   191,
+     232,   530,   384,   385,   193,   415,   394,   395,   214,   194,
+     233,   196,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   203,   306,   386,   557,   204
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_int16 yytable[] =
+{
+      18,    82,    83,    17,   287,    61,   309,    56,   114,   364,
+     110,   363,   279,   468,    34,   108,   537,   103,   324,   107,
+     159,    74,    77,   120,   484,    86,   162,    68,    38,    77,
+     492,    17,    34,   383,   480,   357,   114,    55,   110,    34,
+      36,   313,   543,    69,   105,    35,   106,   544,    77,    62,
+      77,   472,   118,   192,   275,    63,   277,    95,   466,    29,
+      15,    76,    76,    35,    17,    17,   270,   537,   212,    76,
+      35,   358,    17,    36,    16,   114,   314,   285,    15,   192,
+     159,   123,    84,    85,   344,    15,   162,    55,    76,   502,
+      76,    17,    16,    17,   115,   515,  -260,   111,   265,    16,
+      64,   541,   212,    63,   497,   312,   160,   501,   492,   111,
+     317,   122,   -37,   192,   355,    61,   506,   511,   356,   531,
+     260,   161,   115,   205,   207,   111,   329,   330,    26,   334,
+     335,    73,   319,   566,   567,   565,   345,   346,  -192,   388,
+     492,   492,   336,   347,   348,   256,   256,   161,    64,   572,
+      59,   272,   574,   272,  -191,   319,   492,    27,   281,   492,
+    -261,   115,  -192,   308,   111,   337,   160,    39,   282,   111,
+     532,   533,   278,  -192,   159,    74,   338,   216,  -191,    60,
+     362,   161,    40,   479,   212,   268,    15,   283,   315,  -191,
+       1,   485,   320,    41,    26,   311,    42,    43,    44,   316,
+      16,    92,    46,    76,   512,    47,   307,   192,   195,    48,
+     292,   339,    49,   213,   473,    76,   319,   389,    17,  -280,
+     293,   340,   404,   272,   272,   332,   272,   272,   331,  -280,
+     192,    93,    15,   114,   195,   409,    23,  -281,   419,   420,
+     421,   375,   341,    25,   342,   460,    16,  -281,   464,   343,
+      28,  -235,   197,   428,   429,   430,   431,   114,   461,    37,
+     160,   461,    70,   111,   198,    50,   364,   364,   195,   363,
+     349,   387,   350,   -39,    64,   114,    39,   285,   197,   370,
+     422,   423,   373,   424,   425,   426,   463,   320,   465,    87,
+     198,    40,   432,   433,    89,    90,    36,    26,   161,   278,
+      91,   107,    41,   215,   390,    42,    43,    44,   199,   216,
+      45,    46,   197,   265,    47,    61,   219,   364,    48,   115,
+     220,    49,   111,   221,   198,   223,   159,   278,   261,   262,
+     266,   213,   162,   267,   199,   272,   272,   272,   272,   272,
+     272,   272,   272,   115,   272,   272,   272,   272,   272,   272,
+     272,   272,   272,   272,   272,   268,   280,   271,   284,   192,
+      68,   115,   195,   286,   111,   288,   290,   291,   199,   289,
+     500,    74,   310,   503,    50,   318,   326,   319,   328,   212,
+     514,   351,   352,   354,   353,   195,   359,   360,   320,   192,
+     192,   361,   369,   374,   375,   313,   200,   287,   381,   192,
+     380,   393,   399,   410,   401,   403,   197,   408,   414,   396,
+     398,    76,   160,   411,    17,   111,   418,   272,   198,   412,
+     443,   441,   200,   278,   444,   446,   320,   161,   442,   197,
+     447,   490,   159,   416,   417,   450,   445,   454,   362,   448,
+     504,   198,   449,   456,   529,   201,   453,   455,   481,   457,
+     549,   458,   467,   478,   498,   507,   200,   202,   489,   508,
+     159,   482,   199,   509,   192,   192,   162,   161,   192,   192,
+     510,   201,   315,   159,   513,   518,   522,   272,   272,   162,
+     272,   517,   523,   202,   519,   199,   520,  -165,   521,   524,
+     526,   527,   528,   192,   558,   550,   462,   559,   192,   462,
+     192,   192,   551,   552,   534,   201,   192,   553,   554,   387,
+     542,   555,   568,   570,   195,   192,   192,   202,   160,   192,
+     562,   111,   573,   563,   569,   427,   116,    81,    94,   124,
+     402,   125,   471,   -23,   211,   560,   489,   161,   281,   564,
+     400,   490,   504,   126,   195,   195,   160,   -23,   282,   111,
+     200,   477,   561,   571,   195,   538,   452,   542,   197,   160,
+     564,   161,   111,   397,   434,  -278,   161,   283,   489,   489,
+     198,   436,   258,   200,   161,  -278,   516,   437,   435,     0,
+     392,     0,   438,     0,   489,     0,     0,   489,   197,   197,
+       0,     0,     0,     0,     0,     0,     0,     0,   197,   201,
+     198,   198,     0,     0,     0,  -333,     0,   281,     0,  -333,
+     198,   202,     0,     0,   199,  -333,     0,   282,  -333,   195,
+     195,     0,   201,   195,   195,  -333,     0,  -333,  -333,     0,
+       0,     0,     0,  -333,   202,     0,   283,     0,  -333,     0,
+    -333,     0,     0,  -333,   199,   199,     0,     0,   195,  -333,
+       0,     0,     0,   195,   199,   195,   195,     0,     0,     0,
+       0,   195,     0,   197,   197,     0,     0,   197,   197,     0,
+     195,   195,     0,     0,   195,   198,   198,     0,     0,   198,
+     198,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   197,     0,     0,     0,     0,   197,     0,   197,
+     197,     0,   200,     0,   198,   197,     0,     0,     0,   198,
+       0,   198,   198,     0,   197,   197,     0,   198,   197,   199,
+     199,     0,     0,   199,   199,     0,   198,   198,     0,     0,
+     198,     0,   200,   200,     0,     0,     0,     0,     0,     0,
+       0,     0,   200,     0,     6,     0,     7,     0,   199,     8,
+      68,   201,     0,   199,     9,   199,   199,     0,     0,    10,
+       0,   199,     0,   202,     0,    11,    69,    12,     0,     0,
+     199,   199,     0,     0,   199,    13,     0,     0,     0,     0,
+       0,   201,   201,     0,     0,     0,   109,     0,     0,     0,
+     255,   201,     0,   202,   202,     0,    15,   264,     0,     0,
+       0,     0,   269,   202,   273,     0,   273,   200,   200,     0,
+      16,   200,   200,   276,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   200,     0,     0,     0,
+     274,   200,   274,   200,   200,     0,     0,     0,     0,   200,
+       0,     0,     0,     0,     0,     0,   201,   201,   200,   200,
+     201,   201,   200,     0,     0,     0,     0,     0,   202,   202,
+       0,     0,   202,   202,     0,     0,   273,   273,     0,   273,
+     273,     0,     0,     0,     0,   201,   333,     0,     0,     0,
+     201,     0,   201,   201,     0,     0,     0,   202,   201,     0,
+       0,     0,   202,     0,   202,   202,     0,   201,   201,     0,
+     202,   201,   274,   274,     0,   274,   274,     0,     0,   202,
+     202,     0,   368,   202,    39,     0,   371,   372,     0,     0,
+       0,   379,     0,     0,     0,     0,     0,     0,     0,    40,
+       0,   382,     0,     0,     0,     0,     0,     0,     0,     0,
+      41,   391,     0,    42,    43,    44,     0,     0,    45,    46,
+       0,     0,    47,     0,     0,     0,    48,     0,     0,    49,
+       0,     0,     0,     0,     0,     0,   407,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   273,   273,
+     273,   273,   273,   273,   273,   273,     0,   273,   273,   273,
+     273,   273,   273,   273,   273,   273,   273,   273,     0,     0,
+       0,  -105,     0,     0,     0,     0,   439,   440,     0,     0,
+       0,     0,     0,     0,   274,   274,   274,   274,   274,   274,
+     274,   274,     0,   274,   274,   274,   274,   274,   274,   274,
+     274,   274,   274,   274,     6,     0,     7,     0,     0,     8,
+       0,     0,     0,   459,     9,     0,     0,     0,     0,    10,
+       0,     0,     0,     0,   407,    11,     0,    12,     0,     0,
+     273,     0,     0,     0,     0,    13,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    14,     0,     0,     0,
+       6,     0,     7,     0,     0,     8,    15,     0,     0,     0,
+       9,   483,   264,     0,     0,    10,   274,     0,     0,     0,
+      16,    11,     0,    12,     0,   136,   505,     0,     0,    39,
+       0,    13,     0,     0,   138,     0,     0,   141,     0,     0,
+     273,   273,    14,   273,    40,   145,   146,   147,   148,   149,
+     150,   151,    15,     0,     0,    41,   318,     0,    42,    43,
+      44,     0,     0,    45,    46,     0,    16,    47,     0,     0,
+     224,    48,     0,     0,    49,     0,   274,   274,     0,   274,
+     407,     0,   225,     0,   152,     0,   226,     0,     0,     0,
+     539,   540,   227,   121,   154,     0,     0,   228,     0,    39,
+     130,     6,   131,     7,   543,     0,     8,     0,   132,   544,
+     133,     9,     0,   556,    40,     0,    10,   134,   135,     0,
+       0,     0,    11,   264,    12,    41,   136,     0,    42,    43,
+      44,   137,    13,    45,    46,   138,   139,   140,   141,   142,
+       0,    48,   143,    14,    49,   144,   145,   146,   147,   148,
+     149,   150,   151,    15,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -199,   107,     0,     0,    16,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   152,     0,   153,     0,    39,
+     130,     6,   131,     7,     0,   154,     8,   155,   132,     0,
+     133,     9,     0,     0,    40,     0,    10,   134,   135,     0,
+       0,     0,    11,     0,    12,    41,   136,     0,    42,    43,
+      44,   137,    13,    45,    46,   138,   139,   140,   141,   142,
+       0,    48,   143,    14,    49,   144,   145,   146,   147,   148,
+     149,   150,   151,    15,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -149,   107,     0,     0,    16,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   152,     0,   153,     0,    39,
+     130,     6,   131,     7,     0,   154,     8,   155,   132,     0,
+     133,     9,     0,     0,    40,     0,    10,   134,   135,     0,
+       0,     0,    11,     0,    12,    41,   136,     0,    42,    43,
+      44,   137,    13,    45,    46,   138,   139,   140,   141,   142,
+       0,    48,   143,    14,    49,   144,   145,   146,   147,   148,
+     149,   150,   151,    15,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -150,   107,     0,     0,    16,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   152,     0,   153,     0,    39,
+     130,     6,   131,     7,     0,   154,     8,   155,   132,     0,
+     133,     9,     0,     0,    40,     0,    10,   134,   135,     0,
+       0,     0,    11,     0,    12,    41,   136,     0,    42,    43,
+      44,   137,    13,    45,    46,   474,   139,   140,   475,   142,
+       0,    48,   143,    14,    49,   144,   145,   146,   147,   148,
+     149,   150,   151,    15,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -149,   107,     0,     0,    16,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   152,     0,   153,     0,     0,
+       0,     0,     0,     0,     0,   154,     0,   155,    39,   130,
+       6,   131,     7,     0,     0,     8,   -72,   132,     0,   133,
+       9,     0,     0,    40,     0,    10,   134,   135,     0,     0,
+       0,    11,     0,    12,    41,   136,     0,    42,    43,    44,
+     137,    13,    45,    46,   138,   139,   140,   141,   142,     0,
+      48,   143,    14,    49,   144,   145,   146,   147,   148,   149,
+     150,   151,    15,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   107,     0,     0,    16,     0,     0,     0,
+       0,   130,     6,   131,     7,     0,     0,     8,     0,   132,
+       0,   133,     9,     0,   152,     0,   153,    10,   134,   135,
+       0,     0,     0,    11,   154,    12,   155,   136,     0,     0,
+       0,     0,   137,    13,     0,     0,   138,   139,   259,   141,
+     142,     0,     0,   143,    14,     0,   144,   145,   146,   147,
+     148,   149,   150,   151,    15,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   107,     0,     0,    16,     0,
+       0,     0,     0,   130,     6,   131,     7,     0,     0,     8,
+       0,   132,     0,   133,     9,     0,   152,     0,   153,    10,
+     486,   487,     0,     0,     0,    11,   154,    12,   155,   136,
+       0,     0,     0,     0,   137,    13,     0,     0,   138,   139,
+     259,   141,   142,     0,     0,   143,    14,     0,   488,   145,
+     146,   147,   148,   149,   150,   151,    15,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   107,     0,     0,
+      16,     6,     0,     7,     0,     0,     8,     0,     0,     0,
+       0,     9,     0,     0,     0,     0,    10,     0,   152,     0,
+     153,     0,    11,     0,    12,     0,   136,     0,   154,     0,
+     155,     0,    13,     0,     0,   138,     0,     0,   141,     0,
+       0,     0,     0,    14,     0,     0,   145,   146,   147,   148,
+     149,   150,   151,    15,     0,     6,     0,     7,     0,     0,
+       8,     0,     0,     0,   404,     9,     0,    16,     0,     0,
+      10,   224,     0,     0,     0,     0,    11,     0,    12,     0,
+     136,     0,     0,   225,     0,   152,    13,   226,     0,   138,
+       0,     0,   141,   227,     0,   154,     0,    14,   228,     0,
+     145,   146,   147,   148,   149,   150,   151,    15,     0,     6,
+       0,     7,     0,     0,     8,     0,     0,     0,     0,     9,
+       0,    16,     0,     0,    10,   224,     0,     0,     0,     0,
+      11,     0,    12,     0,   136,     0,     0,   225,     0,   152,
+      13,   226,     0,   138,     0,     0,   141,   227,     0,   154,
+       0,    14,   228,     0,   145,   146,   147,   148,   149,   150,
+     151,    15,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    39,    16,     6,     0,     7,   224,
+       0,     8,     0,     0,     0,     0,     9,     0,     0,    40,
+       0,    10,     0,     0,     0,   226,     0,    11,     0,    12,
+      41,   136,     0,    42,    43,    44,   228,    13,    45,    46,
+     138,     0,    47,   141,     0,     0,    48,     0,    14,    49,
+       0,   145,   146,   147,   148,   149,   150,   151,    15,     0,
+       6,     0,     7,     0,     0,     8,     0,     0,     0,     0,
+       9,     0,    16,     0,     0,    10,     0,     0,     0,     0,
+       0,    11,     0,    12,     0,   136,     0,     0,     0,     0,
+     152,    13,   153,     0,   138,     0,     0,   141,     0,     0,
+     154,     0,    14,     0,     0,   145,   146,   147,   148,   149,
+     150,   151,    15,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    16,     0,     0,     0,
+      39,     0,     6,     0,     7,     0,     0,     8,     0,     0,
+       0,     0,     9,     0,   152,    40,   153,    10,     0,     0,
+       0,    39,     0,    11,   154,    12,    41,     0,     0,    42,
+      43,    44,     0,    13,    45,    46,    40,     0,    47,     0,
+       0,     0,    48,     0,    14,    49,     0,    41,     0,     0,
+      42,    43,    44,     0,    15,    45,    46,     0,     0,    47,
+    -334,     0,     0,    48,  -334,     0,    49,     0,    16,     0,
+    -334,     0,     0,  -334,  -335,     0,     0,     0,  -335,     0,
+    -334,     0,  -334,  -334,  -335,     0,     0,  -335,  -334,     0,
+       0,     0,     0,  -334,  -335,  -334,  -335,  -335,  -334,     0,
+       0,   294,  -335,     0,  -334,   295,     0,  -335,     0,  -335,
+       0,   296,  -335,     0,   297,     0,     0,     0,  -335,     0,
+       0,   298,     0,   299,   300,     0,     0,     0,     0,   301,
+       0,     0,     0,     0,   302,     0,   303,     0,     0,   304,
+       0,     0,     0,     0,     0,   305
+};
+
+static const yytype_int16 yycheck[] =
+{
+       1,    65,    66,     1,   167,    52,   204,    30,    95,   261,
+      95,   261,   158,   404,    11,    92,   518,    81,   216,    68,
+     107,    62,    63,   100,   442,    70,   107,    11,    29,    70,
+     444,    29,    11,    30,   418,    65,   123,    30,   123,    11,
+      26,    66,     8,    27,    89,    42,    91,    13,    89,    17,
+      91,   411,   101,   107,   152,    23,   154,    80,   399,    24,
+      57,    62,    63,    42,    62,    63,   143,   569,    62,    70,
+      42,   101,    70,    59,    71,   162,   101,   162,    57,   133,
+     167,   104,    68,    69,    25,    57,   167,    80,    89,   449,
+      91,    89,    71,    91,    95,   479,    90,    95,    72,    71,
+      68,   522,    62,    23,   445,   206,   107,   448,   522,   107,
+     211,   104,    72,   167,    96,   162,   457,    91,   100,   510,
+     133,   107,   123,   109,   110,   123,   224,   225,    72,   227,
+     228,   103,    62,   554,   555,   553,    77,    78,    66,   285,
+     554,   555,    69,    84,    85,   131,   132,   133,    68,   570,
+      72,   152,   573,   154,    66,    62,   570,   101,    62,   573,
+      90,   162,    90,   204,   162,    92,   167,     3,    72,   167,
+     511,   512,   158,   101,   261,   216,   103,    44,    90,   101,
+     261,   167,    18,    90,    62,    72,    57,    91,    62,   101,
+      31,   443,   215,    29,    72,    62,    32,    33,    34,    73,
+      71,    37,    38,   204,    91,    41,   204,   261,   107,    45,
+      89,    87,    48,   111,   412,   216,    62,    42,   216,    89,
+      99,    97,    68,   224,   225,   226,   227,   228,   226,    99,
+     284,    67,    57,   320,   133,   320,     0,    89,   336,   337,
+     338,     9,    79,    57,    81,   394,    71,    99,   397,    86,
+      72,    19,   107,   345,   346,   347,   348,   344,   394,    11,
+     261,   397,    17,   261,   107,   101,   518,   519,   167,   519,
+      74,   284,    76,     0,    68,   362,     3,   362,   133,   265,
+     339,   340,   268,   341,   342,   343,   396,   310,   398,    68,
+     133,    18,   349,   350,    66,   101,   282,    72,   284,   285,
+      66,    68,    29,    91,   290,    32,    33,    34,   107,    44,
+      37,    38,   167,    72,    41,   362,   101,   569,    45,   320,
+     101,    48,   320,   101,   167,   101,   413,   313,    91,    91,
+      91,   229,   413,    91,   133,   336,   337,   338,   339,   340,
+     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
+     351,   352,   353,   354,   355,    72,    72,    91,    65,   413,
+      11,   362,   261,    67,   362,   101,    72,    62,   167,   101,
+     447,   412,    91,   450,   101,    61,    68,    62,   101,    62,
+     478,    58,    63,    59,    94,   284,   101,   101,   411,   443,
+     444,    49,   101,   101,     9,    66,   107,   560,    11,   453,
+      90,    62,    91,    90,    61,    61,   261,    61,   101,   307,
+     308,   412,   413,    66,   412,   413,    90,   418,   261,    66,
+      66,    91,   133,   409,    90,    90,   449,   413,   101,   284,
+      90,   444,   519,   331,   332,    19,    91,    61,   519,    91,
+     453,   284,    91,    66,   508,   107,    90,    90,    65,    91,
+     527,    61,    90,    90,    68,    61,   167,   107,   444,    90,
+     547,   101,   261,    67,   518,   519,   547,   453,   522,   523,
+      66,   133,    62,   560,    67,   101,    65,   478,   479,   560,
+     481,    90,    16,   133,    91,   284,    91,    16,    91,    90,
+      90,    90,    90,   547,    65,    90,   394,    67,   552,   397,
+     554,   555,    90,    90,   101,   167,   560,   101,    90,   522,
+     523,    90,    65,    16,   413,   569,   570,   167,   519,   573,
+     101,   519,    90,   101,   101,   344,    95,    65,    80,   104,
+     313,   104,   409,    57,   110,   547,   522,   523,    62,   552,
+     310,   554,   555,   104,   443,   444,   547,    71,    72,   547,
+     261,   413,   547,   569,   453,   519,   377,   570,   413,   560,
+     573,   547,   560,   308,   351,    89,   552,    91,   554,   555,
+     413,   353,   132,   284,   560,    99,   481,   354,   352,    -1,
+     306,    -1,   355,    -1,   570,    -1,    -1,   573,   443,   444,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   453,   261,
+     443,   444,    -1,    -1,    -1,    60,    -1,    62,    -1,    64,
+     453,   261,    -1,    -1,   413,    70,    -1,    72,    73,   518,
+     519,    -1,   284,   522,   523,    80,    -1,    82,    83,    -1,
+      -1,    -1,    -1,    88,   284,    -1,    91,    -1,    93,    -1,
+      95,    -1,    -1,    98,   443,   444,    -1,    -1,   547,   104,
+      -1,    -1,    -1,   552,   453,   554,   555,    -1,    -1,    -1,
+      -1,   560,    -1,   518,   519,    -1,    -1,   522,   523,    -1,
+     569,   570,    -1,    -1,   573,   518,   519,    -1,    -1,   522,
+     523,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   547,    -1,    -1,    -1,    -1,   552,    -1,   554,
+     555,    -1,   413,    -1,   547,   560,    -1,    -1,    -1,   552,
+      -1,   554,   555,    -1,   569,   570,    -1,   560,   573,   518,
+     519,    -1,    -1,   522,   523,    -1,   569,   570,    -1,    -1,
+     573,    -1,   443,   444,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   453,    -1,     5,    -1,     7,    -1,   547,    10,
+      11,   413,    -1,   552,    15,   554,   555,    -1,    -1,    20,
+      -1,   560,    -1,   413,    -1,    26,    27,    28,    -1,    -1,
+     569,   570,    -1,    -1,   573,    36,    -1,    -1,    -1,    -1,
+      -1,   443,   444,    -1,    -1,    -1,    47,    -1,    -1,    -1,
+     130,   453,    -1,   443,   444,    -1,    57,   137,    -1,    -1,
+      -1,    -1,   142,   453,   152,    -1,   154,   518,   519,    -1,
+      71,   522,   523,   153,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   547,    -1,    -1,    -1,
+     152,   552,   154,   554,   555,    -1,    -1,    -1,    -1,   560,
+      -1,    -1,    -1,    -1,    -1,    -1,   518,   519,   569,   570,
+     522,   523,   573,    -1,    -1,    -1,    -1,    -1,   518,   519,
+      -1,    -1,   522,   523,    -1,    -1,   224,   225,    -1,   227,
+     228,    -1,    -1,    -1,    -1,   547,   226,    -1,    -1,    -1,
+     552,    -1,   554,   555,    -1,    -1,    -1,   547,   560,    -1,
+      -1,    -1,   552,    -1,   554,   555,    -1,   569,   570,    -1,
+     560,   573,   224,   225,    -1,   227,   228,    -1,    -1,   569,
+     570,    -1,   262,   573,     3,    -1,   266,   267,    -1,    -1,
+      -1,   271,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    18,
+      -1,   281,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      29,   291,    -1,    32,    33,    34,    -1,    -1,    37,    38,
+      -1,    -1,    41,    -1,    -1,    -1,    45,    -1,    -1,    48,
+      -1,    -1,    -1,    -1,    -1,    -1,   316,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   336,   337,
+     338,   339,   340,   341,   342,   343,    -1,   345,   346,   347,
+     348,   349,   350,   351,   352,   353,   354,   355,    -1,    -1,
+      -1,    90,    -1,    -1,    -1,    -1,   356,   357,    -1,    -1,
+      -1,    -1,    -1,    -1,   336,   337,   338,   339,   340,   341,
+     342,   343,    -1,   345,   346,   347,   348,   349,   350,   351,
+     352,   353,   354,   355,     5,    -1,     7,    -1,    -1,    10,
+      -1,    -1,    -1,   393,    15,    -1,    -1,    -1,    -1,    20,
+      -1,    -1,    -1,    -1,   404,    26,    -1,    28,    -1,    -1,
+     418,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    47,    -1,    -1,    -1,
+       5,    -1,     7,    -1,    -1,    10,    57,    -1,    -1,    -1,
+      15,   441,   442,    -1,    -1,    20,   418,    -1,    -1,    -1,
+      71,    26,    -1,    28,    -1,    30,   456,    -1,    -1,     3,
+      -1,    36,    -1,    -1,    39,    -1,    -1,    42,    -1,    -1,
+     478,   479,    47,   481,    18,    50,    51,    52,    53,    54,
+      55,    56,    57,    -1,    -1,    29,    61,    -1,    32,    33,
+      34,    -1,    -1,    37,    38,    -1,    71,    41,    -1,    -1,
+      75,    45,    -1,    -1,    48,    -1,   478,   479,    -1,   481,
+     510,    -1,    87,    -1,    89,    -1,    91,    -1,    -1,    -1,
+     520,   521,    97,    67,    99,    -1,    -1,   102,    -1,     3,
+       4,     5,     6,     7,     8,    -1,    10,    -1,    12,    13,
+      14,    15,    -1,   543,    18,    -1,    20,    21,    22,    -1,
+      -1,    -1,    26,   553,    28,    29,    30,    -1,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    67,    68,    -1,    -1,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    89,    -1,    91,    -1,     3,
+       4,     5,     6,     7,    -1,    99,    10,   101,    12,    -1,
+      14,    15,    -1,    -1,    18,    -1,    20,    21,    22,    -1,
+      -1,    -1,    26,    -1,    28,    29,    30,    -1,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    67,    68,    -1,    -1,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    89,    -1,    91,    -1,     3,
+       4,     5,     6,     7,    -1,    99,    10,   101,    12,    -1,
+      14,    15,    -1,    -1,    18,    -1,    20,    21,    22,    -1,
+      -1,    -1,    26,    -1,    28,    29,    30,    -1,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    67,    68,    -1,    -1,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    89,    -1,    91,    -1,     3,
+       4,     5,     6,     7,    -1,    99,    10,   101,    12,    -1,
+      14,    15,    -1,    -1,    18,    -1,    20,    21,    22,    -1,
+      -1,    -1,    26,    -1,    28,    29,    30,    -1,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    67,    68,    -1,    -1,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    89,    -1,    91,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    99,    -1,   101,     3,     4,
+       5,     6,     7,    -1,    -1,    10,    11,    12,    -1,    14,
+      15,    -1,    -1,    18,    -1,    20,    21,    22,    -1,    -1,
+      -1,    26,    -1,    28,    29,    30,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    -1,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    68,    -1,    -1,    71,    -1,    -1,    -1,
+      -1,     4,     5,     6,     7,    -1,    -1,    10,    -1,    12,
+      -1,    14,    15,    -1,    89,    -1,    91,    20,    21,    22,
+      -1,    -1,    -1,    26,    99,    28,   101,    30,    -1,    -1,
+      -1,    -1,    35,    36,    -1,    -1,    39,    40,    41,    42,
+      43,    -1,    -1,    46,    47,    -1,    49,    50,    51,    52,
+      53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    68,    -1,    -1,    71,    -1,
+      -1,    -1,    -1,     4,     5,     6,     7,    -1,    -1,    10,
+      -1,    12,    -1,    14,    15,    -1,    89,    -1,    91,    20,
+      21,    22,    -1,    -1,    -1,    26,    99,    28,   101,    30,
+      -1,    -1,    -1,    -1,    35,    36,    -1,    -1,    39,    40,
+      41,    42,    43,    -1,    -1,    46,    47,    -1,    49,    50,
+      51,    52,    53,    54,    55,    56,    57,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    -1,    -1,
+      71,     5,    -1,     7,    -1,    -1,    10,    -1,    -1,    -1,
+      -1,    15,    -1,    -1,    -1,    -1,    20,    -1,    89,    -1,
+      91,    -1,    26,    -1,    28,    -1,    30,    -1,    99,    -1,
+     101,    -1,    36,    -1,    -1,    39,    -1,    -1,    42,    -1,
+      -1,    -1,    -1,    47,    -1,    -1,    50,    51,    52,    53,
+      54,    55,    56,    57,    -1,     5,    -1,     7,    -1,    -1,
+      10,    -1,    -1,    -1,    68,    15,    -1,    71,    -1,    -1,
+      20,    75,    -1,    -1,    -1,    -1,    26,    -1,    28,    -1,
+      30,    -1,    -1,    87,    -1,    89,    36,    91,    -1,    39,
+      -1,    -1,    42,    97,    -1,    99,    -1,    47,   102,    -1,
+      50,    51,    52,    53,    54,    55,    56,    57,    -1,     5,
+      -1,     7,    -1,    -1,    10,    -1,    -1,    -1,    -1,    15,
+      -1,    71,    -1,    -1,    20,    75,    -1,    -1,    -1,    -1,
+      26,    -1,    28,    -1,    30,    -1,    -1,    87,    -1,    89,
+      36,    91,    -1,    39,    -1,    -1,    42,    97,    -1,    99,
+      -1,    47,   102,    -1,    50,    51,    52,    53,    54,    55,
+      56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,    71,     5,    -1,     7,    75,
+      -1,    10,    -1,    -1,    -1,    -1,    15,    -1,    -1,    18,
+      -1,    20,    -1,    -1,    -1,    91,    -1,    26,    -1,    28,
+      29,    30,    -1,    32,    33,    34,   102,    36,    37,    38,
+      39,    -1,    41,    42,    -1,    -1,    45,    -1,    47,    48,
+      -1,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
+       5,    -1,     7,    -1,    -1,    10,    -1,    -1,    -1,    -1,
+      15,    -1,    71,    -1,    -1,    20,    -1,    -1,    -1,    -1,
+      -1,    26,    -1,    28,    -1,    30,    -1,    -1,    -1,    -1,
+      89,    36,    91,    -1,    39,    -1,    -1,    42,    -1,    -1,
+      99,    -1,    47,    -1,    -1,    50,    51,    52,    53,    54,
+      55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    71,    -1,    -1,    -1,
+       3,    -1,     5,    -1,     7,    -1,    -1,    10,    -1,    -1,
+      -1,    -1,    15,    -1,    89,    18,    91,    20,    -1,    -1,
+      -1,     3,    -1,    26,    99,    28,    29,    -1,    -1,    32,
+      33,    34,    -1,    36,    37,    38,    18,    -1,    41,    -1,
+      -1,    -1,    45,    -1,    47,    48,    -1,    29,    -1,    -1,
+      32,    33,    34,    -1,    57,    37,    38,    -1,    -1,    41,
+      60,    -1,    -1,    45,    64,    -1,    48,    -1,    71,    -1,
+      70,    -1,    -1,    73,    60,    -1,    -1,    -1,    64,    -1,
+      80,    -1,    82,    83,    70,    -1,    -1,    73,    88,    -1,
+      -1,    -1,    -1,    93,    80,    95,    82,    83,    98,    -1,
+      -1,    60,    88,    -1,   104,    64,    -1,    93,    -1,    95,
+      -1,    70,    98,    -1,    73,    -1,    -1,    -1,   104,    -1,
+      -1,    80,    -1,    82,    83,    -1,    -1,    -1,    -1,    88,
+      -1,    -1,    -1,    -1,    93,    -1,    95,    -1,    -1,    98,
+      -1,    -1,    -1,    -1,    -1,   104
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint16 yystos[] =
+{
+       0,    31,   107,   122,   123,   126,     5,     7,    10,    15,
+      20,    26,    28,    36,    47,    57,    71,   111,   117,   118,
+     119,   120,   121,     0,   124,    57,    72,   101,    72,    24,
+     125,   127,   128,   129,    11,    42,   119,    11,   117,     3,
+      18,    29,    32,    33,    34,    37,    38,    41,    45,    48,
+     101,   130,   131,   132,   133,   134,   135,   164,   165,    72,
+     101,   132,    17,    23,    68,   136,   137,   139,    11,    27,
+      17,   166,   167,   103,   113,   114,   117,   113,   115,   138,
+     140,   137,   139,   139,   119,   119,   115,    68,   168,    66,
+     101,    66,    37,    67,   130,   135,   141,   142,   143,   148,
+     149,   158,   159,   139,   169,   115,   115,    68,   177,    47,
+     110,   111,   112,   113,   116,   117,   118,   160,   101,   157,
+     177,    67,   134,   135,   143,   149,   165,   170,   171,   172,
+       4,     6,    12,    14,    21,    22,    30,    35,    39,    40,
+      41,    42,    43,    46,    49,    50,    51,    52,    53,    54,
+      55,    56,    89,    91,    99,   101,   108,   109,   110,   116,
+     117,   119,   131,   134,   135,   177,   178,   179,   180,   181,
+     182,   183,   185,   186,   187,   189,   190,   191,   192,   194,
+     201,   203,   204,   212,   213,   215,   216,   217,   218,   219,
+     224,   225,   226,   230,   235,   236,   237,   238,   239,   240,
+     242,   243,   258,   259,   263,   119,   151,   119,   144,   145,
+     146,   151,    62,   234,   234,    91,    44,   150,   155,   101,
+     101,   101,   173,   101,    75,    87,    91,    97,   102,   111,
+     116,   117,   226,   236,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   261,   119,   214,   214,    41,
+     183,    91,    91,   208,   261,    72,    91,    91,    72,   261,
+     177,    91,   117,   235,   237,   241,   261,   241,   119,   144,
+      72,    62,    72,    91,    65,   110,    67,   180,   101,   101,
+      72,    62,    89,    99,    60,    64,    70,    73,    80,    82,
+      83,    88,    93,    95,    98,   104,   260,   111,   113,   114,
+      91,    62,   150,    66,   101,    62,    73,   150,    61,    62,
+     135,   152,   153,   154,   114,   156,    68,   161,   101,   241,
+     241,   111,   117,   261,   241,   241,    69,    92,   103,    87,
+      97,    79,    81,    86,    25,    77,    78,    84,    85,    74,
+      76,    58,    63,    94,    59,    96,   100,    65,   101,   101,
+     101,    49,   131,   182,   190,   206,   209,   211,   261,   101,
+     119,   261,   261,   119,   101,     9,   220,   221,   222,   261,
+      90,    11,   261,    30,   228,   229,   261,   183,   144,    42,
+     119,   261,   257,    62,   232,   233,   234,   232,   234,    91,
+     152,    61,   145,    61,    68,   147,   174,   261,    61,   110,
+      90,    66,    66,   162,   101,   231,   234,   234,    90,   241,
+     241,   241,   246,   246,   247,   247,   247,   112,   248,   248,
+     248,   248,   249,   249,   250,   251,   252,   253,   254,   261,
+     261,    91,   101,    66,    90,    91,    90,    90,    91,    91,
+      19,   223,   222,    90,    61,    90,    66,    91,    61,   261,
+     231,   233,   234,   174,   231,   174,   228,    90,   147,   175,
+     176,   146,   154,   114,    39,    42,   163,   178,    90,    90,
+     244,    65,   101,   261,   208,   190,    21,    22,    49,   119,
+     183,   184,   185,   188,   193,   202,   207,   228,    68,   195,
+     177,   228,   154,   177,   183,   261,   228,    61,    90,    67,
+      66,    91,    91,    67,   241,   244,   256,    90,   101,    91,
+      91,    91,    65,    16,    90,   197,    90,    90,    90,   139,
+     227,   147,   228,   228,   101,   205,   210,   211,   206,   261,
+     261,   184,   183,     8,    13,   196,   198,   199,   200,   177,
+      90,    90,    90,   101,    90,    90,   261,   262,    65,    67,
+     179,   200,   101,   101,   183,   208,   184,   184,    65,   101,
+      16,   205,   184,    90,   184
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint16 yyr1[] =
+{
+       0,   106,   107,   108,   108,   108,   108,   108,   108,   109,
+     109,   110,   110,   111,   111,   111,   111,   111,   111,   111,
+     111,   112,   112,   113,   114,   115,   116,   116,   117,   117,
+     118,   119,   119,   120,   120,   120,   120,   121,   121,   122,
+     123,   123,   124,   124,   125,   125,   126,   127,   127,   128,
+     129,   130,   130,   130,   131,   131,   132,   132,   132,   132,
+     132,   132,   132,   132,   132,   132,   132,   133,   134,   134,
+     134,   134,   135,   135,   136,   137,   138,   138,   139,   140,
+     140,   141,   141,   141,   141,   142,   142,   143,   144,   144,
+     145,   145,   146,   146,   147,   147,   148,   148,   148,   149,
+     149,   150,   150,   151,   151,   152,   152,   153,   153,   154,
+     155,   156,   156,   157,   158,   159,   159,   160,   161,   162,
+     162,   163,   163,   164,   165,   166,   166,   167,   167,   168,
+     169,   169,   170,   170,   170,   170,   170,   170,   171,   172,
+     173,   173,   174,   175,   175,   175,   176,   176,   177,   178,
+     178,   179,   179,   180,   180,   180,   181,   182,   182,   183,
+     183,   183,   183,   183,   183,   184,   184,   184,   184,   184,
+     185,   185,   185,   185,   185,   185,   185,   185,   185,   185,
+     185,   185,   186,   187,   188,   189,   190,   190,   190,   190,
+     190,   190,   190,   191,   192,   193,   194,   195,   196,   196,
+     197,   197,   198,   199,   199,   200,   200,   201,   202,   203,
+     204,   205,   205,   206,   206,   207,   208,   208,   209,   209,
+     210,   211,   211,   212,   212,   213,   214,   214,   215,   216,
+     217,   218,   219,   219,   220,   220,   221,   221,   222,   223,
+     224,   224,   225,   225,   225,   225,   225,   225,   225,   226,
+     227,   227,   228,   228,   229,   229,   230,   230,   230,   230,
+     231,   231,   232,   232,   233,   234,   234,   235,   235,   235,
+     235,   236,   236,   236,   236,   237,   237,   238,   238,   238,
+     238,   238,   239,   240,   241,   241,   241,   241,   241,   242,
+     243,   244,   244,   244,   244,   245,   245,   245,   246,   246,
+     246,   246,   247,   247,   247,   248,   248,   248,   248,   249,
+     249,   249,   249,   249,   249,   250,   250,   250,   251,   251,
+     252,   252,   253,   253,   254,   254,   255,   255,   256,   256,
+     257,   257,   258,   259,   259,   259,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   261,   262,
+     263,   263
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     2,     2,     1,     1,
+       1,     1,     2,     3,     3,     3,     3,     1,     1,     3,
+       0,     1,     0,     2,     0,     2,     3,     1,     1,     3,
+       5,     1,     1,     1,     1,     2,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     3,     2,     3,
+       3,     4,     0,     1,     2,     2,     1,     3,     3,     0,
+       2,     1,     1,     1,     1,     1,     1,     4,     1,     3,
+       1,     3,     1,     3,     1,     1,     2,     2,     3,     4,
+       4,     0,     1,     4,     3,     0,     1,     1,     3,     3,
+       2,     1,     3,     1,     2,     4,     5,     4,     4,     0,
+       2,     5,     5,     3,     3,     0,     1,     2,     3,     3,
+       0,     2,     1,     1,     1,     2,     1,     2,     1,     2,
+       1,     2,     3,     0,     1,     2,     1,     3,     3,     0,
+       1,     1,     2,     1,     1,     1,     2,     3,     2,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     3,     3,     2,     1,     1,     1,     1,
+       1,     1,     1,     5,     7,     7,     5,     4,     0,     1,
+       0,     2,     2,     1,     2,     3,     2,     5,     5,     7,
+       9,     0,     1,     0,     1,     9,     0,     1,     1,     1,
+       1,     1,     3,     3,     5,     3,     0,     1,     3,     3,
+       3,     5,     3,     4,     0,     1,     1,     2,     5,     2,
+       1,     1,     1,     1,     3,     1,     1,     1,     1,     6,
+       0,     1,     0,     1,     1,     3,     4,     4,     4,     4,
+       0,     1,     1,     2,     3,     2,     3,     3,     3,     3,
+       3,     4,     6,     6,     6,     4,     4,     1,     1,     3,
+       1,     1,     2,     2,     1,     1,     2,     2,     1,     2,
+       2,     1,     2,     2,     1,     5,     4,     5,     1,     3,
+       3,     3,     1,     3,     3,     1,     3,     3,     3,     1,
+       3,     3,     3,     3,     3,     1,     3,     3,     1,     3,
+       1,     3,     1,     3,     1,     3,     1,     3,     1,     5,
+       1,     1,     3,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     3
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (yyscanner, YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value, yyscanner); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  YYUSE (yyscanner);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              , yyscanner);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, yyscan_t yyscanner)
+{
+  YYUSE (yyvaluep);
+  YYUSE (yyscanner);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (yyscan_t yyscanner)
+{
+/* The lookahead symbol.  */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol.  */
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex (&yylval, yyscanner);
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 180 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2293 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 3:
+#line 189 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2304 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 4:
+#line 197 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2315 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 5:
+#line 205 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2326 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 6:
+#line 213 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2337 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 7:
+#line 221 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2348 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 229 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2359 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 238 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2370 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 246 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2381 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 11:
+#line 255 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2392 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 12:
+#line 263 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2403 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 13:
+#line 272 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2411 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 14:
+#line 277 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2419 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 15:
+#line 282 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2427 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 16:
+#line 287 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2435 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 17:
+#line 292 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2443 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 18:
+#line 297 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2451 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 19:
+#line 302 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2459 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 20:
+#line 307 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+}
+#line 2467 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 21:
+#line 313 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2478 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 22:
+#line 321 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2489 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 23:
+#line 330 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpStoreClass((yyvsp[0].str));
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2501 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 24:
+#line 340 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2512 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 25:
+#line 349 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2523 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 26:
+#line 358 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2534 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 27:
+#line 366 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpStoreClass((yyvsp[-1].str));
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2546 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 28:
+#line 376 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = (yyvsp[0].str);
+}
+#line 2555 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 29:
+#line 382 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = (yyvsp[0].str);
+}
+#line 2564 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 30:
+#line 389 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = (yyvsp[0].str);
+}
+#line 2573 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 31:
+#line 396 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = (yyvsp[0].str);
+}
+#line 2582 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 32:
+#line 402 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  (yyval.str) = (yyvsp[0].str);
+}
+#line 2591 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 33:
+#line 409 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->AddClassFound((yyvsp[-2].str));
+  yyGetParser->UpdateCombine((yyvsp[-2].str), (yyvsp[0].str));
+  yyGetParser->DeallocateParserType(&((yyvsp[-2].str)));
+  (yyval.str) = const_cast<char*>(yyGetParser->GetCurrentCombine());
+}
+#line 2603 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 34:
+#line 418 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpStoreClass((yyvsp[-2].str));
+  jpCheckEmpty(3);
+  yyGetParser->SetCurrentCombine("");
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2616 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 35:
+#line 428 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpStoreClass((yyvsp[-2].str));
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2629 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 36:
+#line 438 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2640 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 37:
+#line 447 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2651 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 38:
+#line 455 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2662 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 39:
+#line 464 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2673 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 40:
+#line 472 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2683 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 41:
+#line 479 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2694 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 42:
+#line 487 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2704 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 43:
+#line 494 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2715 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 44:
+#line 502 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2725 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 45:
+#line 509 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2736 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 46:
+#line 518 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->SetCurrentPackage((yyvsp[-1].str));
+  yyGetParser->DeallocateParserType(&((yyvsp[-1].str)));
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2750 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 47:
+#line 530 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2761 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 48:
+#line 538 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2772 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 49:
+#line 547 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->AddPackagesImport((yyvsp[-1].str));
+  yyGetParser->DeallocateParserType(&((yyvsp[-1].str)));
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2786 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 50:
+#line 559 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  std::string str = (yyvsp[-3].str);
+  str += ".*";
+  yyGetParser->AddPackagesImport(str.c_str());
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  yyGetParser->SetCurrentCombine("");
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2801 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 51:
+#line 572 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2812 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 52:
+#line 580 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2823 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 53:
+#line 588 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2834 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 54:
+#line 597 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2845 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 55:
+#line 605 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2856 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 67:
+#line 620 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  yyGetParser->StartClass((yyvsp[0].str));
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+}
+#line 2867 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 68:
+#line 630 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+#line 2879 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 69:
+#line 639 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+#line 2891 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 70:
+#line 648 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+#line 2903 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 71:
+#line 657 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+#line 2915 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 72:
+#line 666 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2925 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 73:
+#line 673 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2936 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 74:
+#line 682 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2947 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 75:
+#line 691 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2958 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 76:
+#line 700 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2969 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 77:
+#line 708 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2980 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 78:
+#line 717 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 2991 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 79:
+#line 725 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3001 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 80:
+#line 732 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3012 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 81:
+#line 741 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3023 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 82:
+#line 749 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3034 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 83:
+#line 757 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3045 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 84:
+#line 765 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3056 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 85:
+#line 774 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3067 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 86:
+#line 782 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3078 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 87:
+#line 791 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+}
+#line 3086 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 88:
+#line 797 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3097 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 89:
+#line 805 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3108 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 90:
+#line 814 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3119 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 91:
+#line 822 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3130 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 92:
+#line 831 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3142 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 93:
+#line 840 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3153 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 94:
+#line 849 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3164 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 95:
+#line 857 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3175 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 96:
+#line 866 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3186 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 97:
+#line 874 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3197 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 98:
+#line 882 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3208 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 99:
+#line 891 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3220 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 100:
+#line 900 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3232 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 101:
+#line 909 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3243 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 102:
+#line 917 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3255 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 103:
+#line 927 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3268 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 104:
+#line 937 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+
+}
+#line 3277 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 105:
+#line 943 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3288 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 107:
+#line 954 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+
+}
+#line 3297 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 108:
+#line 960 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3309 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 109:
+#line 970 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3321 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 110:
+#line 980 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3333 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 111:
+#line 990 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+
+}
+#line 3342 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 112:
+#line 996 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3354 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 113:
+#line 1006 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3366 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 114:
+#line 1016 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3378 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 115:
+#line 1026 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3390 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 116:
+#line 1035 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3402 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 117:
+#line 1045 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3415 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 118:
+#line 1056 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3427 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 119:
+#line 1065 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3438 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 120:
+#line 1073 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3450 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 121:
+#line 1083 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3462 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 122:
+#line 1092 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3474 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 123:
+#line 1102 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  yyGetParser->StartClass((yyvsp[0].str));
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+}
+#line 3485 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 124:
+#line 1111 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+#line 3497 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 125:
+#line 1120 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+#line 3507 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 126:
+#line 1127 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3519 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 127:
+#line 1137 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3531 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 128:
+#line 1146 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3543 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 129:
+#line 1156 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3555 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 130:
+#line 1165 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3566 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 131:
+#line 1173 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3577 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 132:
+#line 1182 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3589 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 133:
+#line 1191 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3601 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 134:
+#line 1200 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3613 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 135:
+#line 1209 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3624 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 136:
+#line 1217 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3636 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 137:
+#line 1226 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3647 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 138:
+#line 1235 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3659 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 139:
+#line 1245 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3671 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 140:
+#line 1255 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3683 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 141:
+#line 1264 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3695 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 142:
+#line 1274 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3707 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 143:
+#line 1283 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3718 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 144:
+#line 1291 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3730 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 145:
+#line 1300 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3742 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 146:
+#line 1310 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3754 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 147:
+#line 1319 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3766 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 148:
+#line 1329 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3777 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 149:
+#line 1337 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3788 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 150:
+#line 1345 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3800 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 151:
+#line 1355 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3812 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 152:
+#line 1364 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3824 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 153:
+#line 1374 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3836 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 154:
+#line 1383 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3848 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 155:
+#line 1392 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3860 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 156:
+#line 1402 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3872 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 157:
+#line 1412 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3884 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 158:
+#line 1421 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3896 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 159:
+#line 1431 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3908 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 160:
+#line 1440 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3920 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 161:
+#line 1449 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3932 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 162:
+#line 1458 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3944 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 163:
+#line 1467 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3956 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 164:
+#line 1476 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3968 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 165:
+#line 1486 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3980 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 166:
+#line 1495 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 3992 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 167:
+#line 1504 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4004 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 168:
+#line 1513 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4016 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 169:
+#line 1522 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4028 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 170:
+#line 1532 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4040 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 171:
+#line 1541 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4052 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 172:
+#line 1550 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4064 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 173:
+#line 1559 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4076 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 174:
+#line 1568 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4088 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 175:
+#line 1577 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4100 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 176:
+#line 1586 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4112 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 177:
+#line 1595 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4124 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 178:
+#line 1604 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4136 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 179:
+#line 1613 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4148 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 180:
+#line 1622 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4160 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 181:
+#line 1631 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4172 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 182:
+#line 1641 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4184 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 183:
+#line 1651 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[-2].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4197 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 184:
+#line 1662 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4209 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 185:
+#line 1672 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4221 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 186:
+#line 1682 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4233 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 187:
+#line 1691 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4245 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 188:
+#line 1700 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4257 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 189:
+#line 1709 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4269 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 190:
+#line 1718 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4281 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 191:
+#line 1727 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4293 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 192:
+#line 1736 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4305 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 193:
+#line 1746 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4317 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 194:
+#line 1756 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(7);
+  jpCheckEmpty(7);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4329 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 195:
+#line 1766 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(7);
+  jpCheckEmpty(7);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4341 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 196:
+#line 1776 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+
+}
+#line 4350 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 197:
+#line 1783 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+
+}
+#line 4359 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 198:
+#line 1789 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4370 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 199:
+#line 1797 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4382 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 200:
+#line 1806 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4393 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 201:
+#line 1814 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4405 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 202:
+#line 1824 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4417 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 203:
+#line 1834 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4429 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 204:
+#line 1843 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4441 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 205:
+#line 1853 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4453 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 206:
+#line 1862 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4465 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 207:
+#line 1872 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+
+}
+#line 4474 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 208:
+#line 1879 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+
+}
+#line 4483 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 209:
+#line 1886 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(7);
+
+}
+#line 4492 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 210:
+#line 1894 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(9);
+
+}
+#line 4501 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 211:
+#line 1900 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4512 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 212:
+#line 1908 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4524 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 213:
+#line 1917 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4535 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 214:
+#line 1925 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4547 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 215:
+#line 1936 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(9);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4558 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 216:
+#line 1944 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4569 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 217:
+#line 1952 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4581 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 218:
+#line 1962 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4593 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 219:
+#line 1971 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4605 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 220:
+#line 1981 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4617 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 221:
+#line 1991 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4629 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 222:
+#line 2000 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4641 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 223:
+#line 2010 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4653 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 224:
+#line 2019 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4665 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 225:
+#line 2029 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[-1].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4678 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 226:
+#line 2039 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4689 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 227:
+#line 2047 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+
+}
+#line 4698 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 228:
+#line 2054 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[-1].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4711 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 229:
+#line 2065 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4723 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 230:
+#line 2075 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4735 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 231:
+#line 2085 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4747 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 232:
+#line 2095 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4759 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 233:
+#line 2104 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4771 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 234:
+#line 2113 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4782 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 235:
+#line 2121 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4794 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 236:
+#line 2131 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4806 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 237:
+#line 2140 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4818 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 238:
+#line 2150 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+
+}
+#line 4827 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 239:
+#line 2157 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4839 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 240:
+#line 2167 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4851 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 241:
+#line 2176 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4863 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 242:
+#line 2186 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4875 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 243:
+#line 2195 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+
+}
+#line 4884 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 244:
+#line 2201 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4896 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 245:
+#line 2210 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4908 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 246:
+#line 2219 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4920 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 247:
+#line 2228 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4932 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 248:
+#line 2237 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4944 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 249:
+#line 2247 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(6);
+  jpCheckEmpty(6);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4956 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 250:
+#line 2256 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4967 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 251:
+#line 2264 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4979 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 252:
+#line 2273 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 4990 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 253:
+#line 2281 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5002 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 254:
+#line 2291 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5014 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 255:
+#line 2300 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5026 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 256:
+#line 2310 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5038 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 257:
+#line 2319 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5050 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 258:
+#line 2328 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5062 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 259:
+#line 2337 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5074 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 260:
+#line 2346 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(0);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5085 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 261:
+#line 2354 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5097 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 262:
+#line 2364 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5109 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 263:
+#line 2373 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5121 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 264:
+#line 2383 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5133 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 265:
+#line 2393 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+
+}
+#line 5142 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 266:
+#line 2399 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+
+}
+#line 5151 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 267:
+#line 2406 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5164 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 268:
+#line 2416 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5177 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 269:
+#line 2426 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5190 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 270:
+#line 2436 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5203 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 271:
+#line 2447 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5216 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 272:
+#line 2457 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&((yyvsp[-5].str)));
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(6);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5230 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 273:
+#line 2468 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(6);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5243 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 274:
+#line 2478 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(6);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5256 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 275:
+#line 2489 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&((yyvsp[-3].str)));
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5269 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 276:
+#line 2499 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5281 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 277:
+#line 2509 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5293 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 278:
+#line 2518 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5305 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 279:
+#line 2527 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5317 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 280:
+#line 2536 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5329 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 281:
+#line 2545 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5341 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 282:
+#line 2555 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5353 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 283:
+#line 2565 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5365 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 284:
+#line 2575 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5377 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 285:
+#line 2584 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5389 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 286:
+#line 2593 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5401 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 287:
+#line 2602 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5413 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 288:
+#line 2611 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5425 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 289:
+#line 2621 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5437 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 290:
+#line 2631 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5449 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 291:
+#line 2641 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5461 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 292:
+#line 2650 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5473 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 293:
+#line 2659 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5485 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 294:
+#line 2668 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5497 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 295:
+#line 2678 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5509 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 296:
+#line 2687 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5521 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 297:
+#line 2696 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+
+}
+#line 5530 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 298:
+#line 2703 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5542 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 299:
+#line 2712 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5554 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 300:
+#line 2721 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5566 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 301:
+#line 2730 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5578 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 302:
+#line 2740 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5590 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 303:
+#line 2749 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5602 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 304:
+#line 2758 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5614 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 305:
+#line 2768 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5626 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 306:
+#line 2777 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5638 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 307:
+#line 2786 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5650 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 308:
+#line 2795 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5662 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 309:
+#line 2805 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5674 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 310:
+#line 2814 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5686 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 311:
+#line 2823 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5698 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 312:
+#line 2832 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5710 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 313:
+#line 2841 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5722 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 314:
+#line 2850 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5734 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 315:
+#line 2860 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5746 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 316:
+#line 2869 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5758 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 317:
+#line 2878 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5770 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 318:
+#line 2888 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5782 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 319:
+#line 2897 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5794 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 320:
+#line 2907 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5806 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 321:
+#line 2916 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5818 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 322:
+#line 2926 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5830 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 323:
+#line 2935 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5842 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 324:
+#line 2945 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5854 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 325:
+#line 2954 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5866 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 326:
+#line 2964 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5878 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 327:
+#line 2973 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5890 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 328:
+#line 2983 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5902 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 329:
+#line 2992 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5914 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 330:
+#line 3002 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5926 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 331:
+#line 3011 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5938 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 332:
+#line 3021 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5950 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 333:
+#line 3031 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&((yyvsp[0].str)));
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5963 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 334:
+#line 3041 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5975 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 335:
+#line 3050 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5987 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 336:
+#line 3060 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 5999 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 337:
+#line 3069 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6011 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 338:
+#line 3078 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6023 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 339:
+#line 3087 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6035 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 340:
+#line 3096 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6047 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 341:
+#line 3105 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6059 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 342:
+#line 3114 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6071 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 343:
+#line 3123 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6083 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 344:
+#line 3132 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6095 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 345:
+#line 3141 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6107 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 346:
+#line 3150 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6119 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 347:
+#line 3159 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6131 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 348:
+#line 3169 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6143 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 349:
+#line 3179 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6155 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 350:
+#line 3189 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6167 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 351:
+#line 3198 "cmDependsJavaParser.y" /* yacc.c:1646  */
+    {
+  jpElementStart(3);
+  jpStoreClass((yyvsp[-2].str));
+  jpCheckEmpty(3);
+  (yyval.str) = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+#line 6180 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+    break;
+
+
+#line 6184 "cmDependsJavaParser.cxx" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (yyscanner, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yyscanner, yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, yyscanner);
+          yychar = YYEMPTY;
+        }
+    }
+
+#if 0
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+#endif
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (yyscanner, YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, yyscanner);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 3207 "cmDependsJavaParser.y" /* yacc.c:1906  */
+
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message)
+{
+  yyGetParser->Error(message);
+}
diff --git a/Source/LexerParser/cmDependsJavaParser.y b/Source/LexerParser/cmDependsJavaParser.y
new file mode 100644
index 0000000..f7eb228
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaParser.y
@@ -0,0 +1,3214 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmDependsJava_yy --defines=cmDependsJavaParserTokens.h -ocmDependsJavaParser.cxx cmDependsJavaParser.y
+
+Modify cmDependsJavaParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+
+#define yyGetParser (cmDependsJava_yyget_extra(yyscanner))
+
+/*-------------------------------------------------------------------------*/
+#include "cmDependsJavaParserHelper.h" /* Interface to parser object.  */
+#include "cmDependsJavaLexer.h"  /* Interface to lexer object.  */
+#include "cmDependsJavaParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message);
+
+#define YYMAXDEPTH 1000000
+
+
+#define jpCheckEmpty(cnt) yyGetParser->CheckEmpty(__LINE__, cnt, yyvsp);
+#define jpElementStart(cnt) yyGetParser->PrepareElement(&yyval)
+#define jpStoreClass(str) yyGetParser->AddClassFound(str); yyGetParser->DeallocateParserType(&(str))
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no case. */
+#endif
+%}
+
+/* Generate a reentrant parser object.  */
+%define api.pure
+
+/* Configure the parser to use a lexer object.  */
+%lex-param   {yyscan_t yyscanner}
+%parse-param {yyscan_t yyscanner}
+
+%define parse.error verbose
+
+/*
+%union {
+  char* string;
+}
+*/
+
+/*-------------------------------------------------------------------------*/
+/* Tokens */
+%token jp_ABSTRACT
+%token jp_ASSERT
+%token jp_BOOLEAN_TYPE
+%token jp_BREAK
+%token jp_BYTE_TYPE
+%token jp_CASE
+%token jp_CATCH
+%token jp_CHAR_TYPE
+%token jp_CLASS
+%token jp_CONTINUE
+%token jp_DEFAULT
+%token jp_DO
+%token jp_DOUBLE_TYPE
+%token jp_ELSE
+%token jp_EXTENDS
+%token jp_FINAL
+%token jp_FINALLY
+%token jp_FLOAT_TYPE
+%token jp_FOR
+%token jp_IF
+%token jp_IMPLEMENTS
+%token jp_IMPORT
+%token jp_INSTANCEOF
+%token jp_INT_TYPE
+%token jp_INTERFACE
+%token jp_LONG_TYPE
+%token jp_NATIVE
+%token jp_NEW
+%token jp_PACKAGE
+%token jp_PRIVATE
+%token jp_PROTECTED
+%token jp_PUBLIC
+%token jp_RETURN
+%token jp_SHORT_TYPE
+%token jp_STATIC
+%token jp_STRICTFP
+%token jp_SUPER
+%token jp_SWITCH
+%token jp_SYNCHRONIZED
+%token jp_THIS
+%token jp_THROW
+%token jp_THROWS
+%token jp_TRANSIENT
+%token jp_TRY
+%token jp_VOID
+%token jp_VOLATILE
+%token jp_WHILE
+
+%token jp_BOOLEANLITERAL
+%token jp_CHARACTERLITERAL
+%token jp_DECIMALINTEGERLITERAL
+%token jp_FLOATINGPOINTLITERAL
+%token jp_HEXINTEGERLITERAL
+%token jp_NULLLITERAL
+%token jp_STRINGLITERAL
+
+%token jp_NAME
+
+%token jp_AND
+%token jp_ANDAND
+%token jp_ANDEQUALS
+%token jp_BRACKETEND
+%token jp_BRACKETSTART
+%token jp_CARROT
+%token jp_CARROTEQUALS
+%token jp_COLON
+%token jp_COMMA
+%token jp_CURLYEND
+%token jp_CURLYSTART
+%token jp_DIVIDE
+%token jp_DIVIDEEQUALS
+%token jp_DOLLAR
+%token jp_DOT
+%token jp_EQUALS
+%token jp_EQUALSEQUALS
+%token jp_EXCLAMATION
+%token jp_EXCLAMATIONEQUALS
+%token jp_GREATER
+%token jp_GTEQUALS
+%token jp_GTGT
+%token jp_GTGTEQUALS
+%token jp_GTGTGT
+%token jp_GTGTGTEQUALS
+%token jp_LESLESEQUALS
+%token jp_LESSTHAN
+%token jp_LTEQUALS
+%token jp_LTLT
+%token jp_MINUS
+%token jp_MINUSEQUALS
+%token jp_MINUSMINUS
+%token jp_PAREEND
+%token jp_PARESTART
+%token jp_PERCENT
+%token jp_PERCENTEQUALS
+%token jp_PIPE
+%token jp_PIPEEQUALS
+%token jp_PIPEPIPE
+%token jp_PLUS
+%token jp_PLUSEQUALS
+%token jp_PLUSPLUS
+%token jp_QUESTION
+%token jp_SEMICOL
+%token jp_TILDE
+%token jp_TIMES
+%token jp_TIMESEQUALS
+
+%token jp_ERROR
+
+/*-------------------------------------------------------------------------*/
+/* grammar */
+%%
+
+Goal:
+CompilationUnit
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Literal:
+IntegerLiteral
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_FLOATINGPOINTLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_BOOLEANLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_CHARACTERLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_STRINGLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_NULLLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+IntegerLiteral:
+jp_DECIMALINTEGERLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_HEXINTEGERLITERAL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Type:
+PrimitiveType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ReferenceType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+PrimitiveType:
+jp_BYTE_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_SHORT_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_INT_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_LONG_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_CHAR_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_FLOAT_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_DOUBLE_TYPE
+{
+  jpElementStart(0);
+}
+|
+jp_BOOLEAN_TYPE
+{
+  jpElementStart(0);
+}
+
+ReferenceType:
+ClassOrInterfaceType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ArrayType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassOrInterfaceType:
+Name
+{
+  jpElementStart(1);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassType:
+ClassOrInterfaceType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+InterfaceType:
+ClassOrInterfaceType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ArrayType:
+PrimitiveType Dims
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+Name Dims
+{
+  jpElementStart(2);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Name:
+SimpleName
+{
+  jpElementStart(1);
+  $<str>$ = $<str>1;
+}
+|
+QualifiedName
+{
+  jpElementStart(1);
+  $<str>$ = $<str>1;
+}
+
+SimpleName:
+Identifier
+{
+  jpElementStart(1);
+  $<str>$ = $<str>1;
+}
+
+Identifier:
+jp_NAME
+{
+  jpElementStart(1);
+  $<str>$ = $<str>1;
+}
+|
+jp_DOLLAR jp_NAME
+{
+  jpElementStart(2);
+  $<str>$ = $<str>2;
+}
+
+QualifiedName:
+Name jp_DOT Identifier
+{
+  jpElementStart(3);
+  yyGetParser->AddClassFound($<str>1);
+  yyGetParser->UpdateCombine($<str>1, $<str>3);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  $<str>$ = const_cast<char*>(yyGetParser->GetCurrentCombine());
+}
+|
+Name jp_DOT jp_CLASS
+{
+  jpElementStart(3);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(3);
+  yyGetParser->SetCurrentCombine("");
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+Name jp_DOT jp_THIS
+{
+  jpElementStart(3);
+  jpStoreClass($<str>1);
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+SimpleType jp_DOT jp_CLASS
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+SimpleType:
+PrimitiveType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_VOID
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+CompilationUnit:
+PackageDeclarationopt ImportDeclarations TypeDeclarations
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+PackageDeclarationopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+PackageDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ImportDeclarations:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ImportDeclarations ImportDeclaration
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+TypeDeclarations:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+TypeDeclarations TypeDeclaration
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+PackageDeclaration:
+jp_PACKAGE Name jp_SEMICOL
+{
+  jpElementStart(3);
+  yyGetParser->SetCurrentPackage($<str>2);
+  yyGetParser->DeallocateParserType(&($<str>2));
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ImportDeclaration:
+SingleTypeImportDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+TypeImportOnDemandDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+SingleTypeImportDeclaration:
+jp_IMPORT Name jp_SEMICOL
+{
+  jpElementStart(3);
+  yyGetParser->AddPackagesImport($<str>2);
+  yyGetParser->DeallocateParserType(&($<str>2));
+  yyGetParser->SetCurrentCombine("");
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+TypeImportOnDemandDeclaration:
+jp_IMPORT Name jp_DOT jp_TIMES jp_SEMICOL
+{
+  jpElementStart(5);
+  std::string str = $<str>2;
+  str += ".*";
+  yyGetParser->AddPackagesImport(str.c_str());
+  yyGetParser->DeallocateParserType(&($<str>2));
+  yyGetParser->SetCurrentCombine("");
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+TypeDeclaration:
+ClassDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+InterfaceDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+jp_SEMICOL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Modifiers:
+Modifier
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+Modifiers Modifier
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Modifier:
+jp_PUBLIC | jp_PROTECTED | jp_PRIVATE |
+jp_STATIC |
+jp_ABSTRACT | jp_FINAL | jp_NATIVE | jp_SYNCHRONIZED | jp_TRANSIENT | jp_VOLATILE |
+jp_STRICTFP
+
+ClassHeader:
+Modifiersopt jp_CLASS Identifier
+{
+  yyGetParser->StartClass($<str>3);
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+}
+
+
+ClassDeclaration:
+ClassHeader ClassBody
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+|
+ClassHeader Interfaces ClassBody
+{
+  jpElementStart(3);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+|
+ClassHeader Super ClassBody
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+|
+ClassHeader Super Interfaces ClassBody
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+
+Modifiersopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+Modifiers
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Super:
+jp_EXTENDS ClassType
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+Interfaces:
+jp_IMPLEMENTS InterfaceTypeList
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+InterfaceTypeList:
+InterfaceType
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+InterfaceTypeList jp_COMMA InterfaceType
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassBody:
+jp_CURLYSTART ClassBodyDeclarations jp_CURLYEND
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassBodyDeclarations:
+{
+  jpElementStart(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ClassBodyDeclarations ClassBodyDeclaration
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassBodyDeclaration:
+ClassMemberDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+StaticInitializer
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ConstructorDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+TypeDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+ClassMemberDeclaration:
+FieldDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+MethodDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+FieldDeclaration:
+Modifiersopt Type VariableDeclarators jp_SEMICOL
+{
+  jpElementStart(4);
+}
+
+VariableDeclarators:
+VariableDeclarator
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+VariableDeclarators jp_COMMA VariableDeclarator
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+VariableDeclarator:
+VariableDeclaratorId
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+VariableDeclaratorId jp_EQUALS VariableInitializer
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+VariableDeclaratorId:
+Identifier
+{
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+VariableDeclaratorId jp_BRACKETSTART jp_BRACKETEND
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+VariableInitializer:
+Expression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ArrayInitializer
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+MethodDeclaration:
+MethodHeader jp_SEMICOL
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+MethodHeader MethodBody
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+MethodHeader MethodBody jp_SEMICOL
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+
+MethodHeader:
+Modifiersopt Type MethodDeclarator Throwsopt
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Modifiersopt jp_VOID MethodDeclarator Throwsopt
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Throwsopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Throws
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+MethodDeclarator:
+Identifier jp_PARESTART FormalParameterListopt jp_PAREEND
+{
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MethodDeclarator jp_BRACKETSTART jp_BRACKETEND
+{
+  jpElementStart(3);
+
+}
+
+FormalParameterListopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+FormalParameterList
+
+FormalParameterList:
+FormalParameter
+{
+  jpElementStart(1);
+
+}
+|
+FormalParameterList jp_COMMA FormalParameter
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+FormalParameter:
+Modifiersopt Type VariableDeclaratorId
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Throws:
+jp_THROWS ClassTypeList
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ClassTypeList:
+ClassType
+{
+  jpElementStart(1);
+
+}
+|
+ClassTypeList jp_COMMA ClassType
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+MethodBody:
+Block
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+StaticInitializer:
+jp_STATIC Block
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConstructorDeclaration:
+Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Modifiersopt ConstructorDeclarator Throwsopt ConstructorBody jp_SEMICOL
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConstructorDeclarator:
+SimpleName jp_PARESTART FormalParameterListopt jp_PAREEND
+{
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConstructorBody:
+jp_CURLYSTART ExplicitConstructorInvocationopt BlockStatementsopt jp_CURLYEND
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ExplicitConstructorInvocationopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ExplicitConstructorInvocationopt ExplicitConstructorInvocation
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ExplicitConstructorInvocation:
+jp_THIS jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_SUPER jp_PARESTART ArgumentListopt jp_PAREEND jp_SEMICOL
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+InterfaceHeader:
+Modifiersopt jp_INTERFACE Identifier
+{
+  yyGetParser->StartClass($<str>3);
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+}
+
+InterfaceDeclaration:
+InterfaceHeader ExtendsInterfacesopt InterfaceBody
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+  yyGetParser->EndClass();
+}
+
+ExtendsInterfacesopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+}
+|
+ExtendsInterfaces
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ExtendsInterfaces:
+jp_EXTENDS InterfaceType
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ExtendsInterfaces jp_COMMA InterfaceType
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+InterfaceBody:
+jp_CURLYSTART InterfaceMemberDeclarations jp_CURLYEND
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+InterfaceMemberDeclarations:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+InterfaceMemberDeclarations InterfaceMemberDeclaration
+{
+  jpElementStart(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+InterfaceMemberDeclaration:
+ConstantDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+AbstractMethodDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassDeclaration jp_SEMICOL
+{
+  jpElementStart(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+InterfaceDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+InterfaceDeclaration jp_SEMICOL
+{
+  jpElementStart(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConstantDeclaration:
+FieldDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AbstractMethodDeclaration:
+MethodHeader Semicols
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Semicols:
+jp_SEMICOL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Semicols jp_SEMICOL
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ArrayInitializer:
+jp_CURLYSTART VariableInitializersOptional jp_CURLYEND
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+VariableInitializersOptional:
+{
+  jpElementStart(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+VariableInitializers
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+VariableInitializers jp_COMMA
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+VariableInitializers:
+VariableInitializer
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+VariableInitializers jp_COMMA VariableInitializer
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Block:
+jp_CURLYSTART BlockStatementsopt jp_CURLYEND
+{
+  jpElementStart(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+BlockStatementsopt:
+{
+  jpElementStart(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+BlockStatements
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+BlockStatements:
+BlockStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+BlockStatements BlockStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+BlockStatement:
+LocalVariableDeclarationStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Statement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+LocalVariableDeclarationStatement:
+LocalVariableDeclaration jp_SEMICOL
+{
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+LocalVariableDeclaration:
+Modifiers Type VariableDeclarators
+{
+  jpElementStart(1);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Type VariableDeclarators
+{
+  jpElementStart(1);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Statement:
+StatementWithoutTrailingSubstatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+LabeledStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+IfThenStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+IfThenElseStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+WhileStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ForStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+StatementNoShortIf:
+StatementWithoutTrailingSubstatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+LabeledStatementNoShortIf
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+IfThenElseStatementNoShortIf
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+WhileStatementNoShortIf
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ForStatementNoShortIf
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+StatementWithoutTrailingSubstatement:
+Block
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+EmptyStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ExpressionStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+SwitchStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+DoStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+BreakStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ContinueStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ReturnStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+SynchronizedStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ThrowStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+TryStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+AssertStatement
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+EmptyStatement:
+jp_SEMICOL
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+LabeledStatement:
+Identifier jp_COLON Statement
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+LabeledStatementNoShortIf:
+Identifier jp_COLON StatementNoShortIf
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ExpressionStatement:
+StatementExpression jp_SEMICOL
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+StatementExpression:
+Assignment
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PreIncrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PreDecrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PostIncrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PostDecrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MethodInvocation
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassInstanceCreationExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+IfThenStatement:
+jp_IF jp_PARESTART Expression jp_PAREEND Statement
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+IfThenElseStatement:
+jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE Statement
+{
+  jpElementStart(7);
+  jpCheckEmpty(7);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+IfThenElseStatementNoShortIf:
+jp_IF jp_PARESTART Expression jp_PAREEND StatementNoShortIf jp_ELSE StatementNoShortIf
+{
+  jpElementStart(7);
+  jpCheckEmpty(7);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SwitchStatement:
+jp_SWITCH jp_PARESTART Expression jp_PAREEND SwitchBlock
+{
+  jpElementStart(5);
+
+}
+
+SwitchBlock:
+jp_CURLYSTART SwitchBlockStatementGroups SwitchLabelsopt jp_CURLYEND
+{
+  jpElementStart(4);
+
+}
+
+SwitchLabelsopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+SwitchLabels
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SwitchBlockStatementGroups:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+SwitchBlockStatementGroups SwitchBlockStatementGroup
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SwitchBlockStatementGroup:
+SwitchLabels BlockStatements
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SwitchLabels:
+SwitchLabel
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+SwitchLabels SwitchLabel
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SwitchLabel:
+jp_CASE ConstantExpression jp_COLON
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_DEFAULT jp_COLON
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+WhileStatement:
+jp_WHILE jp_PARESTART Expression jp_PAREEND Statement
+{
+  jpElementStart(5);
+
+}
+
+WhileStatementNoShortIf:
+jp_WHILE jp_PARESTART Expression jp_PAREEND StatementNoShortIf
+{
+  jpElementStart(5);
+
+}
+
+DoStatement:
+jp_DO Statement jp_WHILE jp_PARESTART Expression jp_PAREEND jp_SEMICOL
+{
+  jpElementStart(7);
+
+}
+
+ForStatement:
+jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
+Statement
+{
+  jpElementStart(9);
+
+}
+
+ForUpdateopt:
+{
+  jpElementStart(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ForUpdate
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ForInitopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ForInit
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ForStatementNoShortIf:
+jp_FOR jp_PARESTART ForInitopt jp_SEMICOL Expressionopt jp_SEMICOL ForUpdateopt jp_PAREEND
+StatementNoShortIf
+{
+  jpElementStart(9);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Expressionopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Expression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ForInit:
+StatementExpressionList
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+LocalVariableDeclaration
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ForUpdate:
+StatementExpressionList
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+StatementExpressionList:
+StatementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+StatementExpressionList jp_COMMA StatementExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AssertStatement:
+jp_ASSERT Expression jp_SEMICOL
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_ASSERT Expression jp_COLON Expression jp_SEMICOL
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+BreakStatement:
+jp_BREAK Identifieropt jp_SEMICOL
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>2));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Identifieropt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Identifier
+{
+  jpElementStart(1);
+
+}
+
+ContinueStatement:
+jp_CONTINUE Identifieropt jp_SEMICOL
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>2));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ReturnStatement:
+jp_RETURN Expressionopt jp_SEMICOL
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ThrowStatement:
+jp_THROW Expression jp_SEMICOL
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+SynchronizedStatement:
+jp_SYNCHRONIZED jp_PARESTART Expression jp_PAREEND Block
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+TryStatement:
+jp_TRY Block Catches
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_TRY Block Catchesopt Finally
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Catchesopt:
+{
+  jpElementStart(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Catches
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Catches:
+CatchClause
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Catches CatchClause
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+CatchClause:
+jp_CATCH jp_PARESTART FormalParameter jp_PAREEND Block
+{
+  jpElementStart(5);
+
+}
+
+Finally:
+jp_FINALLY Block
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Primary:
+PrimaryNoNewArray
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArrayCreationExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PrimaryNoNewArray:
+Literal
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_THIS
+{
+  jpElementStart(1);
+
+}
+|
+jp_PARESTART Expression jp_PAREEND
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassInstanceCreationExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+FieldAccess
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MethodInvocation
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArrayAccess
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ClassInstanceCreationExpression:
+New ClassType jp_PARESTART ArgumentListopt jp_PAREEND ClassBodyOpt
+{
+  jpElementStart(6);
+  jpCheckEmpty(6);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ClassBodyOpt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ClassBody
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ArgumentListopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArgumentList
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ArgumentList:
+Expression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArgumentList jp_COMMA Expression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ArrayCreationExpression:
+New PrimitiveType DimExprs Dimsopt
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+New ClassOrInterfaceType DimExprs Dimsopt
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+New PrimitiveType Dims ArrayInitializer
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+New ClassOrInterfaceType Dims ArrayInitializer
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Dimsopt:
+{
+  jpElementStart(0);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Dims
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+DimExprs:
+DimExpr
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+DimExprs DimExpr
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+DimExpr:
+jp_BRACKETSTART Expression jp_BRACKETEND
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Dims:
+jp_BRACKETSTART jp_BRACKETEND
+{
+  jpElementStart(2);
+
+}
+|
+Dims jp_BRACKETSTART jp_BRACKETEND
+{
+  jpElementStart(3);
+
+}
+
+FieldAccess:
+Primary jp_DOT Identifier
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_SUPER jp_DOT Identifier
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_THIS jp_DOT Identifier
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Primary jp_DOT jp_THIS
+{
+  jpElementStart(3);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+MethodInvocation:
+Name jp_PARESTART ArgumentListopt jp_PAREEND
+{
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Primary jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
+{
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(6);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_SUPER jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
+{
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(6);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_THIS jp_DOT Identifier jp_PARESTART ArgumentListopt jp_PAREEND
+{
+  jpElementStart(6);
+  yyGetParser->DeallocateParserType(&($<str>3));
+  jpCheckEmpty(6);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ArrayAccess:
+Name jp_BRACKETSTART Expression jp_BRACKETEND
+{
+  jpElementStart(4);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PrimaryNoNewArray jp_BRACKETSTART Expression jp_BRACKETEND
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PostfixExpression:
+Primary
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Name
+{
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArrayType jp_DOT jp_CLASS
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PostIncrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PostDecrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PostIncrementExpression:
+PostfixExpression jp_PLUSPLUS
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PostDecrementExpression:
+PostfixExpression jp_MINUSMINUS
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+UnaryExpression:
+PreIncrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+PreDecrementExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PLUS UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_MINUS UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+UnaryExpressionNotPlusMinus
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PreIncrementExpression:
+jp_PLUSPLUS UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+PreDecrementExpression:
+jp_MINUSMINUS UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+UnaryExpressionNotPlusMinus:
+PostfixExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_TILDE UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_EXCLAMATION UnaryExpression
+{
+  jpElementStart(2);
+  jpCheckEmpty(2);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+CastExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+CastExpression:
+jp_PARESTART PrimitiveType Dimsopt jp_PAREEND UnaryExpression
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PARESTART Expression jp_PAREEND UnaryExpressionNotPlusMinus
+{
+  jpElementStart(4);
+  jpCheckEmpty(4);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PARESTART Name Dims jp_PAREEND UnaryExpressionNotPlusMinus
+{
+  jpElementStart(5);
+
+}
+
+MultiplicativeExpression:
+UnaryExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MultiplicativeExpression jp_TIMES UnaryExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MultiplicativeExpression jp_DIVIDE UnaryExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+MultiplicativeExpression jp_PERCENT UnaryExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AdditiveExpression:
+MultiplicativeExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+AdditiveExpression jp_PLUS MultiplicativeExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+AdditiveExpression jp_MINUS MultiplicativeExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ShiftExpression:
+AdditiveExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ShiftExpression jp_LTLT AdditiveExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ShiftExpression jp_GTGT AdditiveExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ShiftExpression jp_GTGTGT AdditiveExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+RelationalExpression:
+ShiftExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+RelationalExpression jp_LESSTHAN ShiftExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+RelationalExpression jp_GREATER ShiftExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+RelationalExpression jp_LTEQUALS ShiftExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+RelationalExpression jp_GTEQUALS ShiftExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+RelationalExpression jp_INSTANCEOF ReferenceType
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+EqualityExpression:
+RelationalExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+EqualityExpression jp_EQUALSEQUALS RelationalExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+EqualityExpression jp_EXCLAMATIONEQUALS RelationalExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AndExpression:
+EqualityExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+AndExpression jp_AND EqualityExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ExclusiveOrExpression:
+AndExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ExclusiveOrExpression jp_CARROT AndExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+InclusiveOrExpression:
+ExclusiveOrExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+InclusiveOrExpression jp_PIPE ExclusiveOrExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConditionalAndExpression:
+InclusiveOrExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ConditionalAndExpression jp_ANDAND InclusiveOrExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConditionalOrExpression:
+ConditionalAndExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ConditionalOrExpression jp_PIPEPIPE ConditionalAndExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConditionalExpression:
+ConditionalOrExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ConditionalOrExpression jp_QUESTION Expression jp_COLON ConditionalExpression
+{
+  jpElementStart(5);
+  jpCheckEmpty(5);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AssignmentExpression:
+ConditionalExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Assignment
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Assignment:
+LeftHandSide AssignmentOperator AssignmentExpression
+{
+  jpElementStart(3);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+LeftHandSide:
+Name
+{
+  jpElementStart(1);
+  yyGetParser->DeallocateParserType(&($<str>1));
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+FieldAccess
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+ArrayAccess
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+AssignmentOperator:
+jp_EQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_TIMESEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_DIVIDEEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PERCENTEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PLUSEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_MINUSEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_LESLESEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_GTGTEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_GTGTGTEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_ANDEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_CARROTEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+jp_PIPEEQUALS
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+Expression:
+AssignmentExpression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+ConstantExpression:
+Expression
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+New:
+jp_NEW
+{
+  jpElementStart(1);
+  jpCheckEmpty(1);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+|
+Name jp_DOT jp_NEW
+{
+  jpElementStart(3);
+  jpStoreClass($<str>1);
+  jpCheckEmpty(3);
+  $<str>$ = 0;
+  yyGetParser->SetCurrentCombine("");
+
+}
+
+%%
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message)
+{
+  yyGetParser->Error(message);
+}
diff --git a/Source/LexerParser/cmDependsJavaParserTokens.h b/Source/LexerParser/cmDependsJavaParserTokens.h
new file mode 100644
index 0000000..7f18f1d
--- /dev/null
+++ b/Source/LexerParser/cmDependsJavaParserTokens.h
@@ -0,0 +1,264 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED
+# define YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmDependsJava_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    jp_ABSTRACT = 258,
+    jp_ASSERT = 259,
+    jp_BOOLEAN_TYPE = 260,
+    jp_BREAK = 261,
+    jp_BYTE_TYPE = 262,
+    jp_CASE = 263,
+    jp_CATCH = 264,
+    jp_CHAR_TYPE = 265,
+    jp_CLASS = 266,
+    jp_CONTINUE = 267,
+    jp_DEFAULT = 268,
+    jp_DO = 269,
+    jp_DOUBLE_TYPE = 270,
+    jp_ELSE = 271,
+    jp_EXTENDS = 272,
+    jp_FINAL = 273,
+    jp_FINALLY = 274,
+    jp_FLOAT_TYPE = 275,
+    jp_FOR = 276,
+    jp_IF = 277,
+    jp_IMPLEMENTS = 278,
+    jp_IMPORT = 279,
+    jp_INSTANCEOF = 280,
+    jp_INT_TYPE = 281,
+    jp_INTERFACE = 282,
+    jp_LONG_TYPE = 283,
+    jp_NATIVE = 284,
+    jp_NEW = 285,
+    jp_PACKAGE = 286,
+    jp_PRIVATE = 287,
+    jp_PROTECTED = 288,
+    jp_PUBLIC = 289,
+    jp_RETURN = 290,
+    jp_SHORT_TYPE = 291,
+    jp_STATIC = 292,
+    jp_STRICTFP = 293,
+    jp_SUPER = 294,
+    jp_SWITCH = 295,
+    jp_SYNCHRONIZED = 296,
+    jp_THIS = 297,
+    jp_THROW = 298,
+    jp_THROWS = 299,
+    jp_TRANSIENT = 300,
+    jp_TRY = 301,
+    jp_VOID = 302,
+    jp_VOLATILE = 303,
+    jp_WHILE = 304,
+    jp_BOOLEANLITERAL = 305,
+    jp_CHARACTERLITERAL = 306,
+    jp_DECIMALINTEGERLITERAL = 307,
+    jp_FLOATINGPOINTLITERAL = 308,
+    jp_HEXINTEGERLITERAL = 309,
+    jp_NULLLITERAL = 310,
+    jp_STRINGLITERAL = 311,
+    jp_NAME = 312,
+    jp_AND = 313,
+    jp_ANDAND = 314,
+    jp_ANDEQUALS = 315,
+    jp_BRACKETEND = 316,
+    jp_BRACKETSTART = 317,
+    jp_CARROT = 318,
+    jp_CARROTEQUALS = 319,
+    jp_COLON = 320,
+    jp_COMMA = 321,
+    jp_CURLYEND = 322,
+    jp_CURLYSTART = 323,
+    jp_DIVIDE = 324,
+    jp_DIVIDEEQUALS = 325,
+    jp_DOLLAR = 326,
+    jp_DOT = 327,
+    jp_EQUALS = 328,
+    jp_EQUALSEQUALS = 329,
+    jp_EXCLAMATION = 330,
+    jp_EXCLAMATIONEQUALS = 331,
+    jp_GREATER = 332,
+    jp_GTEQUALS = 333,
+    jp_GTGT = 334,
+    jp_GTGTEQUALS = 335,
+    jp_GTGTGT = 336,
+    jp_GTGTGTEQUALS = 337,
+    jp_LESLESEQUALS = 338,
+    jp_LESSTHAN = 339,
+    jp_LTEQUALS = 340,
+    jp_LTLT = 341,
+    jp_MINUS = 342,
+    jp_MINUSEQUALS = 343,
+    jp_MINUSMINUS = 344,
+    jp_PAREEND = 345,
+    jp_PARESTART = 346,
+    jp_PERCENT = 347,
+    jp_PERCENTEQUALS = 348,
+    jp_PIPE = 349,
+    jp_PIPEEQUALS = 350,
+    jp_PIPEPIPE = 351,
+    jp_PLUS = 352,
+    jp_PLUSEQUALS = 353,
+    jp_PLUSPLUS = 354,
+    jp_QUESTION = 355,
+    jp_SEMICOL = 356,
+    jp_TILDE = 357,
+    jp_TIMES = 358,
+    jp_TIMESEQUALS = 359,
+    jp_ERROR = 360
+  };
+#endif
+/* Tokens.  */
+#define jp_ABSTRACT 258
+#define jp_ASSERT 259
+#define jp_BOOLEAN_TYPE 260
+#define jp_BREAK 261
+#define jp_BYTE_TYPE 262
+#define jp_CASE 263
+#define jp_CATCH 264
+#define jp_CHAR_TYPE 265
+#define jp_CLASS 266
+#define jp_CONTINUE 267
+#define jp_DEFAULT 268
+#define jp_DO 269
+#define jp_DOUBLE_TYPE 270
+#define jp_ELSE 271
+#define jp_EXTENDS 272
+#define jp_FINAL 273
+#define jp_FINALLY 274
+#define jp_FLOAT_TYPE 275
+#define jp_FOR 276
+#define jp_IF 277
+#define jp_IMPLEMENTS 278
+#define jp_IMPORT 279
+#define jp_INSTANCEOF 280
+#define jp_INT_TYPE 281
+#define jp_INTERFACE 282
+#define jp_LONG_TYPE 283
+#define jp_NATIVE 284
+#define jp_NEW 285
+#define jp_PACKAGE 286
+#define jp_PRIVATE 287
+#define jp_PROTECTED 288
+#define jp_PUBLIC 289
+#define jp_RETURN 290
+#define jp_SHORT_TYPE 291
+#define jp_STATIC 292
+#define jp_STRICTFP 293
+#define jp_SUPER 294
+#define jp_SWITCH 295
+#define jp_SYNCHRONIZED 296
+#define jp_THIS 297
+#define jp_THROW 298
+#define jp_THROWS 299
+#define jp_TRANSIENT 300
+#define jp_TRY 301
+#define jp_VOID 302
+#define jp_VOLATILE 303
+#define jp_WHILE 304
+#define jp_BOOLEANLITERAL 305
+#define jp_CHARACTERLITERAL 306
+#define jp_DECIMALINTEGERLITERAL 307
+#define jp_FLOATINGPOINTLITERAL 308
+#define jp_HEXINTEGERLITERAL 309
+#define jp_NULLLITERAL 310
+#define jp_STRINGLITERAL 311
+#define jp_NAME 312
+#define jp_AND 313
+#define jp_ANDAND 314
+#define jp_ANDEQUALS 315
+#define jp_BRACKETEND 316
+#define jp_BRACKETSTART 317
+#define jp_CARROT 318
+#define jp_CARROTEQUALS 319
+#define jp_COLON 320
+#define jp_COMMA 321
+#define jp_CURLYEND 322
+#define jp_CURLYSTART 323
+#define jp_DIVIDE 324
+#define jp_DIVIDEEQUALS 325
+#define jp_DOLLAR 326
+#define jp_DOT 327
+#define jp_EQUALS 328
+#define jp_EQUALSEQUALS 329
+#define jp_EXCLAMATION 330
+#define jp_EXCLAMATIONEQUALS 331
+#define jp_GREATER 332
+#define jp_GTEQUALS 333
+#define jp_GTGT 334
+#define jp_GTGTEQUALS 335
+#define jp_GTGTGT 336
+#define jp_GTGTGTEQUALS 337
+#define jp_LESLESEQUALS 338
+#define jp_LESSTHAN 339
+#define jp_LTEQUALS 340
+#define jp_LTLT 341
+#define jp_MINUS 342
+#define jp_MINUSEQUALS 343
+#define jp_MINUSMINUS 344
+#define jp_PAREEND 345
+#define jp_PARESTART 346
+#define jp_PERCENT 347
+#define jp_PERCENTEQUALS 348
+#define jp_PIPE 349
+#define jp_PIPEEQUALS 350
+#define jp_PIPEPIPE 351
+#define jp_PLUS 352
+#define jp_PLUSEQUALS 353
+#define jp_PLUSPLUS 354
+#define jp_QUESTION 355
+#define jp_SEMICOL 356
+#define jp_TILDE 357
+#define jp_TIMES 358
+#define jp_TIMESEQUALS 359
+#define jp_ERROR 360
+
+/* Value type.  */
+
+
+
+int cmDependsJava_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED  */
diff --git a/Source/LexerParser/cmExprLexer.cxx b/Source/LexerParser/cmExprLexer.cxx
new file mode 100644
index 0000000..81a1ec5
--- /dev/null
+++ b/Source/LexerParser/cmExprLexer.cxx
@@ -0,0 +1,2205 @@
+#include "cmStandardLexer.h"
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmExpr_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmExpr_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmExpr_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmExpr_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmExpr_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmExpr_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmExpr_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmExpr_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmExpr_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmExpr_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmExpr_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmExpr_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmExpr_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmExpr_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmExpr_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmExpr_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmExpr_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmExpr_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmExpr_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmExpr_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmExpr_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmExpr_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmExpr_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmExpr_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmExpr_yylex_ALREADY_DEFINED
+#else
+#define yylex cmExpr_yylex
+#endif
+
+#ifdef yyrestart
+#define cmExpr_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmExpr_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmExpr_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmExpr_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmExpr_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmExpr_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmExpr_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmExpr_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmExpr_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmExpr_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmExpr_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmExpr_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmExpr_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmExpr_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmExpr_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmExpr_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmExpr_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmExpr_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmExpr_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmExpr_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmExpr_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmExpr_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmExpr_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmExpr_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmExpr_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmExpr_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmExpr_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmExpr_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmExpr_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmExpr_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmExpr_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmExpr_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmExpr_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmExpr_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmExpr_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmExpr_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmExpr_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmExpr_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmExpr_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmExpr_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmExpr_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmExpr_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmExpr_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmExpr_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define cmExpr_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 15
+#define YY_END_OF_BUFFER 16
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[23] =
+    {   0,
+        0,    0,   16,   15,    6,    8,   13,   14,    4,    2,
+        3,    5,    1,   15,   15,    9,    7,   10,    1,   11,
+       12,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    2,    3,    1,    4,
+        5,    6,    7,    1,    8,    1,    9,   10,   10,   10,
+       10,   10,   10,   10,   10,   10,   10,    1,    1,   11,
+        1,   12,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,   13,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,   14,    1,   15,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[16] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[23] =
+    {   0,
+        0,    0,   20,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,    9,    7,    5,   21,   21,   21,    6,   21,
+       21,   21
+    } ;
+
+static const flex_int16_t yy_def[23] =
+    {   0,
+       22,    1,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,    0
+    } ;
+
+static const flex_int16_t yy_nxt[37] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
+       14,   15,   16,   17,   18,   19,   21,   20,   19,   22,
+        3,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22
+    } ;
+
+static const flex_int16_t yy_chk[37] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,   19,   15,   14,   13,    3,
+       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmExprLexer.h -ocmExprLexer.cxx cmExprLexer.in.l
+
+Modify cmExprLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmExprLexer.h cmExprLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmExprLexer.h cmExprLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmExprLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include "cmExprParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmExprParserTokens.h"
+
+/*--------------------------------------------------------------------------*/
+
+#define INITIAL 0
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput ( int c, char *buf_ptr  , yyscan_t yyscanner);
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 23 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 21 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{ yylvalp->Number = atoi(yytext); return exp_NUMBER; }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+{ return exp_PLUS; }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+{ return exp_MINUS; }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+{ return exp_TIMES; }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+{ return exp_DIVIDE; }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+{ return exp_MOD; }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+{ return exp_OR; }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+{ return exp_AND; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+{ return exp_XOR; }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+{ return exp_NOT; }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+{ return exp_SHIFTLEFT; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{ return exp_SHIFTRIGHT; }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+{ return exp_OPENPARENT; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+{ return exp_CLOSEPARENT; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 23 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 23 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 22);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
+{
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    yy_cp = yyg->yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yyg->yy_hold_char;
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = yyg->yy_n_chars + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+	yyg->yytext_ptr = yy_bp;
+	yyg->yy_hold_char = *yy_cp;
+	yyg->yy_c_buf_p = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
diff --git a/Source/LexerParser/cmExprLexer.h b/Source/LexerParser/cmExprLexer.h
new file mode 100644
index 0000000..b55ee92
--- /dev/null
+++ b/Source/LexerParser/cmExprLexer.h
@@ -0,0 +1,687 @@
+#ifndef cmExpr_yyHEADER_H
+#define cmExpr_yyHEADER_H 1
+#define cmExpr_yyIN_HEADER 1
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmExpr_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmExpr_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmExpr_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmExpr_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmExpr_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmExpr_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmExpr_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmExpr_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmExpr_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmExpr_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmExpr_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmExpr_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmExpr_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmExpr_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmExpr_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmExpr_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmExpr_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmExpr_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmExpr_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmExpr_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmExpr_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmExpr_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmExpr_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmExpr_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmExpr_yylex_ALREADY_DEFINED
+#else
+#define yylex cmExpr_yylex
+#endif
+
+#ifdef yyrestart
+#define cmExpr_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmExpr_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmExpr_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmExpr_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmExpr_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmExpr_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmExpr_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmExpr_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmExpr_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmExpr_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmExpr_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmExpr_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmExpr_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmExpr_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmExpr_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmExpr_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmExpr_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmExpr_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmExpr_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmExpr_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmExpr_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmExpr_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmExpr_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmExpr_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmExpr_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmExpr_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmExpr_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmExpr_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmExpr_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmExpr_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmExpr_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmExpr_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmExpr_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmExpr_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmExpr_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmExpr_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmExpr_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmExpr_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmExpr_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmExpr_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmExpr_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmExpr_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmExpr_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmExpr_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define cmExpr_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef cmExpr_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef cmExpr_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef cmExpr_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef cmExpr_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef cmExpr_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef cmExpr_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef cmExpr_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef cmExpr_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef cmExpr_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef cmExpr_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef cmExpr_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef cmExpr_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef cmExpr_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef cmExpr_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef cmExpr_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef cmExpr_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef cmExpr_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef cmExpr_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef cmExpr_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef cmExpr_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef cmExpr_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef cmExpr_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef cmExpr_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef cmExpr_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef cmExpr_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef cmExpr_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef cmExpr_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef cmExpr_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef cmExpr_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef cmExpr_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef cmExpr_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef cmExpr_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef cmExpr_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef cmExpr_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef cmExpr_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef cmExpr_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef cmExpr_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef cmExpr_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef cmExpr_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef cmExpr_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef cmExpr_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef cmExpr_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef cmExpr_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef cmExpr_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef cmExpr_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef cmExpr_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef cmExpr_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef cmExpr_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#undef cmExpr_yyIN_HEADER
+#endif /* cmExpr_yyHEADER_H */
diff --git a/Source/LexerParser/cmExprLexer.in.l b/Source/LexerParser/cmExprLexer.in.l
new file mode 100644
index 0000000..e5f177a
--- /dev/null
+++ b/Source/LexerParser/cmExprLexer.in.l
@@ -0,0 +1,58 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline --header-file=cmExprLexer.h -ocmExprLexer.cxx cmExprLexer.in.l
+
+Modify cmExprLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmExprLexer.h cmExprLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmExprLexer.h cmExprLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmExprLexer.cxx
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#include "cmExprParserHelper.h"
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = yyextra->LexInput(buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmExprParserTokens.h"
+
+/*--------------------------------------------------------------------------*/
+%}
+
+%option prefix="cmExpr_yy"
+
+%option reentrant
+%option noyywrap
+%pointer
+
+%%
+
+[0-9][0-9]* { yylvalp->Number = atoi(yytext); return exp_NUMBER; }
+
+"+" { return exp_PLUS; }
+"-" { return exp_MINUS; }
+"*" { return exp_TIMES; }
+"/" { return exp_DIVIDE; }
+"%" { return exp_MOD; }
+"\|" { return exp_OR; }
+"&" { return exp_AND; }
+"^" { return exp_XOR; }
+"~" { return exp_NOT; }
+"<<" { return exp_SHIFTLEFT; }
+">>" { return exp_SHIFTRIGHT; }
+"(" { return exp_OPENPARENT; }
+")" { return exp_CLOSEPARENT; }
+
+%%
diff --git a/Source/LexerParser/cmExprParser.cxx b/Source/LexerParser/cmExprParser.cxx
new file mode 100644
index 0000000..67664a5
--- /dev/null
+++ b/Source/LexerParser/cmExprParser.cxx
@@ -0,0 +1,1698 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names.  */
+#define yyparse         cmExpr_yyparse
+#define yylex           cmExpr_yylex
+#define yyerror         cmExpr_yyerror
+#define yydebug         cmExpr_yydebug
+#define yynerrs         cmExpr_yynerrs
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "cmExprParser.y" /* yacc.c:339  */
+
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmExpr_yy --defines=cmExprParserTokens.h -ocmExprParser.cxx cmExprParser.y
+
+Modify cmExprParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stdlib.h>
+#include <string.h>
+
+/*-------------------------------------------------------------------------*/
+#define YYDEBUG 1
+#include "cmExprParserHelper.h" /* Interface to parser object.  */
+#include "cmExprLexer.h"  /* Interface to lexer object.  */
+#include "cmExprParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmExpr_yyerror(yyscan_t yyscanner, const char* message);
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no case. */
+#endif
+
+#line 112 "cmExprParser.cxx" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "cmExprParserTokens.h".  */
+#ifndef YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED
+# define YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmExpr_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    exp_PLUS = 258,
+    exp_MINUS = 259,
+    exp_TIMES = 260,
+    exp_DIVIDE = 261,
+    exp_MOD = 262,
+    exp_SHIFTLEFT = 263,
+    exp_SHIFTRIGHT = 264,
+    exp_OPENPARENT = 265,
+    exp_CLOSEPARENT = 266,
+    exp_OR = 267,
+    exp_AND = 268,
+    exp_XOR = 269,
+    exp_NOT = 270,
+    exp_NUMBER = 271
+  };
+#endif
+/* Tokens.  */
+#define exp_PLUS 258
+#define exp_MINUS 259
+#define exp_TIMES 260
+#define exp_DIVIDE 261
+#define exp_MOD 262
+#define exp_SHIFTLEFT 263
+#define exp_SHIFTRIGHT 264
+#define exp_OPENPARENT 265
+#define exp_CLOSEPARENT 266
+#define exp_OR 267
+#define exp_AND 268
+#define exp_XOR 269
+#define exp_NOT 270
+#define exp_NUMBER 271
+
+/* Value type.  */
+
+
+
+int cmExpr_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 189 "cmExprParser.cxx" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  17
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   30
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  17
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  10
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  23
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  39
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   271
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,    73,    73,    78,    81,    86,    89,    94,    97,   102,
+     105,   108,   113,   116,   119,   124,   127,   130,   133,   138,
+     141,   144,   149,   152
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "exp_PLUS", "exp_MINUS", "exp_TIMES",
+  "exp_DIVIDE", "exp_MOD", "exp_SHIFTLEFT", "exp_SHIFTRIGHT",
+  "exp_OPENPARENT", "exp_CLOSEPARENT", "exp_OR", "exp_AND", "exp_XOR",
+  "exp_NOT", "exp_NUMBER", "$accept", "start", "exp", "bitwiseor",
+  "bitwisexor", "bitwiseand", "shift", "term", "unary", "factor", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271
+};
+# endif
+
+#define YYPACT_NINF -8
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-8)))
+
+#define YYTABLE_NINF -1
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int8 yypact[] =
+{
+       0,     0,     0,     0,    -8,     2,    -7,    -5,     8,     3,
+      10,     1,    -8,    -8,    -8,    -8,     6,    -8,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    -8,    -5,
+       8,     3,    10,    10,     1,     1,    -8,    -8,    -8
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       0,     0,     0,     0,    22,     0,     2,     3,     5,     7,
+       9,    12,    15,    19,    20,    21,     0,     1,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    23,     4,
+       6,     8,    10,    11,    13,    14,    16,    17,    18
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+      -8,    -8,    12,     5,    11,     9,    -2,     4,    -1,    -8
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,     5,     6,     7,     8,     9,    10,    11,    12,    13
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_uint8 yytable[] =
+{
+      14,    15,    17,     1,     2,    18,    25,    26,    27,    19,
+       3,    21,    22,    23,    24,    16,     4,    28,    18,    32,
+      33,    20,     0,    29,    36,    37,    38,    34,    35,    31,
+      30
+};
+
+static const yytype_int8 yycheck[] =
+{
+       1,     2,     0,     3,     4,    12,     5,     6,     7,    14,
+      10,     8,     9,     3,     4,     3,    16,    11,    12,    21,
+      22,    13,    -1,    18,    25,    26,    27,    23,    24,    20,
+      19
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     3,     4,    10,    16,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    25,    25,    19,     0,    12,    14,
+      13,     8,     9,     3,     4,     5,     6,     7,    11,    20,
+      21,    22,    23,    23,    24,    24,    25,    25,    25
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    17,    18,    19,    19,    20,    20,    21,    21,    22,
+      22,    22,    23,    23,    23,    24,    24,    24,    24,    25,
+      25,    25,    26,    26
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     1,     3,     1,     3,     1,     3,     1,
+       3,     3,     1,     3,     3,     1,     3,     3,     3,     1,
+       2,     2,     1,     3
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (yyscanner, YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value, yyscanner); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  YYUSE (yyscanner);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              , yyscanner);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, yyscan_t yyscanner)
+{
+  YYUSE (yyvaluep);
+  YYUSE (yyscanner);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (yyscan_t yyscanner)
+{
+/* The lookahead symbol.  */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol.  */
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex (&yylval, yyscanner);
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 73 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    cmExpr_yyget_extra(yyscanner)->SetResult((yyvsp[0].Number));
+  }
+#line 1289 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 3:
+#line 78 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1297 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 4:
+#line 81 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) | (yyvsp[0].Number);
+  }
+#line 1305 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 5:
+#line 86 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1313 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 6:
+#line 89 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) ^ (yyvsp[0].Number);
+  }
+#line 1321 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 7:
+#line 94 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1329 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 97 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) & (yyvsp[0].Number);
+  }
+#line 1337 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 102 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1345 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 105 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) << (yyvsp[0].Number);
+  }
+#line 1353 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 11:
+#line 108 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) >> (yyvsp[0].Number);
+  }
+#line 1361 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 12:
+#line 113 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1369 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 13:
+#line 116 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) + (yyvsp[0].Number);
+  }
+#line 1377 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 14:
+#line 119 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) - (yyvsp[0].Number);
+  }
+#line 1385 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 15:
+#line 124 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1393 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 16:
+#line 127 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) * (yyvsp[0].Number);
+  }
+#line 1401 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 17:
+#line 130 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) / (yyvsp[0].Number);
+  }
+#line 1409 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 18:
+#line 133 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-2].Number) % (yyvsp[0].Number);
+  }
+#line 1417 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 19:
+#line 138 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1425 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 20:
+#line 141 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = + (yyvsp[0].Number);
+  }
+#line 1433 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 21:
+#line 144 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = - (yyvsp[0].Number);
+  }
+#line 1441 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 22:
+#line 149 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[0].Number);
+  }
+#line 1449 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 23:
+#line 152 "cmExprParser.y" /* yacc.c:1646  */
+    {
+    (yyval.Number) = (yyvsp[-1].Number);
+  }
+#line 1457 "cmExprParser.cxx" /* yacc.c:1646  */
+    break;
+
+
+#line 1461 "cmExprParser.cxx" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (yyscanner, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yyscanner, yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, yyscanner);
+          yychar = YYEMPTY;
+        }
+    }
+
+#if 0
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+#endif
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (yyscanner, YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, yyscanner);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 157 "cmExprParser.y" /* yacc.c:1906  */
+
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmExpr_yyerror(yyscan_t yyscanner, const char* message)
+{
+  cmExpr_yyget_extra(yyscanner)->Error(message);
+}
diff --git a/Source/LexerParser/cmExprParser.y b/Source/LexerParser/cmExprParser.y
new file mode 100644
index 0000000..d1c3a97
--- /dev/null
+++ b/Source/LexerParser/cmExprParser.y
@@ -0,0 +1,164 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmExpr_yy --defines=cmExprParserTokens.h -ocmExprParser.cxx cmExprParser.y
+
+Modify cmExprParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stdlib.h>
+#include <string.h>
+
+/*-------------------------------------------------------------------------*/
+#define YYDEBUG 1
+#include "cmExprParserHelper.h" /* Interface to parser object.  */
+#include "cmExprLexer.h"  /* Interface to lexer object.  */
+#include "cmExprParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmExpr_yyerror(yyscan_t yyscanner, const char* message);
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch statement contains default but no case. */
+#endif
+%}
+
+/* Generate a reentrant parser object.  */
+%define api.pure
+
+/* Configure the parser to use a lexer object.  */
+%lex-param   {yyscan_t yyscanner}
+%parse-param {yyscan_t yyscanner}
+
+%define parse.error verbose
+
+/*-------------------------------------------------------------------------*/
+/* Tokens */
+%token exp_PLUS
+%token exp_MINUS
+%token exp_TIMES
+%token exp_DIVIDE
+%token exp_MOD
+%token exp_SHIFTLEFT
+%token exp_SHIFTRIGHT
+%token exp_OPENPARENT
+%token exp_CLOSEPARENT
+%token exp_OR;
+%token exp_AND;
+%token exp_XOR;
+%token exp_NOT;
+%token exp_NUMBER;
+
+/*-------------------------------------------------------------------------*/
+/* grammar */
+%%
+
+
+start:
+  exp {
+    cmExpr_yyget_extra(yyscanner)->SetResult($<Number>1);
+  }
+
+exp:
+  bitwiseor {
+    $<Number>$ = $<Number>1;
+  }
+| exp exp_OR bitwiseor {
+    $<Number>$ = $<Number>1 | $<Number>3;
+  }
+
+bitwiseor:
+  bitwisexor {
+    $<Number>$ = $<Number>1;
+  }
+| bitwiseor exp_XOR bitwisexor {
+    $<Number>$ = $<Number>1 ^ $<Number>3;
+  }
+
+bitwisexor:
+  bitwiseand {
+    $<Number>$ = $<Number>1;
+  }
+| bitwisexor exp_AND bitwiseand {
+    $<Number>$ = $<Number>1 & $<Number>3;
+  }
+
+bitwiseand:
+  shift {
+    $<Number>$ = $<Number>1;
+  }
+| bitwiseand exp_SHIFTLEFT shift {
+    $<Number>$ = $<Number>1 << $<Number>3;
+  }
+| bitwiseand exp_SHIFTRIGHT shift {
+    $<Number>$ = $<Number>1 >> $<Number>3;
+  }
+
+shift:
+  term {
+    $<Number>$ = $<Number>1;
+  }
+| shift exp_PLUS term {
+    $<Number>$ = $<Number>1 + $<Number>3;
+  }
+| shift exp_MINUS term {
+    $<Number>$ = $<Number>1 - $<Number>3;
+  }
+
+term:
+  unary {
+    $<Number>$ = $<Number>1;
+  }
+| term exp_TIMES unary {
+    $<Number>$ = $<Number>1 * $<Number>3;
+  }
+| term exp_DIVIDE unary {
+    $<Number>$ = $<Number>1 / $<Number>3;
+  }
+| term exp_MOD unary {
+    $<Number>$ = $<Number>1 % $<Number>3;
+  }
+
+unary:
+  factor {
+    $<Number>$ = $<Number>1;
+  }
+| exp_PLUS unary {
+    $<Number>$ = + $<Number>2;
+  }
+| exp_MINUS unary {
+    $<Number>$ = - $<Number>2;
+  }
+
+factor:
+  exp_NUMBER {
+    $<Number>$ = $<Number>1;
+  }
+| exp_OPENPARENT exp exp_CLOSEPARENT {
+    $<Number>$ = $<Number>2;
+  }
+;
+
+%%
+/* End of grammar */
+
+/*--------------------------------------------------------------------------*/
+void cmExpr_yyerror(yyscan_t yyscanner, const char* message)
+{
+  cmExpr_yyget_extra(yyscanner)->Error(message);
+}
diff --git a/Source/LexerParser/cmExprParserTokens.h b/Source/LexerParser/cmExprParserTokens.h
new file mode 100644
index 0000000..84b2bbd
--- /dev/null
+++ b/Source/LexerParser/cmExprParserTokens.h
@@ -0,0 +1,86 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED
+# define YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmExpr_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    exp_PLUS = 258,
+    exp_MINUS = 259,
+    exp_TIMES = 260,
+    exp_DIVIDE = 261,
+    exp_MOD = 262,
+    exp_SHIFTLEFT = 263,
+    exp_SHIFTRIGHT = 264,
+    exp_OPENPARENT = 265,
+    exp_CLOSEPARENT = 266,
+    exp_OR = 267,
+    exp_AND = 268,
+    exp_XOR = 269,
+    exp_NOT = 270,
+    exp_NUMBER = 271
+  };
+#endif
+/* Tokens.  */
+#define exp_PLUS 258
+#define exp_MINUS 259
+#define exp_TIMES 260
+#define exp_DIVIDE 261
+#define exp_MOD 262
+#define exp_SHIFTLEFT 263
+#define exp_SHIFTRIGHT 264
+#define exp_OPENPARENT 265
+#define exp_CLOSEPARENT 266
+#define exp_OR 267
+#define exp_AND 268
+#define exp_XOR 269
+#define exp_NOT 270
+#define exp_NUMBER 271
+
+/* Value type.  */
+
+
+
+int cmExpr_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED  */
diff --git a/Source/LexerParser/cmFortranLexer.cxx b/Source/LexerParser/cmFortranLexer.cxx
new file mode 100644
index 0000000..dec0f5e
--- /dev/null
+++ b/Source/LexerParser/cmFortranLexer.cxx
@@ -0,0 +1,2612 @@
+#include "cmStandardLexer.h"
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmFortran_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmFortran_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmFortran_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmFortran_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmFortran_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmFortran_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmFortran_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmFortran_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmFortran_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmFortran_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmFortran_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmFortran_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmFortran_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmFortran_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmFortran_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmFortran_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmFortran_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmFortran_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmFortran_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmFortran_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmFortran_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmFortran_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmFortran_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmFortran_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmFortran_yylex_ALREADY_DEFINED
+#else
+#define yylex cmFortran_yylex
+#endif
+
+#ifdef yyrestart
+#define cmFortran_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmFortran_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmFortran_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmFortran_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmFortran_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmFortran_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmFortran_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmFortran_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmFortran_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmFortran_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmFortran_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmFortran_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmFortran_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmFortran_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmFortran_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmFortran_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmFortran_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmFortran_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmFortran_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmFortran_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmFortran_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmFortran_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmFortran_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmFortran_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmFortran_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmFortran_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmFortran_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmFortran_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmFortran_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmFortran_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmFortran_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmFortran_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmFortran_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmFortran_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmFortran_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmFortran_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmFortran_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmFortran_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmFortran_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmFortran_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmFortran_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmFortran_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmFortran_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmFortran_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    #define YY_LESS_LINENO(n)
+    #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define cmFortran_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 54
+#define YY_END_OF_BUFFER 55
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[210] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       55,   49,   51,   50,   53,    1,   49,   33,    2,   47,
+       48,   35,   37,   50,   39,   49,   46,   46,   46,   46,
+       46,   46,   49,   46,   51,   49,   50,   49,   46,    9,
+        8,    9,    4,    3,   49,    0,   10,    0,    0,    0,
+        0,    0,   33,   33,   34,   36,   39,   49,   46,   46,
+       46,   46,   46,   46,    0,   52,   46,    0,    0,    0,
+       12,    0,    0,    0,    0,    0,    0,   49,    0,   11,
+       46,    0,    0,    5,    0,    0,    0,    0,   29,    0,
+       33,   33,   33,   33,    0,    0,   40,   46,   46,   46,
+
+       46,   45,   12,   12,    0,    0,    0,   23,    0,    0,
+        0,    0,    0,    0,    6,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   46,   46,   46,   46,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   30,   31,    0,    0,    0,    0,    0,   46,   46,
+       46,   46,    0,   24,   25,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   20,   32,   27,    0,    0,    0,
+       46,   46,   43,   46,    0,   26,   21,    0,    0,    0,
+       19,    0,    0,   18,   28,    0,    0,   41,   46,   46,
+       17,   22,    0,    7,   38,    7,   15,    0,   46,   46,
+
+       14,   16,   42,   44,    0,    0,    0,   13,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    5,    6,    7,    8,    9,    1,   10,   11,   12,
+       13,   14,    1,   15,    1,    1,    1,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,   16,   17,   18,   19,
+       20,   21,   22,    1,   23,   24,   25,   26,   27,   28,
+       24,   24,   29,   24,   24,   30,   31,   32,   33,   24,
+       24,   34,   35,   36,   37,   24,   24,   24,   24,   24,
+        1,   38,    1,    1,   39,    1,   23,   40,   41,   42,
+
+       43,   44,   24,   24,   45,   24,   24,   46,   31,   47,
+       33,   24,   24,   34,   48,   36,   49,   24,   24,   24,
+       24,   24,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[50] =
+    {   0,
+        1,    2,    2,    3,    4,    3,    3,    1,    1,    3,
+        3,    3,    3,    1,    3,    5,    3,    3,    1,    3,
+        6,    1,    7,    7,    7,    7,    7,    7,    7,    7,
+        7,    7,    7,    7,    7,    7,    7,    1,    5,    7,
+        7,    7,    7,    7,    7,    7,    7,    7,    7
+    } ;
+
+static const flex_int16_t yy_base[219] =
+    {   0,
+        0,   48,    0,   49,  464,   56,   52,   57,   62,   68,
+      466,    0,  468,  468,  462,  468,   74,   81,  468,  468,
+      468,  468,  447,  468,  442,  440,    0,   41,   42,  428,
+       43,   42,   91,  119,   97,  157,  455,  206,  245,  468,
+      454,  101,  468,  468,    0,  455,  468,  105,  430,  424,
+       62,   68,  119,  141,  468,  468,  468,  111,    0,   59,
+       98,   88,  415,  109,  158,  468,    0,  162,  293,    0,
+      163,  411,  107,  122,  408,  405,  446,  342,  447,  468,
+        0,  444,  169,  173,  420,  421,  132,  404,   90,  404,
+      179,  185,  191,  227,  295,  397,    0,  146,  178,  149,
+
+      412,    0,  208,  206,  398,  171,  399,  170,  399,  391,
+      387,  422,  417,  221,  468,  374,  365,  347,  347,  334,
+      335,  335,  330,  334,  259,  340,  188,  340,  327,  327,
+      327,  324,  325,  325,  320,  322,  319,  355,  354,  325,
+      327,  468,  468,  310,  309,  309,  300,  301,  273,  273,
+      275,  277,  297,  468,  468,  293,  289,  283,  275,  305,
+      261,  238,  237,  214,  468,  468,  468,  196,  197,  189,
+      277,  181,    0,  274,  112,  468,  468,  105,  103,  311,
+      468,  233,    0,  468,  468,   83,   76,    0,  281,  282,
+      468,  468,   52,  468,  468,  468,  468,   23,  287,  298,
+
+      327,  468,    0,    0,  329,    0,   31,  468,  468,  381,
+      388,  394,  397,  404,  411,  418,  425,  432
+    } ;
+
+static const flex_int16_t yy_def[219] =
+    {   0,
+      209,    1,    1,    1,    1,    1,  210,  210,  210,  210,
+      209,  211,  209,  209,  212,  209,  211,  209,  209,  209,
+      209,  209,  209,  209,  209,  211,  213,  213,  213,  213,
+      213,  213,  211,  213,  209,  211,  209,  214,  209,  209,
+      209,  209,  209,  209,  211,  212,  209,  209,  209,  209,
+      209,  209,  209,  215,  209,  209,  209,  211,  213,  213,
+      213,  213,  213,  213,  209,  209,   34,  209,  209,   69,
+      211,  209,  209,  209,  209,  209,  209,  214,  214,  209,
+       39,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      215,  215,  215,  215,  209,  209,  213,  213,  213,  213,
+
+      213,  213,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  213,  213,  213,  213,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  213,  213,
+      213,  213,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      213,  213,  213,  213,  209,  209,  209,  209,  209,  209,
+      209,  216,  217,  209,  209,  209,  209,  213,  213,  213,
+      209,  209,  209,  209,  209,  209,  209,  209,  213,  213,
+
+      209,  209,  213,  213,  209,  218,  218,  209,    0,  209,
+      209,  209,  209,  209,  209,  209,  209,  209
+    } ;
+
+static const flex_int16_t yy_nxt[518] =
+    {   0,
+       12,   13,   14,   13,   13,   15,   16,   12,   17,   18,
+       19,   20,   21,   12,   22,   12,   23,   24,   12,   25,
+       12,   26,   27,   27,   27,   27,   28,   27,   29,   27,
+       30,   27,   27,   27,   31,   27,   32,   33,   34,   27,
+       27,   27,   28,   27,   29,   27,   27,   31,   32,   35,
+       35,  208,   35,   35,   41,   36,   36,   35,   37,   41,
+       35,   42,   43,   36,   41,  202,   42,   43,   44,   38,
+       41,   42,   60,   61,   44,   48,   64,   42,   48,   63,
+       39,   39,   53,   53,   97,   53,   54,   60,   61,   64,
+       55,   63,   65,   66,  201,   65,   39,   39,   68,   49,
+
+       97,   68,   83,   84,   69,   83,   48,   87,   88,   48,
+       50,   89,   95,  100,   90,   95,   51,  198,   52,   45,
+       53,   53,   98,   53,   54,  197,   45,   45,   55,  100,
+       49,  121,   45,   99,   67,  102,  122,   45,   98,   45,
+       45,   50,   92,   53,  193,   92,   93,   51,  192,   52,
+       94,  102,  106,  107,  191,   96,   45,   67,   70,   65,
+       66,   70,   65,   68,  104,  108,   68,  104,  109,   69,
+       83,   84,   71,   83,  114,  125,  118,  114,   71,  119,
+       92,   53,  115,   92,   93,  127,   92,   53,   94,   92,
+       93,  125,   92,   53,   94,   92,   93,  127,   72,   73,
+
+       94,   74,   75,  189,  126,   76,   78,  104,   80,  104,
+      104,  133,  104,   78,   78,  130,  134,  151,  131,   78,
+      126,   78,  114,  103,   78,  114,   78,   78,   92,   53,
+      115,   92,   93,  151,  195,  195,   94,  187,  186,  185,
+      184,  183,  182,   78,   78,   79,   79,   80,   79,   79,
+       79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
+       81,   79,   79,   79,   79,   79,   79,   81,   81,   81,
+       81,   81,   81,   81,   81,   81,   81,   81,   81,   81,
+       81,   81,   79,   81,   81,   81,   81,   81,   81,   81,
+       81,   81,   81,   81,   70,  149,   95,   70,  171,   95,
+
+      172,  173,  174,  188,  181,  199,  180,  149,  103,  180,
+      190,  200,  180,  203,  171,  180,  172,  173,  174,  188,
+      103,  199,  190,  179,  204,  178,  103,  200,  205,  203,
+      205,  205,  177,  205,   72,   73,  176,   74,   75,   96,
+      204,   76,   78,  175,   80,  206,  170,  206,  169,   78,
+       78,  168,  167,  166,  165,   78,  164,   78,  163,  162,
+       78,  161,   78,   78,  160,  159,  158,  157,  156,  155,
+      154,  153,  152,  150,  148,  147,  146,  145,  144,   78,
+       78,   40,   40,   40,   40,   40,   40,   40,   45,  143,
+      142,  141,   45,   45,   46,   46,   46,   46,   46,   46,
+
+       46,   59,  140,   59,   79,   79,   79,   79,   79,   79,
+       79,   91,   91,   91,   91,   91,   91,   91,  194,  194,
+      194,  139,  194,  194,  194,  196,  138,  196,  137,  196,
+      196,  196,  207,  207,  207,  207,  207,  136,  207,  135,
+      132,  129,  128,  124,  123,  120,  117,  116,  113,   80,
+      112,  111,  110,  105,  101,   86,   85,   47,   82,   77,
+       62,   58,   57,   56,   47,  209,   37,   11,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209
+    } ;
+
+static const flex_int16_t yy_chk[518] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
+        4,  207,    2,    4,    7,    2,    4,    6,    6,    8,
+        6,    7,    7,    6,    9,  198,    8,    8,    9,    6,
+       10,    9,   28,   29,   10,   17,   32,   10,   17,   31,
+        6,    6,   18,   18,   60,   18,   18,   28,   29,   32,
+       18,   31,   33,   33,  193,   33,    6,    6,   35,   17,
+
+       60,   35,   42,   42,   35,   42,   48,   51,   51,   48,
+       17,   52,   58,   62,   52,   58,   17,  187,   17,   34,
+       53,   53,   61,   53,   53,  186,   34,   34,   53,   62,
+       48,   89,   34,   61,   34,   64,   89,   34,   61,   34,
+       34,   48,   54,   54,  179,   54,   54,   48,  178,   48,
+       54,   64,   73,   73,  175,   58,   34,   34,   36,   65,
+       65,   36,   65,   68,   71,   74,   68,   71,   74,   68,
+       83,   83,   36,   83,   84,   98,   87,   84,   71,   87,
+       91,   91,   84,   91,   91,  100,   92,   92,   91,   92,
+       92,   98,   93,   93,   92,   93,   93,  100,   36,   36,
+
+       93,   36,   36,  172,   99,   36,   38,  104,   38,  103,
+      104,  108,  103,   38,   38,  106,  108,  127,  106,   38,
+       99,   38,  114,  103,   38,  114,   38,   38,   94,   94,
+      114,   94,   94,  127,  182,  182,   94,  170,  169,  168,
+      164,  163,  162,   38,   38,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   69,  125,   95,   69,  149,   95,
+
+      150,  151,  152,  171,  161,  189,  160,  125,   69,  160,
+      174,  190,  180,  199,  149,  180,  150,  151,  152,  171,
+      160,  189,  174,  159,  200,  158,  180,  190,  201,  199,
+      205,  201,  157,  205,   69,   69,  156,   69,   69,   95,
+      200,   69,   78,  153,   78,  201,  148,  205,  147,   78,
+       78,  146,  145,  144,  141,   78,  140,   78,  139,  138,
+       78,  137,   78,   78,  136,  135,  134,  133,  132,  131,
+      130,  129,  128,  126,  124,  123,  122,  121,  120,   78,
+       78,  210,  210,  210,  210,  210,  210,  210,  211,  119,
+      118,  117,  211,  211,  212,  212,  212,  212,  212,  212,
+
+      212,  213,  116,  213,  214,  214,  214,  214,  214,  214,
+      214,  215,  215,  215,  215,  215,  215,  215,  216,  216,
+      216,  113,  216,  216,  216,  217,  112,  217,  111,  217,
+      217,  217,  218,  218,  218,  218,  218,  110,  218,  109,
+      107,  105,  101,   96,   90,   88,   86,   85,   82,   79,
+       77,   76,   75,   72,   63,   50,   49,   46,   41,   37,
+       30,   26,   25,   23,   15,   11,    5,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+
+      209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
+      209,  209,  209,  209,  209,  209,  209
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*-------------------------------------------------------------------------
+  Portions of this source have been derived from makedepf90 version 2.8.8,
+
+   Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
+
+  The code was originally distributed under the GPL but permission
+  from the copyright holder has been obtained to distribute this
+  derived work under the CMake license.
+-------------------------------------------------------------------------*/
+
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex -i --nounistd -DFLEXINT_H --noline --header-file=cmFortranLexer.h -ocmFortranLexer.cxx cmFortranLexer.in.l
+
+Modify cmFortranLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmFortranLexer.h cmFortranLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmFortranLexer.h cmFortranLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmFortranLexer.cxx
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#undef YY_NO_UNPUT
+
+#define cmFortranLexer_cxx
+#include "cmFortranParser.h" /* Interface to parser object.  */
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = cmFortranParser_Input(yyextra, buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmFortranParserTokens.h"
+
+/*--------------------------------------------------------------------------*/
+
+#define INITIAL 0
+#define free_fmt 1
+#define fixed_fmt 2
+#define str_sq 3
+#define str_dq 4
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput ( int c, char *buf_ptr  , yyscan_t yyscanner);
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	if ( yyleng > 0 ) \
+		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
+				(yytext[yyleng - 1] == '\n'); \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+		yy_current_state += YY_AT_BOL();
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 210 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 468 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{
+  cmFortranParser_StringStart(yyextra);
+  cmFortranParser_SetOldStartcond(yyextra, YY_START);
+  BEGIN(str_dq);
+}
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+{
+  cmFortranParser_StringStart(yyextra);
+  cmFortranParser_SetOldStartcond(yyextra, YY_START);
+  BEGIN(str_sq);
+}
+	YY_BREAK
+case 3:
+case 4:
+YY_RULE_SETUP
+{
+  BEGIN(cmFortranParser_GetOldStartcond(yyextra) );
+  yylvalp->string = strdup(cmFortranParser_StringEnd(yyextra));
+  return STRING;
+}
+	YY_BREAK
+case 5:
+/* rule 5 can match eol */
+case 6:
+/* rule 6 can match eol */
+YY_RULE_SETUP
+/* Ignore (continued strings, free fmt) */
+	YY_BREAK
+case 7:
+/* rule 7 can match eol */
+YY_RULE_SETUP
+{
+  if (cmFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
+    ; /* Ignore (cont. strings, fixed fmt) */
+  else
+    {
+    unput(yytext[strlen(yytext)-1]);
+    }
+}
+	YY_BREAK
+case 8:
+/* rule 8 can match eol */
+YY_RULE_SETUP
+{
+  unput ('\n');
+  BEGIN(INITIAL);
+  return UNTERMINATED_STRING;
+}
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+{
+  cmFortranParser_StringAppend(yyextra, yytext[0]);
+}
+	YY_BREAK
+case 10:
+/* rule 10 can match eol */
+YY_RULE_SETUP
+{ return EOSTMT; } /* Treat comments like */
+	YY_BREAK
+case 11:
+/* rule 11 can match eol */
+YY_RULE_SETUP
+{ return EOSTMT; } /* empty lines */
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{ return CPP_LINE_DIRECTIVE; }
+	YY_BREAK
+case 13:
+/* rule 13 can match eol */
+YY_RULE_SETUP
+{
+  yytext[yyleng-1] = 0;
+  yylvalp->string = strdup(strchr(yytext, '<')+1);
+  return CPP_INCLUDE_ANGLE;
+}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+{ return CPP_INCLUDE; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+{ return F90PPR_INCLUDE; }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+{ return COCO_INCLUDE; }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+{ return CPP_DEFINE; }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+{ return F90PPR_DEFINE; }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+{ return CPP_UNDEF; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+{ return F90PPR_UNDEF; }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+{ return CPP_IFDEF; }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+{ return CPP_IFNDEF; }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+{ return CPP_IF; }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+{ return CPP_ELIF; }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+{ return CPP_ELSE; }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+{ return CPP_ENDIF; }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+{ return F90PPR_IFDEF; }
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+{ return F90PPR_IFNDEF; }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+{ return F90PPR_IF; }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+{ return F90PPR_ELIF; }
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+{ return F90PPR_ELSE; }
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+{ return F90PPR_ENDIF; }
+	YY_BREAK
+/* Line continuations, possible involving comments.  */
+case 33:
+/* rule 33 can match eol */
+YY_RULE_SETUP
+
+	YY_BREAK
+case 34:
+/* rule 34 can match eol */
+YY_RULE_SETUP
+
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+{ return COMMA; }
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+{ return DCOLON; }
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+{ return COLON; }
+	YY_BREAK
+case 38:
+/* rule 38 can match eol */
+YY_RULE_SETUP
+{ return GARBAGE; }
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+{ return ASSIGNMENT_OP; }
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+{ return END; }
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+{ return INCLUDE; }
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+{ return INTERFACE; }
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+{ return MODULE; }
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+{ return SUBMODULE; }
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+{ return USE; }
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+{
+  yylvalp->string = strdup(yytext);
+  return WORD;
+}
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+{ return LPAREN; }
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+{ return RPAREN; }
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+{ return GARBAGE; }
+	YY_BREAK
+case 50:
+/* rule 50 can match eol */
+YY_RULE_SETUP
+{ return EOSTMT; }
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+/* Ignore */
+	YY_BREAK
+case 52:
+/* rule 52 can match eol */
+YY_RULE_SETUP
+/* Ignore line-endings preceded by \ */
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+{ return *yytext; }
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(free_fmt):
+case YY_STATE_EOF(fixed_fmt):
+case YY_STATE_EOF(str_sq):
+case YY_STATE_EOF(str_dq):
+{
+  if(!cmFortranParser_FilePop(yyextra) )
+    {
+    return YY_NULL;
+    }
+}
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+	yy_current_state += YY_AT_BOL();
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 210 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 210 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 209);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
+{
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    yy_cp = yyg->yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yyg->yy_hold_char;
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = yyg->yy_n_chars + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+	yyg->yytext_ptr = yy_bp;
+	yyg->yy_hold_char = *yy_cp;
+	yyg->yy_c_buf_p = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+/*--------------------------------------------------------------------------*/
+YY_BUFFER_STATE cmFortranLexer_GetCurrentBuffer(yyscan_t yyscanner)
+{
+  /* Hack into the internal flex-generated scanner to get the buffer.  */
+  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+  return YY_CURRENT_BUFFER;
+}
diff --git a/Source/LexerParser/cmFortranLexer.h b/Source/LexerParser/cmFortranLexer.h
new file mode 100644
index 0000000..7bb9b44
--- /dev/null
+++ b/Source/LexerParser/cmFortranLexer.h
@@ -0,0 +1,691 @@
+#ifndef cmFortran_yyHEADER_H
+#define cmFortran_yyHEADER_H 1
+#define cmFortran_yyIN_HEADER 1
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmFortran_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmFortran_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmFortran_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmFortran_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmFortran_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmFortran_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmFortran_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmFortran_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmFortran_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmFortran_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmFortran_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmFortran_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmFortran_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmFortran_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmFortran_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmFortran_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmFortran_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmFortran_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmFortran_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmFortran_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmFortran_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmFortran_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmFortran_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmFortran_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmFortran_yylex_ALREADY_DEFINED
+#else
+#define yylex cmFortran_yylex
+#endif
+
+#ifdef yyrestart
+#define cmFortran_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmFortran_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmFortran_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmFortran_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmFortran_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmFortran_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmFortran_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmFortran_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmFortran_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmFortran_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmFortran_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmFortran_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmFortran_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmFortran_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmFortran_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmFortran_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmFortran_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmFortran_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmFortran_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmFortran_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmFortran_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmFortran_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmFortran_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmFortran_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmFortran_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmFortran_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmFortran_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmFortran_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmFortran_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmFortran_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmFortran_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmFortran_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmFortran_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmFortran_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmFortran_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmFortran_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmFortran_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmFortran_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmFortran_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmFortran_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmFortran_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmFortran_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmFortran_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmFortran_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define cmFortran_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define free_fmt 1
+#define fixed_fmt 2
+#define str_sq 3
+#define str_dq 4
+
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef cmFortran_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef cmFortran_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef cmFortran_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef cmFortran_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef cmFortran_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef cmFortran_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef cmFortran_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef cmFortran_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef cmFortran_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef cmFortran_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef cmFortran_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef cmFortran_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef cmFortran_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef cmFortran_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef cmFortran_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef cmFortran_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef cmFortran_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef cmFortran_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef cmFortran_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef cmFortran_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef cmFortran_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef cmFortran_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef cmFortran_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef cmFortran_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef cmFortran_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef cmFortran_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef cmFortran_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef cmFortran_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef cmFortran_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef cmFortran_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef cmFortran_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef cmFortran_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef cmFortran_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef cmFortran_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef cmFortran_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef cmFortran_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef cmFortran_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef cmFortran_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef cmFortran_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef cmFortran_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef cmFortran_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef cmFortran_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef cmFortran_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef cmFortran_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef cmFortran_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef cmFortran_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef cmFortran_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef cmFortran_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#undef cmFortran_yyIN_HEADER
+#endif /* cmFortran_yyHEADER_H */
diff --git a/Source/LexerParser/cmFortranLexer.in.l b/Source/LexerParser/cmFortranLexer.in.l
new file mode 100644
index 0000000..9acba4c
--- /dev/null
+++ b/Source/LexerParser/cmFortranLexer.in.l
@@ -0,0 +1,185 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*-------------------------------------------------------------------------
+  Portions of this source have been derived from makedepf90 version 2.8.8,
+
+   Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
+
+  The code was originally distributed under the GPL but permission
+  from the copyright holder has been obtained to distribute this
+  derived work under the CMake license.
+-------------------------------------------------------------------------*/
+
+/*
+
+This file must be translated to C++ and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex -i --nounistd -DFLEXINT_H --noline --header-file=cmFortranLexer.h -ocmFortranLexer.cxx cmFortranLexer.in.l
+
+Modify cmFortranLexer.cxx:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmFortranLexer.h cmFortranLexer.cxx
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmFortranLexer.h cmFortranLexer.cxx
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmFortranLexer.cxx
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#undef YY_NO_UNPUT
+
+#define cmFortranLexer_cxx
+#include "cmFortranParser.h" /* Interface to parser object.  */
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = cmFortranParser_Input(yyextra, buf, max_size); }
+
+/* Include the set of tokens from the parser.  */
+#include "cmFortranParserTokens.h"
+
+/*--------------------------------------------------------------------------*/
+%}
+
+%option prefix="cmFortran_yy"
+
+%option reentrant
+%option noyywrap
+%pointer
+
+%s free_fmt fixed_fmt
+%x str_sq str_dq
+
+%%
+
+\"              {
+  cmFortranParser_StringStart(yyextra);
+  cmFortranParser_SetOldStartcond(yyextra, YY_START);
+  BEGIN(str_dq);
+}
+
+'               {
+  cmFortranParser_StringStart(yyextra);
+  cmFortranParser_SetOldStartcond(yyextra, YY_START);
+  BEGIN(str_sq);
+}
+
+<str_dq>\" |
+<str_sq>'  {
+  BEGIN(cmFortranParser_GetOldStartcond(yyextra) );
+  yylvalp->string = strdup(cmFortranParser_StringEnd(yyextra));
+  return STRING;
+}
+
+<str_dq,str_sq>&[ \t]*\n |
+<str_dq,str_sq>&[ \t]*\n[ \t]*&  /* Ignore (continued strings, free fmt) */
+
+<fixed_fmt,str_dq,str_sq>\n[ ]{5}[^ \t\n] {
+  if (cmFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
+    ; /* Ignore (cont. strings, fixed fmt) */
+  else
+    {
+    unput(yytext[strlen(yytext)-1]);
+    }
+}
+
+
+<str_dq,str_sq>\n {
+  unput ('\n');
+  BEGIN(INITIAL);
+  return UNTERMINATED_STRING;
+}
+
+<str_sq,str_dq>. {
+  cmFortranParser_StringAppend(yyextra, yytext[0]);
+}
+
+!.*\n                   { return EOSTMT; } /* Treat comments like */
+<fixed_fmt>^[cC*dD].*\n { return EOSTMT; } /* empty lines */
+
+^[ \t]*#([ \t]*line)?[ \t]*[0-9]+[ \t]* { return CPP_LINE_DIRECTIVE; }
+^[ \t]*#[ \t]*include[ \t]*<[^>]+> {
+  yytext[yyleng-1] = 0;
+  yylvalp->string = strdup(strchr(yytext, '<')+1);
+  return CPP_INCLUDE_ANGLE;
+}
+^[ \t]*#[ \t]*include  { return CPP_INCLUDE; }
+\$[ \t]*include { return F90PPR_INCLUDE; }
+\?\?[ \t]*include { return COCO_INCLUDE; }
+
+^[ \t]*#[ \t]*define   { return CPP_DEFINE; }
+\$[ \t]*DEFINE   { return F90PPR_DEFINE; }
+
+^[ \t]*#[ \t]*undef    { return CPP_UNDEF; }
+\$[ \t]*UNDEF   { return F90PPR_UNDEF; }
+
+^[ \t]*#[ \t]*ifdef    { return CPP_IFDEF; }
+^[ \t]*#[ \t]*ifndef   { return CPP_IFNDEF; }
+^[ \t]*#[ \t]*if       { return CPP_IF; }
+^[ \t]*#[ \t]*elif     { return CPP_ELIF; }
+^[ \t]*#[ \t]*else     { return CPP_ELSE; }
+^[ \t]*#[ \t]*endif    { return CPP_ENDIF; }
+
+$[ \t]*ifdef    { return F90PPR_IFDEF; }
+$[ \t]*ifndef   { return F90PPR_IFNDEF; }
+$[ \t]*if       { return F90PPR_IF; }
+$[ \t]*elif     { return F90PPR_ELIF; }
+$[ \t]*else     { return F90PPR_ELSE; }
+$[ \t]*endif    { return F90PPR_ENDIF; }
+
+ /* Line continuations, possible involving comments.  */
+&([ \t\n]*|!.*)*
+&([ \t\n]*|!.*)*&
+
+, { return COMMA; }
+
+:: { return DCOLON; }
+: { return COLON; }
+
+<fixed_fmt>\n[ ]{5}[^ ]  { return GARBAGE; }
+
+=|=>                     { return ASSIGNMENT_OP; }
+
+[Ee][Nn][Dd] { return END; }
+[Ii][Nn][Cc][Ll][Uu][Dd][Ee] { return INCLUDE; }
+[Ii][Nn][Tt][Ee][Rr][Ff][Aa][Cc][Ee] { return INTERFACE; }
+[Mm][Oo][Dd][Uu][Ll][Ee] { return MODULE; }
+[Ss][Uu][bb][Mm][Oo][Dd][Uu][Ll][Ee] { return SUBMODULE; }
+[Uu][Ss][Ee] { return USE; }
+
+[a-zA-Z_][a-zA-Z_0-9]* {
+  yylvalp->string = strdup(yytext);
+  return WORD;
+}
+
+\( { return LPAREN; }
+\) { return RPAREN; }
+
+[^ \t\n\r:;,!'"a-zA-Z=&()]+ { return GARBAGE; }
+
+;|\n { return EOSTMT; }
+
+
+[ \t\r,]         /* Ignore */
+\\[ \t]*\n       /* Ignore line-endings preceded by \ */
+
+. { return *yytext; }
+
+<<EOF>> {
+  if(!cmFortranParser_FilePop(yyextra) )
+    {
+    return YY_NULL;
+    }
+}
+
+%%
+
+/*--------------------------------------------------------------------------*/
+YY_BUFFER_STATE cmFortranLexer_GetCurrentBuffer(yyscan_t yyscanner)
+{
+  /* Hack into the internal flex-generated scanner to get the buffer.  */
+  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+  return YY_CURRENT_BUFFER;
+}
diff --git a/Source/LexerParser/cmFortranParser.cxx b/Source/LexerParser/cmFortranParser.cxx
new file mode 100644
index 0000000..2b3452f
--- /dev/null
+++ b/Source/LexerParser/cmFortranParser.cxx
@@ -0,0 +1,1988 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names.  */
+#define yyparse         cmFortran_yyparse
+#define yylex           cmFortran_yylex
+#define yyerror         cmFortran_yyerror
+#define yydebug         cmFortran_yydebug
+#define yynerrs         cmFortran_yynerrs
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "cmFortranParser.y" /* yacc.c:339  */
+
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*-------------------------------------------------------------------------
+  Portions of this source have been derived from makedepf90 version 2.8.8,
+
+   Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
+
+  The code was originally distributed under the GPL but permission
+  from the copyright holder has been obtained to distribute this
+  derived work under the CMake license.
+-------------------------------------------------------------------------*/
+
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmFortran_yy
+        --defines=cmFortranParserTokens.h
+         -ocmFortranParser.cxx
+          cmFortranParser.y
+
+Modify cmFortranParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/String.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*-------------------------------------------------------------------------*/
+#define cmFortranParser_cxx
+#include "cmFortranParser.h" /* Interface to parser object.  */
+#include "cmFortranParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmFortran_yyerror(yyscan_t yyscanner, const char* message)
+{
+  cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+  cmFortranParser_Error(parser, message);
+}
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch contains default but no case. */
+# pragma warning (disable: 4701) /* Local variable may not be initialized.  */
+# pragma warning (disable: 4702) /* Unreachable code.  */
+# pragma warning (disable: 4127) /* Conditional expression is constant.  */
+# pragma warning (disable: 4244) /* Conversion to smaller type, data loss. */
+#endif
+
+#line 132 "cmFortranParser.cxx" /* yacc.c:339  */
+
+# ifndef YY_NULLPTR
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULLPTR nullptr
+#  else
+#   define YY_NULLPTR 0
+#  endif
+# endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+   by #include "cmFortranParserTokens.h".  */
+#ifndef YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
+# define YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmFortran_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    EOSTMT = 258,
+    ASSIGNMENT_OP = 259,
+    GARBAGE = 260,
+    CPP_LINE_DIRECTIVE = 261,
+    CPP_INCLUDE = 262,
+    F90PPR_INCLUDE = 263,
+    COCO_INCLUDE = 264,
+    F90PPR_DEFINE = 265,
+    CPP_DEFINE = 266,
+    F90PPR_UNDEF = 267,
+    CPP_UNDEF = 268,
+    CPP_IFDEF = 269,
+    CPP_IFNDEF = 270,
+    CPP_IF = 271,
+    CPP_ELSE = 272,
+    CPP_ELIF = 273,
+    CPP_ENDIF = 274,
+    F90PPR_IFDEF = 275,
+    F90PPR_IFNDEF = 276,
+    F90PPR_IF = 277,
+    F90PPR_ELSE = 278,
+    F90PPR_ELIF = 279,
+    F90PPR_ENDIF = 280,
+    COMMA = 281,
+    COLON = 282,
+    DCOLON = 283,
+    LPAREN = 284,
+    RPAREN = 285,
+    UNTERMINATED_STRING = 286,
+    STRING = 287,
+    WORD = 288,
+    CPP_INCLUDE_ANGLE = 289,
+    END = 290,
+    INCLUDE = 291,
+    INTERFACE = 292,
+    MODULE = 293,
+    SUBMODULE = 294,
+    USE = 295
+  };
+#endif
+/* Tokens.  */
+#define EOSTMT 258
+#define ASSIGNMENT_OP 259
+#define GARBAGE 260
+#define CPP_LINE_DIRECTIVE 261
+#define CPP_INCLUDE 262
+#define F90PPR_INCLUDE 263
+#define COCO_INCLUDE 264
+#define F90PPR_DEFINE 265
+#define CPP_DEFINE 266
+#define F90PPR_UNDEF 267
+#define CPP_UNDEF 268
+#define CPP_IFDEF 269
+#define CPP_IFNDEF 270
+#define CPP_IF 271
+#define CPP_ELSE 272
+#define CPP_ELIF 273
+#define CPP_ENDIF 274
+#define F90PPR_IFDEF 275
+#define F90PPR_IFNDEF 276
+#define F90PPR_IF 277
+#define F90PPR_ELSE 278
+#define F90PPR_ELIF 279
+#define F90PPR_ENDIF 280
+#define COMMA 281
+#define COLON 282
+#define DCOLON 283
+#define LPAREN 284
+#define RPAREN 285
+#define UNTERMINATED_STRING 286
+#define STRING 287
+#define WORD 288
+#define CPP_INCLUDE_ANGLE 289
+#define END 290
+#define INCLUDE 291
+#define INTERFACE 292
+#define MODULE 293
+#define SUBMODULE 294
+#define USE 295
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 70 "cmFortranParser.y" /* yacc.c:355  */
+
+  char* string;
+
+#line 256 "cmFortranParser.cxx" /* yacc.c:355  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+int cmFortran_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED  */
+
+/* Copy the second part of user declarations.  */
+
+#line 272 "cmFortranParser.cxx" /* yacc.c:358  */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+    _Pragma ("GCC diagnostic push") \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYSIZE_T yynewbytes;                                            \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  2
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   593
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  41
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  14
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  63
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  126
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+   by yylex, with out-of-bounds checking.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   295
+
+#define YYTRANSLATE(YYX)                                                \
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, without out-of-bounds checking.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40
+};
+
+#if YYDEBUG
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,    98,    98,    98,   101,   105,   110,   119,   125,   132,
+     137,   141,   146,   154,   159,   164,   169,   174,   179,   184,
+     189,   194,   198,   202,   206,   210,   211,   216,   216,   216,
+     217,   217,   218,   218,   219,   219,   220,   220,   221,   221,
+     222,   222,   223,   223,   224,   224,   225,   225,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "EOSTMT", "ASSIGNMENT_OP", "GARBAGE",
+  "CPP_LINE_DIRECTIVE", "CPP_INCLUDE", "F90PPR_INCLUDE", "COCO_INCLUDE",
+  "F90PPR_DEFINE", "CPP_DEFINE", "F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF",
+  "CPP_IFNDEF", "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF",
+  "F90PPR_IFDEF", "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE",
+  "F90PPR_ELIF", "F90PPR_ENDIF", "COMMA", "COLON", "DCOLON", "LPAREN",
+  "RPAREN", "UNTERMINATED_STRING", "STRING", "WORD", "CPP_INCLUDE_ANGLE",
+  "END", "INCLUDE", "INTERFACE", "MODULE", "SUBMODULE", "USE", "$accept",
+  "code", "stmt", "include", "define", "undef", "ifdef", "ifndef", "if",
+  "elif", "else", "endif", "other", "misc_code", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+   (internal) symbol number NUM (which must be that of a token).  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295
+};
+# endif
+
+#define YYPACT_NINF -39
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-39)))
+
+#define YYTABLE_NINF -1
+
+#define yytable_value_is_error(Yytable_value) \
+  0
+
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+     STATE-NUM.  */
+static const yytype_int16 yypact[] =
+{
+     -39,    21,   -39,     1,   -39,   -20,   -39,   -39,   -39,   -39,
+     -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,
+     -39,   -39,   -39,   -39,   -39,   -39,   -24,   -18,    20,    -8,
+      -3,    39,   -39,    15,    16,    18,    19,    33,   -39,   -39,
+     -39,   -39,   -39,   -39,    59,   -39,   -39,   -39,   -39,   -39,
+      35,    36,    37,   -39,   -39,   -39,   -39,   -39,   -39,    76,
+     114,   129,   167,   182,   -39,   -39,   -39,   -39,   -39,   -39,
+     -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,
+     -39,   -39,   220,   235,   273,   288,   -21,    26,   -39,   326,
+     341,   379,   394,   432,   447,   -39,   -39,   -39,   -39,   -39,
+     -39,   -39,   -39,   -39,    38,    40,    41,   485,   -39,   -39,
+     -39,   -39,   -39,   -39,    45,   -39,   -39,   -39,    43,   500,
+     538,   -39,   -39,   -39,   553,   -39
+};
+
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+     Performed when YYTABLE does not specify something else to do.  Zero
+     means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       2,     0,     1,     0,    25,     0,    27,    28,    29,    31,
+      30,    33,    32,    34,    36,    38,    42,    40,    44,    35,
+      37,    39,    43,    41,    45,    46,     0,     0,     0,     0,
+       0,     0,     3,     0,     0,     0,     0,     0,    46,    46,
+      46,    46,    26,    46,     0,    46,    46,     4,    46,    46,
+       0,     0,     0,    46,    46,    46,    46,    46,    46,     0,
+       0,     0,     0,     0,    15,    57,    56,    62,    58,    59,
+      60,    61,    63,    55,    48,    49,    50,    51,    52,    53,
+      54,    47,     0,     0,     0,     0,     0,     0,    46,     0,
+       0,     0,     0,     0,     0,    21,    22,    23,    24,    14,
+      10,    13,     9,     6,     0,     0,     0,     0,     5,    16,
+      17,    18,    19,    20,     0,    46,    46,    11,     0,     0,
+       0,    46,     7,    12,     0,     8
+};
+
+  /* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+     -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,   -39,
+     -39,   -39,   -38,   -39
+};
+
+  /* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,     1,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    44,    81
+};
+
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+     positive, shift that token.  If negative, reduce the rule whose
+     number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_uint8 yytable[] =
+{
+      59,    60,    61,    62,    42,    63,   104,    82,    83,   105,
+      84,    85,    43,    45,    46,    89,    90,    91,    92,    93,
+      94,     2,     3,    47,     4,    49,    50,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    54,     0,    55,
+     107,    56,    57,    48,   106,    25,    26,    27,    28,    29,
+      30,    31,    64,    65,    66,    51,    58,    52,    86,    87,
+      88,   114,    53,   115,   116,   118,   121,   119,   120,    95,
+      65,    66,     0,   124,     0,    67,    68,    69,    70,    71,
+      72,    73,    74,     0,    75,    76,    77,    78,    79,    80,
+       0,     0,    67,    68,    69,    70,    71,    72,    73,    74,
+       0,    75,    76,    77,    78,    79,    80,    96,    65,    66,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    97,    65,    66,     0,     0,     0,     0,     0,
+      67,    68,    69,    70,    71,    72,    73,    74,     0,    75,
+      76,    77,    78,    79,    80,    67,    68,    69,    70,    71,
+      72,    73,    74,     0,    75,    76,    77,    78,    79,    80,
+      98,    65,    66,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    99,    65,    66,     0,     0,
+       0,     0,     0,    67,    68,    69,    70,    71,    72,    73,
+      74,     0,    75,    76,    77,    78,    79,    80,    67,    68,
+      69,    70,    71,    72,    73,    74,     0,    75,    76,    77,
+      78,    79,    80,   100,    65,    66,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   101,    65,
+      66,     0,     0,     0,     0,     0,    67,    68,    69,    70,
+      71,    72,    73,    74,     0,    75,    76,    77,    78,    79,
+      80,    67,    68,    69,    70,    71,    72,    73,    74,     0,
+      75,    76,    77,    78,    79,    80,   102,    65,    66,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   103,    65,    66,     0,     0,     0,     0,     0,    67,
+      68,    69,    70,    71,    72,    73,    74,     0,    75,    76,
+      77,    78,    79,    80,    67,    68,    69,    70,    71,    72,
+      73,    74,     0,    75,    76,    77,    78,    79,    80,   108,
+      65,    66,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   109,    65,    66,     0,     0,     0,
+       0,     0,    67,    68,    69,    70,    71,    72,    73,    74,
+       0,    75,    76,    77,    78,    79,    80,    67,    68,    69,
+      70,    71,    72,    73,    74,     0,    75,    76,    77,    78,
+      79,    80,   110,    65,    66,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   111,    65,    66,
+       0,     0,     0,     0,     0,    67,    68,    69,    70,    71,
+      72,    73,    74,     0,    75,    76,    77,    78,    79,    80,
+      67,    68,    69,    70,    71,    72,    73,    74,     0,    75,
+      76,    77,    78,    79,    80,   112,    65,    66,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     113,    65,    66,     0,     0,     0,     0,     0,    67,    68,
+      69,    70,    71,    72,    73,    74,     0,    75,    76,    77,
+      78,    79,    80,    67,    68,    69,    70,    71,    72,    73,
+      74,     0,    75,    76,    77,    78,    79,    80,   117,    65,
+      66,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   122,    65,    66,     0,     0,     0,     0,
+       0,    67,    68,    69,    70,    71,    72,    73,    74,     0,
+      75,    76,    77,    78,    79,    80,    67,    68,    69,    70,
+      71,    72,    73,    74,     0,    75,    76,    77,    78,    79,
+      80,   123,    65,    66,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   125,    65,    66,     0,
+       0,     0,     0,     0,    67,    68,    69,    70,    71,    72,
+      73,    74,     0,    75,    76,    77,    78,    79,    80,    67,
+      68,    69,    70,    71,    72,    73,    74,     0,    75,    76,
+      77,    78,    79,    80
+};
+
+static const yytype_int8 yycheck[] =
+{
+      38,    39,    40,    41,     3,    43,    27,    45,    46,    30,
+      48,    49,    32,    37,    32,    53,    54,    55,    56,    57,
+      58,     0,     1,     3,     3,    33,    29,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    32,    -1,    33,
+      88,    33,    33,    33,    28,    34,    35,    36,    37,    38,
+      39,    40,     3,     4,     5,    26,    33,    28,    33,    33,
+      33,    33,    33,    33,    33,    30,    33,   115,   116,     3,
+       4,     5,    -1,   121,    -1,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    40,
+      -1,    -1,    26,    27,    28,    29,    30,    31,    32,    33,
+      -1,    35,    36,    37,    38,    39,    40,     3,     4,     5,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,     4,     5,    -1,    -1,    -1,    -1,    -1,
+      26,    27,    28,    29,    30,    31,    32,    33,    -1,    35,
+      36,    37,    38,    39,    40,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    40,
+       3,     4,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,
+      -1,    -1,    -1,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    40,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    40,     3,     4,     5,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,
+      30,    31,    32,    33,    -1,    35,    36,    37,    38,    39,
+      40,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    40,     3,     4,     5,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     3,     4,     5,    -1,    -1,    -1,    -1,    -1,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    40,    26,    27,    28,    29,    30,    31,
+      32,    33,    -1,    35,    36,    37,    38,    39,    40,     3,
+       4,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,
+      -1,    -1,    26,    27,    28,    29,    30,    31,    32,    33,
+      -1,    35,    36,    37,    38,    39,    40,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    40,     3,     4,     5,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
+      -1,    -1,    -1,    -1,    -1,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    40,
+      26,    27,    28,    29,    30,    31,    32,    33,    -1,    35,
+      36,    37,    38,    39,    40,     3,     4,     5,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,    -1,    -1,    -1,    -1,    -1,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    40,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    40,     3,     4,
+       5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,    -1,
+      -1,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    40,    26,    27,    28,    29,
+      30,    31,    32,    33,    -1,    35,    36,    37,    38,    39,
+      40,     3,     4,     5,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
+      -1,    -1,    -1,    -1,    26,    27,    28,    29,    30,    31,
+      32,    33,    -1,    35,    36,    37,    38,    39,    40,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    40
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,    42,     0,     1,     3,     6,     7,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    34,    35,    36,    37,    38,
+      39,    40,    43,    44,    45,    46,    47,    48,    49,    50,
+      51,    52,     3,    32,    53,    37,    32,     3,    33,    33,
+      29,    26,    28,    33,    32,    33,    33,    33,    33,    53,
+      53,    53,    53,    53,     3,     4,     5,    26,    27,    28,
+      29,    30,    31,    32,    33,    35,    36,    37,    38,    39,
+      40,    54,    53,    53,    53,    53,    33,    33,    33,    53,
+      53,    53,    53,    53,    53,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,    27,    30,    28,    53,     3,     3,
+       3,     3,     3,     3,    33,    33,    33,     3,    30,    53,
+      53,    33,     3,     3,    53,     3
+};
+
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    41,    42,    42,    43,    43,    43,    43,    43,    43,
+      43,    43,    43,    43,    43,    43,    43,    43,    43,    43,
+      43,    43,    43,    43,    43,    43,    43,    44,    44,    44,
+      45,    45,    46,    46,    47,    47,    48,    48,    49,    49,
+      50,    50,    51,    51,    52,    52,    53,    53,    54,    54,
+      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
+      54,    54,    54,    54
+};
+
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     0,     2,     2,     4,     4,     7,     9,     4,
+       4,     5,     7,     4,     4,     3,     4,     4,     4,     4,
+       4,     3,     3,     3,     3,     1,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     0,     2,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1
+};
+
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+#define YYEMPTY         (-2)
+#define YYEOF           0
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
+      yyerror (yyscanner, YY_("syntax error: cannot back up")); \
+      YYERROR;                                                  \
+    }                                                           \
+while (0)
+
+/* Error token number */
+#define YYTERROR        1
+#define YYERRCODE       256
+
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Type, Value, yyscanner); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT.  |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
+  YYUSE (yyscanner);
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+  YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner)
+{
+  YYFPRINTF (yyoutput, "%s %s (",
+             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner)
+{
+  unsigned long int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       yystos[yyssp[yyi + 1 - yynrhs]],
+                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                                              , yyscanner);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+        switch (*++yyp)
+          {
+          case '\'':
+          case ',':
+            goto do_not_strip_quotes;
+
+          case '\\':
+            if (*++yyp != '\\')
+              goto do_not_strip_quotes;
+            /* Fall through.  */
+          default:
+            if (yyres)
+              yyres[yyn] = *yyp;
+            yyn++;
+            break;
+
+          case '"':
+            if (yyres)
+              yyres[yyn] = '\0';
+            return yyn;
+          }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = YY_NULLPTR;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                {
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+                  if (! (yysize <= yysize1
+                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                    return 2;
+                  yysize = yysize1;
+                }
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  {
+    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+      return 2;
+    yysize = yysize1;
+  }
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, yyscan_t yyscanner)
+{
+  YYUSE (yyvaluep);
+  YYUSE (yyscanner);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YYUSE (yytype);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (yyscan_t yyscanner)
+{
+/* The lookahead symbol.  */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol.  */
+/* Default value used for initialization, for pacifying older GCCs
+   or non-GCC compilers.  */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       'yyss': related to states.
+       'yyvs': related to semantic values.
+
+       Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yyssp = yyss = yyssa;
+  yyvsp = yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        yytype_int16 *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yytype_int16 *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyexhaustedlab;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = yylex (&yylval, yyscanner);
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 4:
+#line 101 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, true);
+  }
+#line 1536 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 5:
+#line 105 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1546 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 6:
+#line 110 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    if (cmsysString_strcasecmp((yyvsp[-2].string), "function") != 0 &&
+        cmsysString_strcasecmp((yyvsp[-2].string), "procedure") != 0 &&
+        cmsysString_strcasecmp((yyvsp[-2].string), "subroutine") != 0) {
+      cmFortranParser_RuleModule(parser, (yyvsp[-2].string));
+    }
+    free((yyvsp[-2].string));
+  }
+#line 1560 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 7:
+#line 119 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, (yyvsp[-4].string));
+    free((yyvsp[-4].string));
+    free((yyvsp[-2].string));
+  }
+#line 1571 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 8:
+#line 125 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, (yyvsp[-6].string));
+    free((yyvsp[-6].string));
+    free((yyvsp[-4].string));
+    free((yyvsp[-2].string));
+  }
+#line 1583 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 9:
+#line 132 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, true);
+    free((yyvsp[-2].string));
+  }
+#line 1593 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 10:
+#line 137 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, false);
+  }
+#line 1602 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 11:
+#line 141 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1612 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 12:
+#line 146 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    if (cmsysString_strcasecmp((yyvsp[-4].string), "non_intrinsic") == 0) {
+      cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+      cmFortranParser_RuleUse(parser, (yyvsp[-2].string));
+    }
+    free((yyvsp[-4].string));
+    free((yyvsp[-2].string));
+  }
+#line 1625 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 13:
+#line 154 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1635 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 14:
+#line 159 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1645 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 15:
+#line 164 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1655 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 16:
+#line 169 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1665 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 17:
+#line 174 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleDefine(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1675 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 18:
+#line 179 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUndef(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1685 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 19:
+#line 184 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIfdef(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1695 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 20:
+#line 189 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIfndef(parser, (yyvsp[-2].string));
+    free((yyvsp[-2].string));
+  }
+#line 1705 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 21:
+#line 194 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIf(parser);
+  }
+#line 1714 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 22:
+#line 198 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleElif(parser);
+  }
+#line 1723 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 23:
+#line 202 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleElse(parser);
+  }
+#line 1732 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 24:
+#line 206 "cmFortranParser.y" /* yacc.c:1646  */
+    {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleEndif(parser);
+  }
+#line 1741 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 48:
+#line 228 "cmFortranParser.y" /* yacc.c:1646  */
+    { free ((yyvsp[0].string)); }
+#line 1747 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+  case 55:
+#line 235 "cmFortranParser.y" /* yacc.c:1646  */
+    { free ((yyvsp[0].string)); }
+#line 1753 "cmFortranParser.cxx" /* yacc.c:1646  */
+    break;
+
+
+#line 1757 "cmFortranParser.cxx" /* yacc.c:1646  */
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (yyscanner, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (yyscanner, yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, yyscanner);
+          yychar = YYEMPTY;
+        }
+    }
+
+#if 0
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+#endif
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYTERROR;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+
+      yydestruct ("Error: popping",
+                  yystos[yystate], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (yyscanner, YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, yyscanner);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  yystos[*yyssp], yyvsp, yyscanner);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  return yyresult;
+}
+#line 246 "cmFortranParser.y" /* yacc.c:1906  */
+
+/* End of grammar */
diff --git a/Source/LexerParser/cmFortranParser.y b/Source/LexerParser/cmFortranParser.y
new file mode 100644
index 0000000..acfb40a
--- /dev/null
+++ b/Source/LexerParser/cmFortranParser.y
@@ -0,0 +1,247 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*-------------------------------------------------------------------------
+  Portions of this source have been derived from makedepf90 version 2.8.8,
+
+   Copyright (C) 2000--2006 Erik Edelmann <erik.edelmann@iki.fi>
+
+  The code was originally distributed under the GPL but permission
+  from the copyright holder has been obtained to distribute this
+  derived work under the CMake license.
+-------------------------------------------------------------------------*/
+
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run bison like this:
+
+  bison --yacc --name-prefix=cmFortran_yy
+        --defines=cmFortranParserTokens.h
+         -ocmFortranParser.cxx
+          cmFortranParser.y
+
+Modify cmFortranParser.cxx:
+  - "#if 0" out yyerrorlab block in range ["goto yyerrlab1", "yyerrlab1:"]
+*/
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/String.h"
+#include <stdlib.h>
+#include <string.h>
+
+/*-------------------------------------------------------------------------*/
+#define cmFortranParser_cxx
+#include "cmFortranParser.h" /* Interface to parser object.  */
+#include "cmFortranParserTokens.h" /* Need YYSTYPE for YY_DECL.  */
+
+/* Forward declare the lexer entry point.  */
+YY_DECL;
+
+/* Helper function to forward error callback from parser.  */
+static void cmFortran_yyerror(yyscan_t yyscanner, const char* message)
+{
+  cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+  cmFortranParser_Error(parser, message);
+}
+
+/* Disable some warnings in the generated code.  */
+#ifdef _MSC_VER
+# pragma warning (disable: 4102) /* Unused goto label.  */
+# pragma warning (disable: 4065) /* Switch contains default but no case. */
+# pragma warning (disable: 4701) /* Local variable may not be initialized.  */
+# pragma warning (disable: 4702) /* Unreachable code.  */
+# pragma warning (disable: 4127) /* Conditional expression is constant.  */
+# pragma warning (disable: 4244) /* Conversion to smaller type, data loss. */
+#endif
+%}
+
+/* Generate a reentrant parser object.  */
+%define api.pure
+
+/* Configure the parser to use a lexer object.  */
+%lex-param   {yyscan_t yyscanner}
+%parse-param {yyscan_t yyscanner}
+
+%define parse.error verbose
+
+%union {
+  char* string;
+}
+
+/*-------------------------------------------------------------------------*/
+/* Tokens */
+%token EOSTMT ASSIGNMENT_OP GARBAGE
+%token CPP_LINE_DIRECTIVE
+%token CPP_INCLUDE F90PPR_INCLUDE COCO_INCLUDE
+%token F90PPR_DEFINE CPP_DEFINE F90PPR_UNDEF CPP_UNDEF
+%token CPP_IFDEF CPP_IFNDEF CPP_IF CPP_ELSE CPP_ELIF CPP_ENDIF
+%token F90PPR_IFDEF F90PPR_IFNDEF F90PPR_IF
+%token F90PPR_ELSE F90PPR_ELIF F90PPR_ENDIF
+%token COMMA COLON DCOLON LPAREN RPAREN
+%token <number> UNTERMINATED_STRING
+%token <string> STRING WORD
+%token <string> CPP_INCLUDE_ANGLE
+%token END
+%token INCLUDE
+%token INTERFACE
+%token MODULE
+%token SUBMODULE
+%token USE
+
+/*-------------------------------------------------------------------------*/
+/* grammar */
+%%
+
+code: /* empty */ | code stmt;
+
+stmt:
+  INTERFACE EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, true);
+  }
+| USE WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, $2);
+    free($2);
+  }
+| MODULE WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    if (cmsysString_strcasecmp($2, "function") != 0 &&
+        cmsysString_strcasecmp($2, "procedure") != 0 &&
+        cmsysString_strcasecmp($2, "subroutine") != 0) {
+      cmFortranParser_RuleModule(parser, $2);
+    }
+    free($2);
+  }
+| SUBMODULE LPAREN WORD RPAREN WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, $3);
+    free($3);
+    free($5);
+  }
+| SUBMODULE LPAREN WORD COLON WORD RPAREN WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, $3);
+    free($3);
+    free($5);
+    free($7);
+  }
+| INTERFACE WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, true);
+    free($2);
+  }
+| END INTERFACE other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_SetInInterface(parser, false);
+  }
+| USE DCOLON WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUse(parser, $3);
+    free($3);
+  }
+| USE COMMA WORD DCOLON WORD other EOSTMT {
+    if (cmsysString_strcasecmp($3, "non_intrinsic") == 0) {
+      cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+      cmFortranParser_RuleUse(parser, $5);
+    }
+    free($3);
+    free($5);
+  }
+| INCLUDE STRING other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, $2);
+    free($2);
+  }
+| CPP_LINE_DIRECTIVE STRING other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleLineDirective(parser, $2);
+    free($2);
+  }
+| CPP_INCLUDE_ANGLE other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, $1);
+    free($1);
+  }
+| include STRING other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleInclude(parser, $2);
+    free($2);
+  }
+| define WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleDefine(parser, $2);
+    free($2);
+  }
+| undef WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleUndef(parser, $2);
+    free($2);
+  }
+| ifdef WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIfdef(parser, $2);
+    free($2);
+  }
+| ifndef WORD other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIfndef(parser, $2);
+    free($2);
+  }
+| if other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleIf(parser);
+  }
+| elif other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleElif(parser);
+  }
+| else other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleElse(parser);
+  }
+| endif other EOSTMT {
+    cmFortranParser* parser = cmFortran_yyget_extra(yyscanner);
+    cmFortranParser_RuleEndif(parser);
+  }
+| EOSTMT
+| error EOSTMT /* tolerate unknown statements until their end */
+;
+
+
+
+include: CPP_INCLUDE | F90PPR_INCLUDE | COCO_INCLUDE ;
+define: CPP_DEFINE | F90PPR_DEFINE;
+undef: CPP_UNDEF | F90PPR_UNDEF ;
+ifdef: CPP_IFDEF | F90PPR_IFDEF ;
+ifndef: CPP_IFNDEF | F90PPR_IFNDEF ;
+if: CPP_IF | F90PPR_IF ;
+elif: CPP_ELIF | F90PPR_ELIF ;
+else: CPP_ELSE | F90PPR_ELSE ;
+endif: CPP_ENDIF | F90PPR_ENDIF ;
+other: /* empty */ | other misc_code ;
+
+misc_code:
+  WORD                { free ($1); }
+| END
+| INCLUDE
+| INTERFACE
+| MODULE
+| SUBMODULE
+| USE
+| STRING              { free ($1); }
+| GARBAGE
+| ASSIGNMENT_OP
+| COLON
+| DCOLON
+| LPAREN
+| RPAREN
+| COMMA
+| UNTERMINATED_STRING
+;
+
+%%
+/* End of grammar */
diff --git a/Source/LexerParser/cmFortranParserTokens.h b/Source/LexerParser/cmFortranParserTokens.h
new file mode 100644
index 0000000..8d6a5fe
--- /dev/null
+++ b/Source/LexerParser/cmFortranParserTokens.h
@@ -0,0 +1,149 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
+# define YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int cmFortran_yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    EOSTMT = 258,
+    ASSIGNMENT_OP = 259,
+    GARBAGE = 260,
+    CPP_LINE_DIRECTIVE = 261,
+    CPP_INCLUDE = 262,
+    F90PPR_INCLUDE = 263,
+    COCO_INCLUDE = 264,
+    F90PPR_DEFINE = 265,
+    CPP_DEFINE = 266,
+    F90PPR_UNDEF = 267,
+    CPP_UNDEF = 268,
+    CPP_IFDEF = 269,
+    CPP_IFNDEF = 270,
+    CPP_IF = 271,
+    CPP_ELSE = 272,
+    CPP_ELIF = 273,
+    CPP_ENDIF = 274,
+    F90PPR_IFDEF = 275,
+    F90PPR_IFNDEF = 276,
+    F90PPR_IF = 277,
+    F90PPR_ELSE = 278,
+    F90PPR_ELIF = 279,
+    F90PPR_ENDIF = 280,
+    COMMA = 281,
+    COLON = 282,
+    DCOLON = 283,
+    LPAREN = 284,
+    RPAREN = 285,
+    UNTERMINATED_STRING = 286,
+    STRING = 287,
+    WORD = 288,
+    CPP_INCLUDE_ANGLE = 289,
+    END = 290,
+    INCLUDE = 291,
+    INTERFACE = 292,
+    MODULE = 293,
+    SUBMODULE = 294,
+    USE = 295
+  };
+#endif
+/* Tokens.  */
+#define EOSTMT 258
+#define ASSIGNMENT_OP 259
+#define GARBAGE 260
+#define CPP_LINE_DIRECTIVE 261
+#define CPP_INCLUDE 262
+#define F90PPR_INCLUDE 263
+#define COCO_INCLUDE 264
+#define F90PPR_DEFINE 265
+#define CPP_DEFINE 266
+#define F90PPR_UNDEF 267
+#define CPP_UNDEF 268
+#define CPP_IFDEF 269
+#define CPP_IFNDEF 270
+#define CPP_IF 271
+#define CPP_ELSE 272
+#define CPP_ELIF 273
+#define CPP_ENDIF 274
+#define F90PPR_IFDEF 275
+#define F90PPR_IFNDEF 276
+#define F90PPR_IF 277
+#define F90PPR_ELSE 278
+#define F90PPR_ELIF 279
+#define F90PPR_ENDIF 280
+#define COMMA 281
+#define COLON 282
+#define DCOLON 283
+#define LPAREN 284
+#define RPAREN 285
+#define UNTERMINATED_STRING 286
+#define STRING 287
+#define WORD 288
+#define CPP_INCLUDE_ANGLE 289
+#define END 290
+#define INCLUDE 291
+#define INTERFACE 292
+#define MODULE 293
+#define SUBMODULE 294
+#define USE 295
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 70 "cmFortranParser.y" /* yacc.c:1909  */
+
+  char* string;
+
+#line 138 "cmFortranParserTokens.h" /* yacc.c:1909  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+int cmFortran_yyparse (yyscan_t yyscanner);
+
+#endif /* !YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED  */
diff --git a/Source/LexerParser/cmListFileLexer.c b/Source/LexerParser/cmListFileLexer.c
new file mode 100644
index 0000000..c6f524c
--- /dev/null
+++ b/Source/LexerParser/cmListFileLexer.c
@@ -0,0 +1,2859 @@
+#include "cmStandardLexer.h"
+
+#define FLEXINT_H 1
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define cmListFileLexer_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer cmListFileLexer_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define cmListFileLexer_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer cmListFileLexer_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define cmListFileLexer_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer cmListFileLexer_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define cmListFileLexer_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string cmListFileLexer_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define cmListFileLexer_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes cmListFileLexer_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define cmListFileLexer_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer cmListFileLexer_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define cmListFileLexer_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer cmListFileLexer_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define cmListFileLexer_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state cmListFileLexer_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define cmListFileLexer_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer cmListFileLexer_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define cmListFileLexer_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state cmListFileLexer_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define cmListFileLexer_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state cmListFileLexer_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define cmListFileLexer_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack cmListFileLexer_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define cmListFileLexer_yylex_ALREADY_DEFINED
+#else
+#define yylex cmListFileLexer_yylex
+#endif
+
+#ifdef yyrestart
+#define cmListFileLexer_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart cmListFileLexer_yyrestart
+#endif
+
+#ifdef yylex_init
+#define cmListFileLexer_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init cmListFileLexer_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define cmListFileLexer_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra cmListFileLexer_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define cmListFileLexer_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy cmListFileLexer_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define cmListFileLexer_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug cmListFileLexer_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define cmListFileLexer_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug cmListFileLexer_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define cmListFileLexer_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra cmListFileLexer_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define cmListFileLexer_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra cmListFileLexer_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define cmListFileLexer_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in cmListFileLexer_yyget_in
+#endif
+
+#ifdef yyset_in
+#define cmListFileLexer_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in cmListFileLexer_yyset_in
+#endif
+
+#ifdef yyget_out
+#define cmListFileLexer_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out cmListFileLexer_yyget_out
+#endif
+
+#ifdef yyset_out
+#define cmListFileLexer_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out cmListFileLexer_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define cmListFileLexer_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng cmListFileLexer_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define cmListFileLexer_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text cmListFileLexer_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define cmListFileLexer_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno cmListFileLexer_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define cmListFileLexer_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno cmListFileLexer_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define cmListFileLexer_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column cmListFileLexer_yyget_column
+#endif
+
+#ifdef yyset_column
+#define cmListFileLexer_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column cmListFileLexer_yyset_column
+#endif
+
+#ifdef yywrap
+#define cmListFileLexer_yywrap_ALREADY_DEFINED
+#else
+#define yywrap cmListFileLexer_yywrap
+#endif
+
+#ifdef yyalloc
+#define cmListFileLexer_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc cmListFileLexer_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define cmListFileLexer_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc cmListFileLexer_yyrealloc
+#endif
+
+#ifdef yyfree
+#define cmListFileLexer_yyfree_ALREADY_DEFINED
+#else
+#define yyfree cmListFileLexer_yyfree
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
+     *       access to the local variable yy_act. Since yyless() is a macro, it would break
+     *       existing scanners that call yyless() from OUTSIDE yylex.
+     *       One obvious solution it to make yy_act a global. I tried that, and saw
+     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
+     *       normally declared as a register variable-- so it is not worth it.
+     */
+    #define  YY_LESS_LINENO(n) \
+            do { \
+                int yyl;\
+                for ( yyl = n; yyl < yyleng; ++yyl )\
+                    if ( yytext[yyl] == '\n' )\
+                        --yylineno;\
+            }while(0)
+    #define YY_LINENO_REWIND_TO(dst) \
+            do {\
+                const char *p;\
+                for ( p = yy_cp-1; p >= (dst); --p)\
+                    if ( *p == '\n' )\
+                        --yylineno;\
+            }while(0)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define cmListFileLexer_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 24
+#define YY_END_OF_BUFFER 25
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[81] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    4,    4,
+       25,   13,   22,    1,   16,    3,   13,    5,    6,    7,
+       15,   23,   23,   17,   19,   20,   21,   17,   10,   11,
+        8,   10,   12,    9,   24,    4,   13,    0,   13,    0,
+       22,    0,    0,    7,   13,    0,   13,    0,    2,    0,
+       13,   17,    0,   18,   10,    8,    4,    0,   14,    0,
+        0,    0,    0,   14,    0,    0,   14,    0,    0,    0,
+        2,   14,    0,    0,    0,    0,    0,    0,    0,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    5,    6,    7,    1,    1,    1,    8,
+        9,    1,    1,    1,    1,    1,    1,   10,   10,   10,
+       10,   10,   10,   10,   10,   10,   10,    1,    1,    1,
+       11,    1,    1,    1,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       13,   14,   15,    1,   12,    1,   12,   12,   12,   12,
+
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+       12,   12,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[17] =
+    {   0,
+        1,    1,    2,    3,    4,    3,    1,    3,    5,    6,
+        1,    6,    1,    1,    7,    8
+    } ;
+
+static const flex_int16_t yy_base[99] =
+    {   0,
+        0,    0,   14,   28,   42,   56,   70,   84,   18,   19,
+       69,  100,   16,  323,  323,   55,   59,  323,  323,   13,
+      115,    0,  323,   52,  323,  323,   21,   51,    0,  323,
+       53,    0,  323,  323,  323,    0,    0,  126,   55,    0,
+       25,   25,   53,    0,    0,  136,   53,    0,   57,    0,
+        0,   42,   50,  323,    0,   43,    0,  146,  160,   45,
+      172,   43,   26,    0,   42,  184,    0,   42,  195,   40,
+      323,   40,    0,   38,   37,   34,   32,   31,   23,  323,
+      211,  219,  227,  235,  243,  251,  259,  267,  274,  281,
+      285,  291,  298,  302,  304,  310,  314,  316
+
+    } ;
+
+static const flex_int16_t yy_def[99] =
+    {   0,
+       80,    1,   81,   81,   82,   82,   83,   83,   84,   84,
+       80,   80,   80,   80,   80,   80,   12,   80,   80,   12,
+       80,   85,   80,   86,   80,   80,   86,   86,   87,   80,
+       80,   87,   80,   80,   80,   88,   12,   89,   12,   90,
+       80,   80,   91,   20,   12,   92,   12,   21,   80,   93,
+       12,   86,   86,   80,   87,   80,   88,   89,   80,   58,
+       89,   94,   80,   59,   91,   92,   59,   66,   92,   95,
+       80,   59,   96,   97,   94,   98,   95,   97,   98,    0,
+       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
+       80,   80,   80,   80,   80,   80,   80,   80
+
+    } ;
+
+static const flex_int16_t yy_nxt[340] =
+    {   0,
+       12,   13,   14,   13,   15,   16,   17,   18,   19,   12,
+       12,   20,   21,   22,   12,   23,   25,   41,   26,   41,
+       14,   14,   44,   54,   44,   52,   41,   27,   41,   28,
+       25,   66,   26,   35,   35,   63,   63,   49,   49,   58,
+       67,   27,   66,   28,   30,   59,   58,   62,   67,   76,
+       64,   59,   74,   56,   52,   53,   31,   32,   30,   71,
+       70,   64,   62,   56,   53,   53,   43,   42,   80,   80,
+       31,   32,   30,   80,   80,   80,   80,   80,   80,   80,
+       80,   80,   80,   80,   34,   35,   30,   80,   80,   80,
+       80,   80,   80,   80,   80,   80,   80,   80,   34,   35,
+
+       37,   80,   80,   80,   38,   80,   39,   80,   80,   37,
+       37,   37,   37,   40,   37,   45,   80,   80,   80,   46,
+       80,   47,   80,   80,   45,   48,   45,   49,   50,   45,
+       59,   80,   60,   80,   80,   80,   80,   80,   80,   61,
+       67,   80,   68,   80,   80,   80,   80,   80,   80,   69,
+       59,   80,   60,   80,   80,   80,   80,   80,   80,   61,
+       59,   80,   80,   80,   38,   80,   72,   80,   80,   59,
+       59,   59,   59,   73,   59,   58,   80,   58,   80,   58,
+       58,   80,   80,   80,   80,   80,   80,   58,   67,   80,
+       68,   80,   80,   80,   80,   80,   80,   69,   66,   80,
+
+       66,   80,   66,   66,   80,   80,   80,   80,   80,   80,
+       66,   24,   24,   24,   24,   24,   24,   24,   24,   29,
+       29,   29,   29,   29,   29,   29,   29,   33,   33,   33,
+       33,   33,   33,   33,   33,   36,   36,   36,   36,   36,
+       36,   36,   36,   51,   80,   51,   51,   51,   51,   51,
+       51,   52,   80,   52,   80,   52,   52,   52,   52,   55,
+       80,   55,   55,   55,   55,   80,   55,   57,   80,   57,
+       57,   57,   57,   57,   58,   80,   80,   58,   80,   58,
+       58,   37,   80,   37,   37,   37,   37,   37,   37,   65,
+       65,   66,   80,   80,   66,   80,   66,   66,   45,   80,
+
+       45,   45,   45,   45,   45,   45,   75,   75,   77,   77,
+       59,   80,   59,   59,   59,   59,   59,   59,   78,   78,
+       79,   79,   11,   80,   80,   80,   80,   80,   80,   80,
+       80,   80,   80,   80,   80,   80,   80,   80,   80
+    } ;
+
+static const flex_int16_t yy_chk[340] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    3,   13,    3,   13,
+        9,   10,   20,   27,   20,   27,   41,    3,   41,    3,
+        4,   79,    4,    9,   10,   42,   63,   42,   63,   78,
+       77,    4,   76,    4,    5,   75,   74,   72,   70,   68,
+       65,   62,   60,   56,   53,   52,    5,    5,    6,   49,
+       47,   43,   39,   31,   28,   24,   17,   16,   11,    0,
+        6,    6,    7,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    7,    7,    8,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    8,    8,
+
+       12,    0,    0,    0,   12,    0,   12,    0,    0,   12,
+       12,   12,   12,   12,   12,   21,    0,    0,    0,   21,
+        0,   21,    0,    0,   21,   21,   21,   21,   21,   21,
+       38,    0,   38,    0,    0,    0,    0,    0,    0,   38,
+       46,    0,   46,    0,    0,    0,    0,    0,    0,   46,
+       58,    0,   58,    0,    0,    0,    0,    0,    0,   58,
+       59,    0,    0,    0,   59,    0,   59,    0,    0,   59,
+       59,   59,   59,   59,   59,   61,    0,   61,    0,   61,
+       61,    0,    0,    0,    0,    0,    0,   61,   66,    0,
+       66,    0,    0,    0,    0,    0,    0,   66,   69,    0,
+
+       69,    0,   69,   69,    0,    0,    0,    0,    0,    0,
+       69,   81,   81,   81,   81,   81,   81,   81,   81,   82,
+       82,   82,   82,   82,   82,   82,   82,   83,   83,   83,
+       83,   83,   83,   83,   83,   84,   84,   84,   84,   84,
+       84,   84,   84,   85,    0,   85,   85,   85,   85,   85,
+       85,   86,    0,   86,    0,   86,   86,   86,   86,   87,
+        0,   87,   87,   87,   87,    0,   87,   88,    0,   88,
+       88,   88,   88,   88,   89,    0,    0,   89,    0,   89,
+       89,   90,    0,   90,   90,   90,   90,   90,   90,   91,
+       91,   92,    0,    0,   92,    0,   92,   92,   93,    0,
+
+       93,   93,   93,   93,   93,   93,   94,   94,   95,   95,
+       96,    0,   96,   96,   96,   96,   96,   96,   97,   97,
+       98,   98,   80,   80,   80,   80,   80,   80,   80,   80,
+       80,   80,   80,   80,   80,   80,   80,   80,   80
+    } ;
+
+/* Table of booleans, true if rule could match eol. */
+static const flex_int32_t yy_rule_can_match_eol[25] =
+    {   0,
+1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+    0, 0, 0, 0, 0,     };
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline -ocmListFileLexer.c cmListFileLexer.in.l
+
+Modify cmListFileLexer.c:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmListFileLexer.c
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmListFileLexer.c
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmListFileLexer.c
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#ifdef WIN32
+#include "cmsys/Encoding.h"
+#endif
+
+/* Setup the proper cmListFileLexer_yylex declaration.  */
+#define YY_EXTRA_TYPE cmListFileLexer*
+#define YY_DECL int cmListFileLexer_yylex (yyscan_t yyscanner, cmListFileLexer* lexer)
+
+#include "cmListFileLexer.h"
+
+/*--------------------------------------------------------------------------*/
+struct cmListFileLexer_s
+{
+  cmListFileLexer_Token token;
+  int bracket;
+  int comment;
+  int line;
+  int column;
+  int size;
+  FILE* file;
+  size_t cr;
+  char* string_buffer;
+  char* string_position;
+  int string_left;
+  yyscan_t scanner;
+};
+
+static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
+                                    int length);
+static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
+                                  int length);
+static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
+                                size_t bufferSize);
+static void cmListFileLexerInit(cmListFileLexer* lexer);
+static void cmListFileLexerDestroy(cmListFileLexer* lexer);
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = cmListFileLexerInput(cmListFileLexer_yyget_extra(yyscanner), buf, max_size); }
+
+/*--------------------------------------------------------------------------*/
+
+#define INITIAL 0
+#define STRING 1
+#define BRACKET 2
+#define BRACKETEND 3
+#define COMMENT 4
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in  ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out  ( FILE * _out_str , yyscan_t yyscanner );
+
+			int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column  ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput ( int c, char *buf_ptr  , yyscan_t yyscanner);
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+		}
+
+		yy_load_buffer_state( yyscanner );
+		}
+
+	{
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 81 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 323 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+			{
+			int yyl;
+			for ( yyl = 0; yyl < yyleng; ++yyl )
+				if ( yytext[yyl] == '\n' )
+
+    do{ yylineno++;
+        yycolumn=0;
+    }while(0)
+;
+			}
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+/* rule 1 can match eol */
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_Newline;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+  BEGIN(INITIAL);
+  return 1;
+}
+	YY_BREAK
+case 2:
+/* rule 2 can match eol */
+YY_RULE_SETUP
+{
+  const char* bracket = yytext;
+  lexer->comment = yytext[0] == '#';
+  if (lexer->comment) {
+    lexer->token.type = cmListFileLexer_Token_CommentBracket;
+    bracket += 1;
+  } else {
+    lexer->token.type = cmListFileLexer_Token_ArgumentBracket;
+  }
+  cmListFileLexerSetToken(lexer, "", 0);
+  lexer->bracket = strchr(bracket+1, '[') - bracket;
+  if (yytext[yyleng-1] == '\n') {
+    ++lexer->line;
+    lexer->column = 1;
+  } else {
+    lexer->column += yyleng;
+  }
+  BEGIN(BRACKET);
+}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+{
+  lexer->column += yyleng;
+  BEGIN(COMMENT);
+}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+{
+  lexer->column += yyleng;
+}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ParenLeft;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ParenRight;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_Identifier;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+{
+  /* Handle ]]====]=======]*/
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  if (yyleng == lexer->bracket) {
+    BEGIN(BRACKETEND);
+  }
+}
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+{
+  lexer->column += yyleng;
+  /* Erase the partial bracket from the token.  */
+  lexer->token.length -= lexer->bracket;
+  lexer->token.text[lexer->token.length] = 0;
+  BEGIN(INITIAL);
+  return 1;
+}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+	YY_BREAK
+case 11:
+/* rule 11 can match eol */
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+  BEGIN(BRACKET);
+}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  BEGIN(BRACKET);
+}
+	YY_BREAK
+case YY_STATE_EOF(BRACKET):
+case YY_STATE_EOF(BRACKETEND):
+{
+  lexer->token.type = cmListFileLexer_Token_BadBracket;
+  BEGIN(INITIAL);
+  return 1;
+}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_ArgumentQuoted;
+  cmListFileLexerSetToken(lexer, "", 0);
+  lexer->column += yyleng;
+  BEGIN(STRING);
+}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+	YY_BREAK
+case 18:
+/* rule 18 can match eol */
+YY_RULE_SETUP
+{
+  /* Continuation: text is not part of string */
+  ++lexer->line;
+  lexer->column = 1;
+}
+	YY_BREAK
+case 19:
+/* rule 19 can match eol */
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+}
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+{
+  lexer->column += yyleng;
+  BEGIN(INITIAL);
+  return 1;
+}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+{
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+	YY_BREAK
+case YY_STATE_EOF(STRING):
+{
+  lexer->token.type = cmListFileLexer_Token_BadString;
+  BEGIN(INITIAL);
+  return 1;
+}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_Space;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+{
+  lexer->token.type = cmListFileLexer_Token_BadCharacter;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(COMMENT):
+{
+  lexer->token.type = cmListFileLexer_Token_None;
+  cmListFileLexerSetToken(lexer, 0, 0);
+  return 0;
+}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+ECHO;
+	YY_BREAK
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap( yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = yyg->yytext_ptr;
+	int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  , yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 16);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 81 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	char *yy_cp = yyg->yy_c_buf_p;
+
+	YY_CHAR yy_c = 16;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 81 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 80);
+
+	(void)yyg;
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp , yyscan_t yyscanner)
+{
+	char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    yy_cp = yyg->yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yyg->yy_hold_char;
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = yyg->yy_n_chars + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+    if ( c == '\n' ){
+        --yylineno;
+    }
+
+	yyg->yytext_ptr = yy_bp;
+	yyg->yy_hold_char = *yy_cp;
+	yyg->yy_c_buf_p = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin , yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap( yyscanner ) )
+						return 0;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	if ( c == '\n' )
+
+    do{ yylineno++;
+        yycolumn=0;
+    }while(0)
+;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+	yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state( yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file , yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+	yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_flush_buffer( b , yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state( yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state( yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state( yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	yy_size_t num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b , yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n , yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n , yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int  _line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+    yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int  _column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+    yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = _out_str ;
+}
+
+int yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+    struct yyguts_t dummy_yyguts;
+
+    yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = NULL;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	yyfree(yyg->yy_buffer_stack , yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        yyfree( yyg->yy_start_stack , yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	(void)yyg;
+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
+                                    int length)
+{
+  /* Set the token line and column number.  */
+  lexer->token.line = lexer->line;
+  lexer->token.column = lexer->column;
+
+  /* Use the same buffer if possible.  */
+  if (lexer->token.text) {
+    if (text && length < lexer->size) {
+      strcpy(lexer->token.text, text);
+      lexer->token.length = length;
+      return;
+    }
+    free(lexer->token.text);
+    lexer->token.text = 0;
+    lexer->size = 0;
+  }
+
+  /* Need to extend the buffer.  */
+  if (text) {
+    lexer->token.text = strdup(text);
+    lexer->token.length = length;
+    lexer->size = length + 1;
+  } else {
+    lexer->token.length = 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
+                                  int length)
+{
+  char* temp;
+  int newSize;
+
+  /* If the appended text will fit in the buffer, do not reallocate.  */
+  newSize = lexer->token.length + length + 1;
+  if (lexer->token.text && newSize <= lexer->size) {
+    strcpy(lexer->token.text + lexer->token.length, text);
+    lexer->token.length += length;
+    return;
+  }
+
+  /* We need to extend the buffer.  */
+  temp = malloc(newSize);
+  if (lexer->token.text) {
+    memcpy(temp, lexer->token.text, lexer->token.length);
+    free(lexer->token.text);
+  }
+  memcpy(temp + lexer->token.length, text, length);
+  temp[lexer->token.length + length] = 0;
+  lexer->token.text = temp;
+  lexer->token.length += length;
+  lexer->size = newSize;
+}
+
+/*--------------------------------------------------------------------------*/
+static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
+                                size_t bufferSize)
+{
+  if (lexer) {
+    if (lexer->file) {
+      /* Convert CRLF -> LF explicitly.  The C FILE "t"ext mode
+         does not convert newlines on all platforms.  Move any
+         trailing CR to the start of the buffer for the next read. */
+      size_t cr = lexer->cr;
+      size_t n;
+      buffer[0] = '\r';
+      n = fread(buffer + cr, 1, bufferSize - cr, lexer->file);
+      if (n) {
+        char* o = buffer;
+        const char* i = buffer;
+        const char* e;
+        n += cr;
+        cr = (buffer[n - 1] == '\r') ? 1 : 0;
+        e = buffer + n - cr;
+        while (i != e) {
+          if (i[0] == '\r' && i[1] == '\n') {
+            ++i;
+          }
+          *o++ = *i++;
+        }
+        n = o - buffer;
+      } else {
+        n = cr;
+        cr = 0;
+      }
+      lexer->cr = cr;
+      return n;
+    } else if (lexer->string_left) {
+      int length = lexer->string_left;
+      if ((int)bufferSize < length) {
+        length = (int)bufferSize;
+      }
+      memcpy(buffer, lexer->string_position, length);
+      lexer->string_position += length;
+      lexer->string_left -= length;
+      return length;
+    }
+  }
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerInit(cmListFileLexer* lexer)
+{
+  if (lexer->file || lexer->string_buffer) {
+    cmListFileLexer_yylex_init(&lexer->scanner);
+    cmListFileLexer_yyset_extra(lexer, lexer->scanner);
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerDestroy(cmListFileLexer* lexer)
+{
+  cmListFileLexerSetToken(lexer, 0, 0);
+  if (lexer->file || lexer->string_buffer) {
+    cmListFileLexer_yylex_destroy(lexer->scanner);
+    if (lexer->file) {
+      fclose(lexer->file);
+      lexer->file = 0;
+    }
+    if (lexer->string_buffer) {
+      free(lexer->string_buffer);
+      lexer->string_buffer = 0;
+      lexer->string_left = 0;
+      lexer->string_position = 0;
+    }
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+cmListFileLexer* cmListFileLexer_New(void)
+{
+  cmListFileLexer* lexer = (cmListFileLexer*)malloc(sizeof(cmListFileLexer));
+  if (!lexer) {
+    return 0;
+  }
+  memset(lexer, 0, sizeof(*lexer));
+  lexer->line = 1;
+  lexer->column = 1;
+  return lexer;
+}
+
+/*--------------------------------------------------------------------------*/
+void cmListFileLexer_Delete(cmListFileLexer* lexer)
+{
+  cmListFileLexer_SetFileName(lexer, 0, 0);
+  free(lexer);
+}
+
+/*--------------------------------------------------------------------------*/
+static cmListFileLexer_BOM cmListFileLexer_ReadBOM(FILE* f)
+{
+  unsigned char b[2];
+  if (fread(b, 1, 2, f) == 2) {
+    if (b[0] == 0xEF && b[1] == 0xBB) {
+      if (fread(b, 1, 1, f) == 1 && b[0] == 0xBF) {
+        return cmListFileLexer_BOM_UTF8;
+      }
+    } else if (b[0] == 0xFE && b[1] == 0xFF) {
+      /* UTF-16 BE */
+      return cmListFileLexer_BOM_UTF16BE;
+    } else if (b[0] == 0 && b[1] == 0) {
+      if (fread(b, 1, 2, f) == 2 && b[0] == 0xFE && b[1] == 0xFF) {
+        return cmListFileLexer_BOM_UTF32BE;
+      }
+    } else if (b[0] == 0xFF && b[1] == 0xFE) {
+      fpos_t p;
+      fgetpos(f, &p);
+      if (fread(b, 1, 2, f) == 2 && b[0] == 0 && b[1] == 0) {
+        return cmListFileLexer_BOM_UTF32LE;
+      }
+      if (fsetpos(f, &p) != 0) {
+        return cmListFileLexer_BOM_Broken;
+      }
+      return cmListFileLexer_BOM_UTF16LE;
+    }
+  }
+  if (fseek(f, 0, SEEK_SET) != 0) {
+    return cmListFileLexer_BOM_Broken;
+  }
+  return cmListFileLexer_BOM_None;
+}
+
+/*--------------------------------------------------------------------------*/
+int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name,
+                                cmListFileLexer_BOM* bom)
+{
+  int result = 1;
+  cmListFileLexerDestroy(lexer);
+  if (name) {
+#ifdef _WIN32
+    wchar_t* wname = cmsysEncoding_DupToWide(name);
+    lexer->file = _wfopen(wname, L"rb");
+    free(wname);
+#else
+    lexer->file = fopen(name, "rb");
+#endif
+    if (lexer->file) {
+      if (bom) {
+        *bom = cmListFileLexer_ReadBOM(lexer->file);
+      }
+    } else {
+      result = 0;
+    }
+  }
+  cmListFileLexerInit(lexer);
+  return result;
+}
+
+/*--------------------------------------------------------------------------*/
+int cmListFileLexer_SetString(cmListFileLexer* lexer, const char* text)
+{
+  int result = 1;
+  cmListFileLexerDestroy(lexer);
+  if (text) {
+    int length = (int)strlen(text);
+    lexer->string_buffer = (char*)malloc(length + 1);
+    if (lexer->string_buffer) {
+      strcpy(lexer->string_buffer, text);
+      lexer->string_position = lexer->string_buffer;
+      lexer->string_left = length;
+    } else {
+      result = 0;
+    }
+  }
+  cmListFileLexerInit(lexer);
+  return result;
+}
+
+/*--------------------------------------------------------------------------*/
+cmListFileLexer_Token* cmListFileLexer_Scan(cmListFileLexer* lexer)
+{
+  if (!lexer->file) {
+    return 0;
+  }
+  if (cmListFileLexer_yylex(lexer->scanner, lexer)) {
+    return &lexer->token;
+  } else {
+    cmListFileLexer_SetFileName(lexer, 0, 0);
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+long cmListFileLexer_GetCurrentLine(cmListFileLexer* lexer)
+{
+  if (lexer->file) {
+    return lexer->line;
+  } else {
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+long cmListFileLexer_GetCurrentColumn(cmListFileLexer* lexer)
+{
+  if (lexer->file) {
+    return lexer->column;
+  } else {
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+const char* cmListFileLexer_GetTypeAsString(cmListFileLexer* lexer,
+                                            cmListFileLexer_Type type)
+{
+  (void)lexer;
+  switch (type) {
+    case cmListFileLexer_Token_None:
+      return "nothing";
+    case cmListFileLexer_Token_Space:
+      return "space";
+    case cmListFileLexer_Token_Newline:
+      return "newline";
+    case cmListFileLexer_Token_Identifier:
+      return "identifier";
+    case cmListFileLexer_Token_ParenLeft:
+      return "left paren";
+    case cmListFileLexer_Token_ParenRight:
+      return "right paren";
+    case cmListFileLexer_Token_ArgumentUnquoted:
+      return "unquoted argument";
+    case cmListFileLexer_Token_ArgumentQuoted:
+      return "quoted argument";
+    case cmListFileLexer_Token_ArgumentBracket:
+      return "bracket argument";
+    case cmListFileLexer_Token_CommentBracket:
+      return "bracket comment";
+    case cmListFileLexer_Token_BadCharacter:
+      return "bad character";
+    case cmListFileLexer_Token_BadBracket:
+      return "unterminated bracket";
+    case cmListFileLexer_Token_BadString:
+      return "unterminated string";
+  }
+  return "unknown token";
+}
diff --git a/Source/LexerParser/cmListFileLexer.in.l b/Source/LexerParser/cmListFileLexer.in.l
new file mode 100644
index 0000000..f2fd538
--- /dev/null
+++ b/Source/LexerParser/cmListFileLexer.in.l
@@ -0,0 +1,568 @@
+%{
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+
+This file must be translated to C and modified to build everywhere.
+
+Run flex >= 2.6 like this:
+
+  flex --nounistd -DFLEXINT_H --noline -ocmListFileLexer.c cmListFileLexer.in.l
+
+Modify cmListFileLexer.c:
+  - remove trailing whitespace:              sed -i 's/\s*$//' cmListFileLexer.c
+  - remove blank lines at end of file:       sed -i '${/^$/d;}' cmListFileLexer.c
+  - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmListFileLexer.c
+
+*/
+
+/* IWYU pragma: no_forward_declare yyguts_t */
+
+#ifdef WIN32
+#include "cmsys/Encoding.h"
+#endif
+
+/* Setup the proper cmListFileLexer_yylex declaration.  */
+#define YY_EXTRA_TYPE cmListFileLexer*
+#define YY_DECL int cmListFileLexer_yylex (yyscan_t yyscanner, cmListFileLexer* lexer)
+
+#include "cmListFileLexer.h"
+
+/*--------------------------------------------------------------------------*/
+struct cmListFileLexer_s
+{
+  cmListFileLexer_Token token;
+  int bracket;
+  int comment;
+  int line;
+  int column;
+  int size;
+  FILE* file;
+  size_t cr;
+  char* string_buffer;
+  char* string_position;
+  int string_left;
+  yyscan_t scanner;
+};
+
+static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
+                                    int length);
+static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
+                                  int length);
+static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
+                                size_t bufferSize);
+static void cmListFileLexerInit(cmListFileLexer* lexer);
+static void cmListFileLexerDestroy(cmListFileLexer* lexer);
+
+/* Replace the lexer input function.  */
+#undef YY_INPUT
+#define YY_INPUT(buf, result, max_size) \
+  { result = cmListFileLexerInput(cmListFileLexer_yyget_extra(yyscanner), buf, max_size); }
+
+/*--------------------------------------------------------------------------*/
+%}
+
+%option prefix="cmListFileLexer_yy"
+
+%option reentrant
+%option yylineno
+%option noyywrap
+%pointer
+%x STRING
+%x BRACKET
+%x BRACKETEND
+%x COMMENT
+
+MAKEVAR \$\([A-Za-z0-9_]*\)
+UNQUOTED ([^ \0\t\r\n\(\)#\\\"[=]|\\.)
+LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
+
+%%
+
+<INITIAL,COMMENT>\n {
+  lexer->token.type = cmListFileLexer_Token_Newline;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+  BEGIN(INITIAL);
+  return 1;
+}
+
+#?\[=*\[\n? {
+  const char* bracket = yytext;
+  lexer->comment = yytext[0] == '#';
+  if (lexer->comment) {
+    lexer->token.type = cmListFileLexer_Token_CommentBracket;
+    bracket += 1;
+  } else {
+    lexer->token.type = cmListFileLexer_Token_ArgumentBracket;
+  }
+  cmListFileLexerSetToken(lexer, "", 0);
+  lexer->bracket = strchr(bracket+1, '[') - bracket;
+  if (yytext[yyleng-1] == '\n') {
+    ++lexer->line;
+    lexer->column = 1;
+  } else {
+    lexer->column += yyleng;
+  }
+  BEGIN(BRACKET);
+}
+
+# {
+  lexer->column += yyleng;
+  BEGIN(COMMENT);
+}
+
+<COMMENT>[^\0\n]* {
+  lexer->column += yyleng;
+}
+
+\( {
+  lexer->token.type = cmListFileLexer_Token_ParenLeft;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+\) {
+  lexer->token.type = cmListFileLexer_Token_ParenRight;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+[A-Za-z_][A-Za-z0-9_]* {
+  lexer->token.type = cmListFileLexer_Token_Identifier;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+<BRACKET>\]=* {
+  /* Handle ]]====]=======]*/
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  if (yyleng == lexer->bracket) {
+    BEGIN(BRACKETEND);
+  }
+}
+
+<BRACKETEND>\] {
+  lexer->column += yyleng;
+  /* Erase the partial bracket from the token.  */
+  lexer->token.length -= lexer->bracket;
+  lexer->token.text[lexer->token.length] = 0;
+  BEGIN(INITIAL);
+  return 1;
+}
+
+<BRACKET>([^]\n])+ {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+
+<BRACKET,BRACKETEND>\n {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+  BEGIN(BRACKET);
+}
+
+<BRACKET,BRACKETEND>[^\0\n] {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  BEGIN(BRACKET);
+}
+
+<BRACKET,BRACKETEND><<EOF>> {
+  lexer->token.type = cmListFileLexer_Token_BadBracket;
+  BEGIN(INITIAL);
+  return 1;
+}
+
+({UNQUOTED}|=|\[=*{UNQUOTED})({UNQUOTED}|[[=])* {
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+({MAKEVAR}|{UNQUOTED}|=|\[=*{LEGACY})({LEGACY}|[[=])* {
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+\[ {
+  lexer->token.type = cmListFileLexer_Token_ArgumentUnquoted;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+\" {
+  lexer->token.type = cmListFileLexer_Token_ArgumentQuoted;
+  cmListFileLexerSetToken(lexer, "", 0);
+  lexer->column += yyleng;
+  BEGIN(STRING);
+}
+
+<STRING>([^\\\n\"]|\\.)+ {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+
+<STRING>\\\n {
+  /* Continuation: text is not part of string */
+  ++lexer->line;
+  lexer->column = 1;
+}
+
+<STRING>\n {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  ++lexer->line;
+  lexer->column = 1;
+}
+
+<STRING>\" {
+  lexer->column += yyleng;
+  BEGIN(INITIAL);
+  return 1;
+}
+
+<STRING>[^\0\n] {
+  cmListFileLexerAppend(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+}
+
+<STRING><<EOF>> {
+  lexer->token.type = cmListFileLexer_Token_BadString;
+  BEGIN(INITIAL);
+  return 1;
+}
+
+[ \t\r]+ {
+  lexer->token.type = cmListFileLexer_Token_Space;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+. {
+  lexer->token.type = cmListFileLexer_Token_BadCharacter;
+  cmListFileLexerSetToken(lexer, yytext, yyleng);
+  lexer->column += yyleng;
+  return 1;
+}
+
+<<EOF>> {
+  lexer->token.type = cmListFileLexer_Token_None;
+  cmListFileLexerSetToken(lexer, 0, 0);
+  return 0;
+}
+
+%%
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
+                                    int length)
+{
+  /* Set the token line and column number.  */
+  lexer->token.line = lexer->line;
+  lexer->token.column = lexer->column;
+
+  /* Use the same buffer if possible.  */
+  if (lexer->token.text) {
+    if (text && length < lexer->size) {
+      strcpy(lexer->token.text, text);
+      lexer->token.length = length;
+      return;
+    }
+    free(lexer->token.text);
+    lexer->token.text = 0;
+    lexer->size = 0;
+  }
+
+  /* Need to extend the buffer.  */
+  if (text) {
+    lexer->token.text = strdup(text);
+    lexer->token.length = length;
+    lexer->size = length + 1;
+  } else {
+    lexer->token.length = 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
+                                  int length)
+{
+  char* temp;
+  int newSize;
+
+  /* If the appended text will fit in the buffer, do not reallocate.  */
+  newSize = lexer->token.length + length + 1;
+  if (lexer->token.text && newSize <= lexer->size) {
+    strcpy(lexer->token.text + lexer->token.length, text);
+    lexer->token.length += length;
+    return;
+  }
+
+  /* We need to extend the buffer.  */
+  temp = malloc(newSize);
+  if (lexer->token.text) {
+    memcpy(temp, lexer->token.text, lexer->token.length);
+    free(lexer->token.text);
+  }
+  memcpy(temp + lexer->token.length, text, length);
+  temp[lexer->token.length + length] = 0;
+  lexer->token.text = temp;
+  lexer->token.length += length;
+  lexer->size = newSize;
+}
+
+/*--------------------------------------------------------------------------*/
+static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
+                                size_t bufferSize)
+{
+  if (lexer) {
+    if (lexer->file) {
+      /* Convert CRLF -> LF explicitly.  The C FILE "t"ext mode
+         does not convert newlines on all platforms.  Move any
+         trailing CR to the start of the buffer for the next read. */
+      size_t cr = lexer->cr;
+      size_t n;
+      buffer[0] = '\r';
+      n = fread(buffer + cr, 1, bufferSize - cr, lexer->file);
+      if (n) {
+        char* o = buffer;
+        const char* i = buffer;
+        const char* e;
+        n += cr;
+        cr = (buffer[n - 1] == '\r') ? 1 : 0;
+        e = buffer + n - cr;
+        while (i != e) {
+          if (i[0] == '\r' && i[1] == '\n') {
+            ++i;
+          }
+          *o++ = *i++;
+        }
+        n = o - buffer;
+      } else {
+        n = cr;
+        cr = 0;
+      }
+      lexer->cr = cr;
+      return n;
+    } else if (lexer->string_left) {
+      int length = lexer->string_left;
+      if ((int)bufferSize < length) {
+        length = (int)bufferSize;
+      }
+      memcpy(buffer, lexer->string_position, length);
+      lexer->string_position += length;
+      lexer->string_left -= length;
+      return length;
+    }
+  }
+  return 0;
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerInit(cmListFileLexer* lexer)
+{
+  if (lexer->file || lexer->string_buffer) {
+    cmListFileLexer_yylex_init(&lexer->scanner);
+    cmListFileLexer_yyset_extra(lexer, lexer->scanner);
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+static void cmListFileLexerDestroy(cmListFileLexer* lexer)
+{
+  cmListFileLexerSetToken(lexer, 0, 0);
+  if (lexer->file || lexer->string_buffer) {
+    cmListFileLexer_yylex_destroy(lexer->scanner);
+    if (lexer->file) {
+      fclose(lexer->file);
+      lexer->file = 0;
+    }
+    if (lexer->string_buffer) {
+      free(lexer->string_buffer);
+      lexer->string_buffer = 0;
+      lexer->string_left = 0;
+      lexer->string_position = 0;
+    }
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+cmListFileLexer* cmListFileLexer_New(void)
+{
+  cmListFileLexer* lexer = (cmListFileLexer*)malloc(sizeof(cmListFileLexer));
+  if (!lexer) {
+    return 0;
+  }
+  memset(lexer, 0, sizeof(*lexer));
+  lexer->line = 1;
+  lexer->column = 1;
+  return lexer;
+}
+
+/*--------------------------------------------------------------------------*/
+void cmListFileLexer_Delete(cmListFileLexer* lexer)
+{
+  cmListFileLexer_SetFileName(lexer, 0, 0);
+  free(lexer);
+}
+
+/*--------------------------------------------------------------------------*/
+static cmListFileLexer_BOM cmListFileLexer_ReadBOM(FILE* f)
+{
+  unsigned char b[2];
+  if (fread(b, 1, 2, f) == 2) {
+    if (b[0] == 0xEF && b[1] == 0xBB) {
+      if (fread(b, 1, 1, f) == 1 && b[0] == 0xBF) {
+        return cmListFileLexer_BOM_UTF8;
+      }
+    } else if (b[0] == 0xFE && b[1] == 0xFF) {
+      /* UTF-16 BE */
+      return cmListFileLexer_BOM_UTF16BE;
+    } else if (b[0] == 0 && b[1] == 0) {
+      if (fread(b, 1, 2, f) == 2 && b[0] == 0xFE && b[1] == 0xFF) {
+        return cmListFileLexer_BOM_UTF32BE;
+      }
+    } else if (b[0] == 0xFF && b[1] == 0xFE) {
+      fpos_t p;
+      fgetpos(f, &p);
+      if (fread(b, 1, 2, f) == 2 && b[0] == 0 && b[1] == 0) {
+        return cmListFileLexer_BOM_UTF32LE;
+      }
+      if (fsetpos(f, &p) != 0) {
+        return cmListFileLexer_BOM_Broken;
+      }
+      return cmListFileLexer_BOM_UTF16LE;
+    }
+  }
+  if (fseek(f, 0, SEEK_SET) != 0) {
+    return cmListFileLexer_BOM_Broken;
+  }
+  return cmListFileLexer_BOM_None;
+}
+
+/*--------------------------------------------------------------------------*/
+int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name,
+                                cmListFileLexer_BOM* bom)
+{
+  int result = 1;
+  cmListFileLexerDestroy(lexer);
+  if (name) {
+#ifdef _WIN32
+    wchar_t* wname = cmsysEncoding_DupToWide(name);
+    lexer->file = _wfopen(wname, L"rb");
+    free(wname);
+#else
+    lexer->file = fopen(name, "rb");
+#endif
+    if (lexer->file) {
+      if (bom) {
+        *bom = cmListFileLexer_ReadBOM(lexer->file);
+      }
+    } else {
+      result = 0;
+    }
+  }
+  cmListFileLexerInit(lexer);
+  return result;
+}
+
+/*--------------------------------------------------------------------------*/
+int cmListFileLexer_SetString(cmListFileLexer* lexer, const char* text)
+{
+  int result = 1;
+  cmListFileLexerDestroy(lexer);
+  if (text) {
+    int length = (int)strlen(text);
+    lexer->string_buffer = (char*)malloc(length + 1);
+    if (lexer->string_buffer) {
+      strcpy(lexer->string_buffer, text);
+      lexer->string_position = lexer->string_buffer;
+      lexer->string_left = length;
+    } else {
+      result = 0;
+    }
+  }
+  cmListFileLexerInit(lexer);
+  return result;
+}
+
+/*--------------------------------------------------------------------------*/
+cmListFileLexer_Token* cmListFileLexer_Scan(cmListFileLexer* lexer)
+{
+  if (!lexer->file) {
+    return 0;
+  }
+  if (cmListFileLexer_yylex(lexer->scanner, lexer)) {
+    return &lexer->token;
+  } else {
+    cmListFileLexer_SetFileName(lexer, 0, 0);
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+long cmListFileLexer_GetCurrentLine(cmListFileLexer* lexer)
+{
+  if (lexer->file) {
+    return lexer->line;
+  } else {
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+long cmListFileLexer_GetCurrentColumn(cmListFileLexer* lexer)
+{
+  if (lexer->file) {
+    return lexer->column;
+  } else {
+    return 0;
+  }
+}
+
+/*--------------------------------------------------------------------------*/
+const char* cmListFileLexer_GetTypeAsString(cmListFileLexer* lexer,
+                                            cmListFileLexer_Type type)
+{
+  (void)lexer;
+  switch (type) {
+    case cmListFileLexer_Token_None:
+      return "nothing";
+    case cmListFileLexer_Token_Space:
+      return "space";
+    case cmListFileLexer_Token_Newline:
+      return "newline";
+    case cmListFileLexer_Token_Identifier:
+      return "identifier";
+    case cmListFileLexer_Token_ParenLeft:
+      return "left paren";
+    case cmListFileLexer_Token_ParenRight:
+      return "right paren";
+    case cmListFileLexer_Token_ArgumentUnquoted:
+      return "unquoted argument";
+    case cmListFileLexer_Token_ArgumentQuoted:
+      return "quoted argument";
+    case cmListFileLexer_Token_ArgumentBracket:
+      return "bracket argument";
+    case cmListFileLexer_Token_CommentBracket:
+      return "bracket comment";
+    case cmListFileLexer_Token_BadCharacter:
+      return "bad character";
+    case cmListFileLexer_Token_BadBracket:
+      return "unterminated bracket";
+    case cmListFileLexer_Token_BadString:
+      return "unterminated string";
+  }
+  return "unknown token";
+}
diff --git a/Source/Modules/FindJsonCpp.cmake b/Source/Modules/FindJsonCpp.cmake
new file mode 100644
index 0000000..1951b61
--- /dev/null
+++ b/Source/Modules/FindJsonCpp.cmake
@@ -0,0 +1,107 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindJsonCpp
+-----------
+
+Find JsonCpp includes and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+An :ref:`imported target <Imported targets>` named
+``JsonCpp::JsonCpp`` is provided if JsonCpp has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``JsonCpp_FOUND``
+  True if JsonCpp was found, false otherwise.
+``JsonCpp_INCLUDE_DIRS``
+  Include directories needed to include JsonCpp headers.
+``JsonCpp_LIBRARIES``
+  Libraries needed to link to JsonCpp.
+``JsonCpp_VERSION_STRING``
+  The version of JsonCpp found.
+  May not be set for JsonCpp versions prior to 1.0.
+``JsonCpp_VERSION_MAJOR``
+  The major version of JsonCpp.
+``JsonCpp_VERSION_MINOR``
+  The minor version of JsonCpp.
+``JsonCpp_VERSION_PATCH``
+  The patch version of JsonCpp.
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+This module uses the following cache variables:
+
+``JsonCpp_LIBRARY``
+  The location of the JsonCpp library file.
+``JsonCpp_INCLUDE_DIR``
+  The location of the JsonCpp include directory containing ``json/json.h``.
+
+The cache variables should not be used by project code.
+They may be set by end users to point at JsonCpp components.
+#]=======================================================================]
+
+#-----------------------------------------------------------------------------
+find_library(JsonCpp_LIBRARY
+  NAMES jsoncpp
+  )
+mark_as_advanced(JsonCpp_LIBRARY)
+
+find_path(JsonCpp_INCLUDE_DIR
+  NAMES json/json.h
+  PATH_SUFFIXES jsoncpp
+  )
+mark_as_advanced(JsonCpp_INCLUDE_DIR)
+
+#-----------------------------------------------------------------------------
+# Extract version number if possible.
+set(_JsonCpp_H_REGEX "^#[ \t]*define[ \t]+JSONCPP_VERSION_STRING[ \t]+\"(([0-9]+)\\.([0-9]+)\\.([0-9]+)[^\"]*)\".*$")
+if(JsonCpp_INCLUDE_DIR AND EXISTS "${JsonCpp_INCLUDE_DIR}/json/version.h")
+  file(STRINGS "${JsonCpp_INCLUDE_DIR}/json/version.h" _JsonCpp_H REGEX "${_JsonCpp_H_REGEX}")
+else()
+  set(_JsonCpp_H "")
+endif()
+if(_JsonCpp_H MATCHES "${_JsonCpp_H_REGEX}")
+  set(JsonCpp_VERSION_STRING "${CMAKE_MATCH_1}")
+  set(JsonCpp_VERSION_MAJOR "${CMAKE_MATCH_2}")
+  set(JsonCpp_VERSION_MINOR "${CMAKE_MATCH_3}")
+  set(JsonCpp_VERSION_PATCH "${CMAKE_MATCH_4}")
+else()
+  set(JsonCpp_VERSION_STRING "")
+  set(JsonCpp_VERSION_MAJOR "")
+  set(JsonCpp_VERSION_MINOR "")
+  set(JsonCpp_VERSION_PATCH "")
+endif()
+unset(_JsonCpp_H_REGEX)
+unset(_JsonCpp_H)
+
+#-----------------------------------------------------------------------------
+include(${CMAKE_CURRENT_LIST_DIR}/../../Modules/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(JsonCpp
+  FOUND_VAR JsonCpp_FOUND
+  REQUIRED_VARS JsonCpp_LIBRARY JsonCpp_INCLUDE_DIR
+  VERSION_VAR JsonCpp_VERSION_STRING
+  )
+set(JSONCPP_FOUND ${JsonCpp_FOUND})
+
+#-----------------------------------------------------------------------------
+# Provide documented result variables and targets.
+if(JsonCpp_FOUND)
+  set(JsonCpp_INCLUDE_DIRS ${JsonCpp_INCLUDE_DIR})
+  set(JsonCpp_LIBRARIES ${JsonCpp_LIBRARY})
+  if(NOT TARGET JsonCpp::JsonCpp)
+    add_library(JsonCpp::JsonCpp UNKNOWN IMPORTED)
+    set_target_properties(JsonCpp::JsonCpp PROPERTIES
+      IMPORTED_LOCATION "${JsonCpp_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${JsonCpp_INCLUDE_DIRS}"
+      IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
+      )
+  endif()
+endif()
diff --git a/Source/Modules/FindLibRHash.cmake b/Source/Modules/FindLibRHash.cmake
new file mode 100644
index 0000000..86c6189
--- /dev/null
+++ b/Source/Modules/FindLibRHash.cmake
@@ -0,0 +1,73 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLibRHash
+------------
+
+Find LibRHash include directory and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+An :ref:`imported target <Imported targets>` named
+``LibRHash::LibRHash`` is provided if LibRHash has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``LibRHash_FOUND``
+  True if LibRHash was found, false otherwise.
+``LibRHash_INCLUDE_DIRS``
+  Include directories needed to include LibRHash headers.
+``LibRHash_LIBRARIES``
+  Libraries needed to link to LibRHash.
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+This module uses the following cache variables:
+
+``LibRHash_LIBRARY``
+  The location of the LibRHash library file.
+``LibRHash_INCLUDE_DIR``
+  The location of the LibRHash include directory containing ``rhash.h``.
+
+The cache variables should not be used by project code.
+They may be set by end users to point at LibRHash components.
+#]=======================================================================]
+
+#-----------------------------------------------------------------------------
+find_library(LibRHash_LIBRARY
+  NAMES rhash
+  )
+mark_as_advanced(LibRHash_LIBRARY)
+
+find_path(LibRHash_INCLUDE_DIR
+  NAMES rhash.h
+  )
+mark_as_advanced(LibRHash_INCLUDE_DIR)
+
+#-----------------------------------------------------------------------------
+include(${CMAKE_CURRENT_LIST_DIR}/../../Modules/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibRHash
+  FOUND_VAR LibRHash_FOUND
+  REQUIRED_VARS LibRHash_LIBRARY LibRHash_INCLUDE_DIR
+  )
+set(LIBRHASH_FOUND ${LibRHash_FOUND})
+
+#-----------------------------------------------------------------------------
+# Provide documented result variables and targets.
+if(LibRHash_FOUND)
+  set(LibRHash_INCLUDE_DIRS ${LibRHash_INCLUDE_DIR})
+  set(LibRHash_LIBRARIES ${LibRHash_LIBRARY})
+  if(NOT TARGET LibRHash::LibRHash)
+    add_library(LibRHash::LibRHash UNKNOWN IMPORTED)
+    set_target_properties(LibRHash::LibRHash PROPERTIES
+      IMPORTED_LOCATION "${LibRHash_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LibRHash_INCLUDE_DIRS}"
+      )
+  endif()
+endif()
diff --git a/Source/Modules/FindLibUUID.cmake b/Source/Modules/FindLibUUID.cmake
new file mode 100644
index 0000000..17f11c1
--- /dev/null
+++ b/Source/Modules/FindLibUUID.cmake
@@ -0,0 +1,85 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLibUUID
+------------
+
+Find LibUUID include directory and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+An :ref:`imported target <Imported targets>` named
+``LibUUID::LibUUID`` is provided if LibUUID has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``LibUUID_FOUND``
+  True if LibUUID was found, false otherwise.
+``LibUUID_INCLUDE_DIRS``
+  Include directories needed to include LibUUID headers.
+``LibUUID_LIBRARIES``
+  Libraries needed to link to LibUUID.
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+This module uses the following cache variables:
+
+``LibUUID_LIBRARY``
+  The location of the LibUUID library file.
+``LibUUID_INCLUDE_DIR``
+  The location of the LibUUID include directory containing ``uuid/uuid.h``.
+
+The cache variables should not be used by project code.
+They may be set by end users to point at LibUUID components.
+#]=======================================================================]
+
+#-----------------------------------------------------------------------------
+if(CYGWIN)
+  # Note: on current version of Cygwin, linking to libuuid.dll.a doesn't
+  #       import the right symbols sometimes. Fix this by linking directly
+  #       to the DLL that provides the symbols, instead.
+  set(old_suffixes ${CMAKE_FIND_LIBRARY_SUFFIXES})
+  set(CMAKE_FIND_LIBRARY_SUFFIXES .dll)
+  find_library(LibUUID_LIBRARY
+    NAMES cyguuid-1.dll
+    )
+  set(CMAKE_FIND_LIBRARY_SUFFIXES ${old_suffixes})
+else()
+  find_library(LibUUID_LIBRARY
+    NAMES uuid
+    )
+endif()
+mark_as_advanced(LibUUID_LIBRARY)
+
+find_path(LibUUID_INCLUDE_DIR
+  NAMES uuid/uuid.h
+  )
+mark_as_advanced(LibUUID_INCLUDE_DIR)
+
+#-----------------------------------------------------------------------------
+include(${CMAKE_CURRENT_LIST_DIR}/../../Modules/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibUUID
+  FOUND_VAR LibUUID_FOUND
+  REQUIRED_VARS LibUUID_LIBRARY LibUUID_INCLUDE_DIR
+  )
+set(LIBUUID_FOUND ${LibUUID_FOUND})
+
+#-----------------------------------------------------------------------------
+# Provide documented result variables and targets.
+if(LibUUID_FOUND)
+  set(LibUUID_INCLUDE_DIRS ${LibUUID_INCLUDE_DIR})
+  set(LibUUID_LIBRARIES ${LibUUID_LIBRARY})
+  if(NOT TARGET LibUUID::LibUUID)
+    add_library(LibUUID::LibUUID UNKNOWN IMPORTED)
+    set_target_properties(LibUUID::LibUUID PROPERTIES
+      IMPORTED_LOCATION "${LibUUID_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LibUUID_INCLUDE_DIRS}"
+      )
+  endif()
+endif()
diff --git a/Source/Modules/FindLibUV.cmake b/Source/Modules/FindLibUV.cmake
new file mode 100644
index 0000000..ba13d75
--- /dev/null
+++ b/Source/Modules/FindLibUV.cmake
@@ -0,0 +1,121 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindLibUV
+---------
+
+Find libuv includes and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+An :ref:`imported target <Imported targets>` named
+``LibUV::LibUV`` is provided if libuv has been found.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``LibUV_FOUND``
+  True if libuv was found, false otherwise.
+``LibUV_INCLUDE_DIRS``
+  Include directories needed to include libuv headers.
+``LibUV_LIBRARIES``
+  Libraries needed to link to libuv.
+``LibUV_VERSION``
+  The version of libuv found.
+``LibUV_VERSION_MAJOR``
+  The major version of libuv.
+``LibUV_VERSION_MINOR``
+  The minor version of libuv.
+``LibUV_VERSION_PATCH``
+  The patch version of libuv.
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+This module uses the following cache variables:
+
+``LibUV_LIBRARY``
+  The location of the libuv library file.
+``LibUV_INCLUDE_DIR``
+  The location of the libuv include directory containing ``uv.h``.
+
+The cache variables should not be used by project code.
+They may be set by end users to point at libuv components.
+#]=======================================================================]
+
+#-----------------------------------------------------------------------------
+find_library(LibUV_LIBRARY
+  NAMES uv libuv
+  )
+mark_as_advanced(LibUV_LIBRARY)
+
+find_path(LibUV_INCLUDE_DIR
+  NAMES uv.h
+  )
+mark_as_advanced(LibUV_INCLUDE_DIR)
+
+#-----------------------------------------------------------------------------
+# Extract version number if possible.
+set(_LibUV_H_REGEX "#[ \t]*define[ \t]+UV_VERSION_(MAJOR|MINOR|PATCH)[ \t]+[0-9]+")
+if(LibUV_INCLUDE_DIR AND EXISTS "${LibUV_INCLUDE_DIR}/uv-version.h")
+  file(STRINGS "${LibUV_INCLUDE_DIR}/uv-version.h" _LibUV_H REGEX "${_LibUV_H_REGEX}")
+elseif(LibUV_INCLUDE_DIR AND EXISTS "${LibUV_INCLUDE_DIR}/uv.h")
+  file(STRINGS "${LibUV_INCLUDE_DIR}/uv.h" _LibUV_H REGEX "${_LibUV_H_REGEX}")
+else()
+  set(_LibUV_H "")
+endif()
+foreach(c MAJOR MINOR PATCH)
+  if(_LibUV_H MATCHES "#[ \t]*define[ \t]+UV_VERSION_${c}[ \t]+([0-9]+)")
+    set(_LibUV_VERSION_${c} "${CMAKE_MATCH_1}")
+  else()
+    unset(_LibUV_VERSION_${c})
+  endif()
+endforeach()
+if(DEFINED _LibUV_VERSION_MAJOR AND DEFINED _LibUV_VERSION_MINOR)
+  set(LibUV_VERSION_MAJOR "${_LibUV_VERSION_MAJOR}")
+  set(LibUV_VERSION_MINOR "${_LibUV_VERSION_MINOR}")
+  set(LibUV_VERSION "${LibUV_VERSION_MAJOR}.${LibUV_VERSION_MINOR}")
+  if(DEFINED _LibUV_VERSION_PATCH)
+    set(LibUV_VERSION_PATCH "${_LibUV_VERSION_PATCH}")
+    set(LibUV_VERSION "${LibUV_VERSION}.${LibUV_VERSION_PATCH}")
+  else()
+    unset(LibUV_VERSION_PATCH)
+  endif()
+else()
+  set(LibUV_VERSION_MAJOR "")
+  set(LibUV_VERSION_MINOR "")
+  set(LibUV_VERSION_PATCH "")
+  set(LibUV_VERSION "")
+endif()
+unset(_LibUV_VERSION_MAJOR)
+unset(_LibUV_VERSION_MINOR)
+unset(_LibUV_VERSION_PATCH)
+unset(_LibUV_H_REGEX)
+unset(_LibUV_H)
+
+#-----------------------------------------------------------------------------
+include(${CMAKE_CURRENT_LIST_DIR}/../../Modules/FindPackageHandleStandardArgs.cmake)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibUV
+  FOUND_VAR LibUV_FOUND
+  REQUIRED_VARS LibUV_LIBRARY LibUV_INCLUDE_DIR
+  VERSION_VAR LibUV_VERSION
+  )
+set(LIBUV_FOUND ${LibUV_FOUND})
+
+#-----------------------------------------------------------------------------
+# Provide documented result variables and targets.
+if(LibUV_FOUND)
+  set(LibUV_INCLUDE_DIRS ${LibUV_INCLUDE_DIR})
+  set(LibUV_LIBRARIES ${LibUV_LIBRARY})
+  if(NOT TARGET LibUV::LibUV)
+    add_library(LibUV::LibUV UNKNOWN IMPORTED)
+    set_target_properties(LibUV::LibUV PROPERTIES
+      IMPORTED_LOCATION "${LibUV_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LibUV_INCLUDE_DIRS}"
+      )
+  endif()
+endif()
diff --git a/Source/Modules/OverrideC.cmake b/Source/Modules/OverrideC.cmake
new file mode 100644
index 0000000..f8299ad
--- /dev/null
+++ b/Source/Modules/OverrideC.cmake
@@ -0,0 +1,3 @@
+if("${CMAKE_SYSTEM_NAME};${CMAKE_C_COMPILER_ID}" STREQUAL "AIX;GNU")
+  string(APPEND CMAKE_C_FLAGS_INIT " -pthread")
+endif()
diff --git a/Source/Modules/OverrideCXX.cmake b/Source/Modules/OverrideCXX.cmake
new file mode 100644
index 0000000..13689e2
--- /dev/null
+++ b/Source/Modules/OverrideCXX.cmake
@@ -0,0 +1,3 @@
+if("${CMAKE_SYSTEM_NAME};${CMAKE_CXX_COMPILER_ID}" STREQUAL "AIX;GNU")
+  string(APPEND CMAKE_CXX_FLAGS_INIT " -pthread")
+endif()
diff --git a/Source/QtDialog/AddCacheEntry.cxx b/Source/QtDialog/AddCacheEntry.cxx
new file mode 100644
index 0000000..6284ac9
--- /dev/null
+++ b/Source/QtDialog/AddCacheEntry.cxx
@@ -0,0 +1,99 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "AddCacheEntry.h"
+
+#include <QCompleter>
+#include <QMetaProperty>
+
+static const int NumTypes = 4;
+static const int DefaultTypeIndex = 0;
+static const QByteArray TypeStrings[NumTypes] = { "BOOL", "PATH", "FILEPATH",
+                                                  "STRING" };
+static const QCMakeProperty::PropertyType Types[NumTypes] = {
+  QCMakeProperty::BOOL, QCMakeProperty::PATH, QCMakeProperty::FILEPATH,
+  QCMakeProperty::STRING
+};
+
+AddCacheEntry::AddCacheEntry(QWidget* p, const QStringList& varNames,
+                             const QStringList& varTypes)
+  : QWidget(p)
+  , VarNames(varNames)
+  , VarTypes(varTypes)
+{
+  this->setupUi(this);
+  for (int i = 0; i < NumTypes; i++) {
+    this->Type->addItem(TypeStrings[i]);
+  }
+  QWidget* cb = new QCheckBox();
+  QWidget* path = new QCMakePathEditor();
+  QWidget* filepath = new QCMakeFilePathEditor();
+  QWidget* string = new QLineEdit();
+  this->StackedWidget->addWidget(cb);
+  this->StackedWidget->addWidget(path);
+  this->StackedWidget->addWidget(filepath);
+  this->StackedWidget->addWidget(string);
+  this->setTabOrder(this->Name, this->Type);
+  this->setTabOrder(this->Type, cb);
+  this->setTabOrder(cb, path);
+  this->setTabOrder(path, filepath);
+  this->setTabOrder(filepath, string);
+  this->setTabOrder(string, this->Description);
+  QCompleter* completer = new QCompleter(this->VarNames, this);
+  this->Name->setCompleter(completer);
+  connect(completer, SIGNAL(activated(const QString&)), this,
+          SLOT(onCompletionActivated(const QString&)));
+}
+
+QString AddCacheEntry::name() const
+{
+  return this->Name->text().trimmed();
+}
+
+QVariant AddCacheEntry::value() const
+{
+  QWidget* w = this->StackedWidget->currentWidget();
+  if (qobject_cast<QLineEdit*>(w)) {
+    return static_cast<QLineEdit*>(w)->text();
+  }
+  if (qobject_cast<QCheckBox*>(w)) {
+    return static_cast<QCheckBox*>(w)->isChecked();
+  }
+  return QVariant();
+}
+
+QString AddCacheEntry::description() const
+{
+  return this->Description->text();
+}
+
+QCMakeProperty::PropertyType AddCacheEntry::type() const
+{
+  int idx = this->Type->currentIndex();
+  if (idx >= 0 && idx < NumTypes) {
+    return Types[idx];
+  }
+  return Types[DefaultTypeIndex];
+}
+
+QString AddCacheEntry::typeString() const
+{
+  int idx = this->Type->currentIndex();
+  if (idx >= 0 && idx < NumTypes) {
+    return TypeStrings[idx];
+  }
+  return TypeStrings[DefaultTypeIndex];
+}
+
+void AddCacheEntry::onCompletionActivated(const QString& text)
+{
+  int idx = this->VarNames.indexOf(text);
+  if (idx != -1) {
+    QString vartype = this->VarTypes[idx];
+    for (int i = 0; i < NumTypes; i++) {
+      if (TypeStrings[i] == vartype) {
+        this->Type->setCurrentIndex(i);
+        break;
+      }
+    }
+  }
+}
diff --git a/Source/QtDialog/AddCacheEntry.h b/Source/QtDialog/AddCacheEntry.h
new file mode 100644
index 0000000..cc710f5
--- /dev/null
+++ b/Source/QtDialog/AddCacheEntry.h
@@ -0,0 +1,35 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef AddCacheEntry_h
+#define AddCacheEntry_h
+
+#include "QCMake.h"
+
+#include <QCheckBox>
+#include <QStringList>
+#include <QWidget>
+
+#include "ui_AddCacheEntry.h"
+
+class AddCacheEntry : public QWidget, public Ui::AddCacheEntry
+{
+  Q_OBJECT
+public:
+  AddCacheEntry(QWidget* p, const QStringList& varNames,
+                const QStringList& varTypes);
+
+  QString name() const;
+  QVariant value() const;
+  QString description() const;
+  QCMakeProperty::PropertyType type() const;
+  QString typeString() const;
+
+private slots:
+  void onCompletionActivated(const QString& text);
+
+private:
+  const QStringList& VarNames;
+  const QStringList& VarTypes;
+};
+
+#endif
diff --git a/Source/QtDialog/AddCacheEntry.ui b/Source/QtDialog/AddCacheEntry.ui
new file mode 100644
index 0000000..a815874
--- /dev/null
+++ b/Source/QtDialog/AddCacheEntry.ui
@@ -0,0 +1,97 @@
+<ui version="4.0" >
+ <class>AddCacheEntry</class>
+ <widget class="QWidget" name="AddCacheEntry" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>380</width>
+    <height>158</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" >
+   <property name="margin" >
+    <number>0</number>
+   </property>
+   <item row="0" column="0" >
+    <widget class="QLabel" name="label" >
+     <property name="text" >
+      <string>Name:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1" >
+    <widget class="QLineEdit" name="Name" />
+   </item>
+   <item row="1" column="0" >
+    <widget class="QLabel" name="label_2" >
+     <property name="text" >
+      <string>Type:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1" >
+    <widget class="QComboBox" name="Type" >
+    </widget>
+   </item>
+   <item row="2" column="0" >
+    <widget class="QLabel" name="label_5" >
+     <property name="text" >
+      <string>Value:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1" >
+    <widget class="QStackedWidget" name="StackedWidget" >
+     <property name="currentIndex" >
+      <number>0</number>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0" >
+    <widget class="QLabel" name="label_3" >
+     <property name="text" >
+      <string>Description:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="1" >
+    <widget class="QLineEdit" name="Description" />
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QCMakePathEditor</class>
+   <extends>QLineEdit</extends>
+   <header>QCMakeWidgets.h</header>
+  </customwidget>
+  <customwidget>
+   <class>QCMakeFilePathEditor</class>
+   <extends>QLineEdit</extends>
+   <header>QCMakeWidgets.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>Type</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>StackedWidget</receiver>
+   <slot>setCurrentIndex(int)</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>229</x>
+     <y>34</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>287</x>
+     <y>65</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/Source/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt
new file mode 100644
index 0000000..06d13ba
--- /dev/null
+++ b/Source/QtDialog/CMakeLists.txt
@@ -0,0 +1,257 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+project(QtDialog)
+if(POLICY CMP0020)
+  cmake_policy(SET CMP0020 NEW) # Drop when CMake >= 2.8.11 required
+endif()
+CMake_OPTIONAL_COMPONENT(cmake-gui)
+find_package(Qt5Widgets QUIET)
+if (Qt5Widgets_FOUND)
+  include_directories(${Qt5Widgets_INCLUDE_DIRS})
+  add_definitions(${Qt5Widgets_DEFINITONS})
+  macro(qt4_wrap_ui)
+    qt5_wrap_ui(${ARGN})
+  endmacro()
+  macro(qt4_wrap_cpp)
+    qt5_wrap_cpp(${ARGN})
+  endmacro()
+  macro(qt4_add_resources)
+    qt5_add_resources(${ARGN})
+  endmacro()
+  set(CMake_QT_LIBRARIES ${Qt5Widgets_LIBRARIES})
+  set(QT_QTMAIN_LIBRARY ${Qt5Core_QTMAIN_LIBRARIES})
+
+  # Remove this when the minimum version of Qt is 4.6.
+  add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0)
+
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
+
+  if(CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES)
+    list(APPEND CMake_QT_LIBRARIES ${CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES})
+    set_property(SOURCE CMakeSetup.cxx
+      PROPERTY COMPILE_DEFINITIONS USE_QXcbIntegrationPlugin)
+  endif()
+
+  if(CMake_QT_STATIC_QWindowsIntegrationPlugin_LIBRARIES)
+    list(APPEND CMake_QT_LIBRARIES ${CMake_QT_STATIC_QWindowsIntegrationPlugin_LIBRARIES})
+    set_property(SOURCE CMakeSetup.cxx
+      PROPERTY COMPILE_DEFINITIONS USE_QWindowsIntegrationPlugin)
+  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)
+      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)
+        get_filename_component(_qt_plugin_type "${_qt_plugin_type}" NAME)
+        if(APPLE)
+          set(_qt_plugin_dir "PlugIns")
+        elseif(WIN32)
+          set(_qt_plugin_dir "plugins")
+        endif()
+        set(_qt_plugin_dest "${_qt_plugin_dir}/${_qt_plugin_type}")
+        install(FILES "${_qt_plugin_path}"
+          DESTINATION "${_qt_plugin_dest}"
+          ${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()
+    if(APPLE)
+      install_qt5_plugin("Qt5::QCocoaIntegrationPlugin" QT_PLUGINS)
+      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)
+      file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
+        "[Paths]\nPlugins = ../${_qt_plugin_dir}\n")
+      install(FILES "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
+        DESTINATION bin
+        ${COMPONENT})
+    endif()
+  endif()
+
+  if(TARGET Qt5::Core)
+    get_property(_Qt5_Core_LOCATION TARGET Qt5::Core PROPERTY LOCATION)
+    get_filename_component(Qt_BIN_DIR "${_Qt5_Core_LOCATION}" PATH)
+    if(APPLE)
+      get_filename_component(Qt_BIN_DIR "${Qt_BIN_DIR}" PATH)
+    endif()
+  endif()
+else()
+  set(QT_MIN_VERSION "4.4.0")
+  find_package(Qt4 REQUIRED)
+  if(NOT QT4_FOUND)
+    message(SEND_ERROR "Failed to find Qt 4.4 or greater.")
+    return()
+  endif()
+
+  include(${QT_USE_FILE})
+
+  set(CMake_QT_LIBRARIES ${QT_LIBRARIES})
+
+endif()
+
+set(SRCS
+  AddCacheEntry.cxx
+  AddCacheEntry.h
+  CMakeSetup.cxx
+  CMakeSetupDialog.cxx
+  CMakeSetupDialog.h
+  FirstConfigure.cxx
+  FirstConfigure.h
+  QCMake.cxx
+  QCMake.h
+  QCMakeCacheView.cxx
+  QCMakeCacheView.h
+  QCMakeWidgets.cxx
+  QCMakeWidgets.h
+  RegexExplorer.cxx
+  RegexExplorer.h
+  WarningMessagesDialog.cxx
+  WarningMessagesDialog.h
+  )
+QT4_WRAP_UI(UI_SRCS
+  CMakeSetupDialog.ui
+  Compilers.ui
+  CrossCompiler.ui
+  AddCacheEntry.ui
+  RegexExplorer.ui
+  WarningMessagesDialog.ui
+  )
+QT4_WRAP_CPP(MOC_SRCS
+  AddCacheEntry.h
+  Compilers.h
+  CMakeSetupDialog.h
+  FirstConfigure.h
+  QCMake.h
+  QCMakeCacheView.h
+  QCMakeWidgets.h
+  RegexExplorer.h
+  WarningMessagesDialog.h
+  )
+QT4_ADD_RESOURCES(RC_SRCS CMakeSetup.qrc)
+
+set(SRCS ${SRCS} ${UI_SRCS} ${MOC_SRCS} ${RC_SRCS})
+if(WIN32)
+  set(SRCS ${SRCS} CMakeSetup.rc)
+endif()
+if(APPLE)
+  set(SRCS ${SRCS} CMakeSetup.icns)
+  set(MACOSX_BUNDLE_ICON_FILE CMakeSetup.icns)
+  set_source_files_properties(CMakeSetup.icns PROPERTIES
+    MACOSX_PACKAGE_LOCATION Resources)
+endif()
+
+if(USE_LGPL)
+  install(FILES ${CMake_SOURCE_DIR}/Licenses/LGPLv${USE_LGPL}.txt
+    DESTINATION ${CMAKE_DATA_DIR}/Licenses
+    ${COMPONENT})
+  set_property(SOURCE CMakeSetupDialog.cxx
+    PROPERTY COMPILE_DEFINITIONS USE_LGPL="${USE_LGPL}")
+endif()
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+add_executable(cmake-gui WIN32 MACOSX_BUNDLE ${SRCS} ${MANIFEST_FILE})
+target_link_libraries(cmake-gui CMakeLib ${QT_QTMAIN_LIBRARY} ${CMake_QT_LIBRARIES})
+
+# cmake-gui has not been updated for `include-what-you-use`.
+# Block the tool until this is done.
+set_target_properties(cmake-gui PROPERTIES
+  CXX_INCLUDE_WHAT_YOU_USE ""
+  )
+
+# Files generated by MOC, RCC, and UIC may produce clang-tidy warnings.
+# We generate a dummy .clang-tidy file in the binary directory that disables
+# all clang-tidy checks except one that will never match.  This one check is
+# necessary; clang-tidy reports an error when no checks are enabled.
+# Since the Qt code generators will generate source files in the binary tree,
+# clang-tidy will load the configuration from this dummy file when the sources
+# are built.
+file(WRITE "${QtDialog_BINARY_DIR}/.clang-tidy" "
+---
+Checks: '-*,llvm-twine-local'
+...
+")
+
+if(APPLE)
+  file(STRINGS "${CMake_SOURCE_DIR}/Copyright.txt" copyright_line
+    LIMIT_COUNT 1 REGEX "^Copyright 2000-20[0-9][0-9] Kitware")
+
+  set_target_properties(cmake-gui PROPERTIES
+    OUTPUT_NAME CMake
+    MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/Info.plist.in"
+    MACOSX_BUNDLE_SHORT_VERSION_STRING "${CMAKE_BUNDLE_VERSION}"
+    # TBD: MACOSX_BUNDLE_BUNDLE_VERSION "${CMAKE_BUNDLE_VERSION}"
+    MACOSX_BUNDLE_COPYRIGHT "${copyright_line}"
+    MACOSX_BUNDLE_GUI_IDENTIFIER "org.cmake.cmake"
+    )
+
+  # Create a symlink in the build tree to provide a "cmake-gui" next
+  # to the "cmake" executable that refers to the application bundle.
+  add_custom_command(TARGET cmake-gui POST_BUILD
+    COMMAND ln -sf CMake.app/Contents/MacOS/CMake
+                   $<TARGET_FILE_DIR:cmake>/cmake-gui
+    )
+endif()
+set(CMAKE_INSTALL_DESTINATION_ARGS
+  BUNDLE DESTINATION "${CMAKE_BUNDLE_LOCATION}" ${COMPONENT})
+
+install(TARGETS cmake-gui
+  RUNTIME DESTINATION bin ${COMPONENT}
+  ${CMAKE_INSTALL_DESTINATION_ARGS})
+
+if(UNIX AND NOT APPLE)
+  foreach (size IN ITEMS 32 128)
+    install(
+      FILES       "${CMAKE_CURRENT_SOURCE_DIR}/CMakeSetup${size}.png"
+      DESTINATION "${CMAKE_XDGDATA_DIR}/icons/hicolor/${size}x${size}/apps"
+      ${COMPONENT}
+      RENAME      "CMakeSetup.png")
+  endforeach ()
+
+  # install a desktop file so CMake appears in the application start menu
+  # with an icon
+  install(FILES cmake-gui.desktop
+    DESTINATION "${CMAKE_XDGDATA_DIR}/applications"
+    ${COMPONENT})
+  install(FILES cmakecache.xml
+    DESTINATION "${CMAKE_XDGDATA_DIR}/mime/packages"
+    ${COMPONENT})
+endif()
+
+if(APPLE)
+  install(CODE "
+    execute_process(COMMAND ln -s \"../MacOS/CMake\" cmake-gui
+        WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/bin)
+  " ${COMPONENT})
+endif()
+
+if(CMake_INSTALL_DEPENDENCIES AND (APPLE OR WIN32))
+  # install rules for including 3rd party libs such as Qt
+  # if a system Qt is used (e.g. installed in /usr/lib/), it will not be included in the installation
+  set(fixup_exe "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/bin/cmake-gui${CMAKE_EXECUTABLE_SUFFIX}")
+  if(APPLE)
+    set(fixup_exe "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/MacOS/CMake")
+  endif()
+  install(CODE "
+    include(\"${CMake_SOURCE_DIR}/Modules/BundleUtilities.cmake\")
+    set(BU_CHMOD_BUNDLE_ITEMS ON)
+    fixup_bundle(\"${fixup_exe}\" \"${QT_PLUGINS}\" \"${Qt_BIN_DIR};${QT_LIBRARY_DIR};${QT_BINARY_DIR}\")
+  " ${COMPONENT})
+endif()
+
+set(CMAKE_PACKAGE_QTGUI TRUE)
+configure_file("${QtDialog_SOURCE_DIR}/QtDialogCPack.cmake.in"
+  "${QtDialog_BINARY_DIR}/QtDialogCPack.cmake" @ONLY)
diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx
new file mode 100644
index 0000000..193f4d3
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup.cxx
@@ -0,0 +1,261 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "QCMake.h" // include to disable MS warnings
+
+#include "CMakeSetupDialog.h"
+#include "cmAlgorithms.h"
+#include "cmDocumentation.h"
+#include "cmDocumentationEntry.h"
+#include "cmVersion.h"
+#include "cmake.h"
+#include "cmsys/CommandLineArguments.hxx"
+#include "cmsys/Encoding.hxx"
+#include "cmsys/SystemTools.hxx"
+#include <QApplication>
+#include <QDir>
+#include <QLocale>
+#include <QString>
+#include <QTextCodec>
+#include <QTranslator>
+#include <QtPlugin>
+#include <iostream>
+
+#include "cmSystemTools.h" // IWYU pragma: keep
+
+static const char* cmDocumentationName[][2] = { { nullptr,
+                                                  "  cmake-gui - CMake GUI." },
+                                                { nullptr, nullptr } };
+
+static const char* cmDocumentationUsage[][2] = {
+  { nullptr, "  cmake-gui [options]\n"
+             "  cmake-gui [options] <path-to-source>\n"
+             "  cmake-gui [options] <path-to-existing-build>" },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationOptions[][2] = { { nullptr, nullptr } };
+
+#if defined(Q_OS_MAC)
+static int cmOSXInstall(std::string dir);
+static void cmAddPluginPath();
+#endif
+
+#if defined(USE_QXcbIntegrationPlugin)
+Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
+#endif
+
+#if defined(USE_QWindowsIntegrationPlugin)
+Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
+#endif
+
+int main(int argc, char** argv)
+{
+  cmsys::Encoding::CommandLineArguments encoding_args =
+    cmsys::Encoding::CommandLineArguments::Main(argc, argv);
+  int argc2 = encoding_args.argc();
+  char const* const* argv2 = encoding_args.argv();
+
+  cmSystemTools::InitializeLibUV();
+  cmSystemTools::FindCMakeResources(argv2[0]);
+  // check docs first so that X is not need to get docs
+  // do docs, if args were given
+  cmDocumentation doc;
+  doc.addCMakeStandardDocSections();
+  if (argc2 > 1 && doc.CheckOptions(argc2, argv2)) {
+    // Construct and print requested documentation.
+    cmake hcm(cmake::RoleInternal);
+    hcm.SetHomeDirectory("");
+    hcm.SetHomeOutputDirectory("");
+    hcm.AddCMakePaths();
+
+    std::vector<cmDocumentationEntry> generators;
+    hcm.GetGeneratorDocumentation(generators);
+    doc.SetName("cmake");
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    doc.AppendSection("Generators", generators);
+    doc.PrependSection("Options", cmDocumentationOptions);
+
+    return (doc.PrintRequestedDocumentation(std::cout) ? 0 : 1);
+  }
+
+#if defined(Q_OS_MAC)
+  if (argc2 == 2 && strcmp(argv2[1], "--install") == 0) {
+    return cmOSXInstall("/usr/local/bin");
+  }
+  if (argc2 == 2 && cmHasLiteralPrefix(argv2[1], "--install=")) {
+    return cmOSXInstall(argv2[1] + 10);
+  }
+#endif
+
+// When we are on OSX and we are launching cmake-gui from a symlink, the
+// application will fail to launch as it can't find the qt.conf file which
+// tells it what the name of the plugin folder is. We need to add this path
+// BEFORE the application is constructed as that is what triggers the
+// searching for the platform plugins
+#if defined(Q_OS_MAC)
+  cmAddPluginPath();
+#endif
+
+#if QT_VERSION >= 0x050600
+  QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+#endif
+
+  QApplication app(argc, argv);
+
+  setlocale(LC_NUMERIC, "C");
+
+  QTextCodec* utf8_codec = QTextCodec::codecForName("UTF-8");
+  QTextCodec::setCodecForLocale(utf8_codec);
+
+#if QT_VERSION < 0x050000
+  // clean out standard Qt paths for plugins, which we don't use anyway
+  // when creating Mac bundles, it potentially causes problems
+  foreach (QString p, QApplication::libraryPaths()) {
+    QApplication::removeLibraryPath(p);
+  }
+#endif
+
+  // tell the cmake library where cmake is
+  QDir cmExecDir(QApplication::applicationDirPath());
+#if defined(Q_OS_MAC)
+  cmExecDir.cd("../../../");
+#endif
+
+  // pick up translation files if they exists in the data directory
+  QDir translationsDir = cmExecDir;
+  translationsDir.cd(QString::fromLocal8Bit(".." CMAKE_DATA_DIR));
+  translationsDir.cd("i18n");
+  QTranslator translator;
+  QString transfile = QString("cmake_%1").arg(QLocale::system().name());
+  translator.load(transfile, translationsDir.path());
+  app.installTranslator(&translator);
+
+  // app setup
+  app.setApplicationName("CMakeSetup");
+  app.setOrganizationName("Kitware");
+  QIcon appIcon;
+  appIcon.addFile(":/Icons/CMakeSetup32.png");
+  appIcon.addFile(":/Icons/CMakeSetup128.png");
+  app.setWindowIcon(appIcon);
+
+  CMakeSetupDialog dialog;
+  dialog.show();
+
+  cmsys::CommandLineArguments arg;
+  arg.Initialize(argc2, argv2);
+  std::string binaryDirectory;
+  std::string sourceDirectory;
+  typedef cmsys::CommandLineArguments argT;
+  arg.AddArgument("-B", argT::CONCAT_ARGUMENT, &binaryDirectory,
+                  "Binary Directory");
+  arg.AddArgument("-H", argT::CONCAT_ARGUMENT, &sourceDirectory,
+                  "Source Directory");
+  // do not complain about unknown options
+  arg.StoreUnusedArguments(true);
+  arg.Parse();
+  if (!sourceDirectory.empty() && !binaryDirectory.empty()) {
+    dialog.setSourceDirectory(QString::fromLocal8Bit(sourceDirectory.c_str()));
+    dialog.setBinaryDirectory(QString::fromLocal8Bit(binaryDirectory.c_str()));
+  } else {
+    QStringList args = app.arguments();
+    if (args.count() == 2) {
+      std::string filePath =
+        cmSystemTools::CollapseFullPath(args[1].toLocal8Bit().data());
+
+      // check if argument is a directory containing CMakeCache.txt
+      std::string buildFilePath =
+        cmSystemTools::CollapseFullPath("CMakeCache.txt", filePath.c_str());
+
+      // check if argument is a CMakeCache.txt file
+      if (cmSystemTools::GetFilenameName(filePath) == "CMakeCache.txt" &&
+          cmSystemTools::FileExists(filePath.c_str())) {
+        buildFilePath = filePath;
+      }
+
+      // check if argument is a directory containing CMakeLists.txt
+      std::string srcFilePath =
+        cmSystemTools::CollapseFullPath("CMakeLists.txt", filePath.c_str());
+
+      if (cmSystemTools::FileExists(buildFilePath.c_str())) {
+        dialog.setBinaryDirectory(QString::fromLocal8Bit(
+          cmSystemTools::GetFilenamePath(buildFilePath).c_str()));
+      } else if (cmSystemTools::FileExists(srcFilePath.c_str())) {
+        dialog.setSourceDirectory(QString::fromLocal8Bit(filePath.c_str()));
+        dialog.setBinaryDirectory(QString::fromLocal8Bit(
+          cmSystemTools::CollapseFullPath(".").c_str()));
+      }
+    }
+  }
+
+  return app.exec();
+}
+
+#if defined(Q_OS_MAC)
+#include "cm_sys_stat.h"
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+static bool cmOSXInstall(std::string const& dir, std::string const& tool)
+{
+  if (tool.empty()) {
+    return true;
+  }
+  std::string link = dir + cmSystemTools::GetFilenameName(tool);
+  struct stat st;
+  if (lstat(link.c_str(), &st) == 0 && S_ISLNK(st.st_mode)) {
+    char buf[4096];
+    ssize_t s = readlink(link.c_str(), buf, sizeof(buf) - 1);
+    if (s >= 0 && std::string(buf, s) == tool) {
+      std::cerr << "Exists: '" << link << "' -> '" << tool << "'\n";
+      return true;
+    }
+  }
+  cmSystemTools::MakeDirectory(dir);
+  if (symlink(tool.c_str(), link.c_str()) == 0) {
+    std::cerr << "Linked: '" << link << "' -> '" << tool << "'\n";
+    return true;
+  } else {
+    int err = errno;
+    std::cerr << "Failed: '" << link << "' -> '" << tool
+              << "': " << strerror(err) << "\n";
+    return false;
+  }
+}
+static int cmOSXInstall(std::string dir)
+{
+  if (!cmHasLiteralSuffix(dir, "/")) {
+    dir += "/";
+  }
+  return (cmOSXInstall(dir, cmSystemTools::GetCMakeCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCTestCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCPackCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCMakeGUICommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCMakeCursesCommand()))
+    ? 0
+    : 1;
+}
+
+// Locate the PlugIns directory and add it to the QApplication library paths.
+// We need to resolve all symlinks so we have a known relative path between
+// MacOS/CMake and the PlugIns directory.
+//
+// Note we are using cmSystemTools since Qt can't provide the path to the
+// executable before the QApplication is created, and that is when plugin
+// searching occurs.
+static void cmAddPluginPath()
+{
+  std::string const& path = cmSystemTools::GetCMakeGUICommand();
+  if (path.empty()) {
+    return;
+  }
+  std::string const& realPath = cmSystemTools::GetRealPath(path);
+  QFileInfo appPath(QString::fromLocal8Bit(realPath.c_str()));
+  QDir pluginDir = appPath.dir();
+  bool const foundPluginDir = pluginDir.cd("../PlugIns");
+  if (foundPluginDir) {
+    QApplication::addLibraryPath(pluginDir.path());
+  }
+}
+
+#endif
diff --git a/Source/QtDialog/CMakeSetup.icns b/Source/QtDialog/CMakeSetup.icns
new file mode 100644
index 0000000..4a50c04
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup.icns
diff --git a/Source/QtDialog/CMakeSetup.ico b/Source/QtDialog/CMakeSetup.ico
new file mode 100644
index 0000000..e13bb15
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup.ico
diff --git a/Source/QtDialog/CMakeSetup.qrc b/Source/QtDialog/CMakeSetup.qrc
new file mode 100644
index 0000000..eaac192
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup.qrc
@@ -0,0 +1,8 @@
+<RCC>
+    <qresource prefix="/Icons" >
+        <file>CMakeSetup128.png</file>
+        <file>CMakeSetup32.png</file>
+        <file>Delete16.png</file>
+        <file>Plus16.png</file>
+    </qresource>
+</RCC>
diff --git a/Source/QtDialog/CMakeSetup.rc b/Source/QtDialog/CMakeSetup.rc
new file mode 100644
index 0000000..fcc887d
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup.rc
@@ -0,0 +1 @@
+IDI_ICON1   ICON  DISCARDABLE  "CMakeSetup.ico"
diff --git a/Source/QtDialog/CMakeSetup128.png b/Source/QtDialog/CMakeSetup128.png
new file mode 100644
index 0000000..12f1d9a
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup128.png
diff --git a/Source/QtDialog/CMakeSetup32.png b/Source/QtDialog/CMakeSetup32.png
new file mode 100644
index 0000000..7bbcee4
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup32.png
diff --git a/Source/QtDialog/CMakeSetup64.png b/Source/QtDialog/CMakeSetup64.png
new file mode 100644
index 0000000..43a8cc6
--- /dev/null
+++ b/Source/QtDialog/CMakeSetup64.png
diff --git a/Source/QtDialog/CMakeSetupDialog.cxx b/Source/QtDialog/CMakeSetupDialog.cxx
new file mode 100644
index 0000000..5be9ec3
--- /dev/null
+++ b/Source/QtDialog/CMakeSetupDialog.cxx
@@ -0,0 +1,1309 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "CMakeSetupDialog.h"
+
+#include <QCloseEvent>
+#include <QCoreApplication>
+#include <QDesktopServices>
+#include <QDialogButtonBox>
+#include <QDragEnterEvent>
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QKeySequence>
+#include <QMenu>
+#include <QMenuBar>
+#include <QMessageBox>
+#include <QMimeData>
+#include <QProgressBar>
+#include <QSettings>
+#include <QShortcut>
+#include <QStatusBar>
+#include <QToolButton>
+#include <QUrl>
+
+#include "AddCacheEntry.h"
+#include "FirstConfigure.h"
+#include "QCMake.h"
+#include "QCMakeCacheView.h"
+#include "RegexExplorer.h"
+#include "WarningMessagesDialog.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+
+QCMakeThread::QCMakeThread(QObject* p)
+  : QThread(p)
+  , CMakeInstance(nullptr)
+{
+}
+
+QCMake* QCMakeThread::cmakeInstance() const
+{
+  return this->CMakeInstance;
+}
+
+void QCMakeThread::run()
+{
+  this->CMakeInstance = new QCMake;
+  // emit that this cmake thread is ready for use
+  emit this->cmakeInitialized();
+  this->exec();
+  delete this->CMakeInstance;
+  this->CMakeInstance = nullptr;
+}
+
+CMakeSetupDialog::CMakeSetupDialog()
+  : ExitAfterGenerate(true)
+  , CacheModified(false)
+  , ConfigureNeeded(true)
+  , CurrentState(Interrupting)
+{
+  QString title = QString(tr("CMake %1"));
+  title = title.arg(cmVersion::GetCMakeVersion());
+  this->setWindowTitle(title);
+
+  // create the GUI
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+  restoreGeometry(settings.value("geometry").toByteArray());
+  restoreState(settings.value("windowState").toByteArray());
+
+  this->AddVariableNames =
+    settings.value("AddVariableNames", QStringList("CMAKE_INSTALL_PREFIX"))
+      .toStringList();
+  this->AddVariableTypes =
+    settings.value("AddVariableTypes", QStringList("PATH")).toStringList();
+
+  QWidget* cont = new QWidget(this);
+  this->setupUi(cont);
+  this->Splitter->setStretchFactor(0, 3);
+  this->Splitter->setStretchFactor(1, 1);
+  this->setCentralWidget(cont);
+  this->ProgressBar->reset();
+  this->RemoveEntry->setEnabled(false);
+  this->AddEntry->setEnabled(false);
+
+  QByteArray p = settings.value("SplitterSizes").toByteArray();
+  this->Splitter->restoreState(p);
+
+  bool groupView = settings.value("GroupView", false).toBool();
+  this->setGroupedView(groupView);
+  this->groupedCheck->setCheckState(groupView ? Qt::Checked : Qt::Unchecked);
+
+  bool advancedView = settings.value("AdvancedView", false).toBool();
+  this->setAdvancedView(advancedView);
+  this->advancedCheck->setCheckState(advancedView ? Qt::Checked
+                                                  : Qt::Unchecked);
+
+  QMenu* FileMenu = this->menuBar()->addMenu(tr("&File"));
+  this->ReloadCacheAction = FileMenu->addAction(tr("&Reload Cache"));
+  QObject::connect(this->ReloadCacheAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doReloadCache()));
+  this->DeleteCacheAction = FileMenu->addAction(tr("&Delete Cache"));
+  QObject::connect(this->DeleteCacheAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doDeleteCache()));
+  this->ExitAction = FileMenu->addAction(tr("E&xit"));
+  this->ExitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
+  QObject::connect(this->ExitAction, SIGNAL(triggered(bool)), this,
+                   SLOT(close()));
+
+  QMenu* ToolsMenu = this->menuBar()->addMenu(tr("&Tools"));
+  this->ConfigureAction = ToolsMenu->addAction(tr("&Configure"));
+  // prevent merging with Preferences menu item on Mac OS X
+  this->ConfigureAction->setMenuRole(QAction::NoRole);
+  QObject::connect(this->ConfigureAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doConfigure()));
+  this->GenerateAction = ToolsMenu->addAction(tr("&Generate"));
+  QObject::connect(this->GenerateAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doGenerate()));
+  QAction* showChangesAction = ToolsMenu->addAction(tr("&Show My Changes"));
+  QObject::connect(showChangesAction, SIGNAL(triggered(bool)), this,
+                   SLOT(showUserChanges()));
+#if defined(Q_WS_MAC) || defined(Q_OS_MAC)
+  this->InstallForCommandLineAction =
+    ToolsMenu->addAction(tr("&How to Install For Command Line Use"));
+  QObject::connect(this->InstallForCommandLineAction, SIGNAL(triggered(bool)),
+                   this, SLOT(doInstallForCommandLine()));
+#endif
+  ToolsMenu->addSeparator();
+  ToolsMenu->addAction(tr("Regular Expression Explorer..."), this,
+                       SLOT(doRegexExplorerDialog()));
+  ToolsMenu->addSeparator();
+  ToolsMenu->addAction(tr("&Find in Output..."), this,
+                       SLOT(doOutputFindDialog()), QKeySequence::Find);
+  ToolsMenu->addAction(tr("Find Next"), this, SLOT(doOutputFindNext()),
+                       QKeySequence::FindNext);
+  ToolsMenu->addAction(tr("Find Previous"), this, SLOT(doOutputFindPrev()),
+                       QKeySequence::FindPrevious);
+  ToolsMenu->addAction(tr("Goto Next Error"), this, SLOT(doOutputErrorNext()),
+                       QKeySequence(Qt::Key_F8)); // in Visual Studio
+  new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Period), this,
+                SLOT(doOutputErrorNext())); // in Eclipse
+
+  QMenu* OptionsMenu = this->menuBar()->addMenu(tr("&Options"));
+  OptionsMenu->addAction(tr("Warning Messages..."), this,
+                         SLOT(doWarningMessagesDialog()));
+  this->WarnUninitializedAction =
+    OptionsMenu->addAction(tr("&Warn Uninitialized (--warn-uninitialized)"));
+  this->WarnUninitializedAction->setCheckable(true);
+  this->WarnUnusedAction =
+    OptionsMenu->addAction(tr("&Warn Unused (--warn-unused-vars)"));
+  this->WarnUnusedAction->setCheckable(true);
+
+  QAction* debugAction = OptionsMenu->addAction(tr("&Debug Output"));
+  debugAction->setCheckable(true);
+  QObject::connect(debugAction, SIGNAL(toggled(bool)), this,
+                   SLOT(setDebugOutput(bool)));
+
+  OptionsMenu->addSeparator();
+  QAction* expandAction =
+    OptionsMenu->addAction(tr("&Expand Grouped Entries"));
+  QObject::connect(expandAction, SIGNAL(triggered(bool)), this->CacheValues,
+                   SLOT(expandAll()));
+  QAction* collapseAction =
+    OptionsMenu->addAction(tr("&Collapse Grouped Entries"));
+  QObject::connect(collapseAction, SIGNAL(triggered(bool)), this->CacheValues,
+                   SLOT(collapseAll()));
+
+  QMenu* HelpMenu = this->menuBar()->addMenu(tr("&Help"));
+  QAction* a = HelpMenu->addAction(tr("About"));
+  QObject::connect(a, SIGNAL(triggered(bool)), this, SLOT(doAbout()));
+  a = HelpMenu->addAction(tr("Help"));
+  QObject::connect(a, SIGNAL(triggered(bool)), this, SLOT(doHelp()));
+
+  this->setAcceptDrops(true);
+
+  // get the saved binary directories
+  QStringList buildPaths = this->loadBuildPaths();
+  this->BinaryDirectory->addItems(buildPaths);
+
+  this->BinaryDirectory->setCompleter(new QCMakeFileCompleter(this, true));
+  this->SourceDirectory->setCompleter(new QCMakeFileCompleter(this, true));
+
+  // fixed pitch font in output window
+  QFont outputFont("Courier");
+  this->Output->setFont(outputFont);
+  this->ErrorFormat.setForeground(QBrush(Qt::red));
+
+  this->Output->setContextMenuPolicy(Qt::CustomContextMenu);
+  connect(this->Output, SIGNAL(customContextMenuRequested(const QPoint&)),
+          this, SLOT(doOutputContextMenu(const QPoint&)));
+
+  // disable open project button
+  this->OpenProjectButton->setDisabled(true);
+
+  // start the cmake worker thread
+  this->CMakeThread = new QCMakeThread(this);
+  QObject::connect(this->CMakeThread, SIGNAL(cmakeInitialized()), this,
+                   SLOT(initialize()), Qt::QueuedConnection);
+  this->CMakeThread->start();
+
+  this->enterState(ReadyConfigure);
+
+  ProgressOffset = 0.0;
+  ProgressFactor = 1.0;
+}
+
+void CMakeSetupDialog::initialize()
+{
+  // now the cmake worker thread is running, lets make our connections to it
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(propertiesChanged(const QCMakePropertyList&)),
+                   this->CacheValues->cacheModel(),
+                   SLOT(setProperties(const QCMakePropertyList&)));
+
+  QObject::connect(this->ConfigureButton, SIGNAL(clicked(bool)), this,
+                   SLOT(doConfigure()));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(configureDone(int)), this, SLOT(exitLoop(int)));
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(generateDone(int)), this, SLOT(exitLoop(int)));
+
+  QObject::connect(this->GenerateButton, SIGNAL(clicked(bool)), this,
+                   SLOT(doGenerate()));
+  QObject::connect(this->OpenProjectButton, SIGNAL(clicked(bool)), this,
+                   SLOT(doOpenProject()));
+
+  QObject::connect(this->BrowseSourceDirectoryButton, SIGNAL(clicked(bool)),
+                   this, SLOT(doSourceBrowse()));
+  QObject::connect(this->BrowseBinaryDirectoryButton, SIGNAL(clicked(bool)),
+                   this, SLOT(doBinaryBrowse()));
+
+  QObject::connect(this->BinaryDirectory, SIGNAL(editTextChanged(QString)),
+                   this, SLOT(onBinaryDirectoryChanged(QString)));
+  QObject::connect(this->SourceDirectory, SIGNAL(textChanged(QString)), this,
+                   SLOT(onSourceDirectoryChanged(QString)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(sourceDirChanged(QString)), this,
+                   SLOT(updateSourceDirectory(QString)));
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(binaryDirChanged(QString)), this,
+                   SLOT(updateBinaryDirectory(QString)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(progressChanged(QString, float)), this,
+                   SLOT(showProgress(QString, float)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(errorMessage(QString)), this, SLOT(error(QString)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(outputMessage(QString)), this,
+                   SLOT(message(QString)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(openPossible(bool)), this->OpenProjectButton,
+                   SLOT(setEnabled(bool)));
+
+  QObject::connect(this->groupedCheck, SIGNAL(toggled(bool)), this,
+                   SLOT(setGroupedView(bool)));
+  QObject::connect(this->advancedCheck, SIGNAL(toggled(bool)), this,
+                   SLOT(setAdvancedView(bool)));
+  QObject::connect(this->Search, SIGNAL(textChanged(QString)), this,
+                   SLOT(setSearchFilter(QString)));
+
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(generatorChanged(QString)), this,
+                   SLOT(updateGeneratorLabel(QString)));
+  this->updateGeneratorLabel(QString());
+
+  QObject::connect(this->CacheValues->cacheModel(),
+                   SIGNAL(dataChanged(QModelIndex, QModelIndex)), this,
+                   SLOT(setCacheModified()));
+
+  QObject::connect(this->CacheValues->selectionModel(),
+                   SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
+                   this, SLOT(selectionChanged()));
+  QObject::connect(this->RemoveEntry, SIGNAL(clicked(bool)), this,
+                   SLOT(removeSelectedCacheEntries()));
+  QObject::connect(this->AddEntry, SIGNAL(clicked(bool)), this,
+                   SLOT(addCacheEntry()));
+
+  QObject::connect(this->WarnUninitializedAction, SIGNAL(triggered(bool)),
+                   this->CMakeThread->cmakeInstance(),
+                   SLOT(setWarnUninitializedMode(bool)));
+  QObject::connect(this->WarnUnusedAction, SIGNAL(triggered(bool)),
+                   this->CMakeThread->cmakeInstance(),
+                   SLOT(setWarnUnusedMode(bool)));
+
+  if (!this->SourceDirectory->text().isEmpty() ||
+      !this->BinaryDirectory->lineEdit()->text().isEmpty()) {
+    this->onSourceDirectoryChanged(this->SourceDirectory->text());
+    this->onBinaryDirectoryChanged(this->BinaryDirectory->lineEdit()->text());
+  } else {
+    this->onBinaryDirectoryChanged(this->BinaryDirectory->lineEdit()->text());
+  }
+}
+
+CMakeSetupDialog::~CMakeSetupDialog()
+{
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+  settings.setValue("windowState", QVariant(saveState()));
+  settings.setValue("geometry", QVariant(saveGeometry()));
+  settings.setValue("SplitterSizes", this->Splitter->saveState());
+
+  // wait for thread to stop
+  this->CMakeThread->quit();
+  this->CMakeThread->wait();
+}
+
+bool CMakeSetupDialog::prepareConfigure()
+{
+  // make sure build directory exists
+  QString bindir = this->CMakeThread->cmakeInstance()->binaryDirectory();
+  QDir dir(bindir);
+  if (!dir.exists()) {
+    QString msg = tr("Build directory does not exist, "
+                     "should I create it?\n\n"
+                     "Directory: ");
+    msg += bindir;
+    QString title = tr("Create Directory");
+    QMessageBox::StandardButton btn;
+    btn = QMessageBox::information(this, title, msg,
+                                   QMessageBox::Yes | QMessageBox::No);
+    if (btn == QMessageBox::No) {
+      return false;
+    }
+    if (!dir.mkpath(".")) {
+      QMessageBox::information(
+        this, tr("Create Directory Failed"),
+        QString(tr("Failed to create directory %1")).arg(dir.path()),
+        QMessageBox::Ok);
+
+      return false;
+    }
+  }
+
+  // if no generator, prompt for it and other setup stuff
+  if (this->CMakeThread->cmakeInstance()->generator().isEmpty()) {
+    if (!this->setupFirstConfigure()) {
+      return false;
+    }
+  }
+
+  // remember path
+  this->addBinaryPath(dir.absolutePath());
+
+  return true;
+}
+
+void CMakeSetupDialog::exitLoop(int err)
+{
+  this->LocalLoop.exit(err);
+}
+
+void CMakeSetupDialog::doConfigure()
+{
+  if (this->CurrentState == Configuring) {
+    // stop configure
+    doInterrupt();
+    return;
+  }
+
+  if (!prepareConfigure()) {
+    return;
+  }
+
+  this->enterState(Configuring);
+
+  bool ret = doConfigureInternal();
+
+  if (ret) {
+    this->ConfigureNeeded = false;
+  }
+
+  if (ret && !this->CacheValues->cacheModel()->newPropertyCount()) {
+    this->enterState(ReadyGenerate);
+  } else {
+    this->enterState(ReadyConfigure);
+    this->CacheValues->scrollToTop();
+  }
+  this->ProgressBar->reset();
+}
+
+bool CMakeSetupDialog::doConfigureInternal()
+{
+  this->Output->clear();
+  this->CacheValues->selectionModel()->clear();
+
+  QMetaObject::invokeMethod(
+    this->CMakeThread->cmakeInstance(), "setProperties", Qt::QueuedConnection,
+    Q_ARG(QCMakePropertyList, this->CacheValues->cacheModel()->properties()));
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "configure",
+                            Qt::QueuedConnection);
+
+  int err = this->LocalLoop.exec();
+
+  if (err != 0) {
+    QMessageBox::critical(
+      this, tr("Error"),
+      tr("Error in configuration process, project files may be invalid"),
+      QMessageBox::Ok);
+  }
+
+  return 0 == err;
+}
+
+void CMakeSetupDialog::doInstallForCommandLine()
+{
+  QString title = tr("How to Install For Command Line Use");
+  QString msg = tr("One may add CMake to the PATH:\n"
+                   "\n"
+                   " PATH=\"%1\":\"$PATH\"\n"
+                   "\n"
+                   "Or, to install symlinks to '/usr/local/bin', run:\n"
+                   "\n"
+                   " sudo \"%2\" --install\n"
+                   "\n"
+                   "Or, to install symlinks to another directory, run:\n"
+                   "\n"
+                   " sudo \"%3\" --install=/path/to/bin\n");
+  msg = msg.arg(
+    cmSystemTools::GetFilenamePath(cmSystemTools::GetCMakeCommand()).c_str());
+  msg = msg.arg(cmSystemTools::GetCMakeGUICommand().c_str());
+  msg = msg.arg(cmSystemTools::GetCMakeGUICommand().c_str());
+
+  QDialog dialog;
+  dialog.setWindowTitle(title);
+  QVBoxLayout* l = new QVBoxLayout(&dialog);
+  QLabel* lab = new QLabel(&dialog);
+  l->addWidget(lab);
+  lab->setText(msg);
+  lab->setWordWrap(false);
+  lab->setTextInteractionFlags(Qt::TextSelectableByMouse);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
+  QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
+  l->addWidget(btns);
+  dialog.exec();
+}
+
+bool CMakeSetupDialog::doGenerateInternal()
+{
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "generate",
+                            Qt::QueuedConnection);
+
+  int err = this->LocalLoop.exec();
+
+  if (err != 0) {
+    QMessageBox::critical(
+      this, tr("Error"),
+      tr("Error in generation process, project files may be invalid"),
+      QMessageBox::Ok);
+  }
+
+  return 0 == err;
+}
+
+void CMakeSetupDialog::doGenerate()
+{
+  if (this->CurrentState == Generating) {
+    // stop generate
+    doInterrupt();
+    return;
+  }
+
+  // see if we need to configure
+  // we'll need to configure if:
+  //   the configure step hasn't been done yet
+  //   generate was the last step done
+  if (this->ConfigureNeeded) {
+    if (!prepareConfigure()) {
+      return;
+    }
+  }
+
+  this->enterState(Generating);
+
+  bool config_passed = true;
+  if (this->ConfigureNeeded) {
+    this->CacheValues->cacheModel()->setShowNewProperties(false);
+    this->ProgressFactor = 0.5;
+    config_passed = doConfigureInternal();
+    this->ProgressOffset = 0.5;
+  }
+
+  if (config_passed) {
+    doGenerateInternal();
+  }
+
+  this->ProgressOffset = 0.0;
+  this->ProgressFactor = 1.0;
+  this->CacheValues->cacheModel()->setShowNewProperties(true);
+
+  this->enterState(ReadyConfigure);
+  this->ProgressBar->reset();
+
+  this->ConfigureNeeded = true;
+}
+
+void CMakeSetupDialog::doOpenProject()
+{
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "open",
+                            Qt::QueuedConnection);
+}
+
+void CMakeSetupDialog::closeEvent(QCloseEvent* e)
+{
+  // prompt for close if there are unsaved changes, and we're not busy
+  if (this->CacheModified) {
+    QString msg = tr("You have changed options but not rebuilt, "
+                     "are you sure you want to exit?");
+    QString title = tr("Confirm Exit");
+    QMessageBox::StandardButton btn;
+    btn = QMessageBox::critical(this, title, msg,
+                                QMessageBox::Yes | QMessageBox::No);
+    if (btn == QMessageBox::No) {
+      e->ignore();
+    }
+  }
+
+  // don't close if we're busy, unless the user really wants to
+  if (this->CurrentState == Configuring) {
+    QString msg =
+      tr("You are in the middle of a Configure.\n"
+         "If you Exit now the configure information will be lost.\n"
+         "Are you sure you want to Exit?");
+    QString title = tr("Confirm Exit");
+    QMessageBox::StandardButton btn;
+    btn = QMessageBox::critical(this, title, msg,
+                                QMessageBox::Yes | QMessageBox::No);
+    if (btn == QMessageBox::No) {
+      e->ignore();
+    } else {
+      this->doInterrupt();
+    }
+  }
+
+  // let the generate finish
+  if (this->CurrentState == Generating) {
+    e->ignore();
+  }
+}
+
+void CMakeSetupDialog::doHelp()
+{
+  QString msg = tr(
+    "CMake is used to configure and generate build files for "
+    "software projects.   The basic steps for configuring a project are as "
+    "follows:\r\n\r\n1. Select the source directory for the project.  This "
+    "should "
+    "contain the CMakeLists.txt files for the project.\r\n\r\n2. Select the "
+    "build "
+    "directory for the project.   This is the directory where the project "
+    "will be "
+    "built.  It can be the same or a different directory than the source "
+    "directory.   For easy clean up, a separate build directory is "
+    "recommended. "
+    "CMake will create the directory if it does not exist.\r\n\r\n3. Once the "
+    "source and binary directories are selected, it is time to press the "
+    "Configure button.  This will cause CMake to read all of the input files "
+    "and "
+    "discover all the variables used by the project.   The first time a "
+    "variable "
+    "is displayed it will be in Red.   Users should inspect red variables "
+    "making "
+    "sure the values are correct.   For some projects the Configure process "
+    "can "
+    "be iterative, so continue to press the Configure button until there are "
+    "no "
+    "longer red entries.\r\n\r\n4. Once there are no longer red entries, you "
+    "should click the Generate button.  This will write the build files to "
+    "the build "
+    "directory.");
+
+  QDialog dialog;
+  QFontMetrics met(this->font());
+  int msgWidth = met.width(msg);
+  dialog.setMinimumSize(msgWidth / 15, 20);
+  dialog.setWindowTitle(tr("Help"));
+  QVBoxLayout* l = new QVBoxLayout(&dialog);
+  QLabel* lab = new QLabel(&dialog);
+  lab->setText(msg);
+  lab->setWordWrap(true);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
+  QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
+  l->addWidget(lab);
+  l->addWidget(btns);
+  dialog.exec();
+}
+
+void CMakeSetupDialog::doInterrupt()
+{
+  this->enterState(Interrupting);
+  this->CMakeThread->cmakeInstance()->interrupt();
+}
+
+void CMakeSetupDialog::doSourceBrowse()
+{
+  QString dir = QFileDialog::getExistingDirectory(
+    this, tr("Enter Path to Source"), this->SourceDirectory->text(),
+    QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+  if (!dir.isEmpty()) {
+    this->setSourceDirectory(dir);
+  }
+}
+
+void CMakeSetupDialog::updateSourceDirectory(const QString& dir)
+{
+  if (this->SourceDirectory->text() != dir) {
+    this->SourceDirectory->blockSignals(true);
+    this->SourceDirectory->setText(dir);
+    this->SourceDirectory->blockSignals(false);
+  }
+}
+
+void CMakeSetupDialog::updateBinaryDirectory(const QString& dir)
+{
+  if (this->BinaryDirectory->currentText() != dir) {
+    this->BinaryDirectory->blockSignals(true);
+    this->BinaryDirectory->setEditText(dir);
+    this->BinaryDirectory->blockSignals(false);
+  }
+}
+
+void CMakeSetupDialog::doBinaryBrowse()
+{
+  QString dir = QFileDialog::getExistingDirectory(
+    this, tr("Enter Path to Build"), this->BinaryDirectory->currentText(),
+    QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+  if (!dir.isEmpty() && dir != this->BinaryDirectory->currentText()) {
+    this->setBinaryDirectory(dir);
+  }
+}
+
+void CMakeSetupDialog::setBinaryDirectory(const QString& dir)
+{
+  this->BinaryDirectory->setEditText(dir);
+}
+
+void CMakeSetupDialog::onSourceDirectoryChanged(const QString& dir)
+{
+  this->Output->clear();
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+                            "setSourceDirectory", Qt::QueuedConnection,
+                            Q_ARG(QString, dir));
+}
+
+void CMakeSetupDialog::onBinaryDirectoryChanged(const QString& dir)
+{
+  QString title = QString(tr("CMake %1 - %2"));
+  title = title.arg(cmVersion::GetCMakeVersion());
+  title = title.arg(dir);
+  this->setWindowTitle(title);
+
+  this->CacheModified = false;
+  this->CacheValues->cacheModel()->clear();
+  qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())
+    ->clearChanges();
+  this->Output->clear();
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+                            "setBinaryDirectory", Qt::QueuedConnection,
+                            Q_ARG(QString, dir));
+}
+
+void CMakeSetupDialog::setSourceDirectory(const QString& dir)
+{
+  this->SourceDirectory->setText(dir);
+}
+
+void CMakeSetupDialog::showProgress(const QString& /*msg*/, float percent)
+{
+  percent = (percent * ProgressFactor) + ProgressOffset;
+  this->ProgressBar->setValue(qRound(percent * 100));
+}
+
+void CMakeSetupDialog::error(const QString& msg)
+{
+  this->Output->setCurrentCharFormat(this->ErrorFormat);
+  // QTextEdit will terminate the msg with a ParagraphSeparator, but it also
+  // replaces
+  // all newlines with ParagraphSeparators. By replacing the newlines by
+  // ourself, one
+  // error msg will be one paragraph.
+  QString paragraph(msg);
+  paragraph.replace(QLatin1Char('\n'), QChar::LineSeparator);
+  this->Output->append(paragraph);
+}
+
+void CMakeSetupDialog::message(const QString& msg)
+{
+  this->Output->setCurrentCharFormat(this->MessageFormat);
+  this->Output->append(msg);
+}
+
+void CMakeSetupDialog::setEnabledState(bool enabled)
+{
+  // disable parts of the GUI during configure/generate
+  this->CacheValues->cacheModel()->setEditEnabled(enabled);
+  this->SourceDirectory->setEnabled(enabled);
+  this->BrowseSourceDirectoryButton->setEnabled(enabled);
+  this->BinaryDirectory->setEnabled(enabled);
+  this->BrowseBinaryDirectoryButton->setEnabled(enabled);
+  this->ReloadCacheAction->setEnabled(enabled);
+  this->DeleteCacheAction->setEnabled(enabled);
+  this->ExitAction->setEnabled(enabled);
+  this->ConfigureAction->setEnabled(enabled);
+  this->AddEntry->setEnabled(enabled);
+  this->RemoveEntry->setEnabled(false); // let selection re-enable it
+}
+
+bool CMakeSetupDialog::setupFirstConfigure()
+{
+  FirstConfigure dialog;
+
+  // initialize dialog and restore saved settings
+
+  // add generators
+  dialog.setGenerators(
+    this->CMakeThread->cmakeInstance()->availableGenerators());
+
+  // restore from settings
+  dialog.loadFromSettings();
+
+  if (dialog.exec() == QDialog::Accepted) {
+    dialog.saveToSettings();
+    this->CMakeThread->cmakeInstance()->setGenerator(dialog.getGenerator());
+    this->CMakeThread->cmakeInstance()->setToolset(dialog.getToolset());
+
+    QCMakeCacheModel* m = this->CacheValues->cacheModel();
+
+    if (dialog.compilerSetup()) {
+      QString fortranCompiler = dialog.getFortranCompiler();
+      if (!fortranCompiler.isEmpty()) {
+        m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_Fortran_COMPILER",
+                          "Fortran compiler.", fortranCompiler, false);
+      }
+      QString cxxCompiler = dialog.getCXXCompiler();
+      if (!cxxCompiler.isEmpty()) {
+        m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_CXX_COMPILER",
+                          "CXX compiler.", cxxCompiler, false);
+      }
+
+      QString cCompiler = dialog.getCCompiler();
+      if (!cCompiler.isEmpty()) {
+        m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_C_COMPILER",
+                          "C compiler.", cCompiler, false);
+      }
+    } else if (dialog.crossCompilerSetup()) {
+      QString fortranCompiler = dialog.getFortranCompiler();
+      if (!fortranCompiler.isEmpty()) {
+        m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_Fortran_COMPILER",
+                          "Fortran compiler.", fortranCompiler, false);
+      }
+
+      QString mode = dialog.getCrossIncludeMode();
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE",
+                        tr("CMake Find Include Mode"), mode, false);
+      mode = dialog.getCrossLibraryMode();
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY",
+                        tr("CMake Find Library Mode"), mode, false);
+      mode = dialog.getCrossProgramMode();
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM",
+                        tr("CMake Find Program Mode"), mode, false);
+
+      QString rootPath = dialog.getCrossRoot();
+      m->insertProperty(QCMakeProperty::PATH, "CMAKE_FIND_ROOT_PATH",
+                        tr("CMake Find Root Path"), rootPath, false);
+
+      QString systemName = dialog.getSystemName();
+      m->insertProperty(QCMakeProperty::STRING, "CMAKE_SYSTEM_NAME",
+                        tr("CMake System Name"), systemName, false);
+      QString systemVersion = dialog.getSystemVersion();
+      m->insertProperty(QCMakeProperty::STRING, "CMAKE_SYSTEM_VERSION",
+                        tr("CMake System Version"), systemVersion, false);
+      QString cxxCompiler = dialog.getCXXCompiler();
+      m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_CXX_COMPILER",
+                        tr("CXX compiler."), cxxCompiler, false);
+      QString cCompiler = dialog.getCCompiler();
+      m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_C_COMPILER",
+                        tr("C compiler."), cCompiler, false);
+    } else if (dialog.crossCompilerToolChainFile()) {
+      QString toolchainFile = dialog.getCrossCompilerToolChainFile();
+      m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_TOOLCHAIN_FILE",
+                        tr("Cross Compile ToolChain File"), toolchainFile,
+                        false);
+    }
+    return true;
+  }
+
+  return false;
+}
+
+void CMakeSetupDialog::updateGeneratorLabel(const QString& gen)
+{
+  QString str = tr("Current Generator: ");
+  if (gen.isEmpty()) {
+    str += tr("None");
+  } else {
+    str += gen;
+  }
+  this->Generator->setText(str);
+}
+
+void CMakeSetupDialog::doReloadCache()
+{
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "reloadCache",
+                            Qt::QueuedConnection);
+}
+
+void CMakeSetupDialog::doDeleteCache()
+{
+  QString title = tr("Delete Cache");
+  QString msg = tr("Are you sure you want to delete the cache?");
+  QMessageBox::StandardButton btn;
+  btn = QMessageBox::information(this, title, msg,
+                                 QMessageBox::Yes | QMessageBox::No);
+  if (btn == QMessageBox::No) {
+    return;
+  }
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "deleteCache",
+                            Qt::QueuedConnection);
+}
+
+void CMakeSetupDialog::doAbout()
+{
+  QString msg = tr(
+    "CMake %1 (cmake.org).\n"
+    "CMake suite maintained and supported by Kitware (kitware.com/cmake).\n"
+    "Distributed under terms of the BSD 3-Clause License.\n"
+    "\n"
+    "CMake GUI maintained by csimsoft,\n"
+    "built using Qt %2 (qt-project.org).\n"
+#ifdef USE_LGPL
+    "\n"
+    "The Qt Toolkit is Copyright (C) Digia Plc and/or its subsidiary(-ies).\n"
+    "Qt is licensed under terms of the GNU LGPLv" USE_LGPL ", available at:\n"
+    " \"%3\""
+#endif
+    );
+  msg = msg.arg(cmVersion::GetCMakeVersion());
+  msg = msg.arg(qVersion());
+#ifdef USE_LGPL
+  std::string lgpl =
+    cmSystemTools::GetCMakeRoot() + "/Licenses/LGPLv" USE_LGPL ".txt";
+  msg = msg.arg(lgpl.c_str());
+#endif
+
+  QDialog dialog;
+  dialog.setWindowTitle(tr("About"));
+  QVBoxLayout* l = new QVBoxLayout(&dialog);
+  QLabel* lab = new QLabel(&dialog);
+  l->addWidget(lab);
+  lab->setText(msg);
+  lab->setWordWrap(true);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
+  QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
+  l->addWidget(btns);
+  dialog.exec();
+}
+
+void CMakeSetupDialog::setExitAfterGenerate(bool b)
+{
+  this->ExitAfterGenerate = b;
+}
+
+void CMakeSetupDialog::addBinaryPath(const QString& path)
+{
+  QString cleanpath = QDir::cleanPath(path);
+
+  // update UI
+  this->BinaryDirectory->blockSignals(true);
+  int idx = this->BinaryDirectory->findText(cleanpath);
+  if (idx != -1) {
+    this->BinaryDirectory->removeItem(idx);
+  }
+  this->BinaryDirectory->insertItem(0, cleanpath);
+  this->BinaryDirectory->setCurrentIndex(0);
+  this->BinaryDirectory->blockSignals(false);
+
+  // save to registry
+  QStringList buildPaths = this->loadBuildPaths();
+  buildPaths.removeAll(cleanpath);
+  buildPaths.prepend(cleanpath);
+  this->saveBuildPaths(buildPaths);
+}
+
+void CMakeSetupDialog::dragEnterEvent(QDragEnterEvent* e)
+{
+  if (!(this->CurrentState == ReadyConfigure ||
+        this->CurrentState == ReadyGenerate)) {
+    e->ignore();
+    return;
+  }
+
+  const QMimeData* dat = e->mimeData();
+  QList<QUrl> urls = dat->urls();
+  QString file = urls.count() ? urls[0].toLocalFile() : QString();
+  if (!file.isEmpty() &&
+      (file.endsWith("CMakeCache.txt", Qt::CaseInsensitive) ||
+       file.endsWith("CMakeLists.txt", Qt::CaseInsensitive))) {
+    e->accept();
+  } else {
+    e->ignore();
+  }
+}
+
+void CMakeSetupDialog::dropEvent(QDropEvent* e)
+{
+  if (!(this->CurrentState == ReadyConfigure ||
+        this->CurrentState == ReadyGenerate)) {
+    return;
+  }
+
+  const QMimeData* dat = e->mimeData();
+  QList<QUrl> urls = dat->urls();
+  QString file = urls.count() ? urls[0].toLocalFile() : QString();
+  if (file.endsWith("CMakeCache.txt", Qt::CaseInsensitive)) {
+    QFileInfo info(file);
+    if (this->CMakeThread->cmakeInstance()->binaryDirectory() !=
+        info.absolutePath()) {
+      this->setBinaryDirectory(info.absolutePath());
+    }
+  } else if (file.endsWith("CMakeLists.txt", Qt::CaseInsensitive)) {
+    QFileInfo info(file);
+    if (this->CMakeThread->cmakeInstance()->binaryDirectory() !=
+        info.absolutePath()) {
+      this->setSourceDirectory(info.absolutePath());
+      this->setBinaryDirectory(info.absolutePath());
+    }
+  }
+}
+
+QStringList CMakeSetupDialog::loadBuildPaths()
+{
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+
+  QStringList buildPaths;
+  for (int i = 0; i < 10; i++) {
+    QString p = settings.value(QString("WhereBuild%1").arg(i)).toString();
+    if (!p.isEmpty()) {
+      buildPaths.append(p);
+    }
+  }
+  return buildPaths;
+}
+
+void CMakeSetupDialog::saveBuildPaths(const QStringList& paths)
+{
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+
+  int num = paths.count();
+  if (num > 10) {
+    num = 10;
+  }
+
+  for (int i = 0; i < num; i++) {
+    settings.setValue(QString("WhereBuild%1").arg(i), paths[i]);
+  }
+}
+
+void CMakeSetupDialog::setCacheModified()
+{
+  this->CacheModified = true;
+  this->ConfigureNeeded = true;
+  this->enterState(ReadyConfigure);
+}
+
+void CMakeSetupDialog::removeSelectedCacheEntries()
+{
+  QModelIndexList idxs = this->CacheValues->selectionModel()->selectedRows();
+  QList<QPersistentModelIndex> pidxs;
+  foreach (QModelIndex const& i, idxs) {
+    pidxs.append(i);
+  }
+  foreach (QPersistentModelIndex const& pi, pidxs) {
+    this->CacheValues->model()->removeRow(pi.row(), pi.parent());
+  }
+}
+
+void CMakeSetupDialog::selectionChanged()
+{
+  QModelIndexList idxs = this->CacheValues->selectionModel()->selectedRows();
+  if (idxs.count() && (this->CurrentState == ReadyConfigure ||
+                       this->CurrentState == ReadyGenerate)) {
+    this->RemoveEntry->setEnabled(true);
+  } else {
+    this->RemoveEntry->setEnabled(false);
+  }
+}
+
+void CMakeSetupDialog::enterState(CMakeSetupDialog::State s)
+{
+  if (s == this->CurrentState) {
+    return;
+  }
+
+  this->CurrentState = s;
+
+  if (s == Interrupting) {
+    this->ConfigureButton->setEnabled(false);
+    this->GenerateButton->setEnabled(false);
+    this->OpenProjectButton->setEnabled(false);
+  } else if (s == Configuring) {
+    this->setEnabledState(false);
+    this->GenerateButton->setEnabled(false);
+    this->GenerateAction->setEnabled(false);
+    this->OpenProjectButton->setEnabled(false);
+    this->ConfigureButton->setText(tr("&Stop"));
+  } else if (s == Generating) {
+    this->CacheModified = false;
+    this->setEnabledState(false);
+    this->ConfigureButton->setEnabled(false);
+    this->GenerateAction->setEnabled(false);
+    this->OpenProjectButton->setEnabled(false);
+    this->GenerateButton->setText(tr("&Stop"));
+  } else if (s == ReadyConfigure) {
+    this->setEnabledState(true);
+    this->GenerateButton->setEnabled(true);
+    this->GenerateAction->setEnabled(true);
+    this->ConfigureButton->setEnabled(true);
+    this->ConfigureButton->setText(tr("&Configure"));
+    this->GenerateButton->setText(tr("&Generate"));
+  } else if (s == ReadyGenerate) {
+    this->setEnabledState(true);
+    this->GenerateButton->setEnabled(true);
+    this->GenerateAction->setEnabled(true);
+    this->ConfigureButton->setEnabled(true);
+    this->ConfigureButton->setText(tr("&Configure"));
+    this->GenerateButton->setText(tr("&Generate"));
+  }
+}
+
+void CMakeSetupDialog::addCacheEntry()
+{
+  QDialog dialog(this);
+  dialog.resize(400, 200);
+  dialog.setWindowTitle(tr("Add Cache Entry"));
+  QVBoxLayout* l = new QVBoxLayout(&dialog);
+  AddCacheEntry* w =
+    new AddCacheEntry(&dialog, this->AddVariableNames, this->AddVariableTypes);
+  QDialogButtonBox* btns = new QDialogButtonBox(
+    QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, &dialog);
+  QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
+  QObject::connect(btns, SIGNAL(rejected()), &dialog, SLOT(reject()));
+  l->addWidget(w);
+  l->addStretch();
+  l->addWidget(btns);
+  if (QDialog::Accepted == dialog.exec()) {
+    QCMakeCacheModel* m = this->CacheValues->cacheModel();
+    m->insertProperty(w->type(), w->name(), w->description(), w->value(),
+                      false);
+
+    // only add variable names to the completion which are new
+    if (!this->AddVariableNames.contains(w->name())) {
+      this->AddVariableNames << w->name();
+      this->AddVariableTypes << w->typeString();
+      // limit to at most 100 completion items
+      if (this->AddVariableNames.size() > 100) {
+        this->AddVariableNames.removeFirst();
+        this->AddVariableTypes.removeFirst();
+      }
+      // make sure CMAKE_INSTALL_PREFIX is always there
+      if (!this->AddVariableNames.contains("CMAKE_INSTALL_PREFIX")) {
+        this->AddVariableNames << "CMAKE_INSTALL_PREFIX";
+        this->AddVariableTypes << "PATH";
+      }
+      QSettings settings;
+      settings.beginGroup("Settings/StartPath");
+      settings.setValue("AddVariableNames", this->AddVariableNames);
+      settings.setValue("AddVariableTypes", this->AddVariableTypes);
+    }
+  }
+}
+
+void CMakeSetupDialog::startSearch()
+{
+  this->Search->setFocus(Qt::OtherFocusReason);
+  this->Search->selectAll();
+}
+
+void CMakeSetupDialog::setDebugOutput(bool flag)
+{
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+                            "setDebugOutput", Qt::QueuedConnection,
+                            Q_ARG(bool, flag));
+}
+
+void CMakeSetupDialog::setGroupedView(bool v)
+{
+  this->CacheValues->cacheModel()->setViewType(v ? QCMakeCacheModel::GroupView
+                                                 : QCMakeCacheModel::FlatView);
+  this->CacheValues->setRootIsDecorated(v);
+
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+  settings.setValue("GroupView", v);
+}
+
+void CMakeSetupDialog::setAdvancedView(bool v)
+{
+  this->CacheValues->setShowAdvanced(v);
+  QSettings settings;
+  settings.beginGroup("Settings/StartPath");
+  settings.setValue("AdvancedView", v);
+}
+
+void CMakeSetupDialog::showUserChanges()
+{
+  QSet<QCMakeProperty> changes =
+    qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())
+      ->changes();
+
+  QDialog dialog(this);
+  dialog.setWindowTitle(tr("My Changes"));
+  dialog.resize(600, 400);
+  QVBoxLayout* l = new QVBoxLayout(&dialog);
+  QTextEdit* textedit = new QTextEdit(&dialog);
+  textedit->setReadOnly(true);
+  l->addWidget(textedit);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Close, Qt::Horizontal, &dialog);
+  QObject::connect(btns, SIGNAL(rejected()), &dialog, SLOT(accept()));
+  l->addWidget(btns);
+
+  QString command;
+  QString cache;
+
+  foreach (QCMakeProperty const& prop, changes) {
+    QString type;
+    switch (prop.Type) {
+      case QCMakeProperty::BOOL:
+        type = "BOOL";
+        break;
+      case QCMakeProperty::PATH:
+        type = "PATH";
+        break;
+      case QCMakeProperty::FILEPATH:
+        type = "FILEPATH";
+        break;
+      case QCMakeProperty::STRING:
+        type = "STRING";
+        break;
+    }
+    QString value;
+    if (prop.Type == QCMakeProperty::BOOL) {
+      value = prop.Value.toBool() ? "1" : "0";
+    } else {
+      value = prop.Value.toString();
+    }
+
+    QString const line = QString("%1:%2=").arg(prop.Key, type);
+    command += QString("-D%1\"%2\" ").arg(line, value);
+    cache += QString("%1%2\n").arg(line, value);
+  }
+
+  textedit->append(tr("Commandline options:"));
+  textedit->append(command);
+  textedit->append("\n");
+  textedit->append(tr("Cache file:"));
+  textedit->append(cache);
+
+  dialog.exec();
+}
+
+void CMakeSetupDialog::setSearchFilter(const QString& str)
+{
+  this->CacheValues->selectionModel()->clear();
+  this->CacheValues->setSearchFilter(str);
+}
+
+void CMakeSetupDialog::doOutputContextMenu(QPoint pt)
+{
+  QMenu* menu = this->Output->createStandardContextMenu();
+
+  menu->addSeparator();
+  menu->addAction(tr("Find..."), this, SLOT(doOutputFindDialog()),
+                  QKeySequence::Find);
+  menu->addAction(tr("Find Next"), this, SLOT(doOutputFindNext()),
+                  QKeySequence::FindNext);
+  menu->addAction(tr("Find Previous"), this, SLOT(doOutputFindPrev()),
+                  QKeySequence::FindPrevious);
+  menu->addSeparator();
+  menu->addAction(tr("Goto Next Error"), this, SLOT(doOutputErrorNext()),
+                  QKeySequence(Qt::Key_F8));
+
+  menu->exec(this->Output->mapToGlobal(pt));
+  delete menu;
+}
+
+void CMakeSetupDialog::doOutputFindDialog()
+{
+  QStringList strings(this->FindHistory);
+
+  QString selection = this->Output->textCursor().selectedText();
+  if (!selection.isEmpty() && !selection.contains(QChar::ParagraphSeparator) &&
+      !selection.contains(QChar::LineSeparator)) {
+    strings.push_front(selection);
+  }
+
+  bool ok;
+  QString search = QInputDialog::getItem(this, tr("Find in Output"),
+                                         tr("Find:"), strings, 0, true, &ok);
+  if (ok && !search.isEmpty()) {
+    if (!this->FindHistory.contains(search)) {
+      this->FindHistory.push_front(search);
+    }
+    doOutputFindNext();
+  }
+}
+
+void CMakeSetupDialog::doRegexExplorerDialog()
+{
+  RegexExplorer dialog(this);
+  dialog.exec();
+}
+
+void CMakeSetupDialog::doOutputFindPrev()
+{
+  doOutputFindNext(false);
+}
+
+void CMakeSetupDialog::doOutputFindNext(bool directionForward)
+{
+  if (this->FindHistory.isEmpty()) {
+    doOutputFindDialog(); // will re-call this function again
+    return;
+  }
+
+  QString search = this->FindHistory.front();
+
+  QTextCursor textCursor = this->Output->textCursor();
+  QTextDocument* document = this->Output->document();
+  QTextDocument::FindFlags flags;
+  if (!directionForward) {
+    flags |= QTextDocument::FindBackward;
+  }
+
+  textCursor = document->find(search, textCursor, flags);
+
+  if (textCursor.isNull()) {
+    // first search found nothing, wrap around and search again
+    textCursor = this->Output->textCursor();
+    textCursor.movePosition(directionForward ? QTextCursor::Start
+                                             : QTextCursor::End);
+    textCursor = document->find(search, textCursor, flags);
+  }
+
+  if (textCursor.hasSelection()) {
+    this->Output->setTextCursor(textCursor);
+  }
+}
+
+void CMakeSetupDialog::doOutputErrorNext()
+{
+  QTextCursor textCursor = this->Output->textCursor();
+  bool atEnd = false;
+
+  // move cursor out of current error-block
+  if (textCursor.blockCharFormat() == this->ErrorFormat) {
+    atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
+  }
+
+  // move cursor to next error-block
+  while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd) {
+    atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
+  }
+
+  if (atEnd) {
+    // first search found nothing, wrap around and search again
+    atEnd = !textCursor.movePosition(QTextCursor::Start);
+
+    // move cursor to next error-block
+    while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd) {
+      atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
+    }
+  }
+
+  if (!atEnd) {
+    textCursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
+
+    QTextCharFormat selectionFormat;
+    selectionFormat.setBackground(Qt::yellow);
+    QTextEdit::ExtraSelection extraSelection = { textCursor, selectionFormat };
+    this->Output->setExtraSelections(QList<QTextEdit::ExtraSelection>()
+                                     << extraSelection);
+
+    // make the whole error-block visible
+    this->Output->setTextCursor(textCursor);
+
+    // remove the selection to see the extraSelection
+    textCursor.setPosition(textCursor.anchor());
+    this->Output->setTextCursor(textCursor);
+  }
+}
+
+void CMakeSetupDialog::doWarningMessagesDialog()
+{
+  WarningMessagesDialog dialog(this, this->CMakeThread->cmakeInstance());
+  dialog.exec();
+}
diff --git a/Source/QtDialog/CMakeSetupDialog.h b/Source/QtDialog/CMakeSetupDialog.h
new file mode 100644
index 0000000..7b767e5
--- /dev/null
+++ b/Source/QtDialog/CMakeSetupDialog.h
@@ -0,0 +1,139 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef CMakeSetupDialog_h
+#define CMakeSetupDialog_h
+
+#include "QCMake.h"
+
+#include "ui_CMakeSetupDialog.h"
+#include <QEventLoop>
+#include <QMainWindow>
+#include <QThread>
+
+class QCMakeThread;
+class CMakeCacheModel;
+class QProgressBar;
+class QToolButton;
+
+/// Qt user interface for CMake
+class CMakeSetupDialog : public QMainWindow, public Ui::CMakeSetupDialog
+{
+  Q_OBJECT
+public:
+  CMakeSetupDialog();
+  ~CMakeSetupDialog();
+
+public slots:
+  void setBinaryDirectory(const QString& dir);
+  void setSourceDirectory(const QString& dir);
+
+protected slots:
+  void initialize();
+  void doConfigure();
+  void doGenerate();
+  void doOpenProject();
+  void doInstallForCommandLine();
+  void doHelp();
+  void doAbout();
+  void doInterrupt();
+  void error(const QString& message);
+  void message(const QString& message);
+
+  void doSourceBrowse();
+  void doBinaryBrowse();
+  void doReloadCache();
+  void doDeleteCache();
+  void updateSourceDirectory(const QString& dir);
+  void updateBinaryDirectory(const QString& dir);
+  void showProgress(const QString& msg, float percent);
+  void setEnabledState(bool);
+  bool setupFirstConfigure();
+  void updateGeneratorLabel(const QString& gen);
+  void setExitAfterGenerate(bool);
+  void addBinaryPath(const QString&);
+  QStringList loadBuildPaths();
+  void saveBuildPaths(const QStringList&);
+  void onBinaryDirectoryChanged(const QString& dir);
+  void onSourceDirectoryChanged(const QString& dir);
+  void setCacheModified();
+  void removeSelectedCacheEntries();
+  void selectionChanged();
+  void addCacheEntry();
+  void startSearch();
+  void setDebugOutput(bool);
+  void setAdvancedView(bool);
+  void setGroupedView(bool);
+  void showUserChanges();
+  void setSearchFilter(const QString& str);
+  bool prepareConfigure();
+  bool doConfigureInternal();
+  bool doGenerateInternal();
+  void exitLoop(int);
+  void doOutputContextMenu(QPoint pt);
+  void doOutputFindDialog();
+  void doOutputFindNext(bool directionForward = true);
+  void doOutputFindPrev();
+  void doOutputErrorNext();
+  void doRegexExplorerDialog();
+  /// display the modal warning messages dialog window
+  void doWarningMessagesDialog();
+
+protected:
+  enum State
+  {
+    Interrupting,
+    ReadyConfigure,
+    ReadyGenerate,
+    Configuring,
+    Generating
+  };
+  void enterState(State s);
+
+  void closeEvent(QCloseEvent*);
+  void dragEnterEvent(QDragEnterEvent*);
+  void dropEvent(QDropEvent*);
+
+  QCMakeThread* CMakeThread;
+  bool ExitAfterGenerate;
+  bool CacheModified;
+  bool ConfigureNeeded;
+  QAction* ReloadCacheAction;
+  QAction* DeleteCacheAction;
+  QAction* ExitAction;
+  QAction* ConfigureAction;
+  QAction* GenerateAction;
+  QAction* WarnUninitializedAction;
+  QAction* WarnUnusedAction;
+  QAction* InstallForCommandLineAction;
+  State CurrentState;
+
+  QTextCharFormat ErrorFormat;
+  QTextCharFormat MessageFormat;
+
+  QStringList AddVariableNames;
+  QStringList AddVariableTypes;
+  QStringList FindHistory;
+
+  QEventLoop LocalLoop;
+
+  float ProgressOffset;
+  float ProgressFactor;
+};
+
+// QCMake instance on a thread
+class QCMakeThread : public QThread
+{
+  Q_OBJECT
+public:
+  QCMakeThread(QObject* p);
+  QCMake* cmakeInstance() const;
+
+signals:
+  void cmakeInitialized();
+
+protected:
+  virtual void run();
+  QCMake* CMakeInstance;
+};
+
+#endif // CMakeSetupDialog_h
diff --git a/Source/QtDialog/CMakeSetupDialog.ui b/Source/QtDialog/CMakeSetupDialog.ui
new file mode 100644
index 0000000..8d8e0cd
--- /dev/null
+++ b/Source/QtDialog/CMakeSetupDialog.ui
@@ -0,0 +1,320 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CMakeSetupDialog</class>
+ <widget class="QWidget" name="CMakeSetupDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>707</width>
+    <height>582</height>
+   </rect>
+  </property>
+  <layout class="QGridLayout">
+   <property name="margin">
+    <number>9</number>
+   </property>
+   <property name="spacing">
+    <number>6</number>
+   </property>
+   <item row="0" column="0">
+    <layout class="QGridLayout">
+     <property name="margin">
+      <number>0</number>
+     </property>
+     <property name="spacing">
+      <number>6</number>
+     </property>
+     <item row="0" column="0">
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Where is the source code:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QLineEdit" name="SourceDirectory"/>
+     </item>
+     <item row="0" column="2">
+      <widget class="QPushButton" name="BrowseSourceDirectoryButton">
+       <property name="text">
+        <string>Browse &amp;Source...</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_2">
+       <property name="text">
+        <string>Where to build the binaries:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QComboBox" name="BinaryDirectory">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="editable">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="2">
+      <widget class="QPushButton" name="BrowseBinaryDirectoryButton">
+       <property name="text">
+        <string>Browse &amp;Build...</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0">
+    <widget class="QSplitter" name="Splitter">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <widget class="QFrame" name="frame">
+      <property name="frameShape">
+       <enum>QFrame::NoFrame</enum>
+      </property>
+      <property name="frameShadow">
+       <enum>QFrame::Raised</enum>
+      </property>
+      <layout class="QVBoxLayout">
+       <property name="spacing">
+        <number>6</number>
+       </property>
+       <property name="margin">
+        <number>0</number>
+       </property>
+       <item>
+        <layout class="QHBoxLayout">
+         <property name="spacing">
+          <number>6</number>
+         </property>
+         <property name="margin">
+          <number>0</number>
+         </property>
+         <item>
+          <widget class="QLabel" name="label_4">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="text">
+            <string>S&amp;earch:</string>
+           </property>
+           <property name="buddy">
+            <cstring>Search</cstring>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLineEdit" name="Search">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeType">
+            <enum>QSizePolicy::Minimum</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>12</width>
+             <height>23</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QCheckBox" name="groupedCheck">
+           <property name="text">
+            <string>Grouped</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QCheckBox" name="advancedCheck">
+           <property name="text">
+            <string>Advanced</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QToolButton" name="AddEntry">
+           <property name="toolTip">
+            <string>Add New Entry</string>
+           </property>
+           <property name="text">
+            <string>&amp;Add Entry</string>
+           </property>
+           <property name="icon">
+            <iconset resource="CMakeSetup.qrc">
+             <normaloff>:/Icons/Plus16.png</normaloff>:/Icons/Plus16.png</iconset>
+           </property>
+           <property name="toolButtonStyle">
+            <enum>Qt::ToolButtonTextBesideIcon</enum>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QToolButton" name="RemoveEntry">
+           <property name="toolTip">
+            <string>Remove Selected Entries</string>
+           </property>
+           <property name="text">
+            <string>&amp;Remove Entry</string>
+           </property>
+           <property name="icon">
+            <iconset resource="CMakeSetup.qrc">
+             <normaloff>:/Icons/Delete16.png</normaloff>:/Icons/Delete16.png</iconset>
+           </property>
+           <property name="toolButtonStyle">
+            <enum>Qt::ToolButtonTextBesideIcon</enum>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QCMakeCacheView" name="CacheValues">
+         <property name="alternatingRowColors">
+          <bool>true</bool>
+         </property>
+         <property name="selectionMode">
+          <enum>QAbstractItemView::ExtendedSelection</enum>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectRows</enum>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Press Configure to update and display new values in red, then press Generate to generate selected build files.</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignCenter</set>
+         </property>
+         <property name="wordWrap">
+          <bool>true</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <layout class="QHBoxLayout">
+         <property name="spacing">
+          <number>6</number>
+         </property>
+         <property name="margin">
+          <number>0</number>
+         </property>
+         <item>
+          <widget class="QPushButton" name="ConfigureButton">
+           <property name="text">
+            <string>&amp;Configure</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="GenerateButton">
+           <property name="text">
+            <string>&amp;Generate</string>
+           </property>
+          </widget>
+         </item>
+          <item>
+            <widget class="QPushButton" name="OpenProjectButton">
+              <property name="text">
+                <string>Open &amp;Project</string>
+              </property>
+            </widget>
+          </item>
+         <item>
+          <widget class="QLabel" name="Generator">
+           <property name="text">
+            <string>Current Generator:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeType">
+            <enum>QSizePolicy::Expanding</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>121</width>
+             <height>27</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QProgressBar" name="ProgressBar">
+           <property name="minimum">
+            <number>0</number>
+           </property>
+           <property name="maximum">
+            <number>100</number>
+           </property>
+           <property name="value">
+            <number>0</number>
+           </property>
+           <property name="textVisible">
+            <bool>false</bool>
+           </property>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="textDirection">
+            <enum>QProgressBar::BottomToTop</enum>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QTextEdit" name="Output">
+      <property name="lineWrapMode">
+       <enum>QTextEdit::NoWrap</enum>
+      </property>
+      <property name="readOnly">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QCMakeCacheView</class>
+   <extends>QTreeView</extends>
+   <header>QCMakeCacheView.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources>
+  <include location="CMakeSetup.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/Source/QtDialog/Compilers.h b/Source/QtDialog/Compilers.h
new file mode 100644
index 0000000..746266c
--- /dev/null
+++ b/Source/QtDialog/Compilers.h
@@ -0,0 +1,23 @@
+
+
+#ifndef COMPILERS_HPP
+#define COMPILERS_HPP
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <QWidget>
+
+#include <ui_Compilers.h>
+
+class Compilers : public QWidget, public Ui::Compilers
+{
+  Q_OBJECT
+public:
+  Compilers(QWidget* p = nullptr)
+    : QWidget(p)
+  {
+    this->setupUi(this);
+  }
+};
+
+#endif
diff --git a/Source/QtDialog/Compilers.ui b/Source/QtDialog/Compilers.ui
new file mode 100644
index 0000000..41f70ac
--- /dev/null
+++ b/Source/QtDialog/Compilers.ui
@@ -0,0 +1,87 @@
+<ui version="4.0" >
+ <class>Compilers</class>
+ <widget class="QWidget" name="Compilers" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>506</width>
+    <height>115</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" >
+   <property name="leftMargin" >
+    <number>0</number>
+   </property>
+   <property name="topMargin" >
+    <number>0</number>
+   </property>
+   <property name="rightMargin" >
+    <number>0</number>
+   </property>
+   <property name="bottomMargin" >
+    <number>0</number>
+   </property>
+   <item row="0" column="0" >
+    <widget class="QGroupBox" name="groupBox_4" >
+     <property name="title" >
+      <string>Compilers</string>
+     </property>
+     <layout class="QGridLayout" >
+      <property name="leftMargin" >
+       <number>4</number>
+      </property>
+      <property name="topMargin" >
+       <number>4</number>
+      </property>
+      <property name="rightMargin" >
+       <number>4</number>
+      </property>
+      <item row="0" column="0" >
+       <widget class="QLabel" name="label_16" >
+        <property name="text" >
+         <string>C</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" >
+       <widget class="QCMakeFilePathEditor" name="CCompiler" />
+      </item>
+      <item row="0" column="2" >
+       <widget class="QLabel" name="label_17" >
+        <property name="text" >
+         <string>C++</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="3" >
+       <widget class="QCMakeFilePathEditor" name="CXXCompiler" />
+      </item>
+      <item row="1" column="0" >
+       <widget class="QLabel" name="label_18" >
+        <property name="text" >
+         <string>Fortran</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1" >
+       <widget class="QCMakeFilePathEditor" name="FortranCompiler" />
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QCMakeFilePathEditor</class>
+   <extends>QLineEdit</extends>
+   <header>QCMakeWidgets.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Source/QtDialog/CrossCompiler.ui b/Source/QtDialog/CrossCompiler.ui
new file mode 100644
index 0000000..1fb1ebf
--- /dev/null
+++ b/Source/QtDialog/CrossCompiler.ui
@@ -0,0 +1,213 @@
+<ui version="4.0" >
+ <class>CrossCompiler</class>
+ <widget class="QWidget" name="CrossCompiler" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>433</width>
+    <height>319</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>CrossCompiler</string>
+  </property>
+  <layout class="QGridLayout" >
+   <item row="0" column="0" >
+    <widget class="QGroupBox" name="groupBox" >
+     <property name="sizePolicy" >
+      <sizepolicy vsizetype="Preferred" hsizetype="Preferred" >
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title" >
+      <string>Target System</string>
+     </property>
+     <layout class="QGridLayout" >
+      <item row="0" column="0" >
+       <widget class="QLabel" name="label_6" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Operating System</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" >
+       <widget class="QLineEdit" name="systemName" />
+      </item>
+      <item row="0" column="2" colspan="2" >
+       <spacer>
+        <property name="orientation" >
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" >
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="1" column="0" >
+       <widget class="QLabel" name="label_10" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Version</string>
+        </property>
+        <property name="wordWrap" >
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1" >
+       <widget class="QLineEdit" name="systemVersion" />
+      </item>
+      <item row="1" column="2" >
+       <widget class="QLabel" name="label_11" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Processor</string>
+        </property>
+        <property name="wordWrap" >
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="3" >
+       <widget class="QLineEdit" name="systemProcessor" />
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="2" column="0" >
+    <widget class="QGroupBox" name="groupBox_2" >
+     <property name="sizePolicy" >
+      <sizepolicy vsizetype="Preferred" hsizetype="Preferred" >
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title" >
+      <string>Find Program/Library/Include</string>
+     </property>
+     <layout class="QGridLayout" >
+      <item row="0" column="0" >
+       <widget class="QLabel" name="label_9" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Target Root</string>
+        </property>
+        <property name="wordWrap" >
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" >
+       <widget class="QCMakePathEditor" name="crossFindRoot" />
+      </item>
+      <item row="0" column="2" >
+       <widget class="QLabel" name="label_12" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Program Mode</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="3" >
+       <widget class="QComboBox" name="crossProgramMode" />
+      </item>
+      <item row="1" column="0" >
+       <widget class="QLabel" name="label_13" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Library Mode</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1" >
+       <widget class="QComboBox" name="crossLibraryMode" />
+      </item>
+      <item row="1" column="2" >
+       <widget class="QLabel" name="label_14" >
+        <property name="sizePolicy" >
+         <sizepolicy vsizetype="Fixed" hsizetype="Preferred" >
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text" >
+         <string>Include Mode</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="3" >
+       <widget class="QComboBox" name="crossIncludeMode" />
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="1" column="0" >
+    <widget class="Compilers" native="1" name="CrossCompilers" >
+     <property name="focusPolicy" >
+      <enum>Qt::TabFocus</enum>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QCMakePathEditor</class>
+   <extends>QLineEdit</extends>
+   <header>QCMakeWidgets.h</header>
+  </customwidget>
+  <customwidget>
+   <class>Compilers</class>
+   <extends>QWidget</extends>
+   <header>Compilers.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>systemVersion</tabstop>
+  <tabstop>systemProcessor</tabstop>
+  <tabstop>CrossCompilers</tabstop>
+  <tabstop>crossFindRoot</tabstop>
+  <tabstop>crossProgramMode</tabstop>
+  <tabstop>crossLibraryMode</tabstop>
+  <tabstop>crossIncludeMode</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Source/QtDialog/Delete16.png b/Source/QtDialog/Delete16.png
new file mode 100644
index 0000000..16989fee
--- /dev/null
+++ b/Source/QtDialog/Delete16.png
diff --git a/Source/QtDialog/FirstConfigure.cxx b/Source/QtDialog/FirstConfigure.cxx
new file mode 100644
index 0000000..88ce7cb
--- /dev/null
+++ b/Source/QtDialog/FirstConfigure.cxx
@@ -0,0 +1,581 @@
+
+#include "FirstConfigure.h"
+
+#include "Compilers.h"
+
+#include <QComboBox>
+#include <QRadioButton>
+#include <QSettings>
+#include <QVBoxLayout>
+
+StartCompilerSetup::StartCompilerSetup(QWidget* p)
+  : QWizardPage(p)
+{
+  QVBoxLayout* l = new QVBoxLayout(this);
+  l->addWidget(new QLabel(tr("Specify the generator for this project")));
+  this->GeneratorOptions = new QComboBox(this);
+  l->addWidget(this->GeneratorOptions);
+
+  // Add the ability to specify toolset (-T parameter)
+  ToolsetFrame = CreateToolsetWidgets();
+  l->addWidget(ToolsetFrame);
+
+  l->addSpacing(6);
+
+  this->CompilerSetupOptions[0] =
+    new QRadioButton(tr("Use default native compilers"), this);
+  this->CompilerSetupOptions[1] =
+    new QRadioButton(tr("Specify native compilers"), this);
+  this->CompilerSetupOptions[2] =
+    new QRadioButton(tr("Specify toolchain file for cross-compiling"), this);
+  this->CompilerSetupOptions[3] =
+    new QRadioButton(tr("Specify options for cross-compiling"), this);
+  l->addWidget(this->CompilerSetupOptions[0]);
+  l->addWidget(this->CompilerSetupOptions[1]);
+  l->addWidget(this->CompilerSetupOptions[2]);
+  l->addWidget(this->CompilerSetupOptions[3]);
+
+  this->CompilerSetupOptions[0]->setChecked(true);
+
+  QObject::connect(this->CompilerSetupOptions[0], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[1], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[2], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[3], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(GeneratorOptions,
+                   SIGNAL(currentIndexChanged(QString const&)), this,
+                   SLOT(onGeneratorChanged(QString const&)));
+}
+
+QFrame* StartCompilerSetup::CreateToolsetWidgets()
+{
+  QFrame* frame = new QFrame(this);
+  QVBoxLayout* l = new QVBoxLayout(frame);
+  l->setContentsMargins(0, 0, 0, 0);
+
+  ToolsetLabel = new QLabel(tr("Optional toolset to use (argument to -T)"));
+  l->addWidget(ToolsetLabel);
+
+  Toolset = new QLineEdit(frame);
+  l->addWidget(Toolset);
+
+  return frame;
+}
+
+StartCompilerSetup::~StartCompilerSetup()
+{
+}
+
+void StartCompilerSetup::setGenerators(
+  std::vector<cmake::GeneratorInfo> const& gens)
+{
+  this->GeneratorOptions->clear();
+
+  QStringList generator_list;
+
+  std::vector<cmake::GeneratorInfo>::const_iterator it;
+  for (it = gens.begin(); it != gens.end(); ++it) {
+    generator_list.append(QString::fromLocal8Bit(it->name.c_str()));
+
+    if (it->supportsToolset) {
+      this->GeneratorsSupportingToolset.append(
+        QString::fromLocal8Bit(it->name.c_str()));
+    }
+  }
+
+  this->GeneratorOptions->addItems(generator_list);
+}
+
+void StartCompilerSetup::setCurrentGenerator(const QString& gen)
+{
+  int idx = this->GeneratorOptions->findText(gen);
+  if (idx != -1) {
+    this->GeneratorOptions->setCurrentIndex(idx);
+  }
+}
+
+QString StartCompilerSetup::getGenerator() const
+{
+  return this->GeneratorOptions->currentText();
+};
+
+QString StartCompilerSetup::getToolset() const
+{
+  return this->Toolset->text();
+};
+
+bool StartCompilerSetup::defaultSetup() const
+{
+  return this->CompilerSetupOptions[0]->isChecked();
+}
+
+bool StartCompilerSetup::compilerSetup() const
+{
+  return this->CompilerSetupOptions[1]->isChecked();
+}
+
+bool StartCompilerSetup::crossCompilerToolChainFile() const
+{
+  return this->CompilerSetupOptions[2]->isChecked();
+}
+
+bool StartCompilerSetup::crossCompilerSetup() const
+{
+  return this->CompilerSetupOptions[3]->isChecked();
+}
+
+void StartCompilerSetup::onSelectionChanged(bool on)
+{
+  if (on) {
+    emit selectionChanged();
+  }
+}
+
+void StartCompilerSetup::onGeneratorChanged(QString const& name)
+{
+  if (GeneratorsSupportingToolset.contains(name)) {
+    ToolsetFrame->show();
+  } else {
+    ToolsetFrame->hide();
+  }
+}
+
+int StartCompilerSetup::nextId() const
+{
+  if (compilerSetup()) {
+    return NativeSetup;
+  }
+  if (crossCompilerSetup()) {
+    return CrossSetup;
+  }
+  if (crossCompilerToolChainFile()) {
+    return ToolchainSetup;
+  }
+  return -1;
+}
+
+NativeCompilerSetup::NativeCompilerSetup(QWidget* p)
+  : QWizardPage(p)
+{
+  QVBoxLayout* l = new QVBoxLayout(this);
+  QWidget* c = new QWidget(this);
+  l->addWidget(c);
+  this->setupUi(c);
+}
+
+NativeCompilerSetup::~NativeCompilerSetup()
+{
+}
+
+QString NativeCompilerSetup::getCCompiler() const
+{
+  return this->CCompiler->text();
+}
+
+void NativeCompilerSetup::setCCompiler(const QString& s)
+{
+  this->CCompiler->setText(s);
+}
+
+QString NativeCompilerSetup::getCXXCompiler() const
+{
+  return this->CXXCompiler->text();
+}
+
+void NativeCompilerSetup::setCXXCompiler(const QString& s)
+{
+  this->CXXCompiler->setText(s);
+}
+
+QString NativeCompilerSetup::getFortranCompiler() const
+{
+  return this->FortranCompiler->text();
+}
+
+void NativeCompilerSetup::setFortranCompiler(const QString& s)
+{
+  this->FortranCompiler->setText(s);
+}
+
+CrossCompilerSetup::CrossCompilerSetup(QWidget* p)
+  : QWizardPage(p)
+{
+  this->setupUi(this);
+  QWidget::setTabOrder(systemName, systemVersion);
+  QWidget::setTabOrder(systemVersion, systemProcessor);
+  QWidget::setTabOrder(systemProcessor, CrossCompilers->CCompiler);
+  QWidget::setTabOrder(CrossCompilers->CCompiler, CrossCompilers->CXXCompiler);
+  QWidget::setTabOrder(CrossCompilers->CXXCompiler,
+                       CrossCompilers->FortranCompiler);
+  QWidget::setTabOrder(CrossCompilers->FortranCompiler, crossFindRoot);
+  QWidget::setTabOrder(crossFindRoot, crossProgramMode);
+  QWidget::setTabOrder(crossProgramMode, crossLibraryMode);
+  QWidget::setTabOrder(crossLibraryMode, crossIncludeMode);
+
+  // fill in combo boxes
+  QStringList modes;
+  modes << tr("Search in Target Root, then native system");
+  modes << tr("Search only in Target Root");
+  modes << tr("Search only in native system");
+  crossProgramMode->addItems(modes);
+  crossLibraryMode->addItems(modes);
+  crossIncludeMode->addItems(modes);
+  crossProgramMode->setCurrentIndex(2);
+  crossLibraryMode->setCurrentIndex(1);
+  crossIncludeMode->setCurrentIndex(1);
+
+  this->registerField("systemName*", this->systemName);
+}
+
+CrossCompilerSetup::~CrossCompilerSetup()
+{
+}
+
+QString CrossCompilerSetup::getCCompiler() const
+{
+  return this->CrossCompilers->CCompiler->text();
+}
+
+void CrossCompilerSetup::setCCompiler(const QString& s)
+{
+  this->CrossCompilers->CCompiler->setText(s);
+}
+
+QString CrossCompilerSetup::getCXXCompiler() const
+{
+  return this->CrossCompilers->CXXCompiler->text();
+}
+
+void CrossCompilerSetup::setCXXCompiler(const QString& s)
+{
+  this->CrossCompilers->CXXCompiler->setText(s);
+}
+
+QString CrossCompilerSetup::getFortranCompiler() const
+{
+  return this->CrossCompilers->FortranCompiler->text();
+}
+
+void CrossCompilerSetup::setFortranCompiler(const QString& s)
+{
+  this->CrossCompilers->FortranCompiler->setText(s);
+}
+
+QString CrossCompilerSetup::getSystem() const
+{
+  return this->systemName->text();
+}
+
+void CrossCompilerSetup::setSystem(const QString& t)
+{
+  this->systemName->setText(t);
+}
+
+QString CrossCompilerSetup::getVersion() const
+{
+  return this->systemVersion->text();
+}
+
+void CrossCompilerSetup::setVersion(const QString& t)
+{
+  this->systemVersion->setText(t);
+}
+
+QString CrossCompilerSetup::getProcessor() const
+{
+  return this->systemProcessor->text();
+}
+
+void CrossCompilerSetup::setProcessor(const QString& t)
+{
+  this->systemProcessor->setText(t);
+}
+
+QString CrossCompilerSetup::getFindRoot() const
+{
+  return this->crossFindRoot->text();
+}
+
+void CrossCompilerSetup::setFindRoot(const QString& t)
+{
+  this->crossFindRoot->setText(t);
+}
+
+int CrossCompilerSetup::getProgramMode() const
+{
+  return this->crossProgramMode->currentIndex();
+}
+
+int CrossCompilerSetup::getLibraryMode() const
+{
+  return this->crossLibraryMode->currentIndex();
+}
+
+int CrossCompilerSetup::getIncludeMode() const
+{
+  return this->crossIncludeMode->currentIndex();
+}
+
+void CrossCompilerSetup::setProgramMode(int m)
+{
+  this->crossProgramMode->setCurrentIndex(m);
+}
+
+void CrossCompilerSetup::setLibraryMode(int m)
+{
+  this->crossLibraryMode->setCurrentIndex(m);
+}
+
+void CrossCompilerSetup::setIncludeMode(int m)
+{
+  this->crossIncludeMode->setCurrentIndex(m);
+}
+
+ToolchainCompilerSetup::ToolchainCompilerSetup(QWidget* p)
+  : QWizardPage(p)
+{
+  QVBoxLayout* l = new QVBoxLayout(this);
+  l->addWidget(new QLabel(tr("Specify the Toolchain file")));
+  this->ToolchainFile = new QCMakeFilePathEditor(this);
+  l->addWidget(this->ToolchainFile);
+}
+
+ToolchainCompilerSetup::~ToolchainCompilerSetup()
+{
+}
+
+QString ToolchainCompilerSetup::toolchainFile() const
+{
+  return this->ToolchainFile->text();
+}
+
+void ToolchainCompilerSetup::setToolchainFile(const QString& t)
+{
+  this->ToolchainFile->setText(t);
+}
+
+FirstConfigure::FirstConfigure()
+{
+  // this->setOption(QWizard::HaveFinishButtonOnEarlyPages, true);
+  this->mStartCompilerSetupPage = new StartCompilerSetup(this);
+  this->setPage(Start, this->mStartCompilerSetupPage);
+  QObject::connect(this->mStartCompilerSetupPage, SIGNAL(selectionChanged()),
+                   this, SLOT(restart()));
+
+  this->mNativeCompilerSetupPage = new NativeCompilerSetup(this);
+  this->setPage(NativeSetup, this->mNativeCompilerSetupPage);
+
+  this->mCrossCompilerSetupPage = new CrossCompilerSetup(this);
+  this->setPage(CrossSetup, this->mCrossCompilerSetupPage);
+
+  this->mToolchainCompilerSetupPage = new ToolchainCompilerSetup(this);
+  this->setPage(ToolchainSetup, this->mToolchainCompilerSetupPage);
+}
+
+FirstConfigure::~FirstConfigure()
+{
+}
+
+void FirstConfigure::setGenerators(
+  std::vector<cmake::GeneratorInfo> const& gens)
+{
+  this->mStartCompilerSetupPage->setGenerators(gens);
+}
+
+QString FirstConfigure::getGenerator() const
+{
+  return this->mStartCompilerSetupPage->getGenerator();
+}
+
+QString FirstConfigure::getToolset() const
+{
+  return this->mStartCompilerSetupPage->getToolset();
+}
+
+void FirstConfigure::loadFromSettings()
+{
+  QSettings settings;
+  // restore generator
+  settings.beginGroup("Settings/StartPath");
+  QString lastGen = settings.value("LastGenerator").toString();
+  this->mStartCompilerSetupPage->setCurrentGenerator(lastGen);
+  settings.endGroup();
+
+  // restore compiler setup
+  settings.beginGroup("Settings/Compiler");
+  this->mNativeCompilerSetupPage->setCCompiler(
+    settings.value("CCompiler").toString());
+  this->mNativeCompilerSetupPage->setCXXCompiler(
+    settings.value("CXXCompiler").toString());
+  this->mNativeCompilerSetupPage->setFortranCompiler(
+    settings.value("FortranCompiler").toString());
+  settings.endGroup();
+
+  // restore cross compiler setup
+  settings.beginGroup("Settings/CrossCompiler");
+  this->mCrossCompilerSetupPage->setCCompiler(
+    settings.value("CCompiler").toString());
+  this->mCrossCompilerSetupPage->setCXXCompiler(
+    settings.value("CXXCompiler").toString());
+  this->mCrossCompilerSetupPage->setFortranCompiler(
+    settings.value("FortranCompiler").toString());
+  this->mToolchainCompilerSetupPage->setToolchainFile(
+    settings.value("ToolChainFile").toString());
+  this->mCrossCompilerSetupPage->setSystem(
+    settings.value("SystemName").toString());
+  this->mCrossCompilerSetupPage->setVersion(
+    settings.value("SystemVersion").toString());
+  this->mCrossCompilerSetupPage->setProcessor(
+    settings.value("SystemProcessor").toString());
+  this->mCrossCompilerSetupPage->setFindRoot(
+    settings.value("FindRoot").toString());
+  this->mCrossCompilerSetupPage->setProgramMode(
+    settings.value("ProgramMode", 0).toInt());
+  this->mCrossCompilerSetupPage->setLibraryMode(
+    settings.value("LibraryMode", 0).toInt());
+  this->mCrossCompilerSetupPage->setIncludeMode(
+    settings.value("IncludeMode", 0).toInt());
+  settings.endGroup();
+}
+
+void FirstConfigure::saveToSettings()
+{
+  QSettings settings;
+
+  // save generator
+  settings.beginGroup("Settings/StartPath");
+  QString lastGen = this->mStartCompilerSetupPage->getGenerator();
+  settings.setValue("LastGenerator", lastGen);
+  settings.endGroup();
+
+  // save compiler setup
+  settings.beginGroup("Settings/Compiler");
+  settings.setValue("CCompiler",
+                    this->mNativeCompilerSetupPage->getCCompiler());
+  settings.setValue("CXXCompiler",
+                    this->mNativeCompilerSetupPage->getCXXCompiler());
+  settings.setValue("FortranCompiler",
+                    this->mNativeCompilerSetupPage->getFortranCompiler());
+  settings.endGroup();
+
+  // save cross compiler setup
+  settings.beginGroup("Settings/CrossCompiler");
+  settings.setValue("CCompiler",
+                    this->mCrossCompilerSetupPage->getCCompiler());
+  settings.setValue("CXXCompiler",
+                    this->mCrossCompilerSetupPage->getCXXCompiler());
+  settings.setValue("FortranCompiler",
+                    this->mCrossCompilerSetupPage->getFortranCompiler());
+  settings.setValue("ToolChainFile", this->getCrossCompilerToolChainFile());
+  settings.setValue("SystemName", this->mCrossCompilerSetupPage->getSystem());
+  settings.setValue("SystemVersion",
+                    this->mCrossCompilerSetupPage->getVersion());
+  settings.setValue("SystemProcessor",
+                    this->mCrossCompilerSetupPage->getProcessor());
+  settings.setValue("FindRoot", this->mCrossCompilerSetupPage->getFindRoot());
+  settings.setValue("ProgramMode",
+                    this->mCrossCompilerSetupPage->getProgramMode());
+  settings.setValue("LibraryMode",
+                    this->mCrossCompilerSetupPage->getLibraryMode());
+  settings.setValue("IncludeMode",
+                    this->mCrossCompilerSetupPage->getIncludeMode());
+  settings.endGroup();
+}
+
+bool FirstConfigure::defaultSetup() const
+{
+  return this->mStartCompilerSetupPage->defaultSetup();
+}
+
+bool FirstConfigure::compilerSetup() const
+{
+  return this->mStartCompilerSetupPage->compilerSetup();
+}
+
+bool FirstConfigure::crossCompilerSetup() const
+{
+  return this->mStartCompilerSetupPage->crossCompilerSetup();
+}
+
+bool FirstConfigure::crossCompilerToolChainFile() const
+{
+  return this->mStartCompilerSetupPage->crossCompilerToolChainFile();
+}
+
+QString FirstConfigure::getCrossCompilerToolChainFile() const
+{
+  return this->mToolchainCompilerSetupPage->toolchainFile();
+}
+
+QString FirstConfigure::getSystemName() const
+{
+  return this->mCrossCompilerSetupPage->getSystem();
+}
+
+QString FirstConfigure::getCCompiler() const
+{
+  if (this->compilerSetup()) {
+    return this->mNativeCompilerSetupPage->getCCompiler();
+  }
+  if (this->crossCompilerSetup()) {
+    return this->mCrossCompilerSetupPage->getCCompiler();
+  }
+  return QString();
+}
+
+QString FirstConfigure::getCXXCompiler() const
+{
+  if (this->compilerSetup()) {
+    return this->mNativeCompilerSetupPage->getCXXCompiler();
+  }
+  if (this->crossCompilerSetup()) {
+    return this->mCrossCompilerSetupPage->getCXXCompiler();
+  }
+  return QString();
+}
+
+QString FirstConfigure::getFortranCompiler() const
+{
+  if (this->compilerSetup()) {
+    return this->mNativeCompilerSetupPage->getFortranCompiler();
+  }
+  if (this->crossCompilerSetup()) {
+    return this->mCrossCompilerSetupPage->getFortranCompiler();
+  }
+  return QString();
+}
+
+QString FirstConfigure::getSystemVersion() const
+{
+  return this->mCrossCompilerSetupPage->getVersion();
+}
+
+QString FirstConfigure::getSystemProcessor() const
+{
+  return this->mCrossCompilerSetupPage->getProcessor();
+}
+
+QString FirstConfigure::getCrossRoot() const
+{
+  return this->mCrossCompilerSetupPage->getFindRoot();
+}
+
+const QString CrossModes[] = { "BOTH", "ONLY", "NEVER" };
+
+QString FirstConfigure::getCrossProgramMode() const
+{
+  return CrossModes[this->mCrossCompilerSetupPage->getProgramMode()];
+}
+
+QString FirstConfigure::getCrossLibraryMode() const
+{
+  return CrossModes[this->mCrossCompilerSetupPage->getLibraryMode()];
+}
+
+QString FirstConfigure::getCrossIncludeMode() const
+{
+  return CrossModes[this->mCrossCompilerSetupPage->getIncludeMode()];
+}
diff --git a/Source/QtDialog/FirstConfigure.h b/Source/QtDialog/FirstConfigure.h
new file mode 100644
index 0000000..c467ddb
--- /dev/null
+++ b/Source/QtDialog/FirstConfigure.h
@@ -0,0 +1,189 @@
+
+#ifndef FirstConfigure_h
+#define FirstConfigure_h
+
+#include <QWizard>
+#include <QWizardPage>
+
+#include "cmake.h"
+
+#include "ui_Compilers.h"
+#include "ui_CrossCompiler.h"
+
+class QRadioButton;
+class QComboBox;
+
+//! the wizard pages we'll use for the first configure of a build
+enum FirstConfigurePages
+{
+  Start,
+  NativeSetup,
+  ToolchainSetup,
+  CrossSetup,
+  Done
+};
+
+//! the first page that gives basic options for what compilers setup to choose
+//! from
+class StartCompilerSetup : public QWizardPage
+{
+  Q_OBJECT
+public:
+  StartCompilerSetup(QWidget* p);
+  ~StartCompilerSetup();
+  void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
+  void setCurrentGenerator(const QString& gen);
+  QString getGenerator() const;
+  QString getToolset() const;
+
+  bool defaultSetup() const;
+  bool compilerSetup() const;
+  bool crossCompilerSetup() const;
+  bool crossCompilerToolChainFile() const;
+
+  int nextId() const;
+
+signals:
+  void selectionChanged();
+
+protected slots:
+  void onSelectionChanged(bool);
+  void onGeneratorChanged(QString const& name);
+
+protected:
+  QComboBox* GeneratorOptions;
+  QRadioButton* CompilerSetupOptions[4];
+  QFrame* ToolsetFrame;
+  QLineEdit* Toolset;
+  QLabel* ToolsetLabel;
+  QStringList GeneratorsSupportingToolset;
+
+private:
+  QFrame* CreateToolsetWidgets();
+};
+
+//! the page that gives basic options for native compilers
+class NativeCompilerSetup : public QWizardPage, protected Ui::Compilers
+{
+  Q_OBJECT
+public:
+  NativeCompilerSetup(QWidget* p);
+  ~NativeCompilerSetup();
+
+  QString getCCompiler() const;
+  void setCCompiler(const QString&);
+
+  QString getCXXCompiler() const;
+  void setCXXCompiler(const QString&);
+
+  QString getFortranCompiler() const;
+  void setFortranCompiler(const QString&);
+
+  int nextId() const { return -1; }
+};
+
+//! the page that gives options for cross compilers
+class CrossCompilerSetup : public QWizardPage, protected Ui::CrossCompiler
+{
+  Q_OBJECT
+public:
+  CrossCompilerSetup(QWidget* p);
+  ~CrossCompilerSetup();
+
+  QString getSystem() const;
+  void setSystem(const QString&);
+
+  QString getVersion() const;
+  void setVersion(const QString&);
+
+  QString getProcessor() const;
+  void setProcessor(const QString&);
+
+  QString getCCompiler() const;
+  void setCCompiler(const QString&);
+
+  QString getCXXCompiler() const;
+  void setCXXCompiler(const QString&);
+
+  QString getFortranCompiler() const;
+  void setFortranCompiler(const QString&);
+
+  QString getFindRoot() const;
+  void setFindRoot(const QString&);
+
+  enum CrossMode
+  {
+    BOTH,
+    ONLY,
+    NEVER
+  };
+
+  int getProgramMode() const;
+  void setProgramMode(int);
+  int getLibraryMode() const;
+  void setLibraryMode(int);
+  int getIncludeMode() const;
+  void setIncludeMode(int);
+
+  int nextId() const { return -1; }
+};
+
+//! the page that gives options for a toolchain file
+class ToolchainCompilerSetup : public QWizardPage
+{
+  Q_OBJECT
+public:
+  ToolchainCompilerSetup(QWidget* p);
+  ~ToolchainCompilerSetup();
+
+  QString toolchainFile() const;
+  void setToolchainFile(const QString&);
+
+  int nextId() const { return -1; }
+
+protected:
+  QCMakeFilePathEditor* ToolchainFile;
+};
+
+//! the wizard with the pages
+class FirstConfigure : public QWizard
+{
+  Q_OBJECT
+public:
+  FirstConfigure();
+  ~FirstConfigure();
+
+  void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
+  QString getGenerator() const;
+  QString getToolset() const;
+
+  bool defaultSetup() const;
+  bool compilerSetup() const;
+  bool crossCompilerSetup() const;
+  bool crossCompilerToolChainFile() const;
+
+  QString getCCompiler() const;
+  QString getCXXCompiler() const;
+  QString getFortranCompiler() const;
+
+  QString getSystemName() const;
+  QString getSystemVersion() const;
+  QString getSystemProcessor() const;
+  QString getCrossRoot() const;
+  QString getCrossProgramMode() const;
+  QString getCrossLibraryMode() const;
+  QString getCrossIncludeMode() const;
+
+  QString getCrossCompilerToolChainFile() const;
+
+  void loadFromSettings();
+  void saveToSettings();
+
+protected:
+  StartCompilerSetup* mStartCompilerSetupPage;
+  NativeCompilerSetup* mNativeCompilerSetupPage;
+  CrossCompilerSetup* mCrossCompilerSetupPage;
+  ToolchainCompilerSetup* mToolchainCompilerSetupPage;
+};
+
+#endif // FirstConfigure_h
diff --git a/Source/QtDialog/Info.plist.in b/Source/QtDialog/Info.plist.in
new file mode 100644
index 0000000..00a27c3
--- /dev/null
+++ b/Source/QtDialog/Info.plist.in
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
+	<key>CFBundleIdentifier</key>
+	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>LSApplicationCategoryType</key>
+	<string>public.app-category.developer-tools</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>${MACOSX_BUNDLE_COPYRIGHT}</string>
+	<key>NSHighResolutionCapable</key>
+	<true/>
+</dict>
+</plist>
diff --git a/Source/QtDialog/Plus16.png b/Source/QtDialog/Plus16.png
new file mode 100644
index 0000000..552f6f0
--- /dev/null
+++ b/Source/QtDialog/Plus16.png
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
new file mode 100644
index 0000000..7e94a27
--- /dev/null
+++ b/Source/QtDialog/QCMake.cxx
@@ -0,0 +1,481 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "QCMake.h"
+
+#include <QCoreApplication>
+#include <QDir>
+
+#include "cmExternalMakefileProjectGenerator.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+
+#ifdef Q_OS_WIN
+#include "qt_windows.h" // For SetErrorMode
+#endif
+
+QCMake::QCMake(QObject* p)
+  : QObject(p)
+{
+  this->WarnUninitializedMode = false;
+  this->WarnUnusedMode = false;
+  qRegisterMetaType<QCMakeProperty>();
+  qRegisterMetaType<QCMakePropertyList>();
+
+  cmSystemTools::DisableRunCommandOutput();
+  cmSystemTools::SetRunCommandHideConsole(true);
+  cmSystemTools::SetMessageCallback(QCMake::messageCallback, this);
+  cmSystemTools::SetStdoutCallback(QCMake::stdoutCallback, this);
+  cmSystemTools::SetStderrCallback(QCMake::stderrCallback, this);
+
+  this->CMakeInstance = new cmake(cmake::RoleProject);
+  this->CMakeInstance->SetCMakeEditCommand(
+    cmSystemTools::GetCMakeGUICommand());
+  this->CMakeInstance->SetProgressCallback(QCMake::progressCallback, this);
+
+  cmSystemTools::SetInterruptCallback(QCMake::interruptCallback, this);
+
+  std::vector<cmake::GeneratorInfo> generators;
+  this->CMakeInstance->GetRegisteredGenerators(generators);
+
+  std::vector<cmake::GeneratorInfo>::const_iterator it;
+  for (it = generators.begin(); it != generators.end(); ++it) {
+    // Skip the generator "KDevelop3", since there is also
+    // "KDevelop3 - Unix Makefiles", which is the full and official name.
+    // The short name is actually only still there since this was the name
+    // in CMake 2.4, to keep "command line argument compatibility", but
+    // this is not necessary in the GUI.
+    if (it->name == "KDevelop3") {
+      continue;
+    }
+
+    this->AvailableGenerators.push_back(*it);
+  }
+}
+
+QCMake::~QCMake()
+{
+  delete this->CMakeInstance;
+  // cmDynamicLoader::FlushCache();
+}
+
+void QCMake::loadCache(const QString& dir)
+{
+  this->setBinaryDirectory(dir);
+}
+
+void QCMake::setSourceDirectory(const QString& _dir)
+{
+  QString dir = QString::fromLocal8Bit(
+    cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
+  if (this->SourceDirectory != dir) {
+    this->SourceDirectory = QDir::fromNativeSeparators(dir);
+    emit this->sourceDirChanged(this->SourceDirectory);
+  }
+}
+
+void QCMake::setBinaryDirectory(const QString& _dir)
+{
+  QString dir = QString::fromLocal8Bit(
+    cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
+  if (this->BinaryDirectory != dir) {
+    this->BinaryDirectory = QDir::fromNativeSeparators(dir);
+    emit this->binaryDirChanged(this->BinaryDirectory);
+    cmState* state = this->CMakeInstance->GetState();
+    this->setGenerator(QString());
+    this->setToolset(QString());
+    if (!this->CMakeInstance->LoadCache(
+          this->BinaryDirectory.toLocal8Bit().data())) {
+      QDir testDir(this->BinaryDirectory);
+      if (testDir.exists("CMakeCache.txt")) {
+        cmSystemTools::Error(
+          "There is a CMakeCache.txt file for the current binary "
+          "tree but cmake does not have permission to read it.  "
+          "Please check the permissions of the directory you are trying to "
+          "run CMake on.");
+      }
+    }
+
+    QCMakePropertyList props = this->properties();
+    emit this->propertiesChanged(props);
+    const char* homeDir = state->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+    if (homeDir) {
+      setSourceDirectory(QString::fromLocal8Bit(homeDir));
+    }
+    const char* gen = state->GetCacheEntryValue("CMAKE_GENERATOR");
+    if (gen) {
+      const char* extraGen =
+        state->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
+      std::string curGen =
+        cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
+          gen, extraGen ? extraGen : "");
+      this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
+    }
+
+    const char* toolset = state->GetCacheEntryValue("CMAKE_GENERATOR_TOOLSET");
+    if (toolset) {
+      this->setToolset(QString::fromLocal8Bit(toolset));
+    }
+
+    checkOpenPossible();
+  }
+}
+
+void QCMake::setGenerator(const QString& gen)
+{
+  if (this->Generator != gen) {
+    this->Generator = gen;
+    emit this->generatorChanged(this->Generator);
+  }
+}
+
+void QCMake::setToolset(const QString& toolset)
+{
+  if (this->Toolset != toolset) {
+    this->Toolset = toolset;
+    emit this->toolsetChanged(this->Toolset);
+  }
+}
+
+void QCMake::configure()
+{
+#ifdef Q_OS_WIN
+  UINT lastErrorMode = SetErrorMode(0);
+#endif
+
+  this->CMakeInstance->SetHomeDirectory(
+    this->SourceDirectory.toLocal8Bit().data());
+  this->CMakeInstance->SetHomeOutputDirectory(
+    this->BinaryDirectory.toLocal8Bit().data());
+  this->CMakeInstance->SetGlobalGenerator(
+    this->CMakeInstance->CreateGlobalGenerator(
+      this->Generator.toLocal8Bit().data()));
+  this->CMakeInstance->SetGeneratorPlatform("");
+  this->CMakeInstance->SetGeneratorToolset(this->Toolset.toLocal8Bit().data());
+  this->CMakeInstance->LoadCache();
+  this->CMakeInstance->SetWarnUninitialized(this->WarnUninitializedMode);
+  this->CMakeInstance->SetWarnUnused(this->WarnUnusedMode);
+  this->CMakeInstance->PreLoadCMakeFiles();
+
+  InterruptFlag = 0;
+  cmSystemTools::ResetErrorOccuredFlag();
+
+  int err = this->CMakeInstance->Configure();
+
+#ifdef Q_OS_WIN
+  SetErrorMode(lastErrorMode);
+#endif
+
+  emit this->propertiesChanged(this->properties());
+  emit this->configureDone(err);
+}
+
+void QCMake::generate()
+{
+#ifdef Q_OS_WIN
+  UINT lastErrorMode = SetErrorMode(0);
+#endif
+
+  InterruptFlag = 0;
+  cmSystemTools::ResetErrorOccuredFlag();
+
+  int err = this->CMakeInstance->Generate();
+
+#ifdef Q_OS_WIN
+  SetErrorMode(lastErrorMode);
+#endif
+
+  emit this->generateDone(err);
+  checkOpenPossible();
+}
+
+void QCMake::open()
+{
+#ifdef Q_OS_WIN
+  UINT lastErrorMode = SetErrorMode(0);
+#endif
+
+  InterruptFlag = 0;
+  cmSystemTools::ResetErrorOccuredFlag();
+
+  auto successful = this->CMakeInstance->Open(
+    this->BinaryDirectory.toLocal8Bit().data(), false);
+
+#ifdef Q_OS_WIN
+  SetErrorMode(lastErrorMode);
+#endif
+
+  emit this->openDone(successful);
+}
+
+void QCMake::setProperties(const QCMakePropertyList& newProps)
+{
+  QCMakePropertyList props = newProps;
+
+  QStringList toremove;
+
+  // set the value of properties
+  cmState* state = this->CMakeInstance->GetState();
+  std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
+  for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+       it != cacheKeys.end(); ++it) {
+    cmStateEnums::CacheEntryType t = state->GetCacheEntryType(*it);
+    if (t == cmStateEnums::INTERNAL || t == cmStateEnums::STATIC) {
+      continue;
+    }
+
+    QCMakeProperty prop;
+    prop.Key = QString::fromLocal8Bit(it->c_str());
+    int idx = props.indexOf(prop);
+    if (idx == -1) {
+      toremove.append(QString::fromLocal8Bit(it->c_str()));
+    } else {
+      prop = props[idx];
+      if (prop.Value.type() == QVariant::Bool) {
+        state->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
+      } else {
+        state->SetCacheEntryValue(*it,
+                                  prop.Value.toString().toLocal8Bit().data());
+      }
+      props.removeAt(idx);
+    }
+  }
+
+  // remove some properites
+  foreach (QString const& s, toremove) {
+    this->CMakeInstance->UnwatchUnusedCli(s.toLocal8Bit().data());
+
+    state->RemoveCacheEntry(s.toLocal8Bit().data());
+  }
+
+  // add some new properites
+  foreach (QCMakeProperty const& s, props) {
+    this->CMakeInstance->WatchUnusedCli(s.Key.toLocal8Bit().data());
+
+    if (s.Type == QCMakeProperty::BOOL) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toBool() ? "ON" : "OFF",
+        s.Help.toLocal8Bit().data(), cmStateEnums::BOOL);
+    } else if (s.Type == QCMakeProperty::STRING) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmStateEnums::STRING);
+    } else if (s.Type == QCMakeProperty::PATH) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmStateEnums::PATH);
+    } else if (s.Type == QCMakeProperty::FILEPATH) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmStateEnums::FILEPATH);
+    }
+  }
+
+  this->CMakeInstance->SaveCache(this->BinaryDirectory.toLocal8Bit().data());
+}
+
+QCMakePropertyList QCMake::properties() const
+{
+  QCMakePropertyList ret;
+
+  cmState* state = this->CMakeInstance->GetState();
+  std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
+  for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
+       i != cacheKeys.end(); ++i) {
+    cmStateEnums::CacheEntryType t = state->GetCacheEntryType(*i);
+    if (t == cmStateEnums::INTERNAL || t == cmStateEnums::STATIC ||
+        t == cmStateEnums::UNINITIALIZED) {
+      continue;
+    }
+
+    const char* cachedValue = state->GetCacheEntryValue(*i);
+
+    QCMakeProperty prop;
+    prop.Key = QString::fromLocal8Bit(i->c_str());
+    prop.Help =
+      QString::fromLocal8Bit(state->GetCacheEntryProperty(*i, "HELPSTRING"));
+    prop.Value = QString::fromLocal8Bit(cachedValue);
+    prop.Advanced = state->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+    if (t == cmStateEnums::BOOL) {
+      prop.Type = QCMakeProperty::BOOL;
+      prop.Value = cmSystemTools::IsOn(cachedValue);
+    } else if (t == cmStateEnums::PATH) {
+      prop.Type = QCMakeProperty::PATH;
+    } else if (t == cmStateEnums::FILEPATH) {
+      prop.Type = QCMakeProperty::FILEPATH;
+    } else if (t == cmStateEnums::STRING) {
+      prop.Type = QCMakeProperty::STRING;
+      const char* stringsProperty =
+        state->GetCacheEntryProperty(*i, "STRINGS");
+      if (stringsProperty) {
+        prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
+      }
+    }
+
+    ret.append(prop);
+  }
+
+  return ret;
+}
+
+void QCMake::interrupt()
+{
+  this->InterruptFlag.ref();
+}
+
+bool QCMake::interruptCallback(void* cd)
+{
+  QCMake* self = reinterpret_cast<QCMake*>(cd);
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+  return self->InterruptFlag;
+#else
+  return self->InterruptFlag.load();
+#endif
+}
+
+void QCMake::progressCallback(const char* msg, float percent, void* cd)
+{
+  QCMake* self = reinterpret_cast<QCMake*>(cd);
+  if (percent >= 0) {
+    emit self->progressChanged(QString::fromLocal8Bit(msg), percent);
+  } else {
+    emit self->outputMessage(QString::fromLocal8Bit(msg));
+  }
+  QCoreApplication::processEvents();
+}
+
+void QCMake::messageCallback(const char* msg, const char* /*title*/,
+                             bool& /*stop*/, void* cd)
+{
+  QCMake* self = reinterpret_cast<QCMake*>(cd);
+  emit self->errorMessage(QString::fromLocal8Bit(msg));
+  QCoreApplication::processEvents();
+}
+
+void QCMake::stdoutCallback(const char* msg, size_t len, void* cd)
+{
+  QCMake* self = reinterpret_cast<QCMake*>(cd);
+  emit self->outputMessage(QString::fromLocal8Bit(msg, int(len)));
+  QCoreApplication::processEvents();
+}
+
+void QCMake::stderrCallback(const char* msg, size_t len, void* cd)
+{
+  QCMake* self = reinterpret_cast<QCMake*>(cd);
+  emit self->outputMessage(QString::fromLocal8Bit(msg, int(len)));
+  QCoreApplication::processEvents();
+}
+
+QString QCMake::binaryDirectory() const
+{
+  return this->BinaryDirectory;
+}
+
+QString QCMake::sourceDirectory() const
+{
+  return this->SourceDirectory;
+}
+
+QString QCMake::generator() const
+{
+  return this->Generator;
+}
+
+std::vector<cmake::GeneratorInfo> const& QCMake::availableGenerators() const
+{
+  return AvailableGenerators;
+}
+
+void QCMake::deleteCache()
+{
+  // delete cache
+  this->CMakeInstance->DeleteCache(this->BinaryDirectory.toLocal8Bit().data());
+  // reload to make our cache empty
+  this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
+  // emit no generator and no properties
+  this->setGenerator(QString());
+  this->setToolset(QString());
+  QCMakePropertyList props = this->properties();
+  emit this->propertiesChanged(props);
+}
+
+void QCMake::reloadCache()
+{
+  // emit that the cache was cleaned out
+  QCMakePropertyList props;
+  emit this->propertiesChanged(props);
+  // reload
+  this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
+  // emit new cache properties
+  props = this->properties();
+  emit this->propertiesChanged(props);
+}
+
+void QCMake::setDebugOutput(bool flag)
+{
+  if (flag != this->CMakeInstance->GetDebugOutput()) {
+    this->CMakeInstance->SetDebugOutputOn(flag);
+    emit this->debugOutputChanged(flag);
+  }
+}
+
+bool QCMake::getDebugOutput() const
+{
+  return this->CMakeInstance->GetDebugOutput();
+}
+
+bool QCMake::getSuppressDevWarnings()
+{
+  return this->CMakeInstance->GetSuppressDevWarnings();
+}
+
+void QCMake::setSuppressDevWarnings(bool value)
+{
+  this->CMakeInstance->SetSuppressDevWarnings(value);
+}
+
+bool QCMake::getSuppressDeprecatedWarnings()
+{
+  return this->CMakeInstance->GetSuppressDeprecatedWarnings();
+}
+
+void QCMake::setSuppressDeprecatedWarnings(bool value)
+{
+  this->CMakeInstance->SetSuppressDeprecatedWarnings(value);
+}
+
+bool QCMake::getDevWarningsAsErrors()
+{
+  return this->CMakeInstance->GetDevWarningsAsErrors();
+}
+
+void QCMake::setDevWarningsAsErrors(bool value)
+{
+  this->CMakeInstance->SetDevWarningsAsErrors(value);
+}
+
+bool QCMake::getDeprecatedWarningsAsErrors()
+{
+  return this->CMakeInstance->GetDeprecatedWarningsAsErrors();
+}
+
+void QCMake::setDeprecatedWarningsAsErrors(bool value)
+{
+  this->CMakeInstance->SetDeprecatedWarningsAsErrors(value);
+}
+
+void QCMake::setWarnUninitializedMode(bool value)
+{
+  this->WarnUninitializedMode = value;
+}
+
+void QCMake::setWarnUnusedMode(bool value)
+{
+  this->WarnUnusedMode = value;
+}
+
+void QCMake::checkOpenPossible()
+{
+  auto data = this->BinaryDirectory.toLocal8Bit().data();
+  auto possible = this->CMakeInstance->Open(data, true);
+  emit openPossible(possible);
+}
diff --git a/Source/QtDialog/QCMake.h b/Source/QtDialog/QCMake.h
new file mode 100644
index 0000000..6fae7e3
--- /dev/null
+++ b/Source/QtDialog/QCMake.h
@@ -0,0 +1,184 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef QCMake_h
+#define QCMake_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmake.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4127)
+#pragma warning(disable : 4512)
+#endif
+
+#include <vector>
+
+#include <QAtomicInt>
+#include <QList>
+#include <QMetaType>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+/// struct to represent cmake properties in Qt
+/// Value is of type String or Bool
+struct QCMakeProperty
+{
+  enum PropertyType
+  {
+    BOOL,
+    PATH,
+    FILEPATH,
+    STRING
+  };
+  QString Key;
+  QVariant Value;
+  QStringList Strings;
+  QString Help;
+  PropertyType Type;
+  bool Advanced;
+  bool operator==(const QCMakeProperty& other) const
+  {
+    return this->Key == other.Key;
+  }
+  bool operator<(const QCMakeProperty& other) const
+  {
+    return this->Key < other.Key;
+  }
+};
+
+// list of properties
+typedef QList<QCMakeProperty> QCMakePropertyList;
+
+// allow QVariant to be a property or list of properties
+Q_DECLARE_METATYPE(QCMakeProperty)
+Q_DECLARE_METATYPE(QCMakePropertyList)
+
+/// Qt API for CMake library.
+/// Wrapper like class allows for easier integration with
+/// Qt features such as, signal/slot connections, multi-threading, etc..
+class QCMake : public QObject
+{
+  Q_OBJECT
+public:
+  QCMake(QObject* p = nullptr);
+  ~QCMake();
+public slots:
+  /// load the cache file in a directory
+  void loadCache(const QString& dir);
+  /// set the source directory containing the source
+  void setSourceDirectory(const QString& dir);
+  /// set the binary directory to build in
+  void setBinaryDirectory(const QString& dir);
+  /// set the desired generator to use
+  void setGenerator(const QString& generator);
+  /// set the desired generator to use
+  void setToolset(const QString& toolset);
+  /// do the configure step
+  void configure();
+  /// generate the files
+  void generate();
+  /// open the project
+  void open();
+  /// set the property values
+  void setProperties(const QCMakePropertyList&);
+  /// interrupt the configure or generate process (if connecting, make a direct
+  /// connection)
+  void interrupt();
+  /// delete the cache in binary directory
+  void deleteCache();
+  /// reload the cache in binary directory
+  void reloadCache();
+  /// set whether to do debug output
+  void setDebugOutput(bool);
+  /// get whether to do suppress dev warnings
+  bool getSuppressDevWarnings();
+  /// set whether to do suppress dev warnings
+  void setSuppressDevWarnings(bool value);
+  /// get whether to do suppress deprecated warnings
+  bool getSuppressDeprecatedWarnings();
+  /// set whether to do suppress deprecated warnings
+  void setSuppressDeprecatedWarnings(bool value);
+  /// get whether to treat developer (author) warnings as errors
+  bool getDevWarningsAsErrors();
+  /// set whether to treat developer (author) warnings as errors
+  void setDevWarningsAsErrors(bool value);
+  /// get whether to treat deprecated warnings as errors
+  bool getDeprecatedWarningsAsErrors();
+  /// set whether to treat deprecated warnings as errors
+  void setDeprecatedWarningsAsErrors(bool value);
+  /// set whether to run cmake with warnings about uninitialized variables
+  void setWarnUninitializedMode(bool value);
+  /// set whether to run cmake with warnings about unused variables
+  void setWarnUnusedMode(bool value);
+  /// check if project IDE open is possible and emit openPossible signal
+  void checkOpenPossible();
+
+public:
+  /// get the list of cache properties
+  QCMakePropertyList properties() const;
+  /// get the current binary directory
+  QString binaryDirectory() const;
+  /// get the current source directory
+  QString sourceDirectory() const;
+  /// get the current generator
+  QString generator() const;
+  /// get the available generators
+  std::vector<cmake::GeneratorInfo> const& availableGenerators() const;
+  /// get whether to do debug output
+  bool getDebugOutput() const;
+
+signals:
+  /// signal when properties change (during read from disk or configure
+  /// process)
+  void propertiesChanged(const QCMakePropertyList& vars);
+  /// signal when the generator changes
+  void generatorChanged(const QString& gen);
+  /// signal when the source directory changes (binary directory already
+  /// containing a CMakeCache.txt file)
+  void sourceDirChanged(const QString& dir);
+  /// signal when the binary directory changes
+  void binaryDirChanged(const QString& dir);
+  /// signal for progress events
+  void progressChanged(const QString& msg, float percent);
+  /// signal when configure is done
+  void configureDone(int error);
+  /// signal when generate is done
+  void generateDone(int error);
+  /// signal when there is an output message
+  void outputMessage(const QString& msg);
+  /// signal when there is an error message
+  void errorMessage(const QString& msg);
+  /// signal when debug output changes
+  void debugOutputChanged(bool);
+  /// signal when the toolset changes
+  void toolsetChanged(const QString& toolset);
+  /// signal when open is done
+  void openDone(bool successful);
+  /// signal when open is done
+  void openPossible(bool possible);
+
+protected:
+  cmake* CMakeInstance;
+
+  static bool interruptCallback(void*);
+  static void progressCallback(const char* msg, float percent, void* cd);
+  static void messageCallback(const char* msg, const char* title, bool&,
+                              void* cd);
+  static void stdoutCallback(const char* msg, size_t len, void* cd);
+  static void stderrCallback(const char* msg, size_t len, void* cd);
+  bool WarnUninitializedMode;
+  bool WarnUnusedMode;
+  bool WarnUnusedAllMode;
+  QString SourceDirectory;
+  QString BinaryDirectory;
+  QString Generator;
+  QString Toolset;
+  std::vector<cmake::GeneratorInfo> AvailableGenerators;
+  QString CMakeExecutable;
+  QAtomicInt InterruptFlag;
+};
+
+#endif // QCMake_h
diff --git a/Source/QtDialog/QCMakeCacheView.cxx b/Source/QtDialog/QCMakeCacheView.cxx
new file mode 100644
index 0000000..1b3fb15
--- /dev/null
+++ b/Source/QtDialog/QCMakeCacheView.cxx
@@ -0,0 +1,684 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "QCMakeCacheView.h"
+
+#include <QApplication>
+#include <QEvent>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QKeyEvent>
+#include <QMetaProperty>
+#include <QSortFilterProxyModel>
+#include <QStyle>
+
+#include "QCMakeWidgets.h"
+
+// filter for searches
+class QCMakeSearchFilter : public QSortFilterProxyModel
+{
+public:
+  QCMakeSearchFilter(QObject* o)
+    : QSortFilterProxyModel(o)
+  {
+  }
+
+protected:
+  bool filterAcceptsRow(int row, const QModelIndex& p) const override
+  {
+    QStringList strs;
+    const QAbstractItemModel* m = this->sourceModel();
+    QModelIndex idx = m->index(row, 0, p);
+
+    // if there are no children, get strings for column 0 and 1
+    if (!m->hasChildren(idx)) {
+      strs.append(m->data(idx).toString());
+      idx = m->index(row, 1, p);
+      strs.append(m->data(idx).toString());
+    } else {
+      // get strings for children entries to compare with
+      // instead of comparing with the parent
+      int num = m->rowCount(idx);
+      for (int i = 0; i < num; i++) {
+        QModelIndex tmpidx = m->index(i, 0, idx);
+        strs.append(m->data(tmpidx).toString());
+        tmpidx = m->index(i, 1, idx);
+        strs.append(m->data(tmpidx).toString());
+      }
+    }
+
+    // check all strings for a match
+    foreach (QString const& str, strs) {
+      if (str.contains(this->filterRegExp())) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+// filter for searches
+class QCMakeAdvancedFilter : public QSortFilterProxyModel
+{
+public:
+  QCMakeAdvancedFilter(QObject* o)
+    : QSortFilterProxyModel(o)
+    , ShowAdvanced(false)
+  {
+  }
+
+  void setShowAdvanced(bool f)
+  {
+    this->ShowAdvanced = f;
+    this->invalidate();
+  }
+  bool showAdvanced() const { return this->ShowAdvanced; }
+
+protected:
+  bool ShowAdvanced;
+
+  bool filterAcceptsRow(int row, const QModelIndex& p) const override
+  {
+    const QAbstractItemModel* m = this->sourceModel();
+    QModelIndex idx = m->index(row, 0, p);
+
+    // if there are no children
+    if (!m->hasChildren(idx)) {
+      bool adv = m->data(idx, QCMakeCacheModel::AdvancedRole).toBool();
+      return !adv || this->ShowAdvanced;
+    }
+
+    // check children
+    int num = m->rowCount(idx);
+    for (int i = 0; i < num; i++) {
+      bool accept = this->filterAcceptsRow(i, idx);
+      if (accept) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+QCMakeCacheView::QCMakeCacheView(QWidget* p)
+  : QTreeView(p)
+{
+  // hook up our model and search/filter proxies
+  this->CacheModel = new QCMakeCacheModel(this);
+  this->AdvancedFilter = new QCMakeAdvancedFilter(this);
+  this->AdvancedFilter->setSourceModel(this->CacheModel);
+  this->AdvancedFilter->setDynamicSortFilter(true);
+  this->SearchFilter = new QCMakeSearchFilter(this);
+  this->SearchFilter->setSourceModel(this->AdvancedFilter);
+  this->SearchFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
+  this->SearchFilter->setDynamicSortFilter(true);
+  this->setModel(this->SearchFilter);
+
+  // our delegate for creating our editors
+  QCMakeCacheModelDelegate* delegate = new QCMakeCacheModelDelegate(this);
+  this->setItemDelegate(delegate);
+
+  this->setUniformRowHeights(true);
+
+  this->setEditTriggers(QAbstractItemView::AllEditTriggers);
+
+  // tab, backtab doesn't step through items
+  this->setTabKeyNavigation(false);
+
+  this->setRootIsDecorated(false);
+}
+
+bool QCMakeCacheView::event(QEvent* e)
+{
+  if (e->type() == QEvent::Show) {
+    this->header()->setDefaultSectionSize(this->viewport()->width() / 2);
+  }
+  return QTreeView::event(e);
+}
+
+QCMakeCacheModel* QCMakeCacheView::cacheModel() const
+{
+  return this->CacheModel;
+}
+
+QModelIndex QCMakeCacheView::moveCursor(CursorAction act,
+                                        Qt::KeyboardModifiers mod)
+{
+  // want home/end to go to begin/end of rows, not columns
+  if (act == MoveHome) {
+    return this->model()->index(0, 1);
+  }
+  if (act == MoveEnd) {
+    return this->model()->index(this->model()->rowCount() - 1, 1);
+  }
+  return QTreeView::moveCursor(act, mod);
+}
+
+void QCMakeCacheView::setShowAdvanced(bool s)
+{
+#if QT_VERSION >= 040300
+  // new 4.3 API that needs to be called.  what about an older Qt?
+  this->SearchFilter->invalidate();
+#endif
+
+  this->AdvancedFilter->setShowAdvanced(s);
+}
+
+bool QCMakeCacheView::showAdvanced() const
+{
+  return this->AdvancedFilter->showAdvanced();
+}
+
+void QCMakeCacheView::setSearchFilter(const QString& s)
+{
+  this->SearchFilter->setFilterFixedString(s);
+}
+
+QCMakeCacheModel::QCMakeCacheModel(QObject* p)
+  : QStandardItemModel(p)
+  , EditEnabled(true)
+  , NewPropertyCount(0)
+  , View(FlatView)
+{
+  this->ShowNewProperties = true;
+  QStringList labels;
+  labels << tr("Name") << tr("Value");
+  this->setHorizontalHeaderLabels(labels);
+}
+
+QCMakeCacheModel::~QCMakeCacheModel()
+{
+}
+
+static uint qHash(const QCMakeProperty& p)
+{
+  return qHash(p.Key);
+}
+
+void QCMakeCacheModel::setShowNewProperties(bool f)
+{
+  this->ShowNewProperties = f;
+}
+
+void QCMakeCacheModel::clear()
+{
+  this->QStandardItemModel::clear();
+  this->NewPropertyCount = 0;
+
+  QStringList labels;
+  labels << tr("Name") << tr("Value");
+  this->setHorizontalHeaderLabels(labels);
+}
+
+void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
+{
+  QSet<QCMakeProperty> newProps, newProps2;
+
+  if (this->ShowNewProperties) {
+    newProps = props.toSet();
+    newProps2 = newProps;
+    QSet<QCMakeProperty> oldProps = this->properties().toSet();
+    oldProps.intersect(newProps);
+    newProps.subtract(oldProps);
+    newProps2.subtract(newProps);
+  } else {
+    newProps2 = props.toSet();
+  }
+
+  bool b = this->blockSignals(true);
+
+  this->clear();
+  this->NewPropertyCount = newProps.size();
+
+  if (View == FlatView) {
+    QCMakePropertyList newP = newProps.toList();
+    QCMakePropertyList newP2 = newProps2.toList();
+    qSort(newP);
+    qSort(newP2);
+    int row_count = 0;
+    foreach (QCMakeProperty const& p, newP) {
+      this->insertRow(row_count);
+      this->setPropertyData(this->index(row_count, 0), p, true);
+      row_count++;
+    }
+    foreach (QCMakeProperty const& p, newP2) {
+      this->insertRow(row_count);
+      this->setPropertyData(this->index(row_count, 0), p, false);
+      row_count++;
+    }
+  } else if (this->View == GroupView) {
+    QMap<QString, QCMakePropertyList> newPropsTree;
+    this->breakProperties(newProps, newPropsTree);
+    QMap<QString, QCMakePropertyList> newPropsTree2;
+    this->breakProperties(newProps2, newPropsTree2);
+
+    QStandardItem* root = this->invisibleRootItem();
+
+    for (QMap<QString, QCMakePropertyList>::const_iterator iter =
+           newPropsTree.begin();
+         iter != newPropsTree.end(); ++iter) {
+      QString const& key = iter.key();
+      QCMakePropertyList const& props2 = iter.value();
+
+      QList<QStandardItem*> parentItems;
+      parentItems.append(
+        new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key));
+      parentItems.append(new QStandardItem());
+      parentItems[0]->setData(QBrush(QColor(255, 100, 100)),
+                              Qt::BackgroundColorRole);
+      parentItems[1]->setData(QBrush(QColor(255, 100, 100)),
+                              Qt::BackgroundColorRole);
+      parentItems[0]->setData(1, GroupRole);
+      parentItems[1]->setData(1, GroupRole);
+      root->appendRow(parentItems);
+
+      int num = props2.size();
+      for (int i = 0; i < num; i++) {
+        QCMakeProperty prop = props2[i];
+        QList<QStandardItem*> items;
+        items.append(new QStandardItem());
+        items.append(new QStandardItem());
+        parentItems[0]->appendRow(items);
+        this->setPropertyData(this->indexFromItem(items[0]), prop, true);
+      }
+    }
+
+    for (QMap<QString, QCMakePropertyList>::const_iterator iter =
+           newPropsTree2.begin();
+         iter != newPropsTree2.end(); ++iter) {
+      QString const& key = iter.key();
+      QCMakePropertyList const& props2 = iter.value();
+
+      QStandardItem* parentItem =
+        new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key);
+      root->appendRow(parentItem);
+      parentItem->setData(1, GroupRole);
+
+      int num = props2.size();
+      for (int i = 0; i < num; i++) {
+        QCMakeProperty prop = props2[i];
+        QList<QStandardItem*> items;
+        items.append(new QStandardItem());
+        items.append(new QStandardItem());
+        parentItem->appendRow(items);
+        this->setPropertyData(this->indexFromItem(items[0]), prop, false);
+      }
+    }
+  }
+
+  this->blockSignals(b);
+  this->reset();
+}
+
+QCMakeCacheModel::ViewType QCMakeCacheModel::viewType() const
+{
+  return this->View;
+}
+
+void QCMakeCacheModel::setViewType(QCMakeCacheModel::ViewType t)
+{
+  this->View = t;
+
+  QCMakePropertyList props = this->properties();
+  QCMakePropertyList oldProps;
+  int numNew = this->NewPropertyCount;
+  int numTotal = props.count();
+  for (int i = numNew; i < numTotal; i++) {
+    oldProps.append(props[i]);
+  }
+
+  bool b = this->blockSignals(true);
+  this->clear();
+  this->setProperties(oldProps);
+  this->setProperties(props);
+  this->blockSignals(b);
+  this->reset();
+}
+
+void QCMakeCacheModel::setPropertyData(const QModelIndex& idx1,
+                                       const QCMakeProperty& prop, bool isNew)
+{
+  QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
+
+  this->setData(idx1, prop.Key, Qt::DisplayRole);
+  this->setData(idx1, prop.Help, QCMakeCacheModel::HelpRole);
+  this->setData(idx1, prop.Type, QCMakeCacheModel::TypeRole);
+  this->setData(idx1, prop.Advanced, QCMakeCacheModel::AdvancedRole);
+
+  if (prop.Type == QCMakeProperty::BOOL) {
+    int check = prop.Value.toBool() ? Qt::Checked : Qt::Unchecked;
+    this->setData(idx2, check, Qt::CheckStateRole);
+  } else {
+    this->setData(idx2, prop.Value, Qt::DisplayRole);
+  }
+  this->setData(idx2, prop.Help, QCMakeCacheModel::HelpRole);
+
+  if (!prop.Strings.isEmpty()) {
+    this->setData(idx1, prop.Strings, QCMakeCacheModel::StringsRole);
+  }
+
+  if (isNew) {
+    this->setData(idx1, QBrush(QColor(255, 100, 100)),
+                  Qt::BackgroundColorRole);
+    this->setData(idx2, QBrush(QColor(255, 100, 100)),
+                  Qt::BackgroundColorRole);
+  }
+}
+
+void QCMakeCacheModel::getPropertyData(const QModelIndex& idx1,
+                                       QCMakeProperty& prop) const
+{
+  QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
+
+  prop.Key = this->data(idx1, Qt::DisplayRole).toString();
+  prop.Help = this->data(idx1, HelpRole).toString();
+  prop.Type = static_cast<QCMakeProperty::PropertyType>(
+    this->data(idx1, TypeRole).toInt());
+  prop.Advanced = this->data(idx1, AdvancedRole).toBool();
+  prop.Strings =
+    this->data(idx1, QCMakeCacheModel::StringsRole).toStringList();
+  if (prop.Type == QCMakeProperty::BOOL) {
+    int check = this->data(idx2, Qt::CheckStateRole).toInt();
+    prop.Value = check == Qt::Checked;
+  } else {
+    prop.Value = this->data(idx2, Qt::DisplayRole).toString();
+  }
+}
+
+QString QCMakeCacheModel::prefix(const QString& s)
+{
+  QString prefix = s.section('_', 0, 0);
+  if (prefix == s) {
+    prefix = QString();
+  }
+  return prefix;
+}
+
+void QCMakeCacheModel::breakProperties(
+  const QSet<QCMakeProperty>& props, QMap<QString, QCMakePropertyList>& result)
+{
+  QMap<QString, QCMakePropertyList> tmp;
+  // return a map of properties grouped by prefixes, and sorted
+  foreach (QCMakeProperty const& p, props) {
+    QString prefix = QCMakeCacheModel::prefix(p.Key);
+    tmp[prefix].append(p);
+  }
+  // sort it and re-org any properties with only one sub item
+  QCMakePropertyList reorgProps;
+  QMap<QString, QCMakePropertyList>::iterator iter;
+  for (iter = tmp.begin(); iter != tmp.end();) {
+    if (iter->count() == 1) {
+      reorgProps.append((*iter)[0]);
+      iter = tmp.erase(iter);
+    } else {
+      qSort(*iter);
+      ++iter;
+    }
+  }
+  if (reorgProps.count()) {
+    tmp[QString()] += reorgProps;
+  }
+  result = tmp;
+}
+
+QCMakePropertyList QCMakeCacheModel::properties() const
+{
+  QCMakePropertyList props;
+
+  if (!this->rowCount()) {
+    return props;
+  }
+
+  QVector<QModelIndex> idxs;
+  idxs.append(this->index(0, 0));
+
+  // walk the entire model for property entries
+  // this works regardless of a flat view or a tree view
+  while (!idxs.isEmpty()) {
+    QModelIndex idx = idxs.last();
+    if (this->hasChildren(idx) && this->rowCount(idx)) {
+      idxs.append(this->index(0, 0, idx));
+    } else {
+      if (!data(idx, GroupRole).toInt()) {
+        // get data
+        QCMakeProperty prop;
+        this->getPropertyData(idx, prop);
+        props.append(prop);
+      }
+
+      // go to the next in the tree
+      while (!idxs.isEmpty() &&
+             (
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) &&                                \
+  QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
+               (idxs.last().row() + 1) >= rowCount(idxs.last().parent()) ||
+#endif
+               !idxs.last().sibling(idxs.last().row() + 1, 0).isValid())) {
+        idxs.remove(idxs.size() - 1);
+      }
+      if (!idxs.isEmpty()) {
+        idxs.last() = idxs.last().sibling(idxs.last().row() + 1, 0);
+      }
+    }
+  }
+
+  return props;
+}
+
+bool QCMakeCacheModel::insertProperty(QCMakeProperty::PropertyType t,
+                                      const QString& name,
+                                      const QString& description,
+                                      const QVariant& value, bool advanced)
+{
+  QCMakeProperty prop;
+  prop.Key = name;
+  prop.Value = value;
+  prop.Help = description;
+  prop.Type = t;
+  prop.Advanced = advanced;
+
+  // insert at beginning
+  this->insertRow(0);
+  this->setPropertyData(this->index(0, 0), prop, true);
+  this->NewPropertyCount++;
+  return true;
+}
+
+void QCMakeCacheModel::setEditEnabled(bool e)
+{
+  this->EditEnabled = e;
+}
+
+bool QCMakeCacheModel::editEnabled() const
+{
+  return this->EditEnabled;
+}
+
+int QCMakeCacheModel::newPropertyCount() const
+{
+  return this->NewPropertyCount;
+}
+
+Qt::ItemFlags QCMakeCacheModel::flags(const QModelIndex& idx) const
+{
+  Qt::ItemFlags f = QStandardItemModel::flags(idx);
+  if (!this->EditEnabled) {
+    f &= ~Qt::ItemIsEditable;
+    return f;
+  }
+  if (QCMakeProperty::BOOL == this->data(idx, TypeRole).toInt()) {
+    f |= Qt::ItemIsUserCheckable;
+  }
+  return f;
+}
+
+QModelIndex QCMakeCacheModel::buddy(const QModelIndex& idx) const
+{
+  if (!this->hasChildren(idx) &&
+      this->data(idx, TypeRole).toInt() != QCMakeProperty::BOOL) {
+    return this->index(idx.row(), 1, idx.parent());
+  }
+  return idx;
+}
+
+QCMakeCacheModelDelegate::QCMakeCacheModelDelegate(QObject* p)
+  : QItemDelegate(p)
+  , FileDialogFlag(false)
+{
+}
+
+void QCMakeCacheModelDelegate::setFileDialogFlag(bool f)
+{
+  this->FileDialogFlag = f;
+}
+
+QWidget* QCMakeCacheModelDelegate::createEditor(
+  QWidget* p, const QStyleOptionViewItem& /*option*/,
+  const QModelIndex& idx) const
+{
+  QModelIndex var = idx.sibling(idx.row(), 0);
+  int type = var.data(QCMakeCacheModel::TypeRole).toInt();
+  if (type == QCMakeProperty::BOOL) {
+    return nullptr;
+  }
+  if (type == QCMakeProperty::PATH) {
+    QCMakePathEditor* editor =
+      new QCMakePathEditor(p, var.data(Qt::DisplayRole).toString());
+    QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
+                     SLOT(setFileDialogFlag(bool)));
+    return editor;
+  }
+  if (type == QCMakeProperty::FILEPATH) {
+    QCMakeFilePathEditor* editor =
+      new QCMakeFilePathEditor(p, var.data(Qt::DisplayRole).toString());
+    QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
+                     SLOT(setFileDialogFlag(bool)));
+    return editor;
+  }
+  if (type == QCMakeProperty::STRING &&
+      var.data(QCMakeCacheModel::StringsRole).isValid()) {
+    QCMakeComboBox* editor = new QCMakeComboBox(
+      p, var.data(QCMakeCacheModel::StringsRole).toStringList());
+    editor->setFrame(false);
+    return editor;
+  }
+
+  QLineEdit* editor = new QLineEdit(p);
+  editor->setFrame(false);
+  return editor;
+}
+
+bool QCMakeCacheModelDelegate::editorEvent(QEvent* e,
+                                           QAbstractItemModel* model,
+                                           const QStyleOptionViewItem& option,
+                                           const QModelIndex& index)
+{
+  Qt::ItemFlags flags = model->flags(index);
+  if (!(flags & Qt::ItemIsUserCheckable) ||
+      !(option.state & QStyle::State_Enabled) ||
+      !(flags & Qt::ItemIsEnabled)) {
+    return false;
+  }
+
+  QVariant value = index.data(Qt::CheckStateRole);
+  if (!value.isValid()) {
+    return false;
+  }
+
+  if ((e->type() == QEvent::MouseButtonRelease) ||
+      (e->type() == QEvent::MouseButtonDblClick)) {
+    // eat the double click events inside the check rect
+    if (e->type() == QEvent::MouseButtonDblClick) {
+      return true;
+    }
+  } else if (e->type() == QEvent::KeyPress) {
+    if (static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
+        static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+
+  Qt::CheckState state =
+    (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked ? Qt::Unchecked
+                                                               : Qt::Checked);
+  bool success = model->setData(index, state, Qt::CheckStateRole);
+  if (success) {
+    this->recordChange(model, index);
+  }
+  return success;
+}
+
+// Issue 205903 fixed in Qt 4.5.0.
+// Can remove this function and FileDialogFlag when minimum Qt version is 4.5
+bool QCMakeCacheModelDelegate::eventFilter(QObject* object, QEvent* evt)
+{
+  // workaround for what looks like a bug in Qt on Mac OS X
+  // where it doesn't create a QWidget wrapper for the native file dialog
+  // so the Qt library ends up assuming the focus was lost to something else
+
+  if (evt->type() == QEvent::FocusOut && this->FileDialogFlag) {
+    return false;
+  }
+  return QItemDelegate::eventFilter(object, evt);
+}
+
+void QCMakeCacheModelDelegate::setModelData(QWidget* editor,
+                                            QAbstractItemModel* model,
+                                            const QModelIndex& index) const
+{
+  QItemDelegate::setModelData(editor, model, index);
+  const_cast<QCMakeCacheModelDelegate*>(this)->recordChange(model, index);
+}
+
+QSize QCMakeCacheModelDelegate::sizeHint(const QStyleOptionViewItem& option,
+                                         const QModelIndex& index) const
+{
+  QSize sz = QItemDelegate::sizeHint(option, index);
+  QStyle* style = QApplication::style();
+
+  // increase to checkbox size
+  QStyleOptionButton opt;
+  opt.QStyleOption::operator=(option);
+  sz = sz.expandedTo(
+    style->subElementRect(QStyle::SE_ViewItemCheckIndicator, &opt, nullptr)
+      .size());
+
+  return sz;
+}
+
+QSet<QCMakeProperty> QCMakeCacheModelDelegate::changes() const
+{
+  return mChanges;
+}
+
+void QCMakeCacheModelDelegate::clearChanges()
+{
+  mChanges.clear();
+}
+
+void QCMakeCacheModelDelegate::recordChange(QAbstractItemModel* model,
+                                            const QModelIndex& index)
+{
+  QModelIndex idx = index;
+  QAbstractItemModel* mymodel = model;
+  while (qobject_cast<QAbstractProxyModel*>(mymodel)) {
+    idx = static_cast<QAbstractProxyModel*>(mymodel)->mapToSource(idx);
+    mymodel = static_cast<QAbstractProxyModel*>(mymodel)->sourceModel();
+  }
+  QCMakeCacheModel* cache_model = qobject_cast<QCMakeCacheModel*>(mymodel);
+  if (cache_model && idx.isValid()) {
+    QCMakeProperty prop;
+    idx = idx.sibling(idx.row(), 0);
+    cache_model->getPropertyData(idx, prop);
+
+    // clean out an old one
+    QSet<QCMakeProperty>::iterator iter = mChanges.find(prop);
+    if (iter != mChanges.end()) {
+      mChanges.erase(iter);
+    }
+    // now add the new item
+    mChanges.insert(prop);
+  }
+}
diff --git a/Source/QtDialog/QCMakeCacheView.h b/Source/QtDialog/QCMakeCacheView.h
new file mode 100644
index 0000000..c1debf5
--- /dev/null
+++ b/Source/QtDialog/QCMakeCacheView.h
@@ -0,0 +1,170 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef QCMakeCacheView_h
+#define QCMakeCacheView_h
+
+#include "QCMake.h"
+
+#include <QItemDelegate>
+#include <QSet>
+#include <QStandardItemModel>
+#include <QTreeView>
+
+class QSortFilterProxyModel;
+class QCMakeCacheModel;
+class QCMakeAdvancedFilter;
+
+/// Qt view class for cache properties
+class QCMakeCacheView : public QTreeView
+{
+  Q_OBJECT
+public:
+  QCMakeCacheView(QWidget* p);
+
+  // retrieve the QCMakeCacheModel storing all the pointers
+  // this isn't necessarily the model one would get from model()
+  QCMakeCacheModel* cacheModel() const;
+
+  // get whether to show advanced entries
+  bool showAdvanced() const;
+
+  QSize sizeHint() const { return QSize(200, 200); }
+
+public slots:
+  // set whether to show advanced entries
+  void setShowAdvanced(bool);
+  // set the search filter string.  any property key or value not matching will
+  // be filtered out
+  void setSearchFilter(const QString&);
+
+protected:
+  QModelIndex moveCursor(CursorAction, Qt::KeyboardModifiers);
+  bool event(QEvent* e);
+  QCMakeCacheModel* CacheModel;
+  QCMakeAdvancedFilter* AdvancedFilter;
+  QSortFilterProxyModel* SearchFilter;
+};
+
+/// Qt model class for cache properties
+class QCMakeCacheModel : public QStandardItemModel
+{
+  Q_OBJECT
+public:
+  QCMakeCacheModel(QObject* parent);
+  ~QCMakeCacheModel();
+
+  // roles used to retrieve extra data such has help strings, types of
+  // properties, and the advanced flag
+  enum
+  {
+    HelpRole = Qt::ToolTipRole,
+    TypeRole = Qt::UserRole,
+    AdvancedRole,
+    StringsRole,
+    GroupRole
+  };
+
+  enum ViewType
+  {
+    FlatView,
+    GroupView
+  };
+
+public slots:
+  // set a list of properties.  This list will be sorted and grouped according
+  // to prefix.  Any property that existed already and which is found in this
+  // list of properties to set will become an old property.  All others will
+  // become new properties and be marked red.
+  void setProperties(const QCMakePropertyList& props);
+
+  // set whether to show new properties in red
+  void setShowNewProperties(bool);
+
+  // clear everything from the model
+  void clear();
+
+  // set flag whether the model can currently be edited.
+  void setEditEnabled(bool);
+
+  // insert a new property at a row specifying all the information about the
+  // property
+  bool insertProperty(QCMakeProperty::PropertyType t, const QString& name,
+                      const QString& description, const QVariant& value,
+                      bool advanced);
+
+  // set the view type
+  void setViewType(ViewType t);
+  ViewType viewType() const;
+
+public:
+  // get the properties
+  QCMakePropertyList properties() const;
+
+  // editing enabled
+  bool editEnabled() const;
+
+  // returns how many new properties there are
+  int newPropertyCount() const;
+
+  // return flags (overloaded to modify flag based on EditEnabled flag)
+  Qt::ItemFlags flags(const QModelIndex& index) const;
+  QModelIndex buddy(const QModelIndex& idx) const;
+
+  // get the data in the model for this property
+  void getPropertyData(const QModelIndex& idx1, QCMakeProperty& prop) const;
+
+protected:
+  bool EditEnabled;
+  int NewPropertyCount;
+  bool ShowNewProperties;
+  ViewType View;
+
+  // set the data in the model for this property
+  void setPropertyData(const QModelIndex& idx1, const QCMakeProperty& p,
+                       bool isNew);
+
+  // breaks up he property list into groups
+  // where each group has the same prefix up to the first underscore
+  static void breakProperties(const QSet<QCMakeProperty>& props,
+                              QMap<QString, QCMakePropertyList>& result);
+
+  // gets the prefix of a string up to the first _
+  static QString prefix(const QString& s);
+};
+
+/// Qt delegate class for interaction (or other customization)
+/// with cache properties
+class QCMakeCacheModelDelegate : public QItemDelegate
+{
+  Q_OBJECT
+public:
+  QCMakeCacheModelDelegate(QObject* p);
+  /// create our own editors for cache properties
+  QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option,
+                        const QModelIndex& index) const;
+  bool editorEvent(QEvent* event, QAbstractItemModel* model,
+                   const QStyleOptionViewItem& option,
+                   const QModelIndex& index);
+  bool eventFilter(QObject* object, QEvent* event);
+  void setModelData(QWidget* editor, QAbstractItemModel* model,
+                    const QModelIndex& index) const;
+  QSize sizeHint(const QStyleOptionViewItem& option,
+                 const QModelIndex& index) const;
+
+  QSet<QCMakeProperty> changes() const;
+  void clearChanges();
+
+protected slots:
+  void setFileDialogFlag(bool);
+
+protected:
+  bool FileDialogFlag;
+  // record a change to an item in the model.
+  // this simply saves the item in the set of changes
+  void recordChange(QAbstractItemModel* model, const QModelIndex& index);
+
+  // properties changed by user via this delegate
+  QSet<QCMakeProperty> mChanges;
+};
+
+#endif
diff --git a/Source/QtDialog/QCMakeWidgets.cxx b/Source/QtDialog/QCMakeWidgets.cxx
new file mode 100644
index 0000000..b544b86
--- /dev/null
+++ b/Source/QtDialog/QCMakeWidgets.cxx
@@ -0,0 +1,118 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "QCMakeWidgets.h"
+
+#include <QDirModel>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QResizeEvent>
+#include <QToolButton>
+
+QCMakeFileEditor::QCMakeFileEditor(QWidget* p, const QString& var)
+  : QLineEdit(p)
+  , Variable(var)
+{
+  this->ToolButton = new QToolButton(this);
+  this->ToolButton->setText("...");
+  this->ToolButton->setCursor(QCursor(Qt::ArrowCursor));
+  QObject::connect(this->ToolButton, SIGNAL(clicked(bool)), this,
+                   SLOT(chooseFile()));
+}
+
+QCMakeFilePathEditor::QCMakeFilePathEditor(QWidget* p, const QString& var)
+  : QCMakeFileEditor(p, var)
+{
+  this->setCompleter(new QCMakeFileCompleter(this, false));
+}
+
+QCMakePathEditor::QCMakePathEditor(QWidget* p, const QString& var)
+  : QCMakeFileEditor(p, var)
+{
+  this->setCompleter(new QCMakeFileCompleter(this, true));
+}
+
+void QCMakeFileEditor::resizeEvent(QResizeEvent* e)
+{
+  // make the tool button fit on the right side
+  int h = e->size().height();
+  // move the line edit to make room for the tool button
+  this->setContentsMargins(0, 0, h, 0);
+  // put the tool button in its place
+  this->ToolButton->resize(h, h);
+  this->ToolButton->move(this->width() - h, 0);
+}
+
+void QCMakeFilePathEditor::chooseFile()
+{
+  // choose a file and set it
+  QString path;
+  QFileInfo info(this->text());
+  QString title;
+  if (this->Variable.isEmpty()) {
+    title = tr("Select File");
+  } else {
+    title = tr("Select File for %1");
+    title = title.arg(this->Variable);
+  }
+  emit this->fileDialogExists(true);
+  path =
+    QFileDialog::getOpenFileName(this, title, info.absolutePath(), QString(),
+                                 nullptr, QFileDialog::DontResolveSymlinks);
+  emit this->fileDialogExists(false);
+
+  if (!path.isEmpty()) {
+    this->setText(QDir::fromNativeSeparators(path));
+  }
+}
+
+void QCMakePathEditor::chooseFile()
+{
+  // choose a file and set it
+  QString path;
+  QString title;
+  if (this->Variable.isEmpty()) {
+    title = tr("Select Path");
+  } else {
+    title = tr("Select Path for %1");
+    title = title.arg(this->Variable);
+  }
+  emit this->fileDialogExists(true);
+  path = QFileDialog::getExistingDirectory(this, title, this->text(),
+                                           QFileDialog::ShowDirsOnly |
+                                             QFileDialog::DontResolveSymlinks);
+  emit this->fileDialogExists(false);
+  if (!path.isEmpty()) {
+    this->setText(QDir::fromNativeSeparators(path));
+  }
+}
+
+// use same QDirModel for all completers
+static QDirModel* fileDirModel()
+{
+  static QDirModel* m = nullptr;
+  if (!m) {
+    m = new QDirModel();
+  }
+  return m;
+}
+static QDirModel* pathDirModel()
+{
+  static QDirModel* m = nullptr;
+  if (!m) {
+    m = new QDirModel();
+    m->setFilter(QDir::AllDirs | QDir::Drives | QDir::NoDotAndDotDot);
+  }
+  return m;
+}
+
+QCMakeFileCompleter::QCMakeFileCompleter(QObject* o, bool dirs)
+  : QCompleter(o)
+{
+  QDirModel* m = dirs ? pathDirModel() : fileDirModel();
+  this->setModel(m);
+}
+
+QString QCMakeFileCompleter::pathFromIndex(const QModelIndex& idx) const
+{
+  return QDir::fromNativeSeparators(QCompleter::pathFromIndex(idx));
+}
diff --git a/Source/QtDialog/QCMakeWidgets.h b/Source/QtDialog/QCMakeWidgets.h
new file mode 100644
index 0000000..e63c197
--- /dev/null
+++ b/Source/QtDialog/QCMakeWidgets.h
@@ -0,0 +1,81 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef QCMakeWidgets_h
+#define QCMakeWidgets_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <QComboBox>
+#include <QCompleter>
+#include <QLineEdit>
+
+class QToolButton;
+
+// common widgets for Qt based CMake
+
+/// Editor widget for editing paths or file paths
+class QCMakeFileEditor : public QLineEdit
+{
+  Q_OBJECT
+public:
+  QCMakeFileEditor(QWidget* p, const QString& var);
+protected slots:
+  virtual void chooseFile() = 0;
+signals:
+  void fileDialogExists(bool);
+
+protected:
+  void resizeEvent(QResizeEvent* e);
+  QToolButton* ToolButton;
+  QString Variable;
+};
+
+/// editor widget for editing files
+class QCMakePathEditor : public QCMakeFileEditor
+{
+  Q_OBJECT
+public:
+  QCMakePathEditor(QWidget* p = nullptr, const QString& var = QString());
+  void chooseFile();
+};
+
+/// editor widget for editing paths
+class QCMakeFilePathEditor : public QCMakeFileEditor
+{
+  Q_OBJECT
+public:
+  QCMakeFilePathEditor(QWidget* p = nullptr, const QString& var = QString());
+  void chooseFile();
+};
+
+/// completer class that returns native cmake paths
+class QCMakeFileCompleter : public QCompleter
+{
+  Q_OBJECT
+public:
+  QCMakeFileCompleter(QObject* o, bool dirs);
+  virtual QString pathFromIndex(const QModelIndex& idx) const;
+};
+
+// editor for strings
+class QCMakeComboBox : public QComboBox
+{
+  Q_OBJECT
+  Q_PROPERTY(QString value READ currentText WRITE setValue USER true);
+
+public:
+  QCMakeComboBox(QWidget* p, QStringList strings)
+    : QComboBox(p)
+  {
+    this->addItems(strings);
+  }
+  void setValue(const QString& v)
+  {
+    int i = this->findText(v);
+    if (i != -1) {
+      this->setCurrentIndex(i);
+    }
+  }
+};
+
+#endif
diff --git a/Source/QtDialog/QtDialogCPack.cmake.in b/Source/QtDialog/QtDialogCPack.cmake.in
new file mode 100644
index 0000000..7ae8605
--- /dev/null
+++ b/Source/QtDialog/QtDialogCPack.cmake.in
@@ -0,0 +1,15 @@
+set(IS_APPLE @APPLE@)
+set(CMAKE_PACKAGE_QTGUI @CMAKE_PACKAGE_QTGUI@)
+
+if(CMAKE_PACKAGE_QTGUI)
+  set(CPACK_PACKAGE_EXECUTABLES "cmake-gui" "CMake (cmake-gui)" ${CPACK_PACKAGE_EXECUTABLES})
+  set(CPACK_CREATE_DESKTOP_LINKS "cmake-gui" ${CPACK_CREATE_DESKTOP_LINKS})
+  if(IS_APPLE)
+    # for apple install we set the install prefix to
+    # / and then install
+    # cmake into the bundle for cmake-gui and must use DESTDIR
+    set(CPACK_SET_DESTDIR TRUE)
+  endif()
+endif()
+
+
diff --git a/Source/QtDialog/RegexExplorer.cxx b/Source/QtDialog/RegexExplorer.cxx
new file mode 100644
index 0000000..cb67f85
--- /dev/null
+++ b/Source/QtDialog/RegexExplorer.cxx
@@ -0,0 +1,166 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "RegexExplorer.h"
+
+RegexExplorer::RegexExplorer(QWidget* p)
+  : QDialog(p)
+  , m_matched(false)
+{
+  this->setupUi(this);
+
+  for (int i = 1; i < cmsys::RegularExpressionMatch::NSUBEXP; ++i) {
+    matchNumber->addItem(QString("Match %1").arg(QString::number(i)),
+                         QVariant(i));
+  }
+  matchNumber->setCurrentIndex(0);
+}
+
+void RegexExplorer::setStatusColor(QWidget* widget, bool successful)
+{
+  QColor color = successful ? QColor(0, 127, 0) : Qt::red;
+
+  QPalette palette = widget->palette();
+  palette.setColor(QPalette::Foreground, color);
+  widget->setPalette(palette);
+}
+
+void RegexExplorer::on_regularExpression_textChanged(const QString& text)
+{
+#ifdef QT_NO_STL
+  m_regex = text.toAscii().constData();
+#else
+  m_regex = text.toStdString();
+#endif
+
+  bool validExpression =
+    stripEscapes(m_regex) && m_regexParser.compile(m_regex);
+  if (!validExpression) {
+    m_regexParser.set_invalid();
+  }
+
+  setStatusColor(labelRegexValid, validExpression);
+
+  on_inputText_textChanged();
+}
+
+void RegexExplorer::on_inputText_textChanged()
+{
+  if (m_regexParser.is_valid()) {
+    QString plainText = inputText->toPlainText();
+#ifdef QT_NO_STL
+    m_text = plainText.toAscii().constData();
+#else
+    m_text = plainText.toStdString();
+#endif
+    m_matched = m_regexParser.find(m_text);
+  } else {
+    m_matched = false;
+  }
+
+  setStatusColor(labelRegexMatch, m_matched);
+
+  if (!m_matched) {
+    clearMatch();
+    return;
+  }
+
+  std::string matchingText;
+
+  if (matchAll->isChecked()) {
+    const char* p = m_text.c_str();
+    while (m_regexParser.find(p)) {
+      std::string::size_type l = m_regexParser.start();
+      std::string::size_type r = m_regexParser.end();
+      if (r - l == 0) {
+        // matched empty string
+        clearMatch();
+        return;
+      }
+      if (!matchingText.empty()) {
+        matchingText += ";";
+      }
+      matchingText += std::string(p + l, r - l);
+      p += r;
+    }
+  } else {
+    matchingText = m_regexParser.match(0);
+  }
+
+#ifdef QT_NO_STL
+  QString matchText = matchingText.c_str();
+#else
+  QString matchText = QString::fromStdString(matchingText);
+#endif
+  match0->setPlainText(matchText);
+
+  on_matchNumber_currentIndexChanged(matchNumber->currentIndex());
+}
+
+void RegexExplorer::on_matchNumber_currentIndexChanged(int index)
+{
+  if (!m_matched) {
+    return;
+  }
+
+  QVariant itemData = matchNumber->itemData(index);
+  int idx = itemData.toInt();
+
+  if (idx < 1 || idx >= cmsys::RegularExpressionMatch::NSUBEXP) {
+    return;
+  }
+
+#ifdef QT_NO_STL
+  QString match = m_regexParser.match(idx).c_str();
+#else
+  QString match = QString::fromStdString(m_regexParser.match(idx));
+#endif
+  matchN->setPlainText(match);
+}
+
+void RegexExplorer::on_matchAll_toggled(bool checked)
+{
+  Q_UNUSED(checked);
+
+  on_inputText_textChanged();
+}
+
+void RegexExplorer::clearMatch()
+{
+  m_matched = false;
+  match0->clear();
+  matchN->clear();
+}
+
+bool RegexExplorer::stripEscapes(std::string& source)
+{
+  const char* in = source.c_str();
+
+  std::string result;
+  result.reserve(source.size());
+
+  for (char inc = *in; inc != '\0'; inc = *++in) {
+    if (inc == '\\') {
+      char nextc = in[1];
+      if (nextc == 't') {
+        result.append(1, '\t');
+        in++;
+      } else if (nextc == 'n') {
+        result.append(1, '\n');
+        in++;
+      } else if (nextc == 't') {
+        result.append(1, '\t');
+        in++;
+      } else if (isalnum(nextc) || nextc == '\0') {
+        return false;
+      } else {
+        result.append(1, nextc);
+        in++;
+      }
+    } else {
+      result.append(1, inc);
+    }
+  }
+
+  source = result;
+  return true;
+}
diff --git a/Source/QtDialog/RegexExplorer.h b/Source/QtDialog/RegexExplorer.h
new file mode 100644
index 0000000..8679892
--- /dev/null
+++ b/Source/QtDialog/RegexExplorer.h
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef RegexExplorer_h
+#define RegexExplorer_h
+
+#include "cmsys/RegularExpression.hxx"
+#include <QDialog>
+#include <string>
+
+#include "ui_RegexExplorer.h"
+
+class QString;
+class QWidget;
+
+class RegexExplorer : public QDialog, public Ui::RegexExplorer
+{
+  Q_OBJECT
+public:
+  RegexExplorer(QWidget* p);
+
+private slots:
+  void on_regularExpression_textChanged(const QString& text);
+  void on_inputText_textChanged();
+  void on_matchNumber_currentIndexChanged(int index);
+  void on_matchAll_toggled(bool checked);
+
+private:
+  static void setStatusColor(QWidget* widget, bool successful);
+  static bool stripEscapes(std::string& regex);
+
+  void clearMatch();
+
+  cmsys::RegularExpression m_regexParser;
+  std::string m_text;
+  std::string m_regex;
+  bool m_matched;
+};
+
+#endif
diff --git a/Source/QtDialog/RegexExplorer.ui b/Source/QtDialog/RegexExplorer.ui
new file mode 100644
index 0000000..0af6999
--- /dev/null
+++ b/Source/QtDialog/RegexExplorer.ui
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RegexExplorer</class>
+ <widget class="QDialog" name="RegexExplorer">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>639</width>
+    <height>555</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Regular Expression Explorer</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Input Text</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QPlainTextEdit" name="inputText"/>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <item>
+      <widget class="QLabel" name="label_2">
+       <property name="text">
+        <string>Regular Expression</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_3">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeType">
+        <enum>QSizePolicy::Fixed</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLabel" name="labelRegexValid">
+       <property name="text">
+        <string>Valid</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_4">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeType">
+        <enum>QSizePolicy::Fixed</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLabel" name="labelRegexMatch">
+       <property name="text">
+        <string>Match</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_2">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QLineEdit" name="regularExpression"/>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Complete Match</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_5">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeType">
+        <enum>QSizePolicy::Fixed</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QCheckBox" name="matchAll">
+       <property name="text">
+        <string>Match All</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QPlainTextEdit" name="match0">
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QComboBox" name="matchNumber">
+       <property name="editable">
+        <bool>false</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QPlainTextEdit" name="matchN">
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Source/QtDialog/WarningMessagesDialog.cxx b/Source/QtDialog/WarningMessagesDialog.cxx
new file mode 100644
index 0000000..f608a84
--- /dev/null
+++ b/Source/QtDialog/WarningMessagesDialog.cxx
@@ -0,0 +1,86 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "WarningMessagesDialog.h"
+
+WarningMessagesDialog::WarningMessagesDialog(QWidget* prnt, QCMake* instance)
+  : QDialog(prnt)
+  , cmakeInstance(instance)
+{
+  this->setupUi(this);
+  this->setInitialValues();
+  this->setupSignals();
+}
+
+void WarningMessagesDialog::setInitialValues()
+{
+  this->suppressDeveloperWarnings->setChecked(
+    this->cmakeInstance->getSuppressDevWarnings());
+  this->suppressDeprecatedWarnings->setChecked(
+    this->cmakeInstance->getSuppressDeprecatedWarnings());
+
+  this->developerWarningsAsErrors->setChecked(
+    this->cmakeInstance->getDevWarningsAsErrors());
+  this->deprecatedWarningsAsErrors->setChecked(
+    this->cmakeInstance->getDeprecatedWarningsAsErrors());
+}
+
+void WarningMessagesDialog::setupSignals()
+{
+  QObject::connect(this->buttonBox, SIGNAL(accepted()), this,
+                   SLOT(doAccept()));
+
+  QObject::connect(this->suppressDeveloperWarnings, SIGNAL(stateChanged(int)),
+                   this, SLOT(doSuppressDeveloperWarningsChanged(int)));
+  QObject::connect(this->suppressDeprecatedWarnings, SIGNAL(stateChanged(int)),
+                   this, SLOT(doSuppressDeprecatedWarningsChanged(int)));
+
+  QObject::connect(this->developerWarningsAsErrors, SIGNAL(stateChanged(int)),
+                   this, SLOT(doDeveloperWarningsAsErrorsChanged(int)));
+  QObject::connect(this->deprecatedWarningsAsErrors, SIGNAL(stateChanged(int)),
+                   this, SLOT(doDeprecatedWarningsAsErrorsChanged(int)));
+}
+
+void WarningMessagesDialog::doAccept()
+{
+  this->cmakeInstance->setSuppressDevWarnings(
+    this->suppressDeveloperWarnings->isChecked());
+  this->cmakeInstance->setSuppressDeprecatedWarnings(
+    this->suppressDeprecatedWarnings->isChecked());
+
+  this->cmakeInstance->setDevWarningsAsErrors(
+    this->developerWarningsAsErrors->isChecked());
+  this->cmakeInstance->setDeprecatedWarningsAsErrors(
+    this->deprecatedWarningsAsErrors->isChecked());
+}
+
+void WarningMessagesDialog::doSuppressDeveloperWarningsChanged(int state)
+{
+  // no warnings implies no errors either
+  if (state) {
+    this->developerWarningsAsErrors->setChecked(false);
+  }
+}
+
+void WarningMessagesDialog::doSuppressDeprecatedWarningsChanged(int state)
+{
+  // no warnings implies no errors either
+  if (state) {
+    this->deprecatedWarningsAsErrors->setChecked(false);
+  }
+}
+
+void WarningMessagesDialog::doDeveloperWarningsAsErrorsChanged(int state)
+{
+  // warnings as errors implies warnings are not suppressed
+  if (state) {
+    this->suppressDeveloperWarnings->setChecked(false);
+  }
+}
+
+void WarningMessagesDialog::doDeprecatedWarningsAsErrorsChanged(int state)
+{
+  // warnings as errors implies warnings are not suppressed
+  if (state) {
+    this->suppressDeprecatedWarnings->setChecked(false);
+  }
+}
diff --git a/Source/QtDialog/WarningMessagesDialog.h b/Source/QtDialog/WarningMessagesDialog.h
new file mode 100644
index 0000000..acb830d
--- /dev/null
+++ b/Source/QtDialog/WarningMessagesDialog.h
@@ -0,0 +1,65 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef WarningMessagesDialog_h
+#define WarningMessagesDialog_h
+
+#include <QDialog>
+#include <QWidget>
+
+#include "QCMake.h"
+#include "ui_WarningMessagesDialog.h"
+
+/**
+ * Dialog window for setting the warning message related options.
+ */
+class WarningMessagesDialog : public QDialog, public Ui_MessagesDialog
+{
+  Q_OBJECT
+
+public:
+  WarningMessagesDialog(QWidget* prnt, QCMake* instance);
+
+private slots:
+  /**
+   * Handler for the accept event of the ok/cancel button box.
+   */
+  void doAccept();
+
+  /**
+   * Handler for checked state changed event of the suppress developer warnings
+   * checkbox.
+   */
+  void doSuppressDeveloperWarningsChanged(int state);
+  /**
+   * Handler for checked state changed event of the suppress deprecated
+   * warnings checkbox.
+   */
+  void doSuppressDeprecatedWarningsChanged(int state);
+
+  /**
+   * Handler for checked state changed event of the developer warnings as
+   * errors checkbox.
+   */
+  void doDeveloperWarningsAsErrorsChanged(int state);
+  /**
+   * Handler for checked state changed event of the deprecated warnings as
+   * errors checkbox.
+   */
+  void doDeprecatedWarningsAsErrorsChanged(int state);
+
+private:
+  QCMake* cmakeInstance;
+
+  /**
+   * Set the initial values of the widgets on this dialog window, using the
+   * current state of the cache.
+   */
+  void setInitialValues();
+
+  /**
+   * Setup the signals for the widgets on this dialog window.
+   */
+  void setupSignals();
+};
+
+#endif /* MessageDialog_h */
diff --git a/Source/QtDialog/WarningMessagesDialog.ui b/Source/QtDialog/WarningMessagesDialog.ui
new file mode 100644
index 0000000..3b35cbc
--- /dev/null
+++ b/Source/QtDialog/WarningMessagesDialog.ui
@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MessagesDialog</class>
+ <widget class="QDialog" name="MessagesDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>300</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Warning Messages</string>
+  </property>
+  <property name="modal">
+   <bool>true</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title">
+      <string>Suppress Warnings</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QCheckBox" name="suppressDeveloperWarnings">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="toolTip">
+         <string>Suppress developer (author) warnings.</string>
+        </property>
+        <property name="text">
+         <string>Developer Warnings</string>
+        </property>
+        <property name="tristate">
+         <bool>false</bool>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QCheckBox" name="suppressDeprecatedWarnings">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="toolTip">
+         <string>Suppress deprecated warnings.</string>
+        </property>
+        <property name="text">
+         <string>Deprecated Warnings</string>
+        </property>
+        <property name="tristate">
+         <bool>false</bool>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title">
+      <string>Warnings as Errors</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_3">
+      <item>
+       <widget class="QCheckBox" name="developerWarningsAsErrors">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="toolTip">
+         <string>Treat developer (author) warnings as errors.</string>
+        </property>
+        <property name="text">
+         <string>Developer Warnings as Errors</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QCheckBox" name="deprecatedWarningsAsErrors">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="toolTip">
+         <string>Treat deprecated warnings as errors.</string>
+        </property>
+        <property name="text">
+         <string>Deprecated Warnings as Errors</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>MessagesDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>MessagesDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/Source/QtDialog/cmake-gui.desktop b/Source/QtDialog/cmake-gui.desktop
new file mode 100644
index 0000000..842091f
--- /dev/null
+++ b/Source/QtDialog/cmake-gui.desktop
@@ -0,0 +1,12 @@
+[Desktop Entry]
+Version=1.0
+Name=CMake
+Comment=Cross-platform buildsystem
+Exec=cmake-gui %f
+Icon=CMakeSetup
+Terminal=false
+X-MultipleArgs=false
+Type=Application
+Categories=Development;
+StartupNotify=true
+MimeType=application/x-cmakecache;
diff --git a/Source/QtDialog/cmakecache.xml b/Source/QtDialog/cmakecache.xml
new file mode 100644
index 0000000..a13b5b1
--- /dev/null
+++ b/Source/QtDialog/cmakecache.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
+  <mime-type type="application/x-cmakecache">
+    <comment>CMake cache file</comment>
+    <glob pattern="CMakeCache.txt"/>
+    <sub-class-of type="text/plain"/>
+  </mime-type>
+</mime-info>
diff --git a/Source/QtIFW/CMake.DeveloperReference.HTML.qs.in b/Source/QtIFW/CMake.DeveloperReference.HTML.qs.in
new file mode 100644
index 0000000..8cc5835
--- /dev/null
+++ b/Source/QtIFW/CMake.DeveloperReference.HTML.qs.in
@@ -0,0 +1,21 @@
+// Component: CMake.Reference.DoxygenHTML
+
+function Component()
+{
+    // Default constructor
+}
+
+Component.prototype.createOperations = function()
+{
+    // Create shortcut
+    if (installer.value("os") === "win") {
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/%CMAKE_DOC_DIR%/developer-reference/html/index.html",
+                               "@StartMenuDir@/CMake Developer Reference.lnk");
+
+    }
+
+    // Call default implementation
+    component.createOperations();
+}
diff --git a/Source/QtIFW/CMake.Dialogs.QtGUI.qs.in b/Source/QtIFW/CMake.Dialogs.QtGUI.qs.in
new file mode 100644
index 0000000..71f395a
--- /dev/null
+++ b/Source/QtIFW/CMake.Dialogs.QtGUI.qs.in
@@ -0,0 +1,21 @@
+// Component: CMake.Dialogs.QtGUI
+
+function Component()
+{
+    // Default constructor
+}
+
+Component.prototype.createOperations = function()
+{
+    // Create shortcut
+    if (installer.value("os") === "win") {
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/%CMAKE_BIN_DIR%/cmake-gui.exe",
+                               "@StartMenuDir@/CMake (cmake-gui).lnk");
+
+    }
+
+    // Call default implementation
+    component.createOperations();
+}
diff --git a/Source/QtIFW/CMake.Documentation.SphinxHTML.qs.in b/Source/QtIFW/CMake.Documentation.SphinxHTML.qs.in
new file mode 100644
index 0000000..54bc14a
--- /dev/null
+++ b/Source/QtIFW/CMake.Documentation.SphinxHTML.qs.in
@@ -0,0 +1,21 @@
+// Component: CMake.Documentation.SphinxHTML
+
+function Component()
+{
+    // Default constructor
+}
+
+Component.prototype.createOperations = function()
+{
+    // Create shortcut
+    if (installer.value("os") === "win") {
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/%CMAKE_DOC_DIR%/html/index.html",
+                               "@StartMenuDir@/CMake Documentation.lnk");
+
+    }
+
+    // Call default implementation
+    component.createOperations();
+}
diff --git a/Source/QtIFW/CMake.qs.in b/Source/QtIFW/CMake.qs.in
new file mode 100644
index 0000000..1f3166e
--- /dev/null
+++ b/Source/QtIFW/CMake.qs.in
@@ -0,0 +1,24 @@
+// Component: CMake
+
+function Component()
+{
+    // Default constructor
+}
+
+Component.prototype.createOperations = function()
+{
+    // Create shortcut
+    if (installer.value("os") === "win") {
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/%CMAKE_DOC_DIR%/cmake.org.html",
+                               "@StartMenuDir@/CMake Web Site.lnk");
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/cmake-maintenance.exe",
+                               "@StartMenuDir@/CMake Maintenance Tool.lnk");
+    }
+
+    // Call default implementation
+    component.createOperations();
+}
diff --git a/Source/QtIFW/cmake.org.html b/Source/QtIFW/cmake.org.html
new file mode 100644
index 0000000..001d634
--- /dev/null
+++ b/Source/QtIFW/cmake.org.html
@@ -0,0 +1,7 @@
+<html>
+<head>
+<meta http-equiv="Refresh" content="0; url=https://cmake.org/" />
+</head>
+<body>
+</body>
+</html>
diff --git a/Source/QtIFW/controlscript.qs b/Source/QtIFW/controlscript.qs
new file mode 100644
index 0000000..d1a9b10
--- /dev/null
+++ b/Source/QtIFW/controlscript.qs
@@ -0,0 +1,6 @@
+// controlscript.qs - CMake installation control script
+
+function Controller()
+{
+  // do nothing now
+}
diff --git a/Source/QtIFW/installscript.qs.in b/Source/QtIFW/installscript.qs.in
new file mode 100644
index 0000000..72d49e8
--- /dev/null
+++ b/Source/QtIFW/installscript.qs.in
@@ -0,0 +1,27 @@
+// Component: CMake
+
+function Component()
+{
+    // Do not show component selection page
+    installer.setDefaultPageVisible(QInstaller.ComponentSelection, false);
+}
+
+Component.prototype.createOperations = function()
+{
+    // Create shortcut
+    if (installer.value("os") === "win") {
+
+%_CPACK_IFW_SHORTCUT_OPTIONAL%
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/%CMAKE_DOC_DIR%/cmake.org.html",
+                               "@StartMenuDir@/CMake Web Site.lnk");
+
+        component.addOperation("CreateShortcut",
+                               "@TargetDir@/cmake-maintenance.exe",
+                               "@StartMenuDir@/CMake Maintenance Tool.lnk");
+    }
+
+    // Call default implementation
+    component.createOperations();
+}
diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx
new file mode 100644
index 0000000..9ec9624
--- /dev/null
+++ b/Source/bindexplib.cxx
@@ -0,0 +1,420 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*-------------------------------------------------------------------------
+  Portions of this source have been derived from the 'bindexplib' tool
+  provided by the CERN ROOT Data Analysis Framework project (root.cern.ch).
+  Permission has been granted by Pere Mato <pere.mato@cern.ch> to distribute
+  this derived work under the CMake license.
+-------------------------------------------------------------------------*/
+
+/*
+*----------------------------------------------------------------------
+* Program:  dumpexts.exe
+* Author:   Gordon Chaffee
+*
+* History:  The real functionality of this file was written by
+*           Matt Pietrek in 1993 in his pedump utility.  I've
+*           modified it to dump the externals in a bunch of object
+*           files to create a .def file.
+*
+* Notes:    Visual C++ puts an underscore before each exported symbol.
+*           This file removes them.  I don't know if this is a problem
+*           this other compilers.  If _MSC_VER is defined,
+*           the underscore is removed.  If not, it isn't.  To get a
+*           full dump of an object file, use the -f option.  This can
+*           help determine the something that may be different with a
+*           compiler other than Visual C++.
+*   ======================================
+* Corrections (Axel 2006-04-04):
+*   Conversion to C++. Mostly.
+*
+ * Extension (Axel 2006-03-15)
+ *    As soon as an object file contains an /EXPORT directive (which
+ *    is generated by the compiler when a symbol is declared as
+ *    __declspec(dllexport) no to-be-exported symbols are printed,
+ *    as the linker will see these directives, and if those directives
+ *    are present we only export selectively (i.e. we trust the
+ *    programmer).
+ *
+ *   ======================================
+*   ======================================
+* Corrections (Valery Fine 23/02/98):
+*
+*           The "(vector) deleting destructor" MUST not be exported
+*           To recognize it the following test are introduced:
+*  "@@UAEPAXI@Z"  scalar deleting dtor
+*  "@@QAEPAXI@Z"  vector deleting dtor
+*  "AEPAXI@Z"     vector deleting dtor with thunk adjustor
+*   ======================================
+* Corrections (Valery Fine 12/02/97):
+*
+*    It created a wrong EXPORTS for the global pointers and constants.
+*    The Section Header has been involved to discover the missing information
+*    Now the pointers are correctly supplied with "DATA" descriptor
+*        the constants  with no extra descriptor.
+*
+* Corrections (Valery Fine 16/09/96):
+*
+*     It didn't work for C++ code with global variables and class definitions
+*     The DumpExternalObject function has been introduced to generate .DEF file
+*
+* Author:   Valery Fine 16/09/96  (E-mail: fine@vxcern.cern.ch)
+*----------------------------------------------------------------------
+*/
+#include "bindexplib.h"
+
+#include "cmsys/Encoding.hxx"
+#include "cmsys/FStream.hxx"
+#include <iostream>
+#include <windows.h>
+
+#ifndef IMAGE_FILE_MACHINE_ARM
+#define IMAGE_FILE_MACHINE_ARM 0x01c0 // ARM Little-Endian
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_THUMB
+#define IMAGE_FILE_MACHINE_THUMB 0x01c2 // ARM Thumb/Thumb-2 Little-Endian
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_ARMNT
+#define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_ARM64
+#define IMAGE_FILE_MACHINE_ARM64 0xaa64 // ARM64 Little-Endian
+#endif
+
+typedef struct cmANON_OBJECT_HEADER_BIGOBJ
+{
+  /* same as ANON_OBJECT_HEADER_V2 */
+  WORD Sig1;    // Must be IMAGE_FILE_MACHINE_UNKNOWN
+  WORD Sig2;    // Must be 0xffff
+  WORD Version; // >= 2 (implies the Flags field is present)
+  WORD Machine; // Actual machine - IMAGE_FILE_MACHINE_xxx
+  DWORD TimeDateStamp;
+  CLSID ClassID;        // {D1BAA1C7-BAEE-4ba9-AF20-FAF66AA4DCB8}
+  DWORD SizeOfData;     // Size of data that follows the header
+  DWORD Flags;          // 0x1 -> contains metadata
+  DWORD MetaDataSize;   // Size of CLR metadata
+  DWORD MetaDataOffset; // Offset of CLR metadata
+
+  /* bigobj specifics */
+  DWORD NumberOfSections; // extended from WORD
+  DWORD PointerToSymbolTable;
+  DWORD NumberOfSymbols;
+} cmANON_OBJECT_HEADER_BIGOBJ;
+
+typedef struct _cmIMAGE_SYMBOL_EX
+{
+  union
+  {
+    BYTE ShortName[8];
+    struct
+    {
+      DWORD Short; // if 0, use LongName
+      DWORD Long;  // offset into string table
+    } Name;
+    DWORD LongName[2]; // PBYTE  [2]
+  } N;
+  DWORD Value;
+  LONG SectionNumber;
+  WORD Type;
+  BYTE StorageClass;
+  BYTE NumberOfAuxSymbols;
+} cmIMAGE_SYMBOL_EX;
+typedef cmIMAGE_SYMBOL_EX UNALIGNED* cmPIMAGE_SYMBOL_EX;
+
+PIMAGE_SECTION_HEADER GetSectionHeaderOffset(
+  PIMAGE_FILE_HEADER pImageFileHeader)
+{
+  return (PIMAGE_SECTION_HEADER)((DWORD_PTR)pImageFileHeader +
+                                 IMAGE_SIZEOF_FILE_HEADER +
+                                 pImageFileHeader->SizeOfOptionalHeader);
+}
+
+PIMAGE_SECTION_HEADER GetSectionHeaderOffset(
+  cmANON_OBJECT_HEADER_BIGOBJ* pImageFileHeader)
+{
+  return (PIMAGE_SECTION_HEADER)((DWORD_PTR)pImageFileHeader +
+                                 sizeof(cmANON_OBJECT_HEADER_BIGOBJ));
+}
+
+/*
++ * Utility func, strstr with size
++ */
+const char* StrNStr(const char* start, const char* find, size_t& size)
+{
+  size_t len;
+  const char* hint;
+
+  if (!start || !find || !size) {
+    size = 0;
+    return 0;
+  }
+  len = strlen(find);
+
+  while ((hint = (const char*)memchr(start, find[0], size - len + 1))) {
+    size -= (hint - start);
+    if (!strncmp(hint, find, len))
+      return hint;
+    start = hint + 1;
+  }
+
+  size = 0;
+  return 0;
+}
+
+template <
+  // cmANON_OBJECT_HEADER_BIGOBJ or IMAGE_FILE_HEADER
+  class ObjectHeaderType,
+  // cmPIMAGE_SYMBOL_EX or PIMAGE_SYMBOL
+  class SymbolTableType>
+class DumpSymbols
+{
+public:
+  /*
+   *----------------------------------------------------------------------
+   * Constructor --
+   *
+   *     Initialize variables from pointer to object header.
+   *
+   *----------------------------------------------------------------------
+   */
+
+  DumpSymbols(ObjectHeaderType* ih, std::set<std::string>& symbols,
+              std::set<std::string>& dataSymbols, bool isI386)
+    : Symbols(symbols)
+    , DataSymbols(dataSymbols)
+  {
+    this->ObjectImageHeader = ih;
+    this->SymbolTable =
+      (SymbolTableType*)((DWORD_PTR) this->ObjectImageHeader +
+                         this->ObjectImageHeader->PointerToSymbolTable);
+    this->SectionHeaders = GetSectionHeaderOffset(this->ObjectImageHeader);
+    this->SymbolCount = this->ObjectImageHeader->NumberOfSymbols;
+    this->IsI386 = isI386;
+  }
+
+  /*
+   *----------------------------------------------------------------------
+   * DumpObjFile --
+   *
+   *      Dump an object file's exported symbols.
+   *----------------------------------------------------------------------
+   */
+  void DumpObjFile() { this->DumpExternalsObjects(); }
+
+  /*
+   *----------------------------------------------------------------------
+   * DumpExternalsObjects --
+   *
+   *      Dumps a COFF symbol table from an OBJ.
+   *----------------------------------------------------------------------
+   */
+  void DumpExternalsObjects()
+  {
+    unsigned i;
+    PSTR stringTable;
+    std::string symbol;
+    DWORD SectChar;
+    /*
+     * The string table apparently starts right after the symbol table
+     */
+    stringTable = (PSTR) & this->SymbolTable[this->SymbolCount];
+    SymbolTableType* pSymbolTable = this->SymbolTable;
+    for (i = 0; i < this->SymbolCount; i++) {
+      if (pSymbolTable->SectionNumber > 0 &&
+          (pSymbolTable->Type == 0x20 || pSymbolTable->Type == 0x0)) {
+        if (pSymbolTable->StorageClass == IMAGE_SYM_CLASS_EXTERNAL) {
+          /*
+          *    The name of the Function entry points
+          */
+          if (pSymbolTable->N.Name.Short != 0) {
+            symbol.clear();
+            symbol.insert(0, (const char*)pSymbolTable->N.ShortName, 8);
+          } else {
+            symbol = stringTable + pSymbolTable->N.Name.Long;
+          }
+
+          // clear out any leading spaces
+          while (isspace(symbol[0]))
+            symbol.erase(0, 1);
+          // if it starts with _ and has an @ then it is a __cdecl
+          // so remove the @ stuff for the export
+          if (symbol[0] == '_') {
+            std::string::size_type posAt = symbol.find('@');
+            if (posAt != std::string::npos) {
+              symbol.erase(posAt);
+            }
+          }
+          // For i386 builds we need to remove _
+          if (this->IsI386 && symbol[0] == '_') {
+            symbol.erase(0, 1);
+          }
+
+          // Check whether it is "Scalar deleting destructor" and "Vector
+          // deleting destructor"
+          // if scalarPrefix and vectorPrefix are not found then print
+          // the symbol
+          const char* scalarPrefix = "??_G";
+          const char* vectorPrefix = "??_E";
+          // The original code had a check for
+          //     symbol.find("real@") == std::string::npos)
+          // but this disallows member functions with the name "real".
+          if (symbol.compare(0, 4, scalarPrefix) &&
+              symbol.compare(0, 4, vectorPrefix)) {
+            SectChar = this->SectionHeaders[pSymbolTable->SectionNumber - 1]
+                         .Characteristics;
+            // skip symbols containing a dot
+            if (symbol.find('.') == std::string::npos) {
+              if (!pSymbolTable->Type && (SectChar & IMAGE_SCN_MEM_WRITE)) {
+                // Read only (i.e. constants) must be excluded
+                this->DataSymbols.insert(symbol);
+              } else {
+                if (pSymbolTable->Type || !(SectChar & IMAGE_SCN_MEM_READ) ||
+                    (SectChar & IMAGE_SCN_MEM_EXECUTE)) {
+                  this->Symbols.insert(symbol);
+                }
+              }
+            }
+          }
+        }
+      }
+
+      /*
+      * Take into account any aux symbols
+      */
+      i += pSymbolTable->NumberOfAuxSymbols;
+      pSymbolTable += pSymbolTable->NumberOfAuxSymbols;
+      pSymbolTable++;
+    }
+  }
+
+private:
+  std::set<std::string>& Symbols;
+  std::set<std::string>& DataSymbols;
+  DWORD_PTR SymbolCount;
+  PIMAGE_SECTION_HEADER SectionHeaders;
+  ObjectHeaderType* ObjectImageHeader;
+  SymbolTableType* SymbolTable;
+  bool IsI386;
+};
+
+bool DumpFile(const char* filename, std::set<std::string>& symbols,
+              std::set<std::string>& dataSymbols)
+{
+  HANDLE hFile;
+  HANDLE hFileMapping;
+  LPVOID lpFileBase;
+
+  hFile = CreateFileW(cmsys::Encoding::ToWide(filename).c_str(), GENERIC_READ,
+                      FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                      FILE_ATTRIBUTE_NORMAL, 0);
+
+  if (hFile == INVALID_HANDLE_VALUE) {
+    fprintf(stderr, "Couldn't open file '%s' with CreateFile()\n", filename);
+    return false;
+  }
+
+  hFileMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
+  if (hFileMapping == 0) {
+    CloseHandle(hFile);
+    fprintf(stderr, "Couldn't open file mapping with CreateFileMapping()\n");
+    return false;
+  }
+
+  lpFileBase = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
+  if (lpFileBase == 0) {
+    CloseHandle(hFileMapping);
+    CloseHandle(hFile);
+    fprintf(stderr, "Couldn't map view of file with MapViewOfFile()\n");
+    return false;
+  }
+
+  const PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)lpFileBase;
+  if (dosHeader->e_magic == IMAGE_DOS_SIGNATURE) {
+    fprintf(stderr, "File is an executable.  I don't dump those.\n");
+    return false;
+  } else {
+    const PIMAGE_FILE_HEADER imageHeader = (PIMAGE_FILE_HEADER)lpFileBase;
+    /* Does it look like a COFF OBJ file??? */
+    if (((imageHeader->Machine == IMAGE_FILE_MACHINE_I386) ||
+         (imageHeader->Machine == IMAGE_FILE_MACHINE_AMD64) ||
+         (imageHeader->Machine == IMAGE_FILE_MACHINE_ARM) ||
+         (imageHeader->Machine == IMAGE_FILE_MACHINE_ARMNT) ||
+         (imageHeader->Machine == IMAGE_FILE_MACHINE_ARM64)) &&
+        (imageHeader->Characteristics == 0)) {
+      /*
+      * The tests above are checking for IMAGE_FILE_HEADER.Machine
+      * if it contains supported machine formats (currently ARM and x86)
+      * and IMAGE_FILE_HEADER.Characteristics == 0 indicating that
+      * this is not linked COFF OBJ file;
+      */
+      DumpSymbols<IMAGE_FILE_HEADER, IMAGE_SYMBOL> symbolDumper(
+        (PIMAGE_FILE_HEADER)lpFileBase, symbols, dataSymbols,
+        (imageHeader->Machine == IMAGE_FILE_MACHINE_I386));
+      symbolDumper.DumpObjFile();
+    } else {
+      // check for /bigobj format
+      cmANON_OBJECT_HEADER_BIGOBJ* h =
+        (cmANON_OBJECT_HEADER_BIGOBJ*)lpFileBase;
+      if (h->Sig1 == 0x0 && h->Sig2 == 0xffff) {
+        DumpSymbols<cmANON_OBJECT_HEADER_BIGOBJ, cmIMAGE_SYMBOL_EX>
+        symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*)lpFileBase, symbols,
+                     dataSymbols, (h->Machine == IMAGE_FILE_MACHINE_I386));
+        symbolDumper.DumpObjFile();
+      } else {
+        printf("unrecognized file format in '%s'\n", filename);
+        return false;
+      }
+    }
+  }
+  UnmapViewOfFile(lpFileBase);
+  CloseHandle(hFileMapping);
+  CloseHandle(hFile);
+  return true;
+}
+
+bool bindexplib::AddObjectFile(const char* filename)
+{
+  return DumpFile(filename, this->Symbols, this->DataSymbols);
+}
+
+bool bindexplib::AddDefinitionFile(const char* filename)
+{
+  cmsys::ifstream infile(filename);
+  if (!infile) {
+    fprintf(stderr, "Couldn't open definition file '%s'\n", filename);
+    return false;
+  }
+  std::string str;
+  while (std::getline(infile, str)) {
+    // skip the LIBRAY and EXPORTS lines (if any)
+    if ((str.compare(0, 7, "LIBRARY") == 0) ||
+        (str.compare(0, 7, "EXPORTS") == 0)) {
+      continue;
+    }
+    // remove leading tabs & spaces
+    str.erase(0, str.find_first_not_of(" \t"));
+    std::size_t found = str.find(" \t DATA");
+    if (found != std::string::npos) {
+      str.erase(found, std::string::npos);
+      this->DataSymbols.insert(str);
+    } else {
+      this->Symbols.insert(str);
+    }
+  }
+  infile.close();
+  return true;
+}
+
+void bindexplib::WriteFile(FILE* file)
+{
+  fprintf(file, "EXPORTS \n");
+  for (std::string const& ds : this->DataSymbols) {
+    fprintf(file, "\t%s \t DATA\n", ds.c_str());
+  }
+  for (std::string const& s : this->Symbols) {
+    fprintf(file, "\t%s\n", s.c_str());
+  }
+}
diff --git a/Source/bindexplib.h b/Source/bindexplib.h
new file mode 100644
index 0000000..3e22ac7
--- /dev/null
+++ b/Source/bindexplib.h
@@ -0,0 +1,24 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef bindexplib_h
+#define bindexplib_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <set>
+#include <stdio.h>
+#include <string>
+
+class bindexplib
+{
+public:
+  bindexplib() {}
+  bool AddDefinitionFile(const char* filename);
+  bool AddObjectFile(const char* filename);
+  void WriteFile(FILE* file);
+
+private:
+  std::set<std::string> Symbols;
+  std::set<std::string> DataSymbols;
+};
+#endif
diff --git a/Source/cmAddCompileOptionsCommand.cxx b/Source/cmAddCompileOptionsCommand.cxx
new file mode 100644
index 0000000..c37fd9a
--- /dev/null
+++ b/Source/cmAddCompileOptionsCommand.cxx
@@ -0,0 +1,20 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddCompileOptionsCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+
+bool cmAddCompileOptionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.empty()) {
+    return true;
+  }
+
+  for (std::string const& i : args) {
+    this->Makefile->AddCompileOption(i.c_str());
+  }
+  return true;
+}
diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h
new file mode 100644
index 0000000..3d53d09
--- /dev/null
+++ b/Source/cmAddCompileOptionsCommand.h
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddCompileOptionsCommand_h
+#define cmAddCompileOptionsCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+class cmAddCompileOptionsCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddCompileOptionsCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx
new file mode 100644
index 0000000..7fed52d
--- /dev/null
+++ b/Source/cmAddCustomCommandCommand.cxx
@@ -0,0 +1,378 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddCustomCommandCommand.h"
+
+#include <sstream>
+
+#include "cmCustomCommand.h"
+#include "cmCustomCommandLines.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmSourceFile.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmAddCustomCommandCommand
+bool cmAddCustomCommandCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  /* Let's complain at the end of this function about the lack of a particular
+     arg. For the moment, let's say that COMMAND, and either TARGET or SOURCE
+     are required.
+  */
+  if (args.size() < 4) {
+    this->SetError("called with wrong number of arguments.");
+    return false;
+  }
+
+  std::string source, target, main_dependency, working, depfile;
+  std::string comment_buffer;
+  const char* comment = nullptr;
+  std::vector<std::string> depends, outputs, output, byproducts;
+  bool verbatim = false;
+  bool append = false;
+  bool uses_terminal = false;
+  bool command_expand_lists = false;
+  std::string implicit_depends_lang;
+  cmCustomCommand::ImplicitDependsList implicit_depends;
+
+  // Accumulate one command line at a time.
+  cmCustomCommandLine currentLine;
+
+  // Save all command lines.
+  cmCustomCommandLines commandLines;
+
+  cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
+
+  enum tdoing
+  {
+    doing_source,
+    doing_command,
+    doing_target,
+    doing_depends,
+    doing_implicit_depends_lang,
+    doing_implicit_depends_file,
+    doing_main_dependency,
+    doing_output,
+    doing_outputs,
+    doing_byproducts,
+    doing_comment,
+    doing_working_directory,
+    doing_depfile,
+    doing_nothing
+  };
+
+  tdoing doing = doing_nothing;
+
+  for (std::string const& copy : args) {
+    if (copy == "SOURCE") {
+      doing = doing_source;
+    } else if (copy == "COMMAND") {
+      doing = doing_command;
+
+      // Save the current command before starting the next command.
+      if (!currentLine.empty()) {
+        commandLines.push_back(currentLine);
+        currentLine.clear();
+      }
+    } else if (copy == "PRE_BUILD") {
+      cctype = cmTarget::PRE_BUILD;
+    } else if (copy == "PRE_LINK") {
+      cctype = cmTarget::PRE_LINK;
+    } else if (copy == "POST_BUILD") {
+      cctype = cmTarget::POST_BUILD;
+    } else if (copy == "VERBATIM") {
+      verbatim = true;
+    } else if (copy == "APPEND") {
+      append = true;
+    } else if (copy == "USES_TERMINAL") {
+      uses_terminal = true;
+    } else if (copy == "COMMAND_EXPAND_LISTS") {
+      command_expand_lists = true;
+    } else if (copy == "TARGET") {
+      doing = doing_target;
+    } else if (copy == "ARGS") {
+      // Ignore this old keyword.
+    } else if (copy == "DEPENDS") {
+      doing = doing_depends;
+    } else if (copy == "OUTPUTS") {
+      doing = doing_outputs;
+    } else if (copy == "OUTPUT") {
+      doing = doing_output;
+    } else if (copy == "BYPRODUCTS") {
+      doing = doing_byproducts;
+    } else if (copy == "WORKING_DIRECTORY") {
+      doing = doing_working_directory;
+    } else if (copy == "MAIN_DEPENDENCY") {
+      doing = doing_main_dependency;
+    } else if (copy == "IMPLICIT_DEPENDS") {
+      doing = doing_implicit_depends_lang;
+    } else if (copy == "COMMENT") {
+      doing = doing_comment;
+    } else if (copy == "DEPFILE") {
+      doing = doing_depfile;
+      if (this->Makefile->GetGlobalGenerator()->GetName() != "Ninja") {
+        this->SetError("Option DEPFILE not supported by " +
+                       this->Makefile->GetGlobalGenerator()->GetName());
+        return false;
+      }
+    } else {
+      std::string filename;
+      switch (doing) {
+        case doing_output:
+        case doing_outputs:
+        case doing_byproducts:
+          if (!cmSystemTools::FileIsFullPath(copy.c_str())) {
+            // This is an output to be generated, so it should be
+            // under the build tree.  CMake 2.4 placed this under the
+            // source tree.  However the only case that this change
+            // will break is when someone writes
+            //
+            //   add_custom_command(OUTPUT out.txt ...)
+            //
+            // and later references "${CMAKE_CURRENT_SOURCE_DIR}/out.txt".
+            // This is fairly obscure so we can wait for someone to
+            // complain.
+            filename = this->Makefile->GetCurrentBinaryDirectory();
+            filename += "/";
+          }
+          filename += copy;
+          cmSystemTools::ConvertToUnixSlashes(filename);
+          break;
+        case doing_source:
+        // We do not want to convert the argument to SOURCE because
+        // that option is only available for backward compatibility.
+        // Old-style use of this command may use the SOURCE==TARGET
+        // trick which we must preserve.  If we convert the source
+        // to a full path then it will no longer equal the target.
+        default:
+          break;
+      }
+
+      if (cmSystemTools::FileIsFullPath(filename.c_str())) {
+        filename = cmSystemTools::CollapseFullPath(filename);
+      }
+      switch (doing) {
+        case doing_depfile:
+          depfile = copy;
+          break;
+        case doing_working_directory:
+          working = copy;
+          break;
+        case doing_source:
+          source = copy;
+          break;
+        case doing_output:
+          output.push_back(filename);
+          break;
+        case doing_main_dependency:
+          main_dependency = copy;
+          break;
+        case doing_implicit_depends_lang:
+          implicit_depends_lang = copy;
+          doing = doing_implicit_depends_file;
+          break;
+        case doing_implicit_depends_file: {
+          // An implicit dependency starting point is also an
+          // explicit dependency.
+          std::string dep = copy;
+          cmSystemTools::ConvertToUnixSlashes(dep);
+          depends.push_back(dep);
+
+          // Add the implicit dependency language and file.
+          cmCustomCommand::ImplicitDependsPair entry(implicit_depends_lang,
+                                                     dep);
+          implicit_depends.push_back(entry);
+
+          // Switch back to looking for a language.
+          doing = doing_implicit_depends_lang;
+        } break;
+        case doing_command:
+          currentLine.push_back(copy);
+          break;
+        case doing_target:
+          target = copy;
+          break;
+        case doing_depends: {
+          std::string dep = copy;
+          cmSystemTools::ConvertToUnixSlashes(dep);
+          depends.push_back(dep);
+        } break;
+        case doing_outputs:
+          outputs.push_back(filename);
+          break;
+        case doing_byproducts:
+          byproducts.push_back(filename);
+          break;
+        case doing_comment:
+          comment_buffer = copy;
+          comment = comment_buffer.c_str();
+          break;
+        default:
+          this->SetError("Wrong syntax. Unknown type of argument.");
+          return false;
+      }
+    }
+  }
+
+  // Store the last command line finished.
+  if (!currentLine.empty()) {
+    commandLines.push_back(currentLine);
+    currentLine.clear();
+  }
+
+  // At this point we could complain about the lack of arguments.  For
+  // the moment, let's say that COMMAND, TARGET are always required.
+  if (output.empty() && target.empty()) {
+    this->SetError("Wrong syntax. A TARGET or OUTPUT must be specified.");
+    return false;
+  }
+
+  if (source.empty() && !target.empty() && !output.empty()) {
+    this->SetError(
+      "Wrong syntax. A TARGET and OUTPUT can not both be specified.");
+    return false;
+  }
+  if (append && output.empty()) {
+    this->SetError("given APPEND option with no OUTPUT.");
+    return false;
+  }
+
+  // Make sure the output names and locations are safe.
+  if (!this->CheckOutputs(output) || !this->CheckOutputs(outputs) ||
+      !this->CheckOutputs(byproducts)) {
+    return false;
+  }
+
+  // Check for an append request.
+  if (append) {
+    // Lookup an existing command.
+    if (cmSourceFile* sf =
+          this->Makefile->GetSourceFileWithOutput(output[0])) {
+      if (cmCustomCommand* cc = sf->GetCustomCommand()) {
+        cc->AppendCommands(commandLines);
+        cc->AppendDepends(depends);
+        cc->AppendImplicitDepends(implicit_depends);
+        return true;
+      }
+    }
+
+    // No command for this output exists.
+    std::ostringstream e;
+    e << "given APPEND option with output\n\"" << output[0]
+      << "\"\nwhich is not already a custom command output.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Convert working directory to a full path.
+  if (!working.empty()) {
+    const char* build_dir = this->Makefile->GetCurrentBinaryDirectory();
+    working = cmSystemTools::CollapseFullPath(working, build_dir);
+  }
+
+  // Choose which mode of the command to use.
+  bool escapeOldStyle = !verbatim;
+  if (source.empty() && output.empty()) {
+    // Source is empty, use the target.
+    std::vector<std::string> no_depends;
+    this->Makefile->AddCustomCommandToTarget(
+      target, byproducts, no_depends, commandLines, cctype, comment,
+      working.c_str(), escapeOldStyle, uses_terminal, depfile,
+      command_expand_lists);
+  } else if (target.empty()) {
+    // Target is empty, use the output.
+    this->Makefile->AddCustomCommandToOutput(
+      output, byproducts, depends, main_dependency, commandLines, comment,
+      working.c_str(), false, escapeOldStyle, uses_terminal,
+      command_expand_lists, depfile);
+
+    // Add implicit dependency scanning requests if any were given.
+    if (!implicit_depends.empty()) {
+      bool okay = false;
+      if (cmSourceFile* sf =
+            this->Makefile->GetSourceFileWithOutput(output[0])) {
+        if (cmCustomCommand* cc = sf->GetCustomCommand()) {
+          okay = true;
+          cc->SetImplicitDepends(implicit_depends);
+        }
+      }
+      if (!okay) {
+        std::ostringstream e;
+        e << "could not locate source file with a custom command producing \""
+          << output[0] << "\" even though this command tried to create it!";
+        this->SetError(e.str());
+        return false;
+      }
+    }
+  } else if (!byproducts.empty()) {
+    this->SetError("BYPRODUCTS may not be specified with SOURCE signatures");
+    return false;
+  } else if (uses_terminal) {
+    this->SetError("USES_TERMINAL may not be used with SOURCE signatures");
+    return false;
+  } else {
+    bool issueMessage = true;
+    std::ostringstream e;
+    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0050)) {
+      case cmPolicies::WARN:
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0050) << "\n";
+        break;
+      case cmPolicies::OLD:
+        issueMessage = false;
+        break;
+      case cmPolicies::REQUIRED_ALWAYS:
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::NEW:
+        messageType = cmake::FATAL_ERROR;
+        break;
+    }
+
+    if (issueMessage) {
+      e << "The SOURCE signatures of add_custom_command are no longer "
+           "supported.";
+      this->Makefile->IssueMessage(messageType, e.str());
+      if (messageType == cmake::FATAL_ERROR) {
+        return false;
+      }
+    }
+
+    // Use the old-style mode for backward compatibility.
+    this->Makefile->AddCustomCommandOldStyle(target, outputs, depends, source,
+                                             commandLines, comment);
+  }
+
+  return true;
+}
+
+bool cmAddCustomCommandCommand::CheckOutputs(
+  const std::vector<std::string>& outputs)
+{
+  for (std::string const& o : outputs) {
+    // Make sure the file will not be generated into the source
+    // directory during an out of source build.
+    if (!this->Makefile->CanIWriteThisFile(o.c_str())) {
+      std::string e = "attempted to have a file \"" + o +
+        "\" in a source directory as an output of custom command.";
+      this->SetError(e);
+      cmSystemTools::SetFatalErrorOccured();
+      return false;
+    }
+
+    // Make sure the output file name has no invalid characters.
+    std::string::size_type pos = o.find_first_of("#<>");
+    if (pos != std::string::npos) {
+      std::ostringstream msg;
+      msg << "called with OUTPUT containing a \"" << o[pos]
+          << "\".  This character is not allowed.";
+      this->SetError(msg.str());
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h
new file mode 100644
index 0000000..6af4f10
--- /dev/null
+++ b/Source/cmAddCustomCommandCommand.h
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddCustomCommandCommand_h
+#define cmAddCustomCommandCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddCustomCommandCommand
+ * \brief cmAddCustomCommandCommand defines a new command (rule) that can
+ *  be executed within the build process
+ *
+ */
+
+class cmAddCustomCommandCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddCustomCommandCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+protected:
+  bool CheckOutputs(const std::vector<std::string>& outputs);
+};
+
+#endif
diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx
new file mode 100644
index 0000000..819c781
--- /dev/null
+++ b/Source/cmAddCustomTargetCommand.cxx
@@ -0,0 +1,220 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddCustomTargetCommand.h"
+
+#include <sstream>
+
+#include "cmCustomCommandLines.h"
+#include "cmGeneratorExpression.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmAddCustomTargetCommand
+bool cmAddCustomTargetCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  std::string const& targetName = args[0];
+
+  // Check the target name.
+  if (targetName.find_first_of("/\\") != std::string::npos) {
+    std::ostringstream e;
+    e << "called with invalid target name \"" << targetName
+      << "\".  Target names may not contain a slash.  "
+      << "Use ADD_CUSTOM_COMMAND to generate files.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Accumulate one command line at a time.
+  cmCustomCommandLine currentLine;
+
+  // Save all command lines.
+  cmCustomCommandLines commandLines;
+
+  // Accumulate dependencies.
+  std::vector<std::string> depends, byproducts;
+  std::string working_directory;
+  bool verbatim = false;
+  bool uses_terminal = false;
+  bool command_expand_lists = false;
+  std::string comment_buffer;
+  const char* comment = nullptr;
+  std::vector<std::string> sources;
+
+  // Keep track of parser state.
+  enum tdoing
+  {
+    doing_command,
+    doing_depends,
+    doing_byproducts,
+    doing_working_directory,
+    doing_comment,
+    doing_source,
+    doing_nothing
+  };
+  tdoing doing = doing_command;
+
+  // Look for the ALL option.
+  bool excludeFromAll = true;
+  unsigned int start = 1;
+  if (args.size() > 1) {
+    if (args[1] == "ALL") {
+      excludeFromAll = false;
+      start = 2;
+    }
+  }
+
+  // Parse the rest of the arguments.
+  for (unsigned int j = start; j < args.size(); ++j) {
+    std::string const& copy = args[j];
+
+    if (copy == "DEPENDS") {
+      doing = doing_depends;
+    } else if (copy == "BYPRODUCTS") {
+      doing = doing_byproducts;
+    } else if (copy == "WORKING_DIRECTORY") {
+      doing = doing_working_directory;
+    } else if (copy == "VERBATIM") {
+      doing = doing_nothing;
+      verbatim = true;
+    } else if (copy == "USES_TERMINAL") {
+      doing = doing_nothing;
+      uses_terminal = true;
+    } else if (copy == "COMMAND_EXPAND_LISTS") {
+      doing = doing_nothing;
+      command_expand_lists = true;
+    } else if (copy == "COMMENT") {
+      doing = doing_comment;
+    } else if (copy == "COMMAND") {
+      doing = doing_command;
+
+      // Save the current command before starting the next command.
+      if (!currentLine.empty()) {
+        commandLines.push_back(currentLine);
+        currentLine.clear();
+      }
+    } else if (copy == "SOURCES") {
+      doing = doing_source;
+    } else {
+      switch (doing) {
+        case doing_working_directory:
+          working_directory = copy;
+          break;
+        case doing_command:
+          currentLine.push_back(copy);
+          break;
+        case doing_byproducts: {
+          std::string filename;
+          if (!cmSystemTools::FileIsFullPath(copy.c_str())) {
+            filename = this->Makefile->GetCurrentBinaryDirectory();
+            filename += "/";
+          }
+          filename += copy;
+          cmSystemTools::ConvertToUnixSlashes(filename);
+          byproducts.push_back(filename);
+        } break;
+        case doing_depends: {
+          std::string dep = copy;
+          cmSystemTools::ConvertToUnixSlashes(dep);
+          depends.push_back(dep);
+        } break;
+        case doing_comment:
+          comment_buffer = copy;
+          comment = comment_buffer.c_str();
+          break;
+        case doing_source:
+          sources.push_back(copy);
+          break;
+        default:
+          this->SetError("Wrong syntax. Unknown type of argument.");
+          return false;
+      }
+    }
+  }
+
+  std::string::size_type pos = targetName.find_first_of("#<>");
+  if (pos != std::string::npos) {
+    std::ostringstream msg;
+    msg << "called with target name containing a \"" << targetName[pos]
+        << "\".  This character is not allowed.";
+    this->SetError(msg.str());
+    return false;
+  }
+
+  // Some requirements on custom target names already exist
+  // and have been checked at this point.
+  // The following restrictions overlap but depend on policy CMP0037.
+  bool nameOk = cmGeneratorExpression::IsValidTargetName(targetName) &&
+    !cmGlobalGenerator::IsReservedTarget(targetName);
+  if (nameOk) {
+    nameOk = targetName.find(':') == std::string::npos;
+  }
+  if (!nameOk &&
+      !this->Makefile->CheckCMP0037(targetName, cmStateEnums::UTILITY)) {
+    return false;
+  }
+
+  // Store the last command line finished.
+  if (!currentLine.empty()) {
+    commandLines.push_back(currentLine);
+    currentLine.clear();
+  }
+
+  // Enforce name uniqueness.
+  {
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(targetName, msg, true)) {
+      this->SetError(msg);
+      return false;
+    }
+  }
+
+  // Convert working directory to a full path.
+  if (!working_directory.empty()) {
+    const char* build_dir = this->Makefile->GetCurrentBinaryDirectory();
+    working_directory =
+      cmSystemTools::CollapseFullPath(working_directory, build_dir);
+  }
+
+  if (commandLines.empty() && !byproducts.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "BYPRODUCTS may not be specified without any COMMAND");
+    return true;
+  }
+  if (commandLines.empty() && uses_terminal) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "USES_TERMINAL may not be specified without any COMMAND");
+    return true;
+  }
+  if (commandLines.empty() && command_expand_lists) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "COMMAND_EXPAND_LISTS may not be specified without any COMMAND");
+    return true;
+  }
+
+  // Add the utility target to the makefile.
+  bool escapeOldStyle = !verbatim;
+  cmTarget* target = this->Makefile->AddUtilityCommand(
+    targetName, cmMakefile::TargetOrigin::Project, excludeFromAll,
+    working_directory.c_str(), byproducts, depends, commandLines,
+    escapeOldStyle, comment, uses_terminal, command_expand_lists);
+
+  // Add additional user-specified source files to the target.
+  target->AddSources(sources);
+
+  return true;
+}
diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h
new file mode 100644
index 0000000..1a55116
--- /dev/null
+++ b/Source/cmAddCustomTargetCommand.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddCustomTargetCommand_h
+#define cmAddCustomTargetCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddCustomTargetCommand
+ * \brief Command that adds a target to the build system.
+ *
+ * cmAddCustomTargetCommand adds an extra target to the build system.
+ * This is useful when you would like to add special
+ * targets like "install,", "clean," and so on.
+ */
+class cmAddCustomTargetCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddCustomTargetCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddDefinitionsCommand.cxx b/Source/cmAddDefinitionsCommand.cxx
new file mode 100644
index 0000000..261fb5b
--- /dev/null
+++ b/Source/cmAddDefinitionsCommand.cxx
@@ -0,0 +1,22 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddDefinitionsCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+
+// cmAddDefinitionsCommand
+bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
+{
+  // it is OK to have no arguments
+  if (args.empty()) {
+    return true;
+  }
+
+  for (std::string const& i : args) {
+    this->Makefile->AddDefineFlag(i.c_str());
+  }
+  return true;
+}
diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
new file mode 100644
index 0000000..7b75638
--- /dev/null
+++ b/Source/cmAddDefinitionsCommand.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddDefinitionsCommand_h
+#define cmAddDefinitionsCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddDefinitionsCommand
+ * \brief Specify a list of compiler defines
+ *
+ * cmAddDefinitionsCommand specifies a list of compiler defines. These defines
+ * will be added to the compile command.
+ */
+class cmAddDefinitionsCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddDefinitionsCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx
new file mode 100644
index 0000000..a73b57e
--- /dev/null
+++ b/Source/cmAddDependenciesCommand.cxx
@@ -0,0 +1,47 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddDependenciesCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmDependenciesCommand
+bool cmAddDependenciesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.size() < 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  std::string const& target_name = args[0];
+  if (this->Makefile->IsAlias(target_name)) {
+    std::ostringstream e;
+    e << "Cannot add target-level dependencies to alias target \""
+      << target_name << "\".\n";
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+  }
+  if (cmTarget* target = this->Makefile->FindTargetToUse(target_name)) {
+    std::vector<std::string>::const_iterator s = args.begin();
+    ++s; // skip over target_name
+    for (; s != args.end(); ++s) {
+      target->AddUtility(*s, this->Makefile);
+    }
+  } else {
+    std::ostringstream e;
+    e << "Cannot add target-level dependencies to non-existent target \""
+      << target_name << "\".\n"
+      << "The add_dependencies works for top-level logical targets created "
+      << "by the add_executable, add_library, or add_custom_target commands.  "
+      << "If you want to add file-level dependencies see the DEPENDS option "
+      << "of the add_custom_target and add_custom_command commands.";
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+  }
+
+  return true;
+}
diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h
new file mode 100644
index 0000000..e10df71
--- /dev/null
+++ b/Source/cmAddDependenciesCommand.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDependenciessCommand_h
+#define cmDependenciessCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddDependenciesCommand
+ * \brief Add a dependency to a target
+ *
+ * cmAddDependenciesCommand adds a dependency to a target
+ */
+class cmAddDependenciesCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddDependenciesCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
new file mode 100644
index 0000000..b9e200a
--- /dev/null
+++ b/Source/cmAddExecutableCommand.cxx
@@ -0,0 +1,176 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddExecutableCommand.h"
+
+#include <sstream>
+
+#include "cmGeneratorExpression.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmTarget.h"
+
+class cmExecutionStatus;
+
+// cmExecutableCommand
+bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  std::vector<std::string>::const_iterator s = args.begin();
+
+  std::string const& exename = *s;
+
+  ++s;
+  bool use_win32 = false;
+  bool use_macbundle = false;
+  bool excludeFromAll = false;
+  bool importTarget = false;
+  bool importGlobal = false;
+  bool isAlias = false;
+  while (s != args.end()) {
+    if (*s == "WIN32") {
+      ++s;
+      use_win32 = true;
+    } else if (*s == "MACOSX_BUNDLE") {
+      ++s;
+      use_macbundle = true;
+    } else if (*s == "EXCLUDE_FROM_ALL") {
+      ++s;
+      excludeFromAll = true;
+    } else if (*s == "IMPORTED") {
+      ++s;
+      importTarget = true;
+    } else if (importTarget && *s == "GLOBAL") {
+      ++s;
+      importGlobal = true;
+    } else if (*s == "ALIAS") {
+      ++s;
+      isAlias = true;
+    } else {
+      break;
+    }
+  }
+
+  bool nameOk = cmGeneratorExpression::IsValidTargetName(exename) &&
+    !cmGlobalGenerator::IsReservedTarget(exename);
+
+  if (nameOk && !importTarget && !isAlias) {
+    nameOk = exename.find(':') == std::string::npos;
+  }
+  if (!nameOk &&
+      !this->Makefile->CheckCMP0037(exename, cmStateEnums::EXECUTABLE)) {
+    return false;
+  }
+
+  // Special modifiers are not allowed with IMPORTED signature.
+  if (importTarget && (use_win32 || use_macbundle || excludeFromAll)) {
+    if (use_win32) {
+      this->SetError("may not be given WIN32 for an IMPORTED target.");
+    } else if (use_macbundle) {
+      this->SetError("may not be given MACOSX_BUNDLE for an IMPORTED target.");
+    } else // if(excludeFromAll)
+    {
+      this->SetError(
+        "may not be given EXCLUDE_FROM_ALL for an IMPORTED target.");
+    }
+    return false;
+  }
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(exename)) {
+      this->SetError("Invalid name for ALIAS: " + exename);
+      return false;
+    }
+    if (excludeFromAll) {
+      this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
+      return false;
+    }
+    if (importTarget || importGlobal) {
+      this->SetError("IMPORTED with ALIAS is not allowed.");
+      return false;
+    }
+    if (args.size() != 3) {
+      std::ostringstream e;
+      e << "ALIAS requires exactly one target argument.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    const char* aliasedName = s->c_str();
+    if (this->Makefile->IsAlias(aliasedName)) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is itself an ALIAS.";
+      this->SetError(e.str());
+      return false;
+    }
+    cmTarget* aliasedTarget =
+      this->Makefile->FindTargetToUse(aliasedName, true);
+    if (!aliasedTarget) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" does not already exist.";
+      this->SetError(e.str());
+      return false;
+    }
+    cmStateEnums::TargetType type = aliasedTarget->GetType();
+    if (type != cmStateEnums::EXECUTABLE) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is not an executable.";
+      this->SetError(e.str());
+      return false;
+    }
+    if (aliasedTarget->IsImported() &&
+        !aliasedTarget->IsImportedGloballyVisible()) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is imported but not globally visible.";
+      this->SetError(e.str());
+      return false;
+    }
+    this->Makefile->AddAlias(exename, aliasedName);
+    return true;
+  }
+
+  // Handle imported target creation.
+  if (importTarget) {
+    // Make sure the target does not already exist.
+    if (this->Makefile->FindTargetToUse(exename)) {
+      std::ostringstream e;
+      e << "cannot create imported target \"" << exename
+        << "\" because another target with the same name already exists.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    // Create the imported target.
+    this->Makefile->AddImportedTarget(exename, cmStateEnums::EXECUTABLE,
+                                      importGlobal);
+    return true;
+  }
+
+  // Enforce name uniqueness.
+  {
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(exename, msg)) {
+      this->SetError(msg);
+      return false;
+    }
+  }
+
+  std::vector<std::string> srclists(s, args.end());
+  cmTarget* tgt =
+    this->Makefile->AddExecutable(exename.c_str(), srclists, excludeFromAll);
+  if (use_win32) {
+    tgt->SetProperty("WIN32_EXECUTABLE", "ON");
+  }
+  if (use_macbundle) {
+    tgt->SetProperty("MACOSX_BUNDLE", "ON");
+  }
+
+  return true;
+}
diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h
new file mode 100644
index 0000000..bdf607d
--- /dev/null
+++ b/Source/cmAddExecutableCommand.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExecutablesCommand_h
+#define cmExecutablesCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmExecutablesCommand
+ * \brief Defines a list of executables to build.
+ *
+ * cmExecutablesCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmAddExecutableCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddExecutableCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
new file mode 100644
index 0000000..0fcffdd
--- /dev/null
+++ b/Source/cmAddLibraryCommand.cxx
@@ -0,0 +1,335 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddLibraryCommand.h"
+
+#include <sstream>
+
+#include "cmGeneratorExpression.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmLibraryCommand
+bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  // Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
+  // otherwise it defaults to static library.
+  cmStateEnums::TargetType type = cmStateEnums::SHARED_LIBRARY;
+  if (cmSystemTools::IsOff(
+        this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
+    type = cmStateEnums::STATIC_LIBRARY;
+  }
+  bool excludeFromAll = false;
+  bool importTarget = false;
+  bool importGlobal = false;
+
+  std::vector<std::string>::const_iterator s = args.begin();
+
+  std::string const& libName = *s;
+
+  ++s;
+
+  // If the second argument is "SHARED" or "STATIC", then it controls
+  // the type of library.  Otherwise, it is treated as a source or
+  // source list name. There may be two keyword arguments, check for them
+  bool haveSpecifiedType = false;
+  bool isAlias = false;
+  while (s != args.end()) {
+    std::string libType = *s;
+    if (libType == "STATIC") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting STATIC type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::STATIC_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (libType == "SHARED") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting SHARED type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::SHARED_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (libType == "MODULE") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting MODULE type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::MODULE_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (libType == "OBJECT") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting OBJECT type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::OBJECT_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (libType == "UNKNOWN") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting UNKNOWN type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::UNKNOWN_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (libType == "ALIAS") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting ALIAS type.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      isAlias = true;
+    } else if (libType == "INTERFACE") {
+      if (haveSpecifiedType) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting/multiple types.";
+        this->SetError(e.str());
+        return false;
+      }
+      if (isAlias) {
+        std::ostringstream e;
+        e << "INTERFACE library specified with conflicting ALIAS type.";
+        this->SetError(e.str());
+        return false;
+      }
+      if (excludeFromAll) {
+        std::ostringstream e;
+        e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      type = cmStateEnums::INTERFACE_LIBRARY;
+      haveSpecifiedType = true;
+    } else if (*s == "EXCLUDE_FROM_ALL") {
+      if (type == cmStateEnums::INTERFACE_LIBRARY) {
+        std::ostringstream e;
+        e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
+        this->SetError(e.str());
+        return false;
+      }
+      ++s;
+      excludeFromAll = true;
+    } else if (*s == "IMPORTED") {
+      ++s;
+      importTarget = true;
+    } else if (importTarget && *s == "GLOBAL") {
+      ++s;
+      importGlobal = true;
+    } else if (type == cmStateEnums::INTERFACE_LIBRARY && *s == "GLOBAL") {
+      std::ostringstream e;
+      e << "GLOBAL option may only be used with IMPORTED libraries.";
+      this->SetError(e.str());
+      return false;
+    } else {
+      break;
+    }
+  }
+
+  if (type == cmStateEnums::INTERFACE_LIBRARY) {
+    if (s != args.end()) {
+      std::ostringstream e;
+      e << "INTERFACE library requires no source arguments.";
+      this->SetError(e.str());
+      return false;
+    }
+    if (importGlobal && !importTarget) {
+      std::ostringstream e;
+      e << "INTERFACE library specified as GLOBAL, but not as IMPORTED.";
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  bool nameOk = cmGeneratorExpression::IsValidTargetName(libName) &&
+    !cmGlobalGenerator::IsReservedTarget(libName);
+
+  if (nameOk && !importTarget && !isAlias) {
+    nameOk = libName.find(':') == std::string::npos;
+  }
+  if (!nameOk && !this->Makefile->CheckCMP0037(libName, type)) {
+    return false;
+  }
+
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName)) {
+      this->SetError("Invalid name for ALIAS: " + libName);
+      return false;
+    }
+    if (excludeFromAll) {
+      this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
+      return false;
+    }
+    if (importTarget || importGlobal) {
+      this->SetError("IMPORTED with ALIAS is not allowed.");
+      return false;
+    }
+    if (args.size() != 3) {
+      std::ostringstream e;
+      e << "ALIAS requires exactly one target argument.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    const char* aliasedName = s->c_str();
+    if (this->Makefile->IsAlias(aliasedName)) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is itself an ALIAS.";
+      this->SetError(e.str());
+      return false;
+    }
+    cmTarget* aliasedTarget =
+      this->Makefile->FindTargetToUse(aliasedName, true);
+    if (!aliasedTarget) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" does not already "
+                          "exist.";
+      this->SetError(e.str());
+      return false;
+    }
+    cmStateEnums::TargetType aliasedType = aliasedTarget->GetType();
+    if (aliasedType != cmStateEnums::SHARED_LIBRARY &&
+        aliasedType != cmStateEnums::STATIC_LIBRARY &&
+        aliasedType != cmStateEnums::MODULE_LIBRARY &&
+        aliasedType != cmStateEnums::OBJECT_LIBRARY &&
+        aliasedType != cmStateEnums::INTERFACE_LIBRARY) {
+      std::ostringstream e;
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is not a library.";
+      this->SetError(e.str());
+      return false;
+    }
+    this->Makefile->AddAlias(libName, aliasedName);
+    return true;
+  }
+
+  if (importTarget && excludeFromAll) {
+    this->SetError("excludeFromAll with IMPORTED target makes no sense.");
+    return false;
+  }
+
+  /* ideally we should check whether for the linker language of the target
+    CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to
+    STATIC. But at this point we know only the name of the target, but not
+    yet its linker language. */
+  if ((type == cmStateEnums::SHARED_LIBRARY ||
+       type == cmStateEnums::MODULE_LIBRARY) &&
+      !this->Makefile->GetState()->GetGlobalPropertyAsBool(
+        "TARGET_SUPPORTS_SHARED_LIBS")) {
+    std::ostringstream w;
+    w << "ADD_LIBRARY called with "
+      << (type == cmStateEnums::SHARED_LIBRARY ? "SHARED" : "MODULE")
+      << " option but the target platform does not support dynamic linking. "
+         "Building a STATIC library instead. This may lead to problems.";
+    this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+    type = cmStateEnums::STATIC_LIBRARY;
+  }
+
+  // Handle imported target creation.
+  if (importTarget) {
+    // The IMPORTED signature requires a type to be specified explicitly.
+    if (!haveSpecifiedType) {
+      this->SetError("called with IMPORTED argument but no library type.");
+      return false;
+    }
+    if (type == cmStateEnums::OBJECT_LIBRARY) {
+      std::string reason;
+      if (!this->Makefile->GetGlobalGenerator()->HasKnownObjectFileLocation(
+            &reason)) {
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR,
+          "The OBJECT library type may not be used for IMPORTED libraries" +
+            reason + ".");
+        return true;
+      }
+    }
+    if (type == cmStateEnums::INTERFACE_LIBRARY) {
+      if (!cmGeneratorExpression::IsValidTargetName(libName)) {
+        std::ostringstream e;
+        e << "Invalid name for IMPORTED INTERFACE library target: " << libName;
+        this->SetError(e.str());
+        return false;
+      }
+    }
+
+    // Make sure the target does not already exist.
+    if (this->Makefile->FindTargetToUse(libName)) {
+      std::ostringstream e;
+      e << "cannot create imported target \"" << libName
+        << "\" because another target with the same name already exists.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    // Create the imported target.
+    this->Makefile->AddImportedTarget(libName, type, importGlobal);
+    return true;
+  }
+
+  // A non-imported target may not have UNKNOWN type.
+  if (type == cmStateEnums::UNKNOWN_LIBRARY) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "The UNKNOWN library type may be used only for IMPORTED libraries.");
+    return true;
+  }
+
+  // Enforce name uniqueness.
+  {
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(libName, msg)) {
+      this->SetError(msg);
+      return false;
+    }
+  }
+
+  std::vector<std::string> srclists;
+
+  if (type == cmStateEnums::INTERFACE_LIBRARY) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName) ||
+        libName.find("::") != std::string::npos) {
+      std::ostringstream e;
+      e << "Invalid name for INTERFACE library target: " << libName;
+      this->SetError(e.str());
+      return false;
+    }
+
+    this->Makefile->AddLibrary(libName, type, srclists, excludeFromAll);
+    return true;
+  }
+
+  srclists.insert(srclists.end(), s, args.end());
+
+  this->Makefile->AddLibrary(libName, type, srclists, excludeFromAll);
+
+  return true;
+}
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
new file mode 100644
index 0000000..aa21261
--- /dev/null
+++ b/Source/cmAddLibraryCommand.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmLibrarysCommand_h
+#define cmLibrarysCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmLibrarysCommand
+ * \brief Defines a list of executables to build.
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmAddLibraryCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddLibraryCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddSubDirectoryCommand.cxx b/Source/cmAddSubDirectoryCommand.cxx
new file mode 100644
index 0000000..1727ca5
--- /dev/null
+++ b/Source/cmAddSubDirectoryCommand.cxx
@@ -0,0 +1,111 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddSubDirectoryCommand.h"
+
+#include <sstream>
+#include <string.h>
+
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+
+class cmExecutionStatus;
+
+// cmAddSubDirectoryCommand
+bool cmAddSubDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // store the binpath
+  std::string const& srcArg = args[0];
+  std::string binArg;
+
+  bool excludeFromAll = false;
+
+  // process the rest of the arguments looking for optional args
+  std::vector<std::string>::const_iterator i = args.begin();
+  ++i;
+  for (; i != args.end(); ++i) {
+    if (*i == "EXCLUDE_FROM_ALL") {
+      excludeFromAll = true;
+      continue;
+    }
+    if (binArg.empty()) {
+      binArg = *i;
+    } else {
+      this->SetError("called with incorrect number of arguments");
+      return false;
+    }
+  }
+
+  // Compute the full path to the specified source directory.
+  // Interpret a relative path with respect to the current source directory.
+  std::string srcPath;
+  if (cmSystemTools::FileIsFullPath(srcArg.c_str())) {
+    srcPath = srcArg;
+  } else {
+    srcPath = this->Makefile->GetCurrentSourceDirectory();
+    srcPath += "/";
+    srcPath += srcArg;
+  }
+  if (!cmSystemTools::FileIsDirectory(srcPath)) {
+    std::string error = "given source \"";
+    error += srcArg;
+    error += "\" which is not an existing directory.";
+    this->SetError(error);
+    return false;
+  }
+  srcPath = cmSystemTools::CollapseFullPath(srcPath);
+
+  // Compute the full path to the binary directory.
+  std::string binPath;
+  if (binArg.empty()) {
+    // No binary directory was specified.  If the source directory is
+    // not a subdirectory of the current directory then it is an
+    // error.
+    if (!cmSystemTools::IsSubDirectory(
+          srcPath, this->Makefile->GetCurrentSourceDirectory())) {
+      std::ostringstream e;
+      e << "not given a binary directory but the given source directory "
+        << "\"" << srcPath << "\" is not a subdirectory of \""
+        << this->Makefile->GetCurrentSourceDirectory() << "\".  "
+        << "When specifying an out-of-tree source a binary directory "
+        << "must be explicitly specified.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    // Remove the CurrentDirectory from the srcPath and replace it
+    // with the CurrentOutputDirectory.
+    const char* src = this->Makefile->GetCurrentSourceDirectory();
+    const char* bin = this->Makefile->GetCurrentBinaryDirectory();
+    size_t srcLen = strlen(src);
+    size_t binLen = strlen(bin);
+    if (srcLen > 0 && src[srcLen - 1] == '/') {
+      --srcLen;
+    }
+    if (binLen > 0 && bin[binLen - 1] == '/') {
+      --binLen;
+    }
+    binPath = std::string(bin, binLen) + srcPath.substr(srcLen);
+  } else {
+    // Use the binary directory specified.
+    // Interpret a relative path with respect to the current binary directory.
+    if (cmSystemTools::FileIsFullPath(binArg.c_str())) {
+      binPath = binArg;
+    } else {
+      binPath = this->Makefile->GetCurrentBinaryDirectory();
+      binPath += "/";
+      binPath += binArg;
+    }
+  }
+  binPath = cmSystemTools::CollapseFullPath(binPath);
+
+  // Add the subdirectory using the computed full paths.
+  this->Makefile->AddSubDirectory(srcPath, binPath, excludeFromAll, true);
+
+  return true;
+}
diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h
new file mode 100644
index 0000000..0ea4423
--- /dev/null
+++ b/Source/cmAddSubDirectoryCommand.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddSubDirectoryCommand_h
+#define cmAddSubDirectoryCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddSubDirectoryCommand
+ * \brief Specify a subdirectory to build
+ *
+ * cmAddSubDirectoryCommand specifies a subdirectory to process
+ * by CMake. CMake will descend
+ * into the specified source directory and process any CMakeLists.txt found.
+ */
+class cmAddSubDirectoryCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddSubDirectoryCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmAddTestCommand.cxx b/Source/cmAddTestCommand.cxx
new file mode 100644
index 0000000..3a3afdb
--- /dev/null
+++ b/Source/cmAddTestCommand.cxx
@@ -0,0 +1,141 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAddTestCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmTest.h"
+#include "cmTestGenerator.h"
+
+class cmExecutionStatus;
+
+// cmExecutableCommand
+bool cmAddTestCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
+{
+  if (!args.empty() && args[0] == "NAME") {
+    return this->HandleNameMode(args);
+  }
+
+  // First argument is the name of the test Second argument is the name of
+  // the executable to run (a target or external program) Remaining arguments
+  // are the arguments to pass to the executable
+  if (args.size() < 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // Collect the command with arguments.
+  std::vector<std::string> command;
+  command.insert(command.end(), args.begin() + 1, args.end());
+
+  // Create the test but add a generator only the first time it is
+  // seen.  This preserves behavior from before test generators.
+  cmTest* test = this->Makefile->GetTest(args[0]);
+  if (test) {
+    // If the test was already added by a new-style signature do not
+    // allow it to be duplicated.
+    if (!test->GetOldStyle()) {
+      std::ostringstream e;
+      e << " given test name \"" << args[0]
+        << "\" which already exists in this directory.";
+      this->SetError(e.str());
+      return false;
+    }
+  } else {
+    test = this->Makefile->CreateTest(args[0]);
+    test->SetOldStyle(true);
+    this->Makefile->AddTestGenerator(new cmTestGenerator(test));
+  }
+  test->SetCommand(command);
+
+  return true;
+}
+
+bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
+{
+  std::string name;
+  std::vector<std::string> configurations;
+  std::string working_directory;
+  std::vector<std::string> command;
+
+  // Read the arguments.
+  enum Doing
+  {
+    DoingName,
+    DoingCommand,
+    DoingConfigs,
+    DoingWorkingDirectory,
+    DoingNone
+  };
+  Doing doing = DoingName;
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "COMMAND") {
+      if (!command.empty()) {
+        this->SetError(" may be given at most one COMMAND.");
+        return false;
+      }
+      doing = DoingCommand;
+    } else if (args[i] == "CONFIGURATIONS") {
+      if (!configurations.empty()) {
+        this->SetError(" may be given at most one set of CONFIGURATIONS.");
+        return false;
+      }
+      doing = DoingConfigs;
+    } else if (args[i] == "WORKING_DIRECTORY") {
+      if (!working_directory.empty()) {
+        this->SetError(" may be given at most one WORKING_DIRECTORY.");
+        return false;
+      }
+      doing = DoingWorkingDirectory;
+    } else if (doing == DoingName) {
+      name = args[i];
+      doing = DoingNone;
+    } else if (doing == DoingCommand) {
+      command.push_back(args[i]);
+    } else if (doing == DoingConfigs) {
+      configurations.push_back(args[i]);
+    } else if (doing == DoingWorkingDirectory) {
+      working_directory = args[i];
+      doing = DoingNone;
+    } else {
+      std::ostringstream e;
+      e << " given unknown argument:\n  " << args[i] << "\n";
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  // Require a test name.
+  if (name.empty()) {
+    this->SetError(" must be given non-empty NAME.");
+    return false;
+  }
+
+  // Require a command.
+  if (command.empty()) {
+    this->SetError(" must be given non-empty COMMAND.");
+    return false;
+  }
+
+  // Require a unique test name within the directory.
+  if (this->Makefile->GetTest(name)) {
+    std::ostringstream e;
+    e << " given test NAME \"" << name
+      << "\" which already exists in this directory.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Add the test.
+  cmTest* test = this->Makefile->CreateTest(name);
+  test->SetOldStyle(false);
+  test->SetCommand(command);
+  if (!working_directory.empty()) {
+    test->SetProperty("WORKING_DIRECTORY", working_directory.c_str());
+  }
+  this->Makefile->AddTestGenerator(new cmTestGenerator(test, configurations));
+
+  return true;
+}
diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h
new file mode 100644
index 0000000..bea3f3d
--- /dev/null
+++ b/Source/cmAddTestCommand.h
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAddTestCommand_h
+#define cmAddTestCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAddTestCommand
+ * \brief Add a test to the lists of tests to run.
+ *
+ * cmAddTestCommand adds a test to the list of tests to run .
+ */
+class cmAddTestCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAddTestCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  bool HandleNameMode(std::vector<std::string> const& args);
+};
+
+#endif
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
new file mode 100644
index 0000000..3380b78
--- /dev/null
+++ b/Source/cmAlgorithms.h
@@ -0,0 +1,468 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAlgorithms_h
+#define cmAlgorithms_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cm_kwiml.h"
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <sstream>
+#include <string.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+inline bool cmHasLiteralPrefixImpl(const std::string& str1, const char* str2,
+                                   size_t N)
+{
+  return strncmp(str1.c_str(), str2, N) == 0;
+}
+
+inline bool cmHasLiteralPrefixImpl(const char* str1, const char* str2,
+                                   size_t N)
+{
+  return strncmp(str1, str2, N) == 0;
+}
+
+inline bool cmHasLiteralSuffixImpl(const std::string& str1, const char* str2,
+                                   size_t N)
+{
+  size_t len = str1.size();
+  return len >= N && strcmp(str1.c_str() + len - N, str2) == 0;
+}
+
+inline bool cmHasLiteralSuffixImpl(const char* str1, const char* str2,
+                                   size_t N)
+{
+  size_t len = strlen(str1);
+  return len >= N && strcmp(str1 + len - N, str2) == 0;
+}
+
+template <typename T, size_t N>
+bool cmHasLiteralPrefix(const T& str1, const char (&str2)[N])
+{
+  return cmHasLiteralPrefixImpl(str1, str2, N - 1);
+}
+
+template <typename T, size_t N>
+bool cmHasLiteralSuffix(const T& str1, const char (&str2)[N])
+{
+  return cmHasLiteralSuffixImpl(str1, str2, N - 1);
+}
+
+struct cmStrCmp
+{
+  cmStrCmp(const char* test)
+    : m_test(test)
+  {
+  }
+  cmStrCmp(const std::string& test)
+    : m_test(test)
+  {
+  }
+
+  bool operator()(const std::string& input) const { return m_test == input; }
+
+  bool operator()(const char* input) const
+  {
+    return strcmp(input, m_test.c_str()) == 0;
+  }
+
+private:
+  const std::string m_test;
+};
+
+template <typename FwdIt>
+FwdIt cmRotate(FwdIt first, FwdIt middle, FwdIt last)
+{
+  const typename std::iterator_traits<FwdIt>::difference_type dist =
+    std::distance(middle, last);
+  std::rotate(first, middle, last);
+  std::advance(first, dist);
+  return first;
+}
+
+template <typename Container, typename Predicate>
+void cmEraseIf(Container& cont, Predicate pred)
+{
+  cont.erase(std::remove_if(cont.begin(), cont.end(), pred), cont.end());
+}
+
+namespace ContainerAlgorithms {
+
+template <typename T>
+struct cmIsPair
+{
+  enum
+  {
+    value = false
+  };
+};
+
+template <typename K, typename V>
+struct cmIsPair<std::pair<K, V>>
+{
+  enum
+  {
+    value = true
+  };
+};
+
+template <typename Range,
+          bool valueTypeIsPair = cmIsPair<typename Range::value_type>::value>
+struct DefaultDeleter
+{
+  void operator()(typename Range::value_type value) const { delete value; }
+};
+
+template <typename Range>
+struct DefaultDeleter<Range, /* valueTypeIsPair = */ true>
+{
+  void operator()(typename Range::value_type value) const
+  {
+    delete value.second;
+  }
+};
+
+template <typename FwdIt>
+FwdIt RemoveN(FwdIt i1, FwdIt i2, size_t n)
+{
+  FwdIt m = i1;
+  std::advance(m, n);
+  return cmRotate(i1, m, i2);
+}
+
+template <typename Range>
+struct BinarySearcher
+{
+  typedef typename Range::value_type argument_type;
+  BinarySearcher(Range const& r)
+    : m_range(r)
+  {
+  }
+
+  bool operator()(argument_type const& item) const
+  {
+    return std::binary_search(m_range.begin(), m_range.end(), item);
+  }
+
+private:
+  Range const& m_range;
+};
+}
+
+template <typename const_iterator_>
+struct cmRange
+{
+  typedef const_iterator_ const_iterator;
+  typedef typename std::iterator_traits<const_iterator>::value_type value_type;
+  typedef typename std::iterator_traits<const_iterator>::difference_type
+    difference_type;
+  cmRange(const_iterator begin_, const_iterator end_)
+    : Begin(begin_)
+    , End(end_)
+  {
+  }
+  const_iterator begin() const { return Begin; }
+  const_iterator end() const { return End; }
+  bool empty() const { return std::distance(Begin, End) == 0; }
+  difference_type size() const { return std::distance(Begin, End); }
+  cmRange& advance(KWIML_INT_intptr_t amount)
+  {
+    std::advance(Begin, amount);
+    return *this;
+  }
+
+  cmRange& retreat(KWIML_INT_intptr_t amount)
+  {
+    std::advance(End, -amount);
+    return *this;
+  }
+
+private:
+  const_iterator Begin;
+  const_iterator End;
+};
+
+typedef cmRange<std::vector<std::string>::const_iterator> cmStringRange;
+
+class cmListFileBacktrace;
+typedef cmRange<std::vector<cmListFileBacktrace>::const_iterator>
+  cmBacktraceRange;
+
+template <typename Iter1, typename Iter2>
+cmRange<Iter1> cmMakeRange(Iter1 begin, Iter2 end)
+{
+  return cmRange<Iter1>(begin, end);
+}
+
+template <typename Range>
+cmRange<typename Range::const_iterator> cmMakeRange(Range const& range)
+{
+  return cmRange<typename Range::const_iterator>(range.begin(), range.end());
+}
+
+template <typename Range>
+void cmDeleteAll(Range const& r)
+{
+  std::for_each(r.begin(), r.end(),
+                ContainerAlgorithms::DefaultDeleter<Range>());
+}
+
+template <typename Range>
+std::string cmJoin(Range const& r, const char* delimiter)
+{
+  if (r.empty()) {
+    return std::string();
+  }
+  std::ostringstream os;
+  typedef typename Range::value_type ValueType;
+  typedef typename Range::const_iterator InputIt;
+  const InputIt first = r.begin();
+  InputIt last = r.end();
+  --last;
+  std::copy(first, last, std::ostream_iterator<ValueType>(os, delimiter));
+
+  os << *last;
+
+  return os.str();
+}
+
+template <typename Range>
+std::string cmJoin(Range const& r, std::string const& delimiter)
+{
+  return cmJoin(r, delimiter.c_str());
+}
+
+template <typename Range>
+typename Range::const_iterator cmRemoveN(Range& r, size_t n)
+{
+  return ContainerAlgorithms::RemoveN(r.begin(), r.end(), n);
+}
+
+template <typename Range, typename InputRange>
+typename Range::const_iterator cmRemoveIndices(Range& r, InputRange const& rem)
+{
+  typename InputRange::const_iterator remIt = rem.begin();
+  typename InputRange::const_iterator remEnd = rem.end();
+  const typename Range::iterator rangeEnd = r.end();
+  if (remIt == remEnd) {
+    return rangeEnd;
+  }
+
+  typename Range::iterator writer = r.begin();
+  std::advance(writer, *remIt);
+  typename Range::iterator pivot = writer;
+  typename InputRange::value_type prevRem = *remIt;
+  ++remIt;
+  size_t count = 1;
+  for (; writer != rangeEnd && remIt != remEnd; ++count, ++remIt) {
+    std::advance(pivot, *remIt - prevRem);
+    prevRem = *remIt;
+    writer = ContainerAlgorithms::RemoveN(writer, pivot, count);
+  }
+  return ContainerAlgorithms::RemoveN(writer, rangeEnd, count);
+}
+
+template <typename Range, typename MatchRange>
+typename Range::const_iterator cmRemoveMatching(Range& r, MatchRange const& m)
+{
+  return std::remove_if(r.begin(), r.end(),
+                        ContainerAlgorithms::BinarySearcher<MatchRange>(m));
+}
+
+namespace ContainerAlgorithms {
+
+template <typename Range, typename T = typename Range::value_type>
+struct RemoveDuplicatesAPI
+{
+  typedef typename Range::const_iterator const_iterator;
+  typedef typename Range::const_iterator value_type;
+
+  static bool lessThan(value_type a, value_type b) { return *a < *b; }
+  static value_type uniqueValue(const_iterator a) { return a; }
+  template <typename It>
+  static bool valueCompare(It it, const_iterator it2)
+  {
+    return **it != *it2;
+  }
+};
+
+template <typename Range, typename T>
+struct RemoveDuplicatesAPI<Range, T*>
+{
+  typedef typename Range::const_iterator const_iterator;
+  typedef T* value_type;
+
+  static bool lessThan(value_type a, value_type b) { return a < b; }
+  static value_type uniqueValue(const_iterator a) { return *a; }
+  template <typename It>
+  static bool valueCompare(It it, const_iterator it2)
+  {
+    return *it != *it2;
+  }
+};
+}
+
+template <typename Range>
+typename Range::const_iterator cmRemoveDuplicates(Range& r)
+{
+  typedef typename ContainerAlgorithms::RemoveDuplicatesAPI<Range> API;
+  typedef typename API::value_type T;
+  std::vector<T> unique;
+  unique.reserve(r.size());
+  std::vector<size_t> indices;
+  size_t count = 0;
+  const typename Range::const_iterator end = r.end();
+  for (typename Range::const_iterator it = r.begin(); it != end;
+       ++it, ++count) {
+    const typename std::vector<T>::iterator low = std::lower_bound(
+      unique.begin(), unique.end(), API::uniqueValue(it), API::lessThan);
+    if (low == unique.end() || API::valueCompare(low, it)) {
+      unique.insert(low, API::uniqueValue(it));
+    } else {
+      indices.push_back(count);
+    }
+  }
+  if (indices.empty()) {
+    return end;
+  }
+  return cmRemoveIndices(r, indices);
+}
+
+template <typename Range>
+std::string cmWrap(std::string const& prefix, Range const& r,
+                   std::string const& suffix, std::string const& sep)
+{
+  if (r.empty()) {
+    return std::string();
+  }
+  return prefix + cmJoin(r, suffix + sep + prefix) + suffix;
+}
+
+template <typename Range>
+std::string cmWrap(char prefix, Range const& r, char suffix,
+                   std::string const& sep)
+{
+  return cmWrap(std::string(1, prefix), r, std::string(1, suffix), sep);
+}
+
+template <typename Range, typename T>
+typename Range::const_iterator cmFindNot(Range const& r, T const& t)
+{
+  return std::find_if(r.begin(), r.end(), [&t](T const& i) { return i != t; });
+}
+
+template <typename Range>
+cmRange<typename Range::const_reverse_iterator> cmReverseRange(
+  Range const& range)
+{
+  return cmRange<typename Range::const_reverse_iterator>(range.rbegin(),
+                                                         range.rend());
+}
+
+template <class Iter>
+std::reverse_iterator<Iter> cmMakeReverseIterator(Iter it)
+{
+  return std::reverse_iterator<Iter>(it);
+}
+
+inline bool cmHasSuffix(const std::string& str, const std::string& suffix)
+{
+  if (str.size() < suffix.size()) {
+    return false;
+  }
+  return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+inline void cmStripSuffixIfExists(std::string& str, const std::string& suffix)
+{
+  if (cmHasSuffix(str, suffix)) {
+    str.resize(str.size() - suffix.size());
+  }
+}
+
+namespace cm {
+
+#if defined(CMake_HAVE_CXX_MAKE_UNIQUE)
+
+using std::make_unique;
+
+#else
+
+template <typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+#endif
+
+#if __cplusplus >= 201703L || defined(_MSVC_LANG) && _MSVC_LANG >= 201703L
+
+using std::size;
+
+#else
+
+// std::size backport from C++17.
+template <class C>
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+constexpr
+#endif
+  auto
+  size(C const& c) -> decltype(c.size())
+{
+  return c.size();
+}
+
+template <typename T, size_t N>
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+constexpr
+#endif
+  std::size_t
+  size(const T (&)[N]) throw()
+{
+  return N;
+}
+
+#endif
+
+#if __cplusplus >= 201402L || defined(_MSVC_LANG) && _MSVC_LANG >= 201402L
+
+using std::cbegin;
+using std::cend;
+
+#else
+
+// std::c{begin,end} backport from C++14
+template <class C>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+auto cbegin(C const& c)
+#else
+constexpr auto cbegin(C const& c) noexcept(noexcept(std::begin(c)))
+#endif
+  -> decltype(std::begin(c))
+{
+  return std::begin(c);
+}
+
+template <class C>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+auto cend(C const& c)
+#else
+constexpr auto cend(C const& c) noexcept(noexcept(std::end(c)))
+#endif
+  -> decltype(std::end(c))
+{
+  return std::end(c);
+}
+
+#endif
+
+} // namespace cm
+
+#endif
diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx
new file mode 100644
index 0000000..02408a1
--- /dev/null
+++ b/Source/cmArchiveWrite.cxx
@@ -0,0 +1,335 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmArchiveWrite.h"
+
+#include "cmLocale.h"
+#include "cmSystemTools.h"
+#include "cm_get_date.h"
+#include "cm_libarchive.h"
+#include "cmsys/Directory.hxx"
+#include "cmsys/Encoding.hxx"
+#include "cmsys/FStream.hxx"
+#include <iostream>
+#include <string.h>
+#include <time.h>
+
+#ifndef __LA_SSIZE_T
+#define __LA_SSIZE_T la_ssize_t
+#endif
+
+static std::string cm_archive_error_string(struct archive* a)
+{
+  const char* e = archive_error_string(a);
+  return e ? e : "unknown error";
+}
+
+static void cm_archive_entry_copy_pathname(struct archive_entry* e,
+                                           const std::string& dest)
+{
+#if cmsys_STL_HAS_WSTRING
+  archive_entry_copy_pathname_w(e, cmsys::Encoding::ToWide(dest).c_str());
+#else
+  archive_entry_copy_pathname(e, dest.c_str());
+#endif
+}
+
+static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
+                                             const std::string& file)
+{
+#if cmsys_STL_HAS_WSTRING
+  archive_entry_copy_sourcepath_w(e, cmsys::Encoding::ToWide(file).c_str());
+#else
+  archive_entry_copy_sourcepath(e, file.c_str());
+#endif
+}
+
+class cmArchiveWrite::Entry
+{
+  struct archive_entry* Object;
+
+public:
+  Entry()
+    : Object(archive_entry_new())
+  {
+  }
+  ~Entry() { archive_entry_free(this->Object); }
+  operator struct archive_entry*() { return this->Object; }
+};
+
+struct cmArchiveWrite::Callback
+{
+  // archive_write_callback
+  static __LA_SSIZE_T Write(struct archive* /*unused*/, void* cd,
+                            const void* b, size_t n)
+  {
+    cmArchiveWrite* self = static_cast<cmArchiveWrite*>(cd);
+    if (self->Stream.write(static_cast<const char*>(b),
+                           static_cast<std::streamsize>(n))) {
+      return static_cast<__LA_SSIZE_T>(n);
+    }
+    return static_cast<__LA_SSIZE_T>(-1);
+  }
+};
+
+cmArchiveWrite::cmArchiveWrite(std::ostream& os, Compress c,
+                               std::string const& format)
+  : Stream(os)
+  , Archive(archive_write_new())
+  , Disk(archive_read_disk_new())
+  , Verbose(false)
+  , Format(format)
+{
+  switch (c) {
+    case CompressNone:
+      if (archive_write_add_filter_none(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_none: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+    case CompressCompress:
+      if (archive_write_add_filter_compress(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_compress: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+    case CompressGZip:
+      if (archive_write_add_filter_gzip(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_gzip: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+    case CompressBZip2:
+      if (archive_write_add_filter_bzip2(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_bzip2: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+    case CompressLZMA:
+      if (archive_write_add_filter_lzma(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_lzma: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+    case CompressXZ:
+      if (archive_write_add_filter_xz(this->Archive) != ARCHIVE_OK) {
+        this->Error = "archive_write_add_filter_xz: ";
+        this->Error += cm_archive_error_string(this->Archive);
+        return;
+      }
+      break;
+  };
+#if !defined(_WIN32) || defined(__CYGWIN__)
+  if (archive_read_disk_set_standard_lookup(this->Disk) != ARCHIVE_OK) {
+    this->Error = "archive_read_disk_set_standard_lookup: ";
+    this->Error += cm_archive_error_string(this->Archive);
+    return;
+  }
+#endif
+
+  if (archive_write_set_format_by_name(this->Archive, format.c_str()) !=
+      ARCHIVE_OK) {
+    this->Error = "archive_write_set_format_by_name: ";
+    this->Error += cm_archive_error_string(this->Archive);
+    return;
+  }
+
+  // do not pad the last block!!
+  if (archive_write_set_bytes_in_last_block(this->Archive, 1)) {
+    this->Error = "archive_write_set_bytes_in_last_block: ";
+    this->Error += cm_archive_error_string(this->Archive);
+    return;
+  }
+
+  if (archive_write_open(
+        this->Archive, this, nullptr,
+        reinterpret_cast<archive_write_callback*>(&Callback::Write),
+        nullptr) != ARCHIVE_OK) {
+    this->Error = "archive_write_open: ";
+    this->Error += cm_archive_error_string(this->Archive);
+    return;
+  }
+}
+
+cmArchiveWrite::~cmArchiveWrite()
+{
+  archive_read_free(this->Disk);
+  archive_write_free(this->Archive);
+}
+
+bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix,
+                         bool recursive)
+{
+  if (this->Okay()) {
+    if (!path.empty() && path[path.size() - 1] == '/') {
+      path.erase(path.size() - 1);
+    }
+    this->AddPath(path.c_str(), skip, prefix, recursive);
+  }
+  return this->Okay();
+}
+
+bool cmArchiveWrite::AddPath(const char* path, size_t skip, const char* prefix,
+                             bool recursive)
+{
+  if (!this->AddFile(path, skip, prefix)) {
+    return false;
+  }
+  if ((!cmSystemTools::FileIsDirectory(path) || !recursive) ||
+      cmSystemTools::FileIsSymlink(path)) {
+    return true;
+  }
+  cmsys::Directory d;
+  if (d.Load(path)) {
+    std::string next = path;
+    next += "/";
+    std::string::size_type end = next.size();
+    unsigned long n = d.GetNumberOfFiles();
+    for (unsigned long i = 0; i < n; ++i) {
+      const char* file = d.GetFile(i);
+      if (strcmp(file, ".") != 0 && strcmp(file, "..") != 0) {
+        next.erase(end);
+        next += file;
+        if (!this->AddPath(next.c_str(), skip, prefix)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool cmArchiveWrite::AddFile(const char* file, size_t skip, const char* prefix)
+{
+  // Skip the file if we have no name for it.  This may happen on a
+  // top-level directory, which does not need to be included anyway.
+  if (skip >= strlen(file)) {
+    return true;
+  }
+  const char* out = file + skip;
+
+  cmLocaleRAII localeRAII;
+  static_cast<void>(localeRAII);
+
+  // Meta-data.
+  std::string dest = prefix ? prefix : "";
+  dest += out;
+  if (this->Verbose) {
+    std::cout << dest << "\n";
+  }
+  Entry e;
+  cm_archive_entry_copy_sourcepath(e, file);
+  cm_archive_entry_copy_pathname(e, dest);
+  if (archive_read_disk_entry_from_file(this->Disk, e, -1, nullptr) !=
+      ARCHIVE_OK) {
+    this->Error = "archive_read_disk_entry_from_file '";
+    this->Error += file;
+    this->Error += "': ";
+    this->Error += cm_archive_error_string(this->Disk);
+    return false;
+  }
+  if (!this->MTime.empty()) {
+    time_t now;
+    time(&now);
+    time_t t = cm_get_date(now, this->MTime.c_str());
+    if (t == -1) {
+      this->Error = "unable to parse mtime '";
+      this->Error += this->MTime;
+      this->Error += "'";
+      return false;
+    }
+    archive_entry_set_mtime(e, t, 0);
+  }
+
+  // manages the uid/guid of the entry (if any)
+  if (this->Uid.IsSet() && this->Gid.IsSet()) {
+    archive_entry_set_uid(e, this->Uid.Get());
+    archive_entry_set_gid(e, this->Gid.Get());
+  }
+
+  if (!this->Uname.empty() && !this->Gname.empty()) {
+    archive_entry_set_uname(e, this->Uname.c_str());
+    archive_entry_set_gname(e, this->Gname.c_str());
+  }
+
+  // manages the permissions
+  if (this->Permissions.IsSet()) {
+    archive_entry_set_perm(e, this->Permissions.Get());
+  }
+
+  if (this->PermissionsMask.IsSet()) {
+    int perm = archive_entry_perm(e);
+    archive_entry_set_perm(e, perm & this->PermissionsMask.Get());
+  }
+
+  // Clear acl and xattr fields not useful for distribution.
+  archive_entry_acl_clear(e);
+  archive_entry_xattr_clear(e);
+  archive_entry_set_fflags(e, 0, 0);
+
+  if (this->Format == "pax" || this->Format == "paxr") {
+    // Sparse files are a GNU tar extension.
+    // Do not use them in standard tar files.
+    archive_entry_sparse_clear(e);
+  }
+
+  if (archive_write_header(this->Archive, e) != ARCHIVE_OK) {
+    this->Error = "archive_write_header: ";
+    this->Error += cm_archive_error_string(this->Archive);
+    return false;
+  }
+
+  // do not copy content of symlink
+  if (!archive_entry_symlink(e)) {
+    // Content.
+    if (size_t size = static_cast<size_t>(archive_entry_size(e))) {
+      return this->AddData(file, size);
+    }
+  }
+  return true;
+}
+
+bool cmArchiveWrite::AddData(const char* file, size_t size)
+{
+  cmsys::ifstream fin(file, std::ios::in | std::ios::binary);
+  if (!fin) {
+    this->Error = "Error opening \"";
+    this->Error += file;
+    this->Error += "\": ";
+    this->Error += cmSystemTools::GetLastSystemError();
+    return false;
+  }
+
+  char buffer[16384];
+  size_t nleft = size;
+  while (nleft > 0) {
+    typedef std::streamsize ssize_type;
+    size_t const nnext = nleft > sizeof(buffer) ? sizeof(buffer) : nleft;
+    ssize_type const nnext_s = static_cast<ssize_type>(nnext);
+    fin.read(buffer, nnext_s);
+    // Some stream libraries (older HPUX) return failure at end of
+    // file on the last read even if some data were read.  Check
+    // gcount instead of trusting the stream error status.
+    if (static_cast<size_t>(fin.gcount()) != nnext) {
+      break;
+    }
+    if (archive_write_data(this->Archive, buffer, nnext) != nnext_s) {
+      this->Error = "archive_write_data: ";
+      this->Error += cm_archive_error_string(this->Archive);
+      return false;
+    }
+    nleft -= nnext;
+  }
+  if (nleft > 0) {
+    this->Error = "Error reading \"";
+    this->Error += file;
+    this->Error += "\": ";
+    this->Error += cmSystemTools::GetLastSystemError();
+    return false;
+  }
+  return true;
+}
diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h
new file mode 100644
index 0000000..56dce2a
--- /dev/null
+++ b/Source/cmArchiveWrite.h
@@ -0,0 +1,179 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmArchiveWrite_h
+#define cmArchiveWrite_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <stddef.h>
+#include <string>
+
+#if !defined(CMAKE_BUILD_WITH_CMAKE)
+#error "cmArchiveWrite not allowed during bootstrap build!"
+#endif
+
+template <typename T>
+class cmArchiveWriteOptional
+{
+public:
+  cmArchiveWriteOptional() { this->Clear(); }
+  explicit cmArchiveWriteOptional(T val) { this->Set(val); }
+
+  void Set(T val)
+  {
+    this->IsValueSet = true;
+    this->Value = val;
+  }
+  void Clear() { this->IsValueSet = false; }
+  bool IsSet() const { return this->IsValueSet; }
+  T Get() const { return Value; }
+private:
+  T Value;
+  bool IsValueSet;
+};
+
+/** \class cmArchiveWrite
+ * \brief Wrapper around libarchive for writing.
+ *
+ */
+class cmArchiveWrite
+{
+  typedef void (cmArchiveWrite::*safe_bool)();
+  void safe_bool_true() {}
+public:
+  /** Compression type.  */
+  enum Compress
+  {
+    CompressNone,
+    CompressCompress,
+    CompressGZip,
+    CompressBZip2,
+    CompressLZMA,
+    CompressXZ
+  };
+
+  /** Construct with output stream to which to write archive.  */
+  cmArchiveWrite(std::ostream& os, Compress c = CompressNone,
+                 std::string const& format = "paxr");
+
+  ~cmArchiveWrite();
+
+  /**
+   * Add a path (file or directory) to the archive.  Directories are
+   * added recursively.  The "path" must be readable on disk, either
+   * full path or relative to current working directory.  The "skip"
+   * value indicates how many leading bytes from the input path to
+   * skip.  The remaining part of the input path is appended to the
+   * "prefix" value to construct the final name in the archive.
+   */
+  bool Add(std::string path, size_t skip = 0, const char* prefix = nullptr,
+           bool recursive = true);
+
+  /** Returns true if there has been no error.  */
+  operator safe_bool() const
+  {
+    return this->Okay() ? &cmArchiveWrite::safe_bool_true : nullptr;
+  }
+
+  /** Returns true if there has been an error.  */
+  bool operator!() const { return !this->Okay(); }
+
+  /** Return the error string; empty if none.  */
+  std::string GetError() const { return this->Error; }
+
+  // TODO: More general callback instead of hard-coding calls to
+  // std::cout.
+  void SetVerbose(bool v) { this->Verbose = v; }
+
+  void SetMTime(std::string const& t) { this->MTime = t; }
+
+  //! Sets the permissions of the added files/folders
+  void SetPermissions(int permissions_)
+  {
+    this->Permissions.Set(permissions_);
+  }
+
+  //! Clears permissions - default is used instead
+  void ClearPermissions() { this->Permissions.Clear(); }
+
+  //! Sets the permissions mask of files/folders
+  //!
+  //! The permissions will be copied from the existing file
+  //! or folder. The mask will then be applied to unset
+  //! some of them
+  void SetPermissionsMask(int permissionsMask_)
+  {
+    this->PermissionsMask.Set(permissionsMask_);
+  }
+
+  //! Clears permissions mask - default is used instead
+  void ClearPermissionsMask() { this->PermissionsMask.Clear(); }
+
+  //! Sets UID and GID to be used in the tar file
+  void SetUIDAndGID(int uid_, int gid_)
+  {
+    this->Uid.Set(uid_);
+    this->Gid.Set(gid_);
+  }
+
+  //! Clears UID and GID to be used in the tar file - default is used instead
+  void ClearUIDAndGID()
+  {
+    this->Uid.Clear();
+    this->Gid.Clear();
+  }
+
+  //! Sets UNAME and GNAME to be used in the tar file
+  void SetUNAMEAndGNAME(const std::string& uname_, const std::string& gname_)
+  {
+    this->Uname = uname_;
+    this->Gname = gname_;
+  }
+
+  //! Clears UNAME and GNAME to be used in the tar file
+  //! default is used instead
+  void ClearUNAMEAndGNAME()
+  {
+    this->Uname = "";
+    this->Gname = "";
+  }
+
+private:
+  bool Okay() const { return this->Error.empty(); }
+  bool AddPath(const char* path, size_t skip, const char* prefix,
+               bool recursive = true);
+  bool AddFile(const char* file, size_t skip, const char* prefix);
+  bool AddData(const char* file, size_t size);
+
+  struct Callback;
+  friend struct Callback;
+
+  class Entry;
+
+  std::ostream& Stream;
+  struct archive* Archive;
+  struct archive* Disk;
+  bool Verbose;
+  std::string Format;
+  std::string Error;
+  std::string MTime;
+
+  //! UID of the user in the tar file
+  cmArchiveWriteOptional<int> Uid;
+
+  //! GUID of the user in the tar file
+  cmArchiveWriteOptional<int> Gid;
+
+  //! UNAME/GNAME of the user (does not override UID/GID)
+  //!@{
+  std::string Uname;
+  std::string Gname;
+  //!@}
+
+  //! Permissions on files/folders
+  cmArchiveWriteOptional<int> Permissions;
+  cmArchiveWriteOptional<int> PermissionsMask;
+};
+
+#endif
diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx
new file mode 100644
index 0000000..fcdc632
--- /dev/null
+++ b/Source/cmAuxSourceDirectoryCommand.cxx
@@ -0,0 +1,78 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmAuxSourceDirectoryCommand.h"
+
+#include "cmsys/Directory.hxx"
+#include <algorithm>
+#include <stddef.h>
+
+#include "cmAlgorithms.h"
+#include "cmMakefile.h"
+#include "cmSourceFile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmAuxSourceDirectoryCommand
+bool cmAuxSourceDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.size() != 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  std::string sourceListValue;
+  std::string const& templateDirectory = args[0];
+  std::string tdir;
+  if (!cmSystemTools::FileIsFullPath(templateDirectory.c_str())) {
+    tdir = this->Makefile->GetCurrentSourceDirectory();
+    tdir += "/";
+    tdir += templateDirectory;
+  } else {
+    tdir = templateDirectory;
+  }
+
+  // was the list already populated
+  const char* def = this->Makefile->GetDefinition(args[1]);
+  if (def) {
+    sourceListValue = def;
+  }
+
+  std::vector<std::string> files;
+
+  // Load all the files in the directory
+  cmsys::Directory dir;
+  if (dir.Load(tdir)) {
+    size_t numfiles = dir.GetNumberOfFiles();
+    for (size_t i = 0; i < numfiles; ++i) {
+      std::string file = dir.GetFile(static_cast<unsigned long>(i));
+      // Split the filename into base and extension
+      std::string::size_type dotpos = file.rfind('.');
+      if (dotpos != std::string::npos) {
+        std::string ext = file.substr(dotpos + 1);
+        std::string base = file.substr(0, dotpos);
+        // Process only source files
+        auto cm = this->Makefile->GetCMakeInstance();
+        if (!base.empty() && cm->IsSourceExtension(ext)) {
+          std::string fullname = templateDirectory;
+          fullname += "/";
+          fullname += file;
+          // add the file as a class file so
+          // depends can be done
+          cmSourceFile* sf = this->Makefile->GetOrCreateSource(fullname);
+          sf->SetProperty("ABSTRACT", "0");
+          files.push_back(fullname);
+        }
+      }
+    }
+  }
+  std::sort(files.begin(), files.end());
+  if (!sourceListValue.empty()) {
+    sourceListValue += ";";
+  }
+  sourceListValue += cmJoin(files, ";");
+  this->Makefile->AddDefinition(args[1], sourceListValue.c_str());
+  return true;
+}
diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h
new file mode 100644
index 0000000..3742e3e
--- /dev/null
+++ b/Source/cmAuxSourceDirectoryCommand.h
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmAuxSourceDirectoryCommand_h
+#define cmAuxSourceDirectoryCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmAuxSourceDirectoryCommand
+ * \brief Specify auxiliary source code directories.
+ *
+ * cmAuxSourceDirectoryCommand specifies source code directories
+ * that must be built as part of this build process. This directories
+ * are not recursively processed like the SUBDIR command (cmSubdirCommand).
+ * A side effect of this command is to create a subdirectory in the build
+ * directory structure.
+ */
+class cmAuxSourceDirectoryCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmAuxSourceDirectoryCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmBase32.cxx b/Source/cmBase32.cxx
new file mode 100644
index 0000000..1dac212
--- /dev/null
+++ b/Source/cmBase32.cxx
@@ -0,0 +1,99 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmBase32.h"
+
+// -- Static functions
+
+static const unsigned char Base32EncodeTable[33] =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+inline unsigned char Base32EncodeChar(int schar)
+{
+  return Base32EncodeTable[schar];
+}
+
+void Base32Encode5(const unsigned char src[5], char dst[8])
+{
+  // [0]:5 bits
+  dst[0] = Base32EncodeChar((src[0] >> 3) & 0x1F);
+  // [0]:3 bits + [1]:2 bits
+  dst[1] = Base32EncodeChar(((src[0] << 2) & 0x1C) + ((src[1] >> 6) & 0x03));
+  // [1]:5 bits
+  dst[2] = Base32EncodeChar((src[1] >> 1) & 0x1F);
+  // [1]:1 bit + [2]:4 bits
+  dst[3] = Base32EncodeChar(((src[1] << 4) & 0x10) + ((src[2] >> 4) & 0x0F));
+  // [2]:4 bits + [3]:1 bit
+  dst[4] = Base32EncodeChar(((src[2] << 1) & 0x1E) + ((src[3] >> 7) & 0x01));
+  // [3]:5 bits
+  dst[5] = Base32EncodeChar((src[3] >> 2) & 0x1F);
+  // [3]:2 bits + [4]:3 bit
+  dst[6] = Base32EncodeChar(((src[3] << 3) & 0x18) + ((src[4] >> 5) & 0x07));
+  // [4]:5 bits
+  dst[7] = Base32EncodeChar((src[4] << 0) & 0x1F);
+}
+
+// -- Class methods
+
+cmBase32Encoder::cmBase32Encoder()
+{
+}
+
+cmBase32Encoder::~cmBase32Encoder()
+{
+}
+
+std::string cmBase32Encoder::encodeString(const unsigned char* input,
+                                          size_t len, bool padding)
+{
+  std::string res;
+
+  static const size_t blockSize = 5;
+  static const size_t bufferSize = 8;
+  char buffer[bufferSize];
+
+  const unsigned char* end = input + len;
+  while ((input + blockSize) <= end) {
+    Base32Encode5(input, buffer);
+    res.append(buffer, bufferSize);
+    input += blockSize;
+  }
+
+  size_t remain = static_cast<size_t>(end - input);
+  if (remain != 0) {
+    // Temporary source buffer filled up with 0s
+    unsigned char extended[blockSize];
+    for (size_t ii = 0; ii != remain; ++ii) {
+      extended[ii] = input[ii];
+    }
+    for (size_t ii = remain; ii != blockSize; ++ii) {
+      extended[ii] = 0;
+    }
+
+    Base32Encode5(extended, buffer);
+    size_t numPad(0);
+    switch (remain) {
+      case 1:
+        numPad = 6;
+        break;
+      case 2:
+        numPad = 4;
+        break;
+      case 3:
+        numPad = 3;
+        break;
+      case 4:
+        numPad = 1;
+        break;
+      default:
+        break;
+    }
+    res.append(buffer, bufferSize - numPad);
+    if (padding) {
+      for (size_t ii = 0; ii != numPad; ++ii) {
+        res.push_back(paddingChar);
+      }
+    }
+  }
+
+  return res;
+}
diff --git a/Source/cmBase32.h b/Source/cmBase32.h
new file mode 100644
index 0000000..c6758d4
--- /dev/null
+++ b/Source/cmBase32.h
@@ -0,0 +1,33 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmBase32_h
+#define cmBase32_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stddef.h>
+#include <string>
+
+/** \class cmBase32Encoder
+ * \brief Encodes a byte sequence to a Base32 byte sequence according to
+ * RFC4648
+ *
+ */
+class cmBase32Encoder
+{
+public:
+  static const char paddingChar = '=';
+
+public:
+  cmBase32Encoder();
+  ~cmBase32Encoder();
+
+  // Encodes the given input byte sequence into a string
+  // @arg input Input data pointer
+  // @arg len Input data size
+  // @arg padding Flag to append "=" on demand
+  std::string encodeString(const unsigned char* input, size_t len,
+                           bool padding = true);
+};
+
+#endif
diff --git a/Source/cmBreakCommand.cxx b/Source/cmBreakCommand.cxx
new file mode 100644
index 0000000..3772c6f
--- /dev/null
+++ b/Source/cmBreakCommand.cxx
@@ -0,0 +1,74 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmBreakCommand.h"
+
+#include <sstream>
+
+#include "cmExecutionStatus.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmake.h"
+
+// cmBreakCommand
+bool cmBreakCommand::InitialPass(std::vector<std::string> const& args,
+                                 cmExecutionStatus& status)
+{
+  if (!this->Makefile->IsLoopBlock()) {
+    bool issueMessage = true;
+    std::ostringstream e;
+    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0055)) {
+      case cmPolicies::WARN:
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
+        break;
+      case cmPolicies::OLD:
+        issueMessage = false;
+        break;
+      case cmPolicies::REQUIRED_ALWAYS:
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::NEW:
+        messageType = cmake::FATAL_ERROR;
+        break;
+    }
+
+    if (issueMessage) {
+      e << "A BREAK command was found outside of a proper "
+           "FOREACH or WHILE loop scope.";
+      this->Makefile->IssueMessage(messageType, e.str());
+      if (messageType == cmake::FATAL_ERROR) {
+        return false;
+      }
+    }
+  }
+
+  status.SetBreakInvoked();
+
+  if (!args.empty()) {
+    bool issueMessage = true;
+    std::ostringstream e;
+    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0055)) {
+      case cmPolicies::WARN:
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
+        break;
+      case cmPolicies::OLD:
+        issueMessage = false;
+        break;
+      case cmPolicies::REQUIRED_ALWAYS:
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::NEW:
+        messageType = cmake::FATAL_ERROR;
+        break;
+    }
+
+    if (issueMessage) {
+      e << "The BREAK command does not accept any arguments.";
+      this->Makefile->IssueMessage(messageType, e.str());
+      if (messageType == cmake::FATAL_ERROR) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h
new file mode 100644
index 0000000..3b18567
--- /dev/null
+++ b/Source/cmBreakCommand.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmBreakCommand_h
+#define cmBreakCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmBreakCommand
+ * \brief Break from an enclosing foreach or while loop
+ *
+ * cmBreakCommand returns from an enclosing foreach or while loop
+ */
+class cmBreakCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmBreakCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
new file mode 100644
index 0000000..fd87600
--- /dev/null
+++ b/Source/cmBuildCommand.cxx
@@ -0,0 +1,128 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmBuildCommand.h"
+
+#include <sstream>
+
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+bool cmBuildCommand::InitialPass(std::vector<std::string> const& args,
+                                 cmExecutionStatus&)
+{
+  // Support the legacy signature of the command:
+  //
+  if (2 == args.size()) {
+    return this->TwoArgsSignature(args);
+  }
+
+  return this->MainSignature(args);
+}
+
+bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
+{
+  if (args.empty()) {
+    this->SetError("requires at least one argument naming a CMake variable");
+    return false;
+  }
+
+  // The cmake variable in which to store the result.
+  std::string const& variable = args[0];
+
+  // Parse remaining arguments.
+  std::string configuration;
+  std::string project_name;
+  std::string target;
+  enum Doing
+  {
+    DoingNone,
+    DoingConfiguration,
+    DoingProjectName,
+    DoingTarget
+  };
+  Doing doing = DoingNone;
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "CONFIGURATION") {
+      doing = DoingConfiguration;
+    } else if (args[i] == "PROJECT_NAME") {
+      doing = DoingProjectName;
+    } else if (args[i] == "TARGET") {
+      doing = DoingTarget;
+    } else if (doing == DoingConfiguration) {
+      doing = DoingNone;
+      configuration = args[i];
+    } else if (doing == DoingProjectName) {
+      doing = DoingNone;
+      project_name = args[i];
+    } else if (doing == DoingTarget) {
+      doing = DoingNone;
+      target = args[i];
+    } else {
+      std::ostringstream e;
+      e << "unknown argument \"" << args[i] << "\"";
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  // If null/empty CONFIGURATION argument, cmake --build uses 'Debug'
+  // in the currently implemented multi-configuration global generators...
+  // so we put this code here to end up with the same default configuration
+  // as the original 2-arg build_command signature:
+  //
+  if (configuration.empty()) {
+    cmSystemTools::GetEnv("CMAKE_CONFIG_TYPE", configuration);
+  }
+  if (configuration.empty()) {
+    configuration = "Release";
+  }
+
+  if (!project_name.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::AUTHOR_WARNING,
+      "Ignoring PROJECT_NAME option because it has no effect.");
+  }
+
+  std::string makecommand =
+    this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
+      target, configuration, "", this->Makefile->IgnoreErrorsCMP0061());
+
+  this->Makefile->AddDefinition(variable, makecommand.c_str());
+
+  return true;
+}
+
+bool cmBuildCommand::TwoArgsSignature(std::vector<std::string> const& args)
+{
+  if (args.size() < 2) {
+    this->SetError("called with less than two arguments");
+    return false;
+  }
+
+  std::string const& define = args[0];
+  const char* cacheValue = this->Makefile->GetDefinition(define);
+
+  std::string configType;
+  if (!cmSystemTools::GetEnv("CMAKE_CONFIG_TYPE", configType) ||
+      configType.empty()) {
+    configType = "Release";
+  }
+
+  std::string makecommand =
+    this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
+      "", configType, "", this->Makefile->IgnoreErrorsCMP0061());
+
+  if (cacheValue) {
+    return true;
+  }
+  this->Makefile->AddCacheDefinition(define, makecommand.c_str(),
+                                     "Command used to build entire project "
+                                     "from the command line.",
+                                     cmStateEnums::STRING);
+  return true;
+}
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
new file mode 100644
index 0000000..e0529a4
--- /dev/null
+++ b/Source/cmBuildCommand.h
@@ -0,0 +1,49 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmBuildCommand_h
+#define cmBuildCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmBuildCommand
+ * \brief build_command command
+ *
+ * cmBuildCommand implements the build_command CMake command
+ */
+class cmBuildCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmBuildCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  /**
+   * The primary command signature with optional, KEYWORD-based args.
+   */
+  virtual bool MainSignature(std::vector<std::string> const& args);
+
+  /**
+   * Legacy "exactly 2 args required" signature.
+   */
+  virtual bool TwoArgsSignature(std::vector<std::string> const& args);
+
+private:
+  bool IgnoreErrors() const;
+};
+
+#endif
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
new file mode 100644
index 0000000..5f54338
--- /dev/null
+++ b/Source/cmBuildNameCommand.cxx
@@ -0,0 +1,60 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmBuildNameCommand.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+
+class cmExecutionStatus;
+
+// cmBuildNameCommand
+bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args,
+                                     cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  const char* cacheValue = this->Makefile->GetDefinition(args[0]);
+  if (cacheValue) {
+    // do we need to correct the value?
+    cmsys::RegularExpression reg("[()/]");
+    if (reg.find(cacheValue)) {
+      std::string cv = cacheValue;
+      std::replace(cv.begin(), cv.end(), '/', '_');
+      std::replace(cv.begin(), cv.end(), '(', '_');
+      std::replace(cv.begin(), cv.end(), ')', '_');
+      this->Makefile->AddCacheDefinition(args[0], cv.c_str(), "Name of build.",
+                                         cmStateEnums::STRING);
+    }
+    return true;
+  }
+
+  std::string buildname = "WinNT";
+  if (this->Makefile->GetDefinition("UNIX")) {
+    buildname.clear();
+    cmSystemTools::RunSingleCommand("uname -a", &buildname, &buildname);
+    if (!buildname.empty()) {
+      std::string RegExp = "([^ ]*) [^ ]* ([^ ]*) ";
+      cmsys::RegularExpression reg(RegExp.c_str());
+      if (reg.find(buildname.c_str())) {
+        buildname = reg.match(1) + "-" + reg.match(2);
+      }
+    }
+  }
+  std::string compiler = "${CMAKE_CXX_COMPILER}";
+  this->Makefile->ExpandVariablesInString(compiler);
+  buildname += "-";
+  buildname += cmSystemTools::GetFilenameName(compiler);
+  std::replace(buildname.begin(), buildname.end(), '/', '_');
+  std::replace(buildname.begin(), buildname.end(), '(', '_');
+  std::replace(buildname.begin(), buildname.end(), ')', '_');
+
+  this->Makefile->AddCacheDefinition(args[0], buildname.c_str(),
+                                     "Name of build.", cmStateEnums::STRING);
+  return true;
+}
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
new file mode 100644
index 0000000..4bb72d1
--- /dev/null
+++ b/Source/cmBuildNameCommand.h
@@ -0,0 +1,23 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmBuildNameCommand_h
+#define cmBuildNameCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+class cmBuildNameCommand : public cmCommand
+{
+public:
+  cmCommand* Clone() override { return new cmBuildNameCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmCLocaleEnvironmentScope.cxx b/Source/cmCLocaleEnvironmentScope.cxx
new file mode 100644
index 0000000..737e3ea
--- /dev/null
+++ b/Source/cmCLocaleEnvironmentScope.cxx
@@ -0,0 +1,53 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCLocaleEnvironmentScope.h"
+
+#include "cmSystemTools.h"
+
+#include <sstream>
+#include <utility>
+
+cmCLocaleEnvironmentScope::cmCLocaleEnvironmentScope()
+{
+  this->SetEnv("LANGUAGE", "");
+  this->SetEnv("LC_MESSAGES", "C");
+
+  std::string lcAll = this->GetEnv("LC_ALL");
+
+  if (!lcAll.empty()) {
+    this->SetEnv("LC_ALL", "");
+    this->SetEnv("LC_CTYPE", lcAll);
+  }
+}
+
+std::string cmCLocaleEnvironmentScope::GetEnv(std::string const& key)
+{
+  std::string value;
+  cmSystemTools::GetEnv(key, value);
+  return value;
+}
+
+void cmCLocaleEnvironmentScope::SetEnv(std::string const& key,
+                                       std::string const& value)
+{
+  std::string oldValue = this->GetEnv(key);
+
+  this->EnvironmentBackup.insert(std::make_pair(key, oldValue));
+
+  if (value.empty()) {
+    cmSystemTools::UnsetEnv(key.c_str());
+  } else {
+    std::ostringstream tmp;
+    tmp << key << "=" << value;
+    cmSystemTools::PutEnv(tmp.str());
+  }
+}
+
+cmCLocaleEnvironmentScope::~cmCLocaleEnvironmentScope()
+{
+  for (auto const& envb : this->EnvironmentBackup) {
+    std::ostringstream tmp;
+    tmp << envb.first << "=" << envb.second;
+    cmSystemTools::PutEnv(tmp.str());
+  }
+}
diff --git a/Source/cmCLocaleEnvironmentScope.h b/Source/cmCLocaleEnvironmentScope.h
new file mode 100644
index 0000000..ec81cb9
--- /dev/null
+++ b/Source/cmCLocaleEnvironmentScope.h
@@ -0,0 +1,27 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCLocaleEnvironmentScope_h
+#define cmCLocaleEnvironmentScope_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+
+class cmCLocaleEnvironmentScope
+{
+  CM_DISABLE_COPY(cmCLocaleEnvironmentScope)
+
+public:
+  cmCLocaleEnvironmentScope();
+  ~cmCLocaleEnvironmentScope();
+
+private:
+  std::string GetEnv(std::string const& key);
+  void SetEnv(std::string const& key, std::string const& value);
+
+  typedef std::map<std::string, std::string> backup_map_t;
+  backup_map_t EnvironmentBackup;
+};
+
+#endif
diff --git a/Source/cmCMakeHostSystemInformationCommand.cxx b/Source/cmCMakeHostSystemInformationCommand.cxx
new file mode 100644
index 0000000..662dd74
--- /dev/null
+++ b/Source/cmCMakeHostSystemInformationCommand.cxx
@@ -0,0 +1,177 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCMakeHostSystemInformationCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmsys/SystemInformation.hxx"
+
+#if defined(_WIN32)
+#include "cmAlgorithms.h"
+#include "cmGlobalGenerator.h"
+#include "cmGlobalVisualStudio15Generator.h"
+#include "cmSystemTools.h"
+#include "cmVSSetupHelper.h"
+#define HAVE_VS_SETUP_HELPER
+#endif
+
+class cmExecutionStatus;
+
+// cmCMakeHostSystemInformation
+bool cmCMakeHostSystemInformationCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  size_t current_index = 0;
+
+  if (args.size() < (current_index + 2) || args[current_index] != "RESULT") {
+    this->SetError("missing RESULT specification.");
+    return false;
+  }
+
+  std::string const& variable = args[current_index + 1];
+  current_index += 2;
+
+  if (args.size() < (current_index + 2) || args[current_index] != "QUERY") {
+    this->SetError("missing QUERY specification");
+    return false;
+  }
+
+  cmsys::SystemInformation info;
+  info.RunCPUCheck();
+  info.RunOSCheck();
+  info.RunMemoryCheck();
+
+  std::string result_list;
+  for (size_t i = current_index + 1; i < args.size(); ++i) {
+    std::string const& key = args[i];
+    if (i != current_index + 1) {
+      result_list += ";";
+    }
+    std::string value;
+    if (!this->GetValue(info, key, value)) {
+      return false;
+    }
+    result_list += value;
+  }
+
+  this->Makefile->AddDefinition(variable, result_list.c_str());
+
+  return true;
+}
+
+bool cmCMakeHostSystemInformationCommand::GetValue(
+  cmsys::SystemInformation& info, std::string const& key, std::string& value)
+{
+  if (key == "NUMBER_OF_LOGICAL_CORES") {
+    value = this->ValueToString(info.GetNumberOfLogicalCPU());
+  } else if (key == "NUMBER_OF_PHYSICAL_CORES") {
+    value = this->ValueToString(info.GetNumberOfPhysicalCPU());
+  } else if (key == "HOSTNAME") {
+    value = this->ValueToString(info.GetHostname());
+  } else if (key == "FQDN") {
+    value = this->ValueToString(info.GetFullyQualifiedDomainName());
+  } else if (key == "TOTAL_VIRTUAL_MEMORY") {
+    value = this->ValueToString(info.GetTotalVirtualMemory());
+  } else if (key == "AVAILABLE_VIRTUAL_MEMORY") {
+    value = this->ValueToString(info.GetAvailableVirtualMemory());
+  } else if (key == "TOTAL_PHYSICAL_MEMORY") {
+    value = this->ValueToString(info.GetTotalPhysicalMemory());
+  } else if (key == "AVAILABLE_PHYSICAL_MEMORY") {
+    value = this->ValueToString(info.GetAvailablePhysicalMemory());
+  } else if (key == "IS_64BIT") {
+    value = this->ValueToString(info.Is64Bits());
+  } else if (key == "HAS_FPU") {
+    value = this->ValueToString(
+      info.DoesCPUSupportFeature(cmsys::SystemInformation::CPU_FEATURE_FPU));
+  } else if (key == "HAS_MMX") {
+    value = this->ValueToString(
+      info.DoesCPUSupportFeature(cmsys::SystemInformation::CPU_FEATURE_MMX));
+  } else if (key == "HAS_MMX_PLUS") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_MMX_PLUS));
+  } else if (key == "HAS_SSE") {
+    value = this->ValueToString(
+      info.DoesCPUSupportFeature(cmsys::SystemInformation::CPU_FEATURE_SSE));
+  } else if (key == "HAS_SSE2") {
+    value = this->ValueToString(
+      info.DoesCPUSupportFeature(cmsys::SystemInformation::CPU_FEATURE_SSE2));
+  } else if (key == "HAS_SSE_FP") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_SSE_FP));
+  } else if (key == "HAS_SSE_MMX") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_SSE_MMX));
+  } else if (key == "HAS_AMD_3DNOW") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_AMD_3DNOW));
+  } else if (key == "HAS_AMD_3DNOW_PLUS") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_AMD_3DNOW_PLUS));
+  } else if (key == "HAS_IA64") {
+    value = this->ValueToString(
+      info.DoesCPUSupportFeature(cmsys::SystemInformation::CPU_FEATURE_IA64));
+  } else if (key == "HAS_SERIAL_NUMBER") {
+    value = this->ValueToString(info.DoesCPUSupportFeature(
+      cmsys::SystemInformation::CPU_FEATURE_SERIALNUMBER));
+  } else if (key == "PROCESSOR_NAME") {
+    value = this->ValueToString(info.GetExtendedProcessorName());
+  } else if (key == "PROCESSOR_DESCRIPTION") {
+    value = info.GetCPUDescription();
+  } else if (key == "PROCESSOR_SERIAL_NUMBER") {
+    value = this->ValueToString(info.GetProcessorSerialNumber());
+  } else if (key == "OS_NAME") {
+    value = this->ValueToString(info.GetOSName());
+  } else if (key == "OS_RELEASE") {
+    value = this->ValueToString(info.GetOSRelease());
+  } else if (key == "OS_VERSION") {
+    value = this->ValueToString(info.GetOSVersion());
+  } else if (key == "OS_PLATFORM") {
+    value = this->ValueToString(info.GetOSPlatform());
+#ifdef HAVE_VS_SETUP_HELPER
+  } else if (key == "VS_15_DIR") {
+    // If generating for the VS 15 IDE, use the same instance.
+    cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+    if (cmHasLiteralPrefix(gg->GetName(), "Visual Studio 15 ")) {
+      cmGlobalVisualStudio15Generator* vs15gen =
+        static_cast<cmGlobalVisualStudio15Generator*>(gg);
+      if (vs15gen->GetVSInstance(value)) {
+        return true;
+      }
+    }
+
+    // Otherwise, find a VS 15 instance ourselves.
+    cmVSSetupAPIHelper vsSetupAPIHelper;
+    if (vsSetupAPIHelper.GetVSInstanceInfo(value)) {
+      cmSystemTools::ConvertToUnixSlashes(value);
+    }
+#endif
+  } else {
+    std::string e = "does not recognize <key> " + key;
+    this->SetError(e);
+    return false;
+  }
+
+  return true;
+}
+
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  size_t value) const
+{
+  std::ostringstream tmp;
+  tmp << value;
+  return tmp.str();
+}
+
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  const char* value) const
+{
+  std::string safe_string = value ? value : "";
+  return safe_string;
+}
+
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  std::string const& value) const
+{
+  return value;
+}
diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h
new file mode 100644
index 0000000..b871641
--- /dev/null
+++ b/Source/cmCMakeHostSystemInformationCommand.h
@@ -0,0 +1,52 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCMakeHostSystemInformationCommand_h
+#define cmCMakeHostSystemInformationCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+namespace cmsys {
+class SystemInformation;
+} // namespace cmsys
+
+/** \class cmCMakeHostSystemInformationCommand
+ * \brief Query host system specific information
+ *
+ * cmCMakeHostSystemInformationCommand queries system information of
+ * the system on which CMake runs.
+ */
+class cmCMakeHostSystemInformationCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override
+  {
+    return new cmCMakeHostSystemInformationCommand;
+  }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  bool GetValue(cmsys::SystemInformation& info, std::string const& key,
+                std::string& value);
+
+  std::string ValueToString(size_t value) const;
+  std::string ValueToString(const char* value) const;
+  std::string ValueToString(std::string const& value) const;
+};
+
+#endif
diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx
new file mode 100644
index 0000000..bcc41fc
--- /dev/null
+++ b/Source/cmCMakeMinimumRequired.cxx
@@ -0,0 +1,116 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCMakeMinimumRequired.h"
+
+#include <sstream>
+#include <stdio.h>
+
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmCMakeMinimumRequired
+bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
+{
+  // Process arguments.
+  std::string version_string;
+  bool doing_version = false;
+  for (std::string const& arg : args) {
+    if (arg == "VERSION") {
+      doing_version = true;
+    } else if (arg == "FATAL_ERROR") {
+      if (doing_version) {
+        this->SetError("called with no value for VERSION.");
+        return false;
+      }
+      doing_version = false;
+    } else if (doing_version) {
+      doing_version = false;
+      version_string = arg;
+    } else {
+      this->UnknownArguments.push_back(arg);
+    }
+  }
+  if (doing_version) {
+    this->SetError("called with no value for VERSION.");
+    return false;
+  }
+
+  // Make sure there was a version to check.
+  if (version_string.empty()) {
+    return this->EnforceUnknownArguments();
+  }
+
+  // Save the required version string.
+  this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
+                                version_string.c_str());
+
+  // Get the current version number.
+  unsigned int current_major = cmVersion::GetMajorVersion();
+  unsigned int current_minor = cmVersion::GetMinorVersion();
+  unsigned int current_patch = cmVersion::GetPatchVersion();
+  unsigned int current_tweak = cmVersion::GetTweakVersion();
+
+  // Parse at least two components of the version number.
+  // Use zero for those not specified.
+  unsigned int required_major = 0;
+  unsigned int required_minor = 0;
+  unsigned int required_patch = 0;
+  unsigned int required_tweak = 0;
+  if (sscanf(version_string.c_str(), "%u.%u.%u.%u", &required_major,
+             &required_minor, &required_patch, &required_tweak) < 2) {
+    std::ostringstream e;
+    e << "could not parse VERSION \"" << version_string << "\".";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Compare the version numbers.
+  if ((current_major < required_major) ||
+      (current_major == required_major && current_minor < required_minor) ||
+      (current_major == required_major && current_minor == required_minor &&
+       current_patch < required_patch) ||
+      (current_major == required_major && current_minor == required_minor &&
+       current_patch == required_patch && current_tweak < required_tweak)) {
+    // The current version is too low.
+    std::ostringstream e;
+    e << "CMake " << version_string
+      << " or higher is required.  You are running version "
+      << cmVersion::GetCMakeVersion();
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+    cmSystemTools::SetFatalErrorOccured();
+    return true;
+  }
+
+  // The version is not from the future, so enforce unknown arguments.
+  if (!this->EnforceUnknownArguments()) {
+    return false;
+  }
+
+  if (required_major < 2 || (required_major == 2 && required_minor < 4)) {
+    this->Makefile->IssueMessage(
+      cmake::AUTHOR_WARNING,
+      "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.");
+    this->Makefile->SetPolicyVersion("2.4");
+  } else {
+    this->Makefile->SetPolicyVersion(version_string.c_str());
+  }
+
+  return true;
+}
+
+bool cmCMakeMinimumRequired::EnforceUnknownArguments()
+{
+  if (!this->UnknownArguments.empty()) {
+    std::ostringstream e;
+    e << "called with unknown argument \"" << this->UnknownArguments[0]
+      << "\".";
+    this->SetError(e.str());
+    return false;
+  }
+  return true;
+}
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
new file mode 100644
index 0000000..18d9460
--- /dev/null
+++ b/Source/cmCMakeMinimumRequired.h
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCMakeMinimumRequired_h
+#define cmCMakeMinimumRequired_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmCMakeMinimumRequired
+ * \brief cmake_minimum_required command
+ *
+ * cmCMakeMinimumRequired implements the cmake_minimum_required CMake command
+ */
+class cmCMakeMinimumRequired : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmCMakeMinimumRequired; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  std::vector<std::string> UnknownArguments;
+  bool EnforceUnknownArguments();
+};
+
+#endif
diff --git a/Source/cmCMakePolicyCommand.cxx b/Source/cmCMakePolicyCommand.cxx
new file mode 100644
index 0000000..3ccc815
--- /dev/null
+++ b/Source/cmCMakePolicyCommand.cxx
@@ -0,0 +1,161 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCMakePolicyCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmCMakePolicyCommand
+bool cmCMakePolicyCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("requires at least one argument.");
+    return false;
+  }
+
+  if (args[0] == "SET") {
+    return this->HandleSetMode(args);
+  }
+  if (args[0] == "GET") {
+    return this->HandleGetMode(args);
+  }
+  if (args[0] == "PUSH") {
+    if (args.size() > 1) {
+      this->SetError("PUSH may not be given additional arguments.");
+      return false;
+    }
+    this->Makefile->PushPolicy();
+    return true;
+  }
+  if (args[0] == "POP") {
+    if (args.size() > 1) {
+      this->SetError("POP may not be given additional arguments.");
+      return false;
+    }
+    this->Makefile->PopPolicy();
+    return true;
+  }
+  if (args[0] == "VERSION") {
+    return this->HandleVersionMode(args);
+  }
+
+  std::ostringstream e;
+  e << "given unknown first argument \"" << args[0] << "\"";
+  this->SetError(e.str());
+  return false;
+}
+
+bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
+{
+  if (args.size() != 3) {
+    this->SetError("SET must be given exactly 2 additional arguments.");
+    return false;
+  }
+
+  cmPolicies::PolicyStatus status;
+  if (args[2] == "OLD") {
+    status = cmPolicies::OLD;
+  } else if (args[2] == "NEW") {
+    status = cmPolicies::NEW;
+  } else {
+    std::ostringstream e;
+    e << "SET given unrecognized policy status \"" << args[2] << "\"";
+    this->SetError(e.str());
+    return false;
+  }
+
+  if (!this->Makefile->SetPolicy(args[1].c_str(), status)) {
+    this->SetError("SET failed to set policy.");
+    return false;
+  }
+  if (args[1] == "CMP0001" &&
+      (status == cmPolicies::WARN || status == cmPolicies::OLD)) {
+    if (!(this->Makefile->GetState()->GetInitializedCacheValue(
+          "CMAKE_BACKWARDS_COMPATIBILITY"))) {
+      // Set it to 2.4 because that is the last version where the
+      // variable had meaning.
+      this->Makefile->AddCacheDefinition(
+        "CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
+        "For backwards compatibility, what version of CMake "
+        "commands and "
+        "syntax should this version of CMake try to support.",
+        cmStateEnums::STRING);
+    }
+  }
+  return true;
+}
+
+bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
+{
+  if (args.size() != 3) {
+    this->SetError("GET must be given exactly 2 additional arguments.");
+    return false;
+  }
+
+  // Get arguments.
+  std::string const& id = args[1];
+  std::string const& var = args[2];
+
+  // Lookup the policy number.
+  cmPolicies::PolicyID pid;
+  if (!cmPolicies::GetPolicyID(id.c_str(), pid)) {
+    std::ostringstream e;
+    e << "GET given policy \"" << id << "\" which is not known to this "
+      << "version of CMake.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Lookup the policy setting.
+  cmPolicies::PolicyStatus status = this->Makefile->GetPolicyStatus(pid);
+  switch (status) {
+    case cmPolicies::OLD:
+      // Report that the policy is set to OLD.
+      this->Makefile->AddDefinition(var, "OLD");
+      break;
+    case cmPolicies::WARN:
+      // Report that the policy is not set.
+      this->Makefile->AddDefinition(var, "");
+      break;
+    case cmPolicies::NEW:
+      // Report that the policy is set to NEW.
+      this->Makefile->AddDefinition(var, "NEW");
+      break;
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::REQUIRED_ALWAYS:
+      // The policy is required to be set before anything needs it.
+      {
+        std::ostringstream e;
+        e << cmPolicies::GetRequiredPolicyError(pid) << "\n"
+          << "The call to cmake_policy(GET " << id << " ...) at which this "
+          << "error appears requests the policy, and this version of CMake "
+          << "requires that the policy be set to NEW before it is checked.";
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      }
+  }
+
+  return true;
+}
+
+bool cmCMakePolicyCommand::HandleVersionMode(
+  std::vector<std::string> const& args)
+{
+  if (args.size() <= 1) {
+    this->SetError("VERSION not given an argument");
+    return false;
+  }
+  if (args.size() >= 3) {
+    this->SetError("VERSION given too many arguments");
+    return false;
+  }
+  this->Makefile->SetPolicyVersion(args[1].c_str());
+  return true;
+}
diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h
new file mode 100644
index 0000000..b18576c
--- /dev/null
+++ b/Source/cmCMakePolicyCommand.h
@@ -0,0 +1,42 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCMakePolicyCommand_h
+#define cmCMakePolicyCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmCMakePolicyCommand
+ * \brief Set how CMake should handle policies
+ *
+ * cmCMakePolicyCommand sets how CMake should deal with backwards
+ * compatibility policies.
+ */
+class cmCMakePolicyCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmCMakePolicyCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  bool HandleSetMode(std::vector<std::string> const& args);
+  bool HandleGetMode(std::vector<std::string> const& args);
+  bool HandleVersionMode(std::vector<std::string> const& args);
+};
+
+#endif
diff --git a/Source/cmCPackPropertiesGenerator.cxx b/Source/cmCPackPropertiesGenerator.cxx
new file mode 100644
index 0000000..a33b824
--- /dev/null
+++ b/Source/cmCPackPropertiesGenerator.cxx
@@ -0,0 +1,45 @@
+#include "cmCPackPropertiesGenerator.h"
+
+#include "cmGeneratorExpression.h"
+#include "cmInstalledFile.h"
+#include "cmOutputConverter.h"
+
+#include <map>
+#include <ostream>
+
+cmCPackPropertiesGenerator::cmCPackPropertiesGenerator(
+  cmLocalGenerator* lg, cmInstalledFile const& installedFile,
+  std::vector<std::string> const& configurations)
+  : cmScriptGenerator("CPACK_BUILD_CONFIG", configurations)
+  , LG(lg)
+  , InstalledFile(installedFile)
+{
+  this->ActionsPerConfig = true;
+}
+
+void cmCPackPropertiesGenerator::GenerateScriptForConfig(
+  std::ostream& os, const std::string& config, Indent indent)
+{
+  std::string const& expandedFileName =
+    this->InstalledFile.GetNameExpression().Evaluate(this->LG, config);
+
+  cmInstalledFile::PropertyMapType const& properties =
+    this->InstalledFile.GetProperties();
+
+  for (cmInstalledFile::PropertyMapType::value_type const& i : properties) {
+    std::string const& name = i.first;
+    cmInstalledFile::Property const& property = i.second;
+
+    os << indent << "set_property(INSTALL "
+       << cmOutputConverter::EscapeForCMake(expandedFileName) << " PROPERTY "
+       << cmOutputConverter::EscapeForCMake(name);
+
+    for (cmInstalledFile::ExpressionVectorType::value_type const& j :
+         property.ValueExpressions) {
+      std::string value = j->Evaluate(this->LG, config);
+      os << " " << cmOutputConverter::EscapeForCMake(value);
+    }
+
+    os << ")\n";
+  }
+}
diff --git a/Source/cmCPackPropertiesGenerator.h b/Source/cmCPackPropertiesGenerator.h
new file mode 100644
index 0000000..e580e04
--- /dev/null
+++ b/Source/cmCPackPropertiesGenerator.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCPackPropertiesGenerator_h
+#define cmCPackPropertiesGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmScriptGenerator.h"
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+class cmInstalledFile;
+class cmLocalGenerator;
+
+/** \class cmCPackPropertiesGenerator
+ * \brief Support class for generating CPackProperties.cmake.
+ *
+ */
+class cmCPackPropertiesGenerator : public cmScriptGenerator
+{
+  CM_DISABLE_COPY(cmCPackPropertiesGenerator)
+
+public:
+  cmCPackPropertiesGenerator(cmLocalGenerator* lg,
+                             cmInstalledFile const& installedFile,
+                             std::vector<std::string> const& configurations);
+
+protected:
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent indent) override;
+
+  cmLocalGenerator* LG;
+  cmInstalledFile const& InstalledFile;
+};
+
+#endif
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
new file mode 100644
index 0000000..18a1022
--- /dev/null
+++ b/Source/cmCPluginAPI.cxx
@@ -0,0 +1,861 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/*
+   this file contains the implementation of the C API to CMake. Generally
+   these routines just manipulate arguments and then call the associated
+   methods on the CMake classes. */
+
+#include "cmCPluginAPI.h"
+
+#include "cmExecutionStatus.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSourceFile.h"
+#include "cmState.h"
+#include "cmVersion.h"
+
+#include <stdlib.h>
+
+#ifdef __QNX__
+#include <malloc.h> /* for malloc/free on QNX */
+#endif
+
+extern "C" {
+
+void CCONV* cmGetClientData(void* info)
+{
+  return ((cmLoadedCommandInfo*)info)->ClientData;
+}
+
+void CCONV cmSetClientData(void* info, void* cd)
+{
+  ((cmLoadedCommandInfo*)info)->ClientData = cd;
+}
+
+void CCONV cmSetError(void* info, const char* err)
+{
+  if (((cmLoadedCommandInfo*)info)->Error) {
+    free(((cmLoadedCommandInfo*)info)->Error);
+  }
+  ((cmLoadedCommandInfo*)info)->Error = strdup(err);
+}
+
+unsigned int CCONV cmGetCacheMajorVersion(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmState* state = mf->GetState();
+  return state->GetCacheMajorVersion();
+}
+unsigned int CCONV cmGetCacheMinorVersion(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmState* state = mf->GetState();
+  return state->GetCacheMinorVersion();
+}
+
+unsigned int CCONV cmGetMajorVersion(void*)
+{
+  return cmVersion::GetMajorVersion();
+}
+
+unsigned int CCONV cmGetMinorVersion(void*)
+{
+  return cmVersion::GetMinorVersion();
+}
+
+void CCONV cmAddDefinition(void* arg, const char* name, const char* value)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->AddDefinition(name, value);
+}
+
+/* Add a definition to this makefile and the global cmake cache. */
+void CCONV cmAddCacheDefinition(void* arg, const char* name, const char* value,
+                                const char* doc, int type)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  switch (type) {
+    case CM_CACHE_BOOL:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::BOOL);
+      break;
+    case CM_CACHE_PATH:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::PATH);
+      break;
+    case CM_CACHE_FILEPATH:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::FILEPATH);
+      break;
+    case CM_CACHE_STRING:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::STRING);
+      break;
+    case CM_CACHE_INTERNAL:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::INTERNAL);
+      break;
+    case CM_CACHE_STATIC:
+      mf->AddCacheDefinition(name, value, doc, cmStateEnums::STATIC);
+      break;
+  }
+}
+
+const char* CCONV cmGetProjectName(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  static std::string name;
+  name = mf->GetStateSnapshot().GetProjectName();
+  return name.c_str();
+}
+
+const char* CCONV cmGetHomeDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetHomeDirectory();
+}
+const char* CCONV cmGetHomeOutputDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetHomeOutputDirectory();
+}
+const char* CCONV cmGetStartDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetCurrentSourceDirectory();
+}
+const char* CCONV cmGetStartOutputDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetCurrentBinaryDirectory();
+}
+const char* CCONV cmGetCurrentDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetCurrentSourceDirectory();
+}
+const char* CCONV cmGetCurrentOutputDirectory(void* arg)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetCurrentBinaryDirectory();
+}
+const char* CCONV cmGetDefinition(void* arg, const char* def)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return mf->GetDefinition(def);
+}
+
+int CCONV cmIsOn(void* arg, const char* name)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return static_cast<int>(mf->IsOn(name));
+}
+
+/** Check if a command exists. */
+int CCONV cmCommandExists(void* arg, const char* name)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  return static_cast<int>(mf->GetState()->GetCommand(name) ? 1 : 0);
+}
+
+void CCONV cmAddDefineFlag(void* arg, const char* definition)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->AddDefineFlag(definition);
+}
+
+void CCONV cmAddLinkDirectoryForTarget(void* arg, const char* tgt,
+                                       const char* d)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmTarget* t = mf->FindLocalNonAliasTarget(tgt);
+  if (!t) {
+    cmSystemTools::Error(
+      "Attempt to add link directories to non-existent target: ", tgt,
+      " for directory ", d);
+    return;
+  }
+  t->AddLinkDirectory(d);
+}
+
+void CCONV cmAddExecutable(void* arg, const char* exename, int numSrcs,
+                           const char** srcs, int win32)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  std::vector<std::string> srcs2;
+  int i;
+  for (i = 0; i < numSrcs; ++i) {
+    srcs2.push_back(srcs[i]);
+  }
+  cmTarget* tg = mf->AddExecutable(exename, srcs2);
+  if (win32) {
+    tg->SetProperty("WIN32_EXECUTABLE", "ON");
+  }
+}
+
+void CCONV cmAddUtilityCommand(void* arg, const char* utilityName,
+                               const char* command, const char* arguments,
+                               int all, int numDepends, const char** depends,
+                               int, const char**)
+{
+  // Get the makefile instance.  Perform an extra variable expansion
+  // now because the API caller expects it.
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  // Construct the command line for the command.
+  cmCustomCommandLine commandLine;
+  std::string expand = command;
+  commandLine.push_back(mf->ExpandVariablesInString(expand));
+  if (arguments && arguments[0]) {
+    // TODO: Parse arguments!
+    expand = arguments;
+    commandLine.push_back(mf->ExpandVariablesInString(expand));
+  }
+  cmCustomCommandLines commandLines;
+  commandLines.push_back(commandLine);
+
+  // Accumulate the list of dependencies.
+  std::vector<std::string> depends2;
+  for (int i = 0; i < numDepends; ++i) {
+    expand = depends[i];
+    depends2.push_back(mf->ExpandVariablesInString(expand));
+  }
+
+  // Pass the call to the makefile instance.
+  mf->AddUtilityCommand(utilityName, cmMakefile::TargetOrigin::Project,
+                        (all ? false : true), nullptr, depends2, commandLines);
+}
+void CCONV cmAddCustomCommand(void* arg, const char* source,
+                              const char* command, int numArgs,
+                              const char** args, int numDepends,
+                              const char** depends, int numOutputs,
+                              const char** outputs, const char* target)
+{
+  // Get the makefile instance.  Perform an extra variable expansion
+  // now because the API caller expects it.
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  // Construct the command line for the command.
+  cmCustomCommandLine commandLine;
+  std::string expand = command;
+  commandLine.push_back(mf->ExpandVariablesInString(expand));
+  for (int i = 0; i < numArgs; ++i) {
+    expand = args[i];
+    commandLine.push_back(mf->ExpandVariablesInString(expand));
+  }
+  cmCustomCommandLines commandLines;
+  commandLines.push_back(commandLine);
+
+  // Accumulate the list of dependencies.
+  std::vector<std::string> depends2;
+  for (int i = 0; i < numDepends; ++i) {
+    expand = depends[i];
+    depends2.push_back(mf->ExpandVariablesInString(expand));
+  }
+
+  // Accumulate the list of outputs.
+  std::vector<std::string> outputs2;
+  for (int i = 0; i < numOutputs; ++i) {
+    expand = outputs[i];
+    outputs2.push_back(mf->ExpandVariablesInString(expand));
+  }
+
+  // Pass the call to the makefile instance.
+  const char* no_comment = nullptr;
+  mf->AddCustomCommandOldStyle(target, outputs2, depends2, source,
+                               commandLines, no_comment);
+}
+
+void CCONV cmAddCustomCommandToOutput(void* arg, const char* output,
+                                      const char* command, int numArgs,
+                                      const char** args,
+                                      const char* main_dependency,
+                                      int numDepends, const char** depends)
+{
+  // Get the makefile instance.  Perform an extra variable expansion
+  // now because the API caller expects it.
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  // Construct the command line for the command.
+  cmCustomCommandLine commandLine;
+  std::string expand = command;
+  commandLine.push_back(mf->ExpandVariablesInString(expand));
+  for (int i = 0; i < numArgs; ++i) {
+    expand = args[i];
+    commandLine.push_back(mf->ExpandVariablesInString(expand));
+  }
+  cmCustomCommandLines commandLines;
+  commandLines.push_back(commandLine);
+
+  // Accumulate the list of dependencies.
+  std::vector<std::string> depends2;
+  for (int i = 0; i < numDepends; ++i) {
+    expand = depends[i];
+    depends2.push_back(mf->ExpandVariablesInString(expand));
+  }
+
+  // Pass the call to the makefile instance.
+  const char* no_comment = nullptr;
+  const char* no_working_dir = nullptr;
+  mf->AddCustomCommandToOutput(output, depends2, main_dependency, commandLines,
+                               no_comment, no_working_dir);
+}
+
+void CCONV cmAddCustomCommandToTarget(void* arg, const char* target,
+                                      const char* command, int numArgs,
+                                      const char** args, int commandType)
+{
+  // Get the makefile instance.
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  // Construct the command line for the command.  Perform an extra
+  // variable expansion now because the API caller expects it.
+  cmCustomCommandLine commandLine;
+  std::string expand = command;
+  commandLine.push_back(mf->ExpandVariablesInString(expand));
+  for (int i = 0; i < numArgs; ++i) {
+    expand = args[i];
+    commandLine.push_back(mf->ExpandVariablesInString(expand));
+  }
+  cmCustomCommandLines commandLines;
+  commandLines.push_back(commandLine);
+
+  // Select the command type.
+  cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
+  switch (commandType) {
+    case CM_PRE_BUILD:
+      cctype = cmTarget::PRE_BUILD;
+      break;
+    case CM_PRE_LINK:
+      cctype = cmTarget::PRE_LINK;
+      break;
+    case CM_POST_BUILD:
+      cctype = cmTarget::POST_BUILD;
+      break;
+  }
+
+  // Pass the call to the makefile instance.
+  std::vector<std::string> no_byproducts;
+  std::vector<std::string> no_depends;
+  const char* no_comment = nullptr;
+  const char* no_working_dir = nullptr;
+  mf->AddCustomCommandToTarget(target, no_byproducts, no_depends, commandLines,
+                               cctype, no_comment, no_working_dir);
+}
+
+static void addLinkLibrary(cmMakefile* mf, std::string const& target,
+                           std::string const& lib, cmTargetLinkLibraryType llt)
+{
+  cmTarget* t = mf->FindLocalNonAliasTarget(target);
+  if (!t) {
+    std::ostringstream e;
+    e << "Attempt to add link library \"" << lib << "\" to target \"" << target
+      << "\" which is not built in this directory.";
+    mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+    return;
+  }
+
+  cmTarget* tgt = mf->GetGlobalGenerator()->FindTarget(lib);
+  if (tgt && (tgt->GetType() != cmStateEnums::STATIC_LIBRARY) &&
+      (tgt->GetType() != cmStateEnums::SHARED_LIBRARY) &&
+      (tgt->GetType() != cmStateEnums::INTERFACE_LIBRARY) &&
+      !tgt->IsExecutableWithExports()) {
+    std::ostringstream e;
+    e << "Target \"" << lib << "\" of type "
+      << cmState::GetTargetTypeName(tgt->GetType())
+      << " may not be linked into another target.  "
+      << "One may link only to STATIC or SHARED libraries, or "
+      << "to executables with the ENABLE_EXPORTS property set.";
+    mf->IssueMessage(cmake::FATAL_ERROR, e.str());
+  }
+
+  t->AddLinkLibrary(*mf, lib, llt);
+}
+
+void CCONV cmAddLinkLibraryForTarget(void* arg, const char* tgt,
+                                     const char* value, int libtype)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+
+  switch (libtype) {
+    case CM_LIBRARY_GENERAL:
+      addLinkLibrary(mf, tgt, value, GENERAL_LibraryType);
+      break;
+    case CM_LIBRARY_DEBUG:
+      addLinkLibrary(mf, tgt, value, DEBUG_LibraryType);
+      break;
+    case CM_LIBRARY_OPTIMIZED:
+      addLinkLibrary(mf, tgt, value, OPTIMIZED_LibraryType);
+      break;
+  }
+}
+
+void CCONV cmAddLibrary(void* arg, const char* libname, int shared,
+                        int numSrcs, const char** srcs)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  std::vector<std::string> srcs2;
+  int i;
+  for (i = 0; i < numSrcs; ++i) {
+    srcs2.push_back(srcs[i]);
+  }
+  mf->AddLibrary(libname, (shared ? cmStateEnums::SHARED_LIBRARY
+                                  : cmStateEnums::STATIC_LIBRARY),
+                 srcs2);
+}
+
+char CCONV* cmExpandVariablesInString(void* arg, const char* source,
+                                      int escapeQuotes, int atOnly)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  std::string barf = source;
+  std::string result = mf->ExpandVariablesInString(barf, escapeQuotes, atOnly);
+  return strdup(result.c_str());
+}
+
+int CCONV cmExecuteCommand(void* arg, const char* name, int numArgs,
+                           const char** args)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmListFileFunction lff;
+  lff.Name = name;
+  for (int i = 0; i < numArgs; ++i) {
+    // Assume all arguments are quoted.
+    lff.Arguments.push_back(
+      cmListFileArgument(args[i], cmListFileArgument::Quoted, 0));
+  }
+  cmExecutionStatus status;
+  return mf->ExecuteCommand(lff, status);
+}
+
+void CCONV cmExpandSourceListArguments(void* arg, int numArgs,
+                                       const char** args, int* resArgc,
+                                       char*** resArgv,
+                                       unsigned int startArgumentIndex)
+{
+  (void)arg;
+  (void)startArgumentIndex;
+  std::vector<std::string> result;
+  int i;
+  for (i = 0; i < numArgs; ++i) {
+    result.push_back(args[i]);
+  }
+  int resargc = static_cast<int>(result.size());
+  char** resargv = nullptr;
+  if (resargc) {
+    resargv = (char**)malloc(resargc * sizeof(char*));
+  }
+  for (i = 0; i < resargc; ++i) {
+    resargv[i] = strdup(result[i].c_str());
+  }
+  *resArgc = resargc;
+  *resArgv = resargv;
+}
+
+void CCONV cmFreeArguments(int argc, char** argv)
+{
+  int i;
+  for (i = 0; i < argc; ++i) {
+    free(argv[i]);
+  }
+  free(argv);
+}
+
+int CCONV cmGetTotalArgumentSize(int argc, char** argv)
+{
+  int i;
+  int result = 0;
+  for (i = 0; i < argc; ++i) {
+    if (argv[i]) {
+      result = result + static_cast<int>(strlen(argv[i]));
+    }
+  }
+  return result;
+}
+
+// Source file proxy object to support the old cmSourceFile/cmMakefile
+// API for source files.
+struct cmCPluginAPISourceFile
+{
+  cmCPluginAPISourceFile()
+    : RealSourceFile(nullptr)
+  {
+  }
+  cmSourceFile* RealSourceFile;
+  std::string SourceName;
+  std::string SourceExtension;
+  std::string FullPath;
+  std::vector<std::string> Depends;
+  cmPropertyMap Properties;
+};
+
+// Keep a map from real cmSourceFile instances stored in a makefile to
+// the CPluginAPI proxy source file.
+class cmCPluginAPISourceFileMap
+  : public std::map<cmSourceFile*, cmCPluginAPISourceFile*>
+{
+public:
+  typedef std::map<cmSourceFile*, cmCPluginAPISourceFile*> derived;
+  typedef derived::iterator iterator;
+  typedef derived::value_type value_type;
+  ~cmCPluginAPISourceFileMap()
+  {
+    for (auto const& i : *this) {
+      delete i.second;
+    }
+  }
+};
+cmCPluginAPISourceFileMap cmCPluginAPISourceFiles;
+
+void* CCONV cmCreateSourceFile(void)
+{
+  return new cmCPluginAPISourceFile;
+}
+
+void* CCONV cmCreateNewSourceFile(void*)
+{
+  return new cmCPluginAPISourceFile;
+}
+
+void CCONV cmDestroySourceFile(void* arg)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  // Only delete if it was created by cmCreateSourceFile or
+  // cmCreateNewSourceFile and is therefore not in the map.
+  if (!sf->RealSourceFile) {
+    delete sf;
+  }
+}
+
+void CCONV* cmGetSource(void* arg, const char* name)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  if (cmSourceFile* rsf = mf->GetSource(name)) {
+    // Lookup the proxy source file object for this source.
+    cmCPluginAPISourceFileMap::iterator i = cmCPluginAPISourceFiles.find(rsf);
+    if (i == cmCPluginAPISourceFiles.end()) {
+      // Create a proxy source file object for this source.
+      cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
+      sf->RealSourceFile = rsf;
+      sf->FullPath = rsf->GetFullPath();
+      sf->SourceName =
+        cmSystemTools::GetFilenameWithoutLastExtension(sf->FullPath);
+      sf->SourceExtension =
+        cmSystemTools::GetFilenameLastExtension(sf->FullPath);
+
+      // Store the proxy in the map so it can be re-used and deleted later.
+      cmCPluginAPISourceFileMap::value_type entry(rsf, sf);
+      i = cmCPluginAPISourceFiles.insert(entry).first;
+    }
+    return i->second;
+  }
+  return nullptr;
+}
+
+void* CCONV cmAddSource(void* arg, void* arg2)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmCPluginAPISourceFile* osf = static_cast<cmCPluginAPISourceFile*>(arg2);
+  if (osf->FullPath.empty()) {
+    return nullptr;
+  }
+
+  // Create the real cmSourceFile instance and copy over saved information.
+  cmSourceFile* rsf = mf->GetOrCreateSource(osf->FullPath);
+  rsf->GetProperties() = osf->Properties;
+  for (std::string const& d : osf->Depends) {
+    rsf->AddDepend(d);
+  }
+
+  // Create the proxy for the real source file.
+  cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
+  sf->RealSourceFile = rsf;
+  sf->FullPath = osf->FullPath;
+  sf->SourceName = osf->SourceName;
+  sf->SourceExtension = osf->SourceExtension;
+
+  // Store the proxy in the map so it can be re-used and deleted later.
+  cmCPluginAPISourceFiles[rsf] = sf;
+  return sf;
+}
+
+const char* CCONV cmSourceFileGetSourceName(void* arg)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  return sf->SourceName.c_str();
+}
+
+const char* CCONV cmSourceFileGetFullPath(void* arg)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  return sf->FullPath.c_str();
+}
+
+const char* CCONV cmSourceFileGetProperty(void* arg, const char* prop)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
+    return rsf->GetProperty(prop);
+  }
+  if (!strcmp(prop, "LOCATION")) {
+    return sf->FullPath.c_str();
+  }
+  return sf->Properties.GetPropertyValue(prop);
+}
+
+int CCONV cmSourceFileGetPropertyAsBool(void* arg, const char* prop)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
+    return rsf->GetPropertyAsBool(prop) ? 1 : 0;
+  }
+  return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
+}
+
+void CCONV cmSourceFileSetProperty(void* arg, const char* prop,
+                                   const char* value)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
+    rsf->SetProperty(prop, value);
+  } else if (prop) {
+    if (!value) {
+      value = "NOTFOUND";
+    }
+    sf->Properties.SetProperty(prop, value);
+  }
+}
+
+void CCONV cmSourceFileAddDepend(void* arg, const char* depend)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
+    rsf->AddDepend(depend);
+  } else {
+    sf->Depends.push_back(depend);
+  }
+}
+
+void CCONV cmSourceFileSetName(void* arg, const char* name, const char* dir,
+                               int numSourceExtensions,
+                               const char** sourceExtensions,
+                               int numHeaderExtensions,
+                               const char** headerExtensions)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (sf->RealSourceFile) {
+    // SetName is allowed only on temporary source files created by
+    // the command for building and passing to AddSource.
+    return;
+  }
+  std::vector<std::string> sourceExts;
+  std::vector<std::string> headerExts;
+  int i;
+  for (i = 0; i < numSourceExtensions; ++i) {
+    sourceExts.push_back(sourceExtensions[i]);
+  }
+  for (i = 0; i < numHeaderExtensions; ++i) {
+    headerExts.push_back(headerExtensions[i]);
+  }
+
+  // Save the original name given.
+  sf->SourceName = name;
+
+  // Convert the name to a full path in case the given name is a
+  // relative path.
+  std::string pathname = cmSystemTools::CollapseFullPath(name, dir);
+
+  // First try and see whether the listed file can be found
+  // as is without extensions added on.
+  std::string hname = pathname;
+  if (cmSystemTools::FileExists(hname.c_str())) {
+    sf->SourceName = cmSystemTools::GetFilenamePath(name);
+    if (!sf->SourceName.empty()) {
+      sf->SourceName += "/";
+    }
+    sf->SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
+    std::string::size_type pos = hname.rfind('.');
+    if (pos != std::string::npos) {
+      sf->SourceExtension = hname.substr(pos + 1, hname.size() - pos);
+      if (cmSystemTools::FileIsFullPath(name)) {
+        std::string::size_type pos2 = hname.rfind('/');
+        if (pos2 != std::string::npos) {
+          sf->SourceName = hname.substr(pos2 + 1, pos - pos2 - 1);
+        }
+      }
+    }
+
+    sf->FullPath = hname;
+    return;
+  }
+
+  // Next, try the various source extensions
+  for (std::vector<std::string>::const_iterator ext = sourceExts.begin();
+       ext != sourceExts.end(); ++ext) {
+    hname = pathname;
+    hname += ".";
+    hname += *ext;
+    if (cmSystemTools::FileExists(hname.c_str())) {
+      sf->SourceExtension = *ext;
+      sf->FullPath = hname;
+      return;
+    }
+  }
+
+  // Finally, try the various header extensions
+  for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+       ext != headerExts.end(); ++ext) {
+    hname = pathname;
+    hname += ".";
+    hname += *ext;
+    if (cmSystemTools::FileExists(hname.c_str())) {
+      sf->SourceExtension = *ext;
+      sf->FullPath = hname;
+      return;
+    }
+  }
+
+  std::ostringstream e;
+  e << "Cannot find source file \"" << pathname << "\"";
+  e << "\n\nTried extensions";
+  for (std::vector<std::string>::const_iterator ext = sourceExts.begin();
+       ext != sourceExts.end(); ++ext) {
+    e << " ." << *ext;
+  }
+  for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+       ext != headerExts.end(); ++ext) {
+    e << " ." << *ext;
+  }
+  cmSystemTools::Error(e.str().c_str());
+}
+
+void CCONV cmSourceFileSetName2(void* arg, const char* name, const char* dir,
+                                const char* ext, int headerFileOnly)
+{
+  cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
+  if (sf->RealSourceFile) {
+    // SetName is allowed only on temporary source files created by
+    // the command for building and passing to AddSource.
+    return;
+  }
+
+  // Implement the old SetName method code here.
+  if (headerFileOnly) {
+    sf->Properties.SetProperty("HEADER_FILE_ONLY", "1");
+  }
+  sf->SourceName = name;
+  std::string fname = sf->SourceName;
+  if (ext && strlen(ext)) {
+    fname += ".";
+    fname += ext;
+  }
+  sf->FullPath = cmSystemTools::CollapseFullPath(fname, dir);
+  cmSystemTools::ConvertToUnixSlashes(sf->FullPath);
+  sf->SourceExtension = ext;
+}
+
+char* CCONV cmGetFilenameWithoutExtension(const char* name)
+{
+  std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
+  return strdup(sres.c_str());
+}
+
+char* CCONV cmGetFilenamePath(const char* name)
+{
+  std::string sres = cmSystemTools::GetFilenamePath(name);
+  return strdup(sres.c_str());
+}
+
+char* CCONV cmCapitalized(const char* name)
+{
+  std::string sres = cmSystemTools::Capitalized(name);
+  return strdup(sres.c_str());
+}
+
+void CCONV cmCopyFileIfDifferent(const char* name1, const char* name2)
+{
+  cmSystemTools::CopyFileIfDifferent(name1, name2);
+}
+
+void CCONV cmRemoveFile(const char* name)
+{
+  cmSystemTools::RemoveFile(name);
+}
+
+void CCONV cmDisplayStatus(void* arg, const char* message)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->DisplayStatus(message, -1);
+}
+
+void CCONV cmFree(void* data)
+{
+  free(data);
+}
+
+void CCONV DefineSourceFileProperty(void* arg, const char* name,
+                                    const char* briefDocs,
+                                    const char* longDocs, int chained)
+{
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->GetState()->DefineProperty(name, cmProperty::SOURCE_FILE, briefDocs,
+                                 longDocs, chained != 0);
+}
+
+} // close the extern "C" scope
+
+cmCAPI cmStaticCAPI = {
+  cmGetClientData,
+  cmGetTotalArgumentSize,
+  cmFreeArguments,
+  cmSetClientData,
+  cmSetError,
+  cmAddCacheDefinition,
+  cmAddCustomCommand,
+  cmAddDefineFlag,
+  cmAddDefinition,
+  cmAddExecutable,
+  cmAddLibrary,
+  cmAddLinkDirectoryForTarget,
+  cmAddLinkLibraryForTarget,
+  cmAddUtilityCommand,
+  cmCommandExists,
+  cmExecuteCommand,
+  cmExpandSourceListArguments,
+  cmExpandVariablesInString,
+  cmGetCacheMajorVersion,
+  cmGetCacheMinorVersion,
+  cmGetCurrentDirectory,
+  cmGetCurrentOutputDirectory,
+  cmGetDefinition,
+  cmGetHomeDirectory,
+  cmGetHomeOutputDirectory,
+  cmGetMajorVersion,
+  cmGetMinorVersion,
+  cmGetProjectName,
+  cmGetStartDirectory,
+  cmGetStartOutputDirectory,
+  cmIsOn,
+
+  cmAddSource,
+  cmCreateSourceFile,
+  cmDestroySourceFile,
+  cmGetSource,
+  cmSourceFileAddDepend,
+  cmSourceFileGetProperty,
+  cmSourceFileGetPropertyAsBool,
+  cmSourceFileGetSourceName,
+  cmSourceFileGetFullPath,
+  cmSourceFileSetName,
+  cmSourceFileSetName2,
+  cmSourceFileSetProperty,
+
+  cmCapitalized,
+  cmCopyFileIfDifferent,
+  cmGetFilenameWithoutExtension,
+  cmGetFilenamePath,
+  cmRemoveFile,
+  cmFree,
+
+  cmAddCustomCommandToOutput,
+  cmAddCustomCommandToTarget,
+  cmDisplayStatus,
+  cmCreateNewSourceFile,
+  DefineSourceFileProperty,
+};
diff --git a/Source/cmCPluginAPI.h b/Source/cmCPluginAPI.h
new file mode 100644
index 0000000..88b81c6
--- /dev/null
+++ b/Source/cmCPluginAPI.h
@@ -0,0 +1,225 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+/* This header file defines the API that loadable commands can use. In many
+   of these commands C++ instances of cmMakefile of cmSourceFile are passed
+   in as arguments or returned. In these cases they are passed as a void *
+   argument. In the function prototypes mf is used to represent a makefile
+   and sf is used to represent a source file. The functions are grouped
+   loosely into four groups 1) Utility 2) cmMakefile 3) cmSourceFile 4)
+   cmSystemTools. Within each grouping functions are listed alphabetically */
+/*=========================================================================*/
+#ifndef cmCPluginAPI_h
+#define cmCPluginAPI_h
+
+#define CMAKE_VERSION_MAJOR 2
+#define CMAKE_VERSION_MINOR 5
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __WATCOMC__
+#define CCONV __cdecl
+#else
+#define CCONV
+#endif
+/*=========================================================================
+this is the structure of function entry points that a plugin may call. This
+structure must be kept in sync with the static decaled at the bottom of
+cmCPLuginAPI.cxx
+=========================================================================*/
+typedef struct
+{
+  /*=========================================================================
+  Here we define the set of functions that a plugin may call. The first goup
+  of functions are utility functions that are specific to the plugin API
+  =========================================================================*/
+  /* set/Get the ClientData in the cmLoadedCommandInfo structure, this is how
+     information is passed from the InitialPass to FInalPass for commands
+     that need a FinalPass and need information from the InitialPass */
+  void*(CCONV* GetClientData)(void* info);
+  /* return the summed size in characters of all the arguments */
+  int(CCONV* GetTotalArgumentSize)(int argc, char** argv);
+  /* free all the memory associated with an argc, argv pair */
+  void(CCONV* FreeArguments)(int argc, char** argv);
+  /* set/Get the ClientData in the cmLoadedCommandInfo structure, this is how
+     information is passed from the InitialPass to FInalPass for commands
+     that need a FinalPass and need information from the InitialPass */
+  void(CCONV* SetClientData)(void* info, void* cd);
+  /* when an error occurs, call this function to set the error string */
+  void(CCONV* SetError)(void* info, const char* err);
+
+  /*=========================================================================
+  The following functions all directly map to methods in the cmMakefile
+  class. See cmMakefile.h for descriptions of what each method does. All of
+  these methods take the void * makefile pointer as their first argument.
+  =========================================================================*/
+  void(CCONV* AddCacheDefinition)(void* mf, const char* name,
+                                  const char* value, const char* doc,
+                                  int cachetype);
+  void(CCONV* AddCustomCommand)(void* mf, const char* source,
+                                const char* command, int numArgs,
+                                const char** args, int numDepends,
+                                const char** depends, int numOutputs,
+                                const char** outputs, const char* target);
+  void(CCONV* AddDefineFlag)(void* mf, const char* definition);
+  void(CCONV* AddDefinition)(void* mf, const char* name, const char* value);
+  void(CCONV* AddExecutable)(void* mf, const char* exename, int numSrcs,
+                             const char** srcs, int win32);
+  void(CCONV* AddLibrary)(void* mf, const char* libname, int shared,
+                          int numSrcs, const char** srcs);
+  void(CCONV* AddLinkDirectoryForTarget)(void* mf, const char* tgt,
+                                         const char* d);
+  void(CCONV* AddLinkLibraryForTarget)(void* mf, const char* tgt,
+                                       const char* libname, int libtype);
+  void(CCONV* AddUtilityCommand)(void* mf, const char* utilityName,
+                                 const char* command, const char* arguments,
+                                 int all, int numDepends, const char** depends,
+                                 int numOutputs, const char** outputs);
+  int(CCONV* CommandExists)(void* mf, const char* name);
+  int(CCONV* ExecuteCommand)(void* mf, const char* name, int numArgs,
+                             const char** args);
+  void(CCONV* ExpandSourceListArguments)(void* mf, int argc, const char** argv,
+                                         int* resArgc, char*** resArgv,
+                                         unsigned int startArgumentIndex);
+  char*(CCONV* ExpandVariablesInString)(void* mf, const char* source,
+                                        int escapeQuotes, int atOnly);
+  unsigned int(CCONV* GetCacheMajorVersion)(void* mf);
+  unsigned int(CCONV* GetCacheMinorVersion)(void* mf);
+  const char*(CCONV* GetCurrentDirectory)(void* mf);
+  const char*(CCONV* GetCurrentOutputDirectory)(void* mf);
+  const char*(CCONV* GetDefinition)(void* mf, const char* def);
+  const char*(CCONV* GetHomeDirectory)(void* mf);
+  const char*(CCONV* GetHomeOutputDirectory)(void* mf);
+  unsigned int(CCONV* GetMajorVersion)(void* mf);
+  unsigned int(CCONV* GetMinorVersion)(void* mf);
+  const char*(CCONV* GetProjectName)(void* mf);
+  const char*(CCONV* GetStartDirectory)(void* mf);
+  const char*(CCONV* GetStartOutputDirectory)(void* mf);
+  int(CCONV* IsOn)(void* mf, const char* name);
+
+  /*=========================================================================
+  The following functions are designed to operate or manipulate
+  cmSourceFiles. Please see cmSourceFile.h for additional information on many
+  of these methods. Some of these methods are in cmMakefile.h.
+  =========================================================================*/
+  void*(CCONV* AddSource)(void* mf, void* sf);
+  void*(CCONV* CreateSourceFile)();
+  void(CCONV* DestroySourceFile)(void* sf);
+  void*(CCONV* GetSource)(void* mf, const char* sourceName);
+  void(CCONV* SourceFileAddDepend)(void* sf, const char* depend);
+  const char*(CCONV* SourceFileGetProperty)(void* sf, const char* prop);
+  int(CCONV* SourceFileGetPropertyAsBool)(void* sf, const char* prop);
+  const char*(CCONV* SourceFileGetSourceName)(void* sf);
+  const char*(CCONV* SourceFileGetFullPath)(void* sf);
+  void(CCONV* SourceFileSetName)(void* sf, const char* name, const char* dir,
+                                 int numSourceExtensions,
+                                 const char** sourceExtensions,
+                                 int numHeaderExtensions,
+                                 const char** headerExtensions);
+  void(CCONV* SourceFileSetName2)(void* sf, const char* name, const char* dir,
+                                  const char* ext, int headerFileOnly);
+  void(CCONV* SourceFileSetProperty)(void* sf, const char* prop,
+                                     const char* value);
+
+  /*=========================================================================
+  The following methods are from cmSystemTools.h see that file for specific
+  documentation on each method.
+  =========================================================================*/
+  char*(CCONV* Capitalized)(const char*);
+  void(CCONV* CopyFileIfDifferent)(const char* f1, const char* f2);
+  char*(CCONV* GetFilenameWithoutExtension)(const char*);
+  char*(CCONV* GetFilenamePath)(const char*);
+  void(CCONV* RemoveFile)(const char* f1);
+  void(CCONV* Free)(void*);
+
+  /*=========================================================================
+    The following are new functions added after 1.6
+  =========================================================================*/
+  void(CCONV* AddCustomCommandToOutput)(void* mf, const char* output,
+                                        const char* command, int numArgs,
+                                        const char** args,
+                                        const char* main_dependency,
+                                        int numDepends, const char** depends);
+  void(CCONV* AddCustomCommandToTarget)(void* mf, const char* target,
+                                        const char* command, int numArgs,
+                                        const char** args, int commandType);
+
+  /* display status information */
+  void(CCONV* DisplaySatus)(void* info, const char* message);
+
+  /* new functions added after 2.4 */
+  void*(CCONV* CreateNewSourceFile)(void* mf);
+  void(CCONV* DefineSourceFileProperty)(void* mf, const char* name,
+                                        const char* briefDocs,
+                                        const char* longDocs, int chained);
+
+  /* this is the end of the C function stub API structure */
+} cmCAPI;
+
+/*=========================================================================
+CM_PLUGIN_EXPORT should be used by plugins
+=========================================================================*/
+#ifdef _WIN32
+#define CM_PLUGIN_EXPORT __declspec(dllexport)
+#else
+#define CM_PLUGIN_EXPORT
+#endif
+
+/*=========================================================================
+define the different types of cache entries, see cmCacheManager.h for more
+information
+=========================================================================*/
+#define CM_CACHE_BOOL 0
+#define CM_CACHE_PATH 1
+#define CM_CACHE_FILEPATH 2
+#define CM_CACHE_STRING 3
+#define CM_CACHE_INTERNAL 4
+#define CM_CACHE_STATIC 5
+
+/*=========================================================================
+define the different types of compiles a library may be
+=========================================================================*/
+#define CM_LIBRARY_GENERAL 0
+#define CM_LIBRARY_DEBUG 1
+#define CM_LIBRARY_OPTIMIZED 2
+
+/*=========================================================================
+define the different types of custom commands for a target
+=========================================================================*/
+#define CM_PRE_BUILD 0
+#define CM_PRE_LINK 1
+#define CM_POST_BUILD 2
+
+/*=========================================================================
+Finally we define the key data structures and function prototypes
+=========================================================================*/
+typedef const char*(CCONV* CM_DOC_FUNCTION)();
+typedef int(CCONV* CM_INITIAL_PASS_FUNCTION)(void* info, void* mf, int argc,
+                                             char* []);
+typedef void(CCONV* CM_FINAL_PASS_FUNCTION)(void* info, void* mf);
+typedef void(CCONV* CM_DESTRUCTOR_FUNCTION)(void* info);
+
+typedef struct
+{
+  unsigned long reserved1; /* Reserved for future use.  DO NOT USE.  */
+  unsigned long reserved2; /* Reserved for future use.  DO NOT USE.  */
+  cmCAPI* CAPI;
+  int m_Inherited; /* this ivar is no longer used in CMake 2.2 or later */
+  CM_INITIAL_PASS_FUNCTION InitialPass;
+  CM_FINAL_PASS_FUNCTION FinalPass;
+  CM_DESTRUCTOR_FUNCTION Destructor;
+  CM_DOC_FUNCTION GetTerseDocumentation;
+  CM_DOC_FUNCTION GetFullDocumentation;
+  const char* Name;
+  char* Error;
+  void* ClientData;
+} cmLoadedCommandInfo;
+
+typedef void(CCONV* CM_INIT_FUNCTION)(cmLoadedCommandInfo*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
new file mode 100644
index 0000000..fd7c5e8
--- /dev/null
+++ b/Source/cmCTest.cxx
@@ -0,0 +1,2860 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCTest.h"
+
+#include "cm_curl.h"
+#include "cm_zlib.h"
+#include "cmsys/Base64.h"
+#include "cmsys/Directory.hxx"
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include "cmsys/Process.h"
+#include "cmsys/String.hxx"
+#include "cmsys/SystemInformation.hxx"
+#include <algorithm>
+#include <chrono>
+#include <ctype.h>
+#include <iostream>
+#include <map>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <time.h>
+#include <utility>
+#include <vector>
+
+#include "cmAlgorithms.h"
+#include "cmCTestBuildAndTestHandler.h"
+#include "cmCTestBuildHandler.h"
+#include "cmCTestConfigureHandler.h"
+#include "cmCTestCoverageHandler.h"
+#include "cmCTestGenericHandler.h"
+#include "cmCTestMemCheckHandler.h"
+#include "cmCTestScriptHandler.h"
+#include "cmCTestStartCommand.h"
+#include "cmCTestSubmitHandler.h"
+#include "cmCTestTestHandler.h"
+#include "cmCTestUpdateHandler.h"
+#include "cmCTestUploadHandler.h"
+#include "cmCurl.h"
+#include "cmDynamicLoader.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmProcessOutput.h"
+#include "cmState.h"
+#include "cmStateSnapshot.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmVersionConfig.h"
+#include "cmXMLWriter.h"
+#include "cmake.h"
+
+#if defined(__BEOS__) || defined(__HAIKU__)
+#include <be/kernel/OS.h> /* disable_debugger() API. */
+#endif
+
+#define DEBUGOUT                                                              \
+  std::cout << __LINE__ << " ";                                               \
+  std::cout
+#define DEBUGERR                                                              \
+  std::cerr << __LINE__ << " ";                                               \
+  std::cerr
+
+struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag)
+{
+  struct tm* lctime;
+  time_t tctime = time(nullptr);
+  lctime = gmtime(&tctime);
+  char buf[1024];
+  // add todays year day and month to the time in str because
+  // curl_getdate no longer assumes the day is today
+  sprintf(buf, "%d%02d%02d %s", lctime->tm_year + 1900, lctime->tm_mon + 1,
+          lctime->tm_mday, str.c_str());
+  cmCTestLog(this, OUTPUT, "Determine Nightly Start Time"
+               << std::endl
+               << "   Specified time: " << str << std::endl);
+  // Convert the nightly start time to seconds. Since we are
+  // providing only a time and a timezone, the current date of
+  // the local machine is assumed. Consequently, nightlySeconds
+  // is the time at which the nightly dashboard was opened or
+  // will be opened on the date of the current client machine.
+  // As such, this time may be in the past or in the future.
+  time_t ntime = curl_getdate(buf, &tctime);
+  cmCTestLog(this, DEBUG, "   Get curl time: " << ntime << std::endl);
+  tctime = time(nullptr);
+  cmCTestLog(this, DEBUG, "   Get the current time: " << tctime << std::endl);
+
+  const int dayLength = 24 * 60 * 60;
+  cmCTestLog(this, DEBUG, "Seconds: " << tctime << std::endl);
+  while (ntime > tctime) {
+    // If nightlySeconds is in the past, this is the current
+    // open dashboard, then return nightlySeconds.  If
+    // nightlySeconds is in the future, this is the next
+    // dashboard to be opened, so subtract 24 hours to get the
+    // time of the current open dashboard
+    ntime -= dayLength;
+    cmCTestLog(this, DEBUG, "Pick yesterday" << std::endl);
+    cmCTestLog(this, DEBUG, "   Future time, subtract day: " << ntime
+                                                             << std::endl);
+  }
+  while (tctime > (ntime + dayLength)) {
+    ntime += dayLength;
+    cmCTestLog(this, DEBUG, "   Past time, add day: " << ntime << std::endl);
+  }
+  cmCTestLog(this, DEBUG, "nightlySeconds: " << ntime << std::endl);
+  cmCTestLog(this, DEBUG, "   Current time: " << tctime << " Nightly time: "
+                                              << ntime << std::endl);
+  if (tomorrowtag) {
+    cmCTestLog(this, OUTPUT, "   Use future tag, Add a day" << std::endl);
+    ntime += dayLength;
+  }
+  lctime = gmtime(&ntime);
+  return lctime;
+}
+
+std::string cmCTest::CleanString(const std::string& str)
+{
+  std::string::size_type spos = str.find_first_not_of(" \n\t\r\f\v");
+  std::string::size_type epos = str.find_last_not_of(" \n\t\r\f\v");
+  if (spos == std::string::npos) {
+    return std::string();
+  }
+  if (epos != std::string::npos) {
+    epos = epos - spos + 1;
+  }
+  return str.substr(spos, epos);
+}
+
+std::string cmCTest::CurrentTime()
+{
+  time_t currenttime = time(nullptr);
+  struct tm* t = localtime(&currenttime);
+  // return ::CleanString(ctime(&currenttime));
+  char current_time[1024];
+  if (this->ShortDateFormat) {
+    strftime(current_time, 1000, "%b %d %H:%M %Z", t);
+  } else {
+    strftime(current_time, 1000, "%a %b %d %H:%M:%S %Z %Y", t);
+  }
+  cmCTestLog(this, DEBUG, "   Current_Time: " << current_time << std::endl);
+  return cmCTest::CleanString(current_time);
+}
+
+std::string cmCTest::GetCostDataFile()
+{
+  std::string fname = this->GetCTestConfiguration("CostDataFile");
+  if (fname.empty()) {
+    fname = this->GetBinaryDir() + "/Testing/Temporary/CTestCostData.txt";
+  }
+  return fname;
+}
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+static size_t HTTPResponseCallback(void* ptr, size_t size, size_t nmemb,
+                                   void* data)
+{
+  int realsize = static_cast<int>(size * nmemb);
+
+  std::string* response = static_cast<std::string*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  *response += chPtr;
+
+  return realsize;
+}
+
+int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
+                         std::string& response, std::string const& fields,
+                         std::string const& putFile, int timeout)
+{
+  CURL* curl;
+  FILE* file;
+  ::curl_global_init(CURL_GLOBAL_ALL);
+  curl = ::curl_easy_init();
+  cmCurlSetCAInfo(curl);
+
+  // set request options based on method
+  switch (method) {
+    case cmCTest::HTTP_POST:
+      ::curl_easy_setopt(curl, CURLOPT_POST, 1);
+      ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, fields.c_str());
+      break;
+    case cmCTest::HTTP_PUT:
+      if (!cmSystemTools::FileExists(putFile.c_str())) {
+        response = "Error: File ";
+        response += putFile + " does not exist.\n";
+        return -1;
+      }
+      ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
+      file = cmsys::SystemTools::Fopen(putFile, "rb");
+      ::curl_easy_setopt(curl, CURLOPT_INFILE, file);
+      // fall through to append GET fields
+      CM_FALLTHROUGH;
+    case cmCTest::HTTP_GET:
+      if (!fields.empty()) {
+        url += "?" + fields;
+      }
+      break;
+  }
+
+  ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
+  ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+
+  // set response options
+  ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HTTPResponseCallback);
+  ::curl_easy_setopt(curl, CURLOPT_FILE, &response);
+  ::curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+
+  CURLcode res = ::curl_easy_perform(curl);
+
+  ::curl_easy_cleanup(curl);
+  ::curl_global_cleanup();
+
+  return static_cast<int>(res);
+}
+#endif
+
+std::string cmCTest::MakeURLSafe(const std::string& str)
+{
+  std::ostringstream ost;
+  char buffer[10];
+  for (unsigned char ch : str) {
+    if ((ch > 126 || ch < 32 || ch == '&' || ch == '%' || ch == '+' ||
+         ch == '=' || ch == '@') &&
+        ch != 9) {
+      sprintf(buffer, "%02x;", static_cast<unsigned int>(ch));
+      ost << buffer;
+    } else {
+      ost << ch;
+    }
+  }
+  return ost.str();
+}
+
+std::string cmCTest::DecodeURL(const std::string& in)
+{
+  std::string out;
+  for (const char* c = in.c_str(); *c; ++c) {
+    if (*c == '%' && isxdigit(*(c + 1)) && isxdigit(*(c + 2))) {
+      char buf[3] = { *(c + 1), *(c + 2), 0 };
+      out.append(1, char(strtoul(buf, nullptr, 16)));
+      c += 2;
+    } else {
+      out.append(1, *c);
+    }
+  }
+  return out;
+}
+
+cmCTest::cmCTest()
+{
+  this->LabelSummary = true;
+  this->SubprojectSummary = true;
+  this->ParallelLevel = 1;
+  this->ParallelLevelSetInCli = false;
+  this->TestLoad = 0;
+  this->SubmitIndex = 0;
+  this->Failover = false;
+  this->ForceNewCTestProcess = false;
+  this->TomorrowTag = false;
+  this->Verbose = false;
+
+  this->Debug = false;
+  this->ShowLineNumbers = false;
+  this->Quiet = false;
+  this->ExtraVerbose = false;
+  this->ProduceXML = false;
+  this->ShowOnly = false;
+  this->RunConfigurationScript = false;
+  this->UseHTTP10 = false;
+  this->PrintLabels = false;
+  this->CompressTestOutput = true;
+  this->TestModel = cmCTest::EXPERIMENTAL;
+  this->MaxTestNameWidth = 30;
+  this->InteractiveDebugMode = true;
+  this->TimeOut = std::chrono::duration<double>::zero();
+  this->GlobalTimeout = std::chrono::duration<double>::zero();
+  this->CompressXMLFiles = false;
+  this->ScheduleType.clear();
+  this->OutputLogFile = nullptr;
+  this->OutputLogFileLastTag = -1;
+  this->SuppressUpdatingCTestConfiguration = false;
+  this->DartVersion = 1;
+  this->DropSiteCDash = false;
+  this->OutputTestOutputOnTestFailure = false;
+  this->RepeatTests = 1; // default to run each test once
+  this->RepeatUntilFail = false;
+  std::string outOnFail;
+  if (cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE", outOnFail)) {
+    this->OutputTestOutputOnTestFailure =
+      !cmSystemTools::IsOff(outOnFail.c_str());
+  }
+  this->InitStreams();
+
+  this->Parts[PartStart].SetName("Start");
+  this->Parts[PartUpdate].SetName("Update");
+  this->Parts[PartConfigure].SetName("Configure");
+  this->Parts[PartBuild].SetName("Build");
+  this->Parts[PartTest].SetName("Test");
+  this->Parts[PartCoverage].SetName("Coverage");
+  this->Parts[PartMemCheck].SetName("MemCheck");
+  this->Parts[PartSubmit].SetName("Submit");
+  this->Parts[PartNotes].SetName("Notes");
+  this->Parts[PartExtraFiles].SetName("ExtraFiles");
+  this->Parts[PartUpload].SetName("Upload");
+
+  // Fill the part name-to-id map.
+  for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
+    this->PartMap[cmSystemTools::LowerCase(this->Parts[p].GetName())] = p;
+  }
+
+  this->ShortDateFormat = true;
+
+  this->TestingHandlers["build"] = new cmCTestBuildHandler;
+  this->TestingHandlers["buildtest"] = new cmCTestBuildAndTestHandler;
+  this->TestingHandlers["coverage"] = new cmCTestCoverageHandler;
+  this->TestingHandlers["script"] = new cmCTestScriptHandler;
+  this->TestingHandlers["test"] = new cmCTestTestHandler;
+  this->TestingHandlers["update"] = new cmCTestUpdateHandler;
+  this->TestingHandlers["configure"] = new cmCTestConfigureHandler;
+  this->TestingHandlers["memcheck"] = new cmCTestMemCheckHandler;
+  this->TestingHandlers["submit"] = new cmCTestSubmitHandler;
+  this->TestingHandlers["upload"] = new cmCTestUploadHandler;
+
+  for (auto& handler : this->TestingHandlers) {
+    handler.second->SetCTestInstance(this);
+  }
+
+  // Make sure we can capture the build tool output.
+  cmSystemTools::EnableVSConsoleOutput();
+}
+
+cmCTest::~cmCTest()
+{
+  cmDeleteAll(this->TestingHandlers);
+  this->SetOutputLogFileName(nullptr);
+}
+
+void cmCTest::SetParallelLevel(int level)
+{
+  this->ParallelLevel = level < 1 ? 1 : level;
+}
+
+void cmCTest::SetTestLoad(unsigned long load)
+{
+  this->TestLoad = load;
+}
+
+bool cmCTest::ShouldCompressTestOutput()
+{
+  return this->CompressTestOutput;
+}
+
+cmCTest::Part cmCTest::GetPartFromName(const char* name)
+{
+  // Look up by lower-case to make names case-insensitive.
+  std::string lower_name = cmSystemTools::LowerCase(name);
+  PartMapType::const_iterator i = this->PartMap.find(lower_name);
+  if (i != this->PartMap.end()) {
+    return i->second;
+  }
+
+  // The string does not name a valid part.
+  return PartCount;
+}
+
+int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
+{
+  bool quiet = false;
+  if (command && command->ShouldBeQuiet()) {
+    quiet = true;
+  }
+
+  cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
+  if (!this->InteractiveDebugMode) {
+    this->BlockTestErrorDiagnostics();
+  } else {
+    cmSystemTools::PutEnv("CTEST_INTERACTIVE_DEBUG_MODE=1");
+  }
+
+  this->BinaryDir = binary_dir;
+  cmSystemTools::ConvertToUnixSlashes(this->BinaryDir);
+
+  this->UpdateCTestConfiguration();
+
+  cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
+  if (this->ProduceXML) {
+    cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
+    cmCTestOptionalLog(
+      this, OUTPUT, "   Site: "
+        << this->GetCTestConfiguration("Site") << std::endl
+        << "   Build name: "
+        << cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"))
+        << std::endl,
+      quiet);
+    cmCTestOptionalLog(this, DEBUG, "Produce XML is on" << std::endl, quiet);
+    if (this->TestModel == cmCTest::NIGHTLY &&
+        this->GetCTestConfiguration("NightlyStartTime").empty()) {
+      cmCTestOptionalLog(
+        this, WARNING,
+        "WARNING: No nightly start time found please set in CTestConfig.cmake"
+        " or DartConfig.cmake"
+          << std::endl,
+        quiet);
+      cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl,
+                         quiet);
+      return 0;
+    }
+  }
+
+  cmake cm(cmake::RoleScript);
+  cm.SetHomeDirectory("");
+  cm.SetHomeOutputDirectory("");
+  cm.GetCurrentSnapshot().SetDefaultDefinitions();
+  cmGlobalGenerator gg(&cm);
+  cmMakefile mf(&gg, cm.GetCurrentSnapshot());
+  if (!this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(), &mf)) {
+    cmCTestOptionalLog(
+      this, DEBUG, "Cannot find custom configuration file tree" << std::endl,
+      quiet);
+    return 0;
+  }
+
+  if (this->ProduceXML) {
+    // Verify "Testing" directory exists:
+    //
+    std::string testingDir = this->BinaryDir + "/Testing";
+    if (cmSystemTools::FileExists(testingDir.c_str())) {
+      if (!cmSystemTools::FileIsDirectory(testingDir)) {
+        cmCTestLog(this, ERROR_MESSAGE, "File "
+                     << testingDir
+                     << " is in the place of the testing directory"
+                     << std::endl);
+        return 0;
+      }
+    } else {
+      if (!cmSystemTools::MakeDirectory(testingDir.c_str())) {
+        cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory "
+                     << testingDir << std::endl);
+        return 0;
+      }
+    }
+
+    // Create new "TAG" file or read existing one:
+    //
+    bool createNewTag = true;
+    if (command) {
+      createNewTag = command->ShouldCreateNewTag();
+    }
+
+    std::string tagfile = testingDir + "/TAG";
+    cmsys::ifstream tfin(tagfile.c_str());
+    std::string tag;
+
+    if (createNewTag) {
+      time_t tctime = time(nullptr);
+      if (this->TomorrowTag) {
+        tctime += (24 * 60 * 60);
+      }
+      struct tm* lctime = gmtime(&tctime);
+      if (tfin && cmSystemTools::GetLineFromStream(tfin, tag)) {
+        int year = 0;
+        int mon = 0;
+        int day = 0;
+        int hour = 0;
+        int min = 0;
+        sscanf(tag.c_str(), "%04d%02d%02d-%02d%02d", &year, &mon, &day, &hour,
+               &min);
+        if (year != lctime->tm_year + 1900 || mon != lctime->tm_mon + 1 ||
+            day != lctime->tm_mday) {
+          tag.clear();
+        }
+        std::string tagmode;
+        if (cmSystemTools::GetLineFromStream(tfin, tagmode)) {
+          if (tagmode.size() > 4 && !this->Parts[PartStart]) {
+            this->TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
+          }
+        }
+        tfin.close();
+      }
+      if (tag.empty() || (nullptr != command) || this->Parts[PartStart]) {
+        cmCTestOptionalLog(
+          this, DEBUG,
+          "TestModel: " << this->GetTestModelString() << std::endl, quiet);
+        cmCTestOptionalLog(
+          this, DEBUG, "TestModel: " << this->TestModel << std::endl, quiet);
+        if (this->TestModel == cmCTest::NIGHTLY) {
+          lctime = this->GetNightlyTime(
+            this->GetCTestConfiguration("NightlyStartTime"),
+            this->TomorrowTag);
+        }
+        char datestring[100];
+        sprintf(datestring, "%04d%02d%02d-%02d%02d", lctime->tm_year + 1900,
+                lctime->tm_mon + 1, lctime->tm_mday, lctime->tm_hour,
+                lctime->tm_min);
+        tag = datestring;
+        cmsys::ofstream ofs(tagfile.c_str());
+        if (ofs) {
+          ofs << tag << std::endl;
+          ofs << this->GetTestModelString() << std::endl;
+        }
+        ofs.close();
+        if (nullptr == command) {
+          cmCTestOptionalLog(this, OUTPUT, "Create new tag: "
+                               << tag << " - " << this->GetTestModelString()
+                               << std::endl,
+                             quiet);
+        }
+      }
+    } else {
+      if (tfin) {
+        cmSystemTools::GetLineFromStream(tfin, tag);
+        tfin.close();
+      }
+
+      if (tag.empty()) {
+        cmCTestLog(this, ERROR_MESSAGE, "Cannot read existing TAG file in "
+                     << testingDir << std::endl);
+        return 0;
+      }
+
+      cmCTestOptionalLog(this, OUTPUT, "  Use existing tag: "
+                           << tag << " - " << this->GetTestModelString()
+                           << std::endl,
+                         quiet);
+    }
+
+    this->CurrentTag = tag;
+  }
+
+  return 1;
+}
+
+bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
+{
+  std::string src_dir = this->GetCTestConfiguration("SourceDirectory");
+  std::string bld_dir = this->GetCTestConfiguration("BuildDirectory");
+  this->DartVersion = 1;
+  this->DropSiteCDash = false;
+  for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
+    this->Parts[p].SubmitFiles.clear();
+  }
+
+  cmMakefile* mf = command->GetMakefile();
+  std::string fname;
+
+  std::string src_dir_fname = src_dir;
+  src_dir_fname += "/CTestConfig.cmake";
+  cmSystemTools::ConvertToUnixSlashes(src_dir_fname);
+
+  std::string bld_dir_fname = bld_dir;
+  bld_dir_fname += "/CTestConfig.cmake";
+  cmSystemTools::ConvertToUnixSlashes(bld_dir_fname);
+
+  if (cmSystemTools::FileExists(bld_dir_fname.c_str())) {
+    fname = bld_dir_fname;
+  } else if (cmSystemTools::FileExists(src_dir_fname.c_str())) {
+    fname = src_dir_fname;
+  }
+
+  if (!fname.empty()) {
+    cmCTestOptionalLog(this, OUTPUT, "   Reading ctest configuration file: "
+                         << fname << std::endl,
+                       command->ShouldBeQuiet());
+    bool readit = mf->ReadDependentFile(fname.c_str());
+    if (!readit) {
+      std::string m = "Could not find include file: ";
+      m += fname;
+      command->SetError(m);
+      return false;
+    }
+  } else {
+    cmCTestOptionalLog(this, WARNING,
+                       "Cannot locate CTest configuration: in BuildDirectory: "
+                         << bld_dir_fname << std::endl,
+                       command->ShouldBeQuiet());
+    cmCTestOptionalLog(
+      this, WARNING, "Cannot locate CTest configuration: in SourceDirectory: "
+        << src_dir_fname << std::endl,
+      command->ShouldBeQuiet());
+  }
+
+  this->SetCTestConfigurationFromCMakeVariable(mf, "NightlyStartTime",
+                                               "CTEST_NIGHTLY_START_TIME",
+                                               command->ShouldBeQuiet());
+  this->SetCTestConfigurationFromCMakeVariable(mf, "Site", "CTEST_SITE",
+                                               command->ShouldBeQuiet());
+  this->SetCTestConfigurationFromCMakeVariable(
+    mf, "BuildName", "CTEST_BUILD_NAME", command->ShouldBeQuiet());
+  const char* dartVersion = mf->GetDefinition("CTEST_DART_SERVER_VERSION");
+  if (dartVersion) {
+    this->DartVersion = atoi(dartVersion);
+    if (this->DartVersion < 0) {
+      cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: "
+                   << dartVersion << ". Please specify the version number."
+                   << std::endl);
+      return false;
+    }
+  }
+  this->DropSiteCDash = mf->IsOn("CTEST_DROP_SITE_CDASH");
+
+  if (!this->Initialize(bld_dir.c_str(), command)) {
+    return false;
+  }
+  cmCTestOptionalLog(this, OUTPUT, "   Use "
+                       << this->GetTestModelString()
+                       << " tag: " << this->GetCurrentTag() << std::endl,
+                     command->ShouldBeQuiet());
+  return true;
+}
+
+bool cmCTest::UpdateCTestConfiguration()
+{
+  if (this->SuppressUpdatingCTestConfiguration) {
+    return true;
+  }
+  std::string fileName = this->BinaryDir + "/CTestConfiguration.ini";
+  if (!cmSystemTools::FileExists(fileName.c_str())) {
+    fileName = this->BinaryDir + "/DartConfiguration.tcl";
+  }
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+             "UpdateCTestConfiguration  from :" << fileName << "\n");
+  if (!cmSystemTools::FileExists(fileName.c_str())) {
+    // No need to exit if we are not producing XML
+    if (this->ProduceXML) {
+      cmCTestLog(this, ERROR_MESSAGE, "Cannot find file: " << fileName
+                                                           << std::endl);
+      return false;
+    }
+  } else {
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Parse Config file:" << fileName
+                                                                  << "\n");
+    // parse the dart test file
+    cmsys::ifstream fin(fileName.c_str());
+
+    if (!fin) {
+      return false;
+    }
+
+    char buffer[1024];
+    while (fin) {
+      buffer[0] = 0;
+      fin.getline(buffer, 1023);
+      buffer[1023] = 0;
+      std::string line = cmCTest::CleanString(buffer);
+      if (line.empty()) {
+        continue;
+      }
+      while (fin && (line[line.size() - 1] == '\\')) {
+        line = line.substr(0, line.size() - 1);
+        buffer[0] = 0;
+        fin.getline(buffer, 1023);
+        buffer[1023] = 0;
+        line += cmCTest::CleanString(buffer);
+      }
+      if (line[0] == '#') {
+        continue;
+      }
+      std::string::size_type cpos = line.find_first_of(':');
+      if (cpos == std::string::npos) {
+        continue;
+      }
+      std::string key = line.substr(0, cpos);
+      std::string value = cmCTest::CleanString(line.substr(cpos + 1));
+      this->CTestConfiguration[key] = value;
+    }
+    fin.close();
+  }
+  if (!this->GetCTestConfiguration("BuildDirectory").empty()) {
+    this->BinaryDir = this->GetCTestConfiguration("BuildDirectory");
+    cmSystemTools::ChangeDirectory(this->BinaryDir);
+  }
+  this->TimeOut =
+    std::chrono::seconds(atoi(this->GetCTestConfiguration("TimeOut").c_str()));
+  std::string const& testLoad = this->GetCTestConfiguration("TestLoad");
+  if (!testLoad.empty()) {
+    unsigned long load;
+    if (cmSystemTools::StringToULong(testLoad.c_str(), &load)) {
+      this->SetTestLoad(load);
+    } else {
+      cmCTestLog(this, WARNING,
+                 "Invalid value for 'Test Load' : " << testLoad << std::endl);
+    }
+  }
+  if (this->ProduceXML) {
+    this->CompressXMLFiles = cmSystemTools::IsOn(
+      this->GetCTestConfiguration("CompressSubmission").c_str());
+  }
+  return true;
+}
+
+void cmCTest::BlockTestErrorDiagnostics()
+{
+  cmSystemTools::PutEnv("DART_TEST_FROM_DART=1");
+  cmSystemTools::PutEnv("DASHBOARD_TEST_FROM_CTEST=" CMake_VERSION);
+#if defined(_WIN32)
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+#elif defined(__BEOS__) || defined(__HAIKU__)
+  disable_debugger(1);
+#endif
+}
+
+void cmCTest::SetTestModel(int mode)
+{
+  this->InteractiveDebugMode = false;
+  this->TestModel = mode;
+}
+
+bool cmCTest::SetTest(const char* ttype, bool report)
+{
+  if (cmSystemTools::LowerCase(ttype) == "all") {
+    for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
+      this->Parts[p].Enable();
+    }
+    return true;
+  }
+  Part p = this->GetPartFromName(ttype);
+  if (p != PartCount) {
+    this->Parts[p].Enable();
+    return true;
+  }
+  if (report) {
+    cmCTestLog(this, ERROR_MESSAGE, "Don't know about test \""
+                 << ttype << "\" yet..." << std::endl);
+  }
+  return false;
+}
+
+void cmCTest::Finalize()
+{
+}
+
+bool cmCTest::OpenOutputFile(const std::string& path, const std::string& name,
+                             cmGeneratedFileStream& stream, bool compress)
+{
+  std::string testingDir = this->BinaryDir + "/Testing";
+  if (!path.empty()) {
+    testingDir += "/" + path;
+  }
+  if (cmSystemTools::FileExists(testingDir.c_str())) {
+    if (!cmSystemTools::FileIsDirectory(testingDir)) {
+      cmCTestLog(this, ERROR_MESSAGE, "File "
+                   << testingDir << " is in the place of the testing directory"
+                   << std::endl);
+      return false;
+    }
+  } else {
+    if (!cmSystemTools::MakeDirectory(testingDir.c_str())) {
+      cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory " << testingDir
+                                                                 << std::endl);
+      return false;
+    }
+  }
+  std::string filename = testingDir + "/" + name;
+  stream.Open(filename.c_str());
+  if (!stream) {
+    cmCTestLog(this, ERROR_MESSAGE, "Problem opening file: " << filename
+                                                             << std::endl);
+    return false;
+  }
+  if (compress) {
+    if (this->CompressXMLFiles) {
+      stream.SetCompression(true);
+    }
+  }
+  return true;
+}
+
+bool cmCTest::AddIfExists(Part part, const char* file)
+{
+  if (this->CTestFileExists(file)) {
+    this->AddSubmitFile(part, file);
+  } else {
+    std::string name = file;
+    name += ".gz";
+    if (this->CTestFileExists(name)) {
+      this->AddSubmitFile(part, file);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool cmCTest::CTestFileExists(const std::string& filename)
+{
+  std::string testingDir =
+    this->BinaryDir + "/Testing/" + this->CurrentTag + "/" + filename;
+  return cmSystemTools::FileExists(testingDir.c_str());
+}
+
+cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
+{
+  cmCTest::t_TestingHandlers::iterator it =
+    this->TestingHandlers.find(handler);
+  if (it == this->TestingHandlers.end()) {
+    return nullptr;
+  }
+  it->second->Initialize();
+  return it->second;
+}
+
+cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
+{
+  cmCTest::t_TestingHandlers::iterator it =
+    this->TestingHandlers.find(handler);
+  if (it == this->TestingHandlers.end()) {
+    return nullptr;
+  }
+  return it->second;
+}
+
+int cmCTest::ExecuteHandler(const char* shandler)
+{
+  cmCTestGenericHandler* handler = this->GetHandler(shandler);
+  if (!handler) {
+    return -1;
+  }
+  handler->Initialize();
+  return handler->ProcessHandler();
+}
+
+int cmCTest::ProcessSteps()
+{
+  int res = 0;
+  bool notest = true;
+  int update_count = 0;
+
+  for (Part p = PartStart; notest && p != PartCount; p = Part(p + 1)) {
+    notest = !this->Parts[p];
+  }
+  if (this->Parts[PartUpdate] &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    cmCTestGenericHandler* uphandler = this->GetHandler("update");
+    uphandler->SetPersistentOption(
+      "SourceDirectory",
+      this->GetCTestConfiguration("SourceDirectory").c_str());
+    update_count = uphandler->ProcessHandler();
+    if (update_count < 0) {
+      res |= cmCTest::UPDATE_ERRORS;
+    }
+  }
+  if (this->TestModel == cmCTest::CONTINUOUS && !update_count) {
+    return 0;
+  }
+  if (this->Parts[PartConfigure] &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    if (this->GetHandler("configure")->ProcessHandler() < 0) {
+      res |= cmCTest::CONFIGURE_ERRORS;
+    }
+  }
+  if (this->Parts[PartBuild] &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    this->UpdateCTestConfiguration();
+    if (this->GetHandler("build")->ProcessHandler() < 0) {
+      res |= cmCTest::BUILD_ERRORS;
+    }
+  }
+  if ((this->Parts[PartTest] || notest) &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    this->UpdateCTestConfiguration();
+    if (this->GetHandler("test")->ProcessHandler() < 0) {
+      res |= cmCTest::TEST_ERRORS;
+    }
+  }
+  if (this->Parts[PartCoverage] &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    this->UpdateCTestConfiguration();
+    if (this->GetHandler("coverage")->ProcessHandler() < 0) {
+      res |= cmCTest::COVERAGE_ERRORS;
+    }
+  }
+  if (this->Parts[PartMemCheck] &&
+      (this->GetRemainingTimeAllowed() > std::chrono::minutes(2))) {
+    this->UpdateCTestConfiguration();
+    if (this->GetHandler("memcheck")->ProcessHandler() < 0) {
+      res |= cmCTest::MEMORY_ERRORS;
+    }
+  }
+  if (!notest) {
+    std::string notes_dir = this->BinaryDir + "/Testing/Notes";
+    if (cmSystemTools::FileIsDirectory(notes_dir)) {
+      cmsys::Directory d;
+      d.Load(notes_dir);
+      unsigned long kk;
+      for (kk = 0; kk < d.GetNumberOfFiles(); kk++) {
+        const char* file = d.GetFile(kk);
+        std::string fullname = notes_dir + "/" + file;
+        if (cmSystemTools::FileExists(fullname.c_str()) &&
+            !cmSystemTools::FileIsDirectory(fullname)) {
+          if (!this->NotesFiles.empty()) {
+            this->NotesFiles += ";";
+          }
+          this->NotesFiles += fullname;
+          this->Parts[PartNotes].Enable();
+        }
+      }
+    }
+  }
+  if (this->Parts[PartNotes]) {
+    this->UpdateCTestConfiguration();
+    if (!this->NotesFiles.empty()) {
+      this->GenerateNotesFile(this->NotesFiles.c_str());
+    }
+  }
+  if (this->Parts[PartSubmit]) {
+    this->UpdateCTestConfiguration();
+    if (this->GetHandler("submit")->ProcessHandler() < 0) {
+      res |= cmCTest::SUBMIT_ERRORS;
+    }
+  }
+  if (res != 0) {
+    cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest" << std::endl);
+  }
+  return res;
+}
+
+std::string cmCTest::GetTestModelString()
+{
+  if (!this->SpecificTrack.empty()) {
+    return this->SpecificTrack;
+  }
+  switch (this->TestModel) {
+    case cmCTest::NIGHTLY:
+      return "Nightly";
+    case cmCTest::CONTINUOUS:
+      return "Continuous";
+  }
+  return "Experimental";
+}
+
+int cmCTest::GetTestModelFromString(const char* str)
+{
+  if (!str) {
+    return cmCTest::EXPERIMENTAL;
+  }
+  std::string rstr = cmSystemTools::LowerCase(str);
+  if (cmHasLiteralPrefix(rstr.c_str(), "cont")) {
+    return cmCTest::CONTINUOUS;
+  }
+  if (cmHasLiteralPrefix(rstr.c_str(), "nigh")) {
+    return cmCTest::NIGHTLY;
+  }
+  return cmCTest::EXPERIMENTAL;
+}
+
+//######################################################################
+//######################################################################
+//######################################################################
+//######################################################################
+
+int cmCTest::RunMakeCommand(const char* command, std::string& output,
+                            int* retVal, const char* dir,
+                            std::chrono::duration<double> timeout,
+                            std::ostream& ofs, Encoding encoding)
+{
+  // First generate the command and arguments
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
+
+  if (args.empty()) {
+    return false;
+  }
+
+  std::vector<const char*> argv;
+  argv.reserve(args.size() + 1);
+  for (std::string const& a : args) {
+    argv.push_back(a.c_str());
+  }
+  argv.push_back(nullptr);
+
+  output.clear();
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Run command:");
+  for (char const* arg : argv) {
+    if (!arg) {
+      break;
+    }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, " \"" << arg << "\"");
+  }
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, std::endl);
+
+  // Now create process object
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*argv.begin());
+  cmsysProcess_SetWorkingDirectory(cp, dir);
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  cmsysProcess_SetTimeout(cp, timeout.count());
+  cmsysProcess_Execute(cp);
+
+  // Initialize tick's
+  std::string::size_type tick = 0;
+  std::string::size_type tick_len = 1024;
+  std::string::size_type tick_line_len = 50;
+
+  char* data;
+  int length;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, "   Each . represents "
+               << tick_len << " bytes of output" << std::endl
+               << "    " << std::flush);
+  while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
+    processOutput.DecodeText(data, length, strdata);
+    for (char& cc : strdata) {
+      if (cc == 0) {
+        cc = '\n';
+      }
+    }
+    output.append(strdata);
+    while (output.size() > (tick * tick_len)) {
+      tick++;
+      cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, "." << std::flush);
+      if (tick % tick_line_len == 0 && tick > 0) {
+        cmCTestLog(this, HANDLER_PROGRESS_OUTPUT,
+                   "  Size: " << int((double(output.size()) / 1024.0) + 1)
+                              << "K" << std::endl
+                              << "    " << std::flush);
+      }
+    }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               cmCTestLogWrite(strdata.c_str(), strdata.size()));
+    if (ofs) {
+      ofs << cmCTestLogWrite(strdata.c_str(), strdata.size());
+    }
+  }
+  processOutput.DecodeText(std::string(), strdata);
+  if (!strdata.empty()) {
+    output.append(strdata);
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               cmCTestLogWrite(strdata.c_str(), strdata.size()));
+    if (ofs) {
+      ofs << cmCTestLogWrite(strdata.c_str(), strdata.size());
+    }
+  }
+  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, " Size of output: "
+               << int(double(output.size()) / 1024.0) << "K" << std::endl);
+
+  cmsysProcess_WaitForExit(cp, nullptr);
+
+  int result = cmsysProcess_GetState(cp);
+
+  if (result == cmsysProcess_State_Exited) {
+    *retVal = cmsysProcess_GetExitValue(cp);
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               "Command exited with the value: " << *retVal << std::endl);
+  } else if (result == cmsysProcess_State_Exception) {
+    *retVal = cmsysProcess_GetExitException(cp);
+    cmCTestLog(this, WARNING, "There was an exception: " << *retVal
+                                                         << std::endl);
+  } else if (result == cmsysProcess_State_Expired) {
+    cmCTestLog(this, WARNING, "There was a timeout" << std::endl);
+  } else if (result == cmsysProcess_State_Error) {
+    output += "\n*** ERROR executing: ";
+    output += cmsysProcess_GetErrorString(cp);
+    output += "\n***The build process failed.";
+    cmCTestLog(this, ERROR_MESSAGE, "There was an error: "
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
+  }
+
+  cmsysProcess_Delete(cp);
+
+  return result;
+}
+
+//######################################################################
+//######################################################################
+//######################################################################
+//######################################################################
+
+int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
+                     int* retVal, std::ostream* log,
+                     std::chrono::duration<double> testTimeOut,
+                     std::vector<std::string>* environment, Encoding encoding)
+{
+  bool modifyEnv = (environment && !environment->empty());
+
+  // determine how much time we have
+  std::chrono::duration<double> timeout = this->GetRemainingTimeAllowed();
+  if (timeout != cmCTest::MaxDuration()) {
+    timeout -= std::chrono::minutes(2);
+  }
+  if (this->TimeOut > std::chrono::duration<double>::zero() &&
+      this->TimeOut < timeout) {
+    timeout = this->TimeOut;
+  }
+  if (testTimeOut > std::chrono::duration<double>::zero() &&
+      testTimeOut < this->GetRemainingTimeAllowed()) {
+    timeout = testTimeOut;
+  }
+
+  // always have at least 1 second if we got to here
+  if (timeout <= std::chrono::duration<double>::zero()) {
+    timeout = std::chrono::seconds(1);
+  }
+  cmCTestLog(
+    this, HANDLER_VERBOSE_OUTPUT, "Test timeout computed to be: "
+      << (timeout == cmCTest::MaxDuration()
+            ? std::string("infinite")
+            : std::to_string(
+                std::chrono::duration_cast<std::chrono::seconds>(timeout)
+                  .count()))
+      << "\n");
+  if (cmSystemTools::SameFile(argv[0], cmSystemTools::GetCTestCommand()) &&
+      !this->ForceNewCTestProcess) {
+    cmCTest inst;
+    inst.ConfigType = this->ConfigType;
+    inst.TimeOut = timeout;
+
+    // Capture output of the child ctest.
+    std::ostringstream oss;
+    inst.SetStreams(&oss, &oss);
+
+    std::vector<std::string> args;
+    for (char const* i : argv) {
+      if (i) {
+        // make sure we pass the timeout in for any build and test
+        // invocations. Since --build-generator is required this is a
+        // good place to check for it, and to add the arguments in
+        if (strcmp(i, "--build-generator") == 0 &&
+            timeout != cmCTest::MaxDuration() &&
+            timeout > std::chrono::duration<double>::zero()) {
+          args.push_back("--test-timeout");
+          std::ostringstream msg;
+          msg << std::chrono::duration_cast<std::chrono::seconds>(timeout)
+                   .count();
+          args.push_back(msg.str());
+        }
+        args.push_back(i);
+      }
+    }
+    if (log) {
+      *log << "* Run internal CTest" << std::endl;
+    }
+
+    std::unique_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
+    if (modifyEnv) {
+      saveEnv = cm::make_unique<cmSystemTools::SaveRestoreEnvironment>();
+      cmSystemTools::AppendEnv(*environment);
+    }
+
+    *retVal = inst.Run(args, output);
+    if (output) {
+      *output += oss.str();
+    }
+    if (log && output) {
+      *log << *output;
+    }
+    if (output) {
+      cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+                 "Internal cmCTest object used to run test." << std::endl
+                                                             << *output
+                                                             << std::endl);
+    }
+
+    return cmsysProcess_State_Exited;
+  }
+  std::vector<char> tempOutput;
+  if (output) {
+    output->clear();
+  }
+
+  std::unique_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
+  if (modifyEnv) {
+    saveEnv = cm::make_unique<cmSystemTools::SaveRestoreEnvironment>();
+    cmSystemTools::AppendEnv(*environment);
+  }
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*argv.begin());
+  cmCTestLog(this, DEBUG, "Command is: " << argv[0] << std::endl);
+  if (cmSystemTools::GetRunCommandHideConsole()) {
+    cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  }
+
+  cmsysProcess_SetTimeout(cp, timeout.count());
+  cmsysProcess_Execute(cp);
+
+  char* data;
+  int length;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
+    processOutput.DecodeText(data, length, strdata);
+    if (output) {
+      tempOutput.insert(tempOutput.end(), data, data + length);
+    }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               cmCTestLogWrite(strdata.c_str(), strdata.size()));
+    if (log) {
+      log->write(strdata.c_str(), strdata.size());
+    }
+  }
+  processOutput.DecodeText(std::string(), strdata);
+  if (!strdata.empty()) {
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               cmCTestLogWrite(strdata.c_str(), strdata.size()));
+    if (log) {
+      log->write(strdata.c_str(), strdata.size());
+    }
+  }
+
+  cmsysProcess_WaitForExit(cp, nullptr);
+  processOutput.DecodeText(tempOutput, tempOutput);
+  if (output && tempOutput.begin() != tempOutput.end()) {
+    output->append(&*tempOutput.begin(), tempOutput.size());
+  }
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- Process completed"
+               << std::endl);
+
+  int result = cmsysProcess_GetState(cp);
+
+  if (result == cmsysProcess_State_Exited) {
+    *retVal = cmsysProcess_GetExitValue(cp);
+    if (*retVal != 0 && this->OutputTestOutputOnTestFailure) {
+      OutputTestErrors(tempOutput);
+    }
+  } else if (result == cmsysProcess_State_Exception) {
+    if (this->OutputTestOutputOnTestFailure) {
+      OutputTestErrors(tempOutput);
+    }
+    *retVal = cmsysProcess_GetExitException(cp);
+    std::string outerr = "\n*** Exception executing: ";
+    outerr += cmsysProcess_GetExceptionString(cp);
+    if (output) {
+      *output += outerr;
+    }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr << std::endl
+                                                    << std::flush);
+  } else if (result == cmsysProcess_State_Error) {
+    std::string outerr = "\n*** ERROR executing: ";
+    outerr += cmsysProcess_GetErrorString(cp);
+    if (output) {
+      *output += outerr;
+    }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr << std::endl
+                                                    << std::flush);
+  }
+  cmsysProcess_Delete(cp);
+
+  return result;
+}
+
+std::string cmCTest::SafeBuildIdField(const std::string& value)
+{
+  std::string safevalue(value);
+
+  if (!safevalue.empty()) {
+    // Disallow non-filename and non-space whitespace characters.
+    // If they occur, replace them with ""
+    //
+    const char* disallowed = "\\:*?\"<>|\n\r\t\f\v";
+
+    if (safevalue.find_first_of(disallowed) != std::string::npos) {
+      std::string::size_type i = 0;
+      std::string::size_type n = strlen(disallowed);
+      char replace[2];
+      replace[1] = 0;
+
+      for (i = 0; i < n; ++i) {
+        replace[0] = disallowed[i];
+        cmSystemTools::ReplaceString(safevalue, replace, "");
+      }
+    }
+  }
+
+  if (safevalue.empty()) {
+    safevalue = "(empty)";
+  }
+
+  return safevalue;
+}
+
+void cmCTest::StartXML(cmXMLWriter& xml, bool append)
+{
+  if (this->CurrentTag.empty()) {
+    cmCTestLog(this, ERROR_MESSAGE, "Current Tag empty, this may mean"
+                                    " NightlStartTime was not set correctly."
+                 << std::endl);
+    cmSystemTools::SetFatalErrorOccured();
+  }
+
+  // find out about the system
+  cmsys::SystemInformation info;
+  info.RunCPUCheck();
+  info.RunOSCheck();
+  info.RunMemoryCheck();
+
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"));
+  std::string stamp = cmCTest::SafeBuildIdField(this->CurrentTag + "-" +
+                                                this->GetTestModelString());
+  std::string site =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("Site"));
+
+  xml.StartDocument();
+  xml.StartElement("Site");
+  xml.Attribute("BuildName", buildname);
+  xml.BreakAttributes();
+  xml.Attribute("BuildStamp", stamp);
+  xml.Attribute("Name", site);
+  xml.Attribute("Generator",
+                std::string("ctest-") + cmVersion::GetCMakeVersion());
+  if (append) {
+    xml.Attribute("Append", "true");
+  }
+  xml.Attribute("CompilerName", this->GetCTestConfiguration("Compiler"));
+  xml.Attribute("CompilerVersion",
+                this->GetCTestConfiguration("CompilerVersion"));
+  xml.Attribute("OSName", info.GetOSName());
+  xml.Attribute("Hostname", info.GetHostname());
+  xml.Attribute("OSRelease", info.GetOSRelease());
+  xml.Attribute("OSVersion", info.GetOSVersion());
+  xml.Attribute("OSPlatform", info.GetOSPlatform());
+  xml.Attribute("Is64Bits", info.Is64Bits());
+  xml.Attribute("VendorString", info.GetVendorString());
+  xml.Attribute("VendorID", info.GetVendorID());
+  xml.Attribute("FamilyID", info.GetFamilyID());
+  xml.Attribute("ModelID", info.GetModelID());
+  xml.Attribute("ProcessorCacheSize", info.GetProcessorCacheSize());
+  xml.Attribute("NumberOfLogicalCPU", info.GetNumberOfLogicalCPU());
+  xml.Attribute("NumberOfPhysicalCPU", info.GetNumberOfPhysicalCPU());
+  xml.Attribute("TotalVirtualMemory", info.GetTotalVirtualMemory());
+  xml.Attribute("TotalPhysicalMemory", info.GetTotalPhysicalMemory());
+  xml.Attribute("LogicalProcessorsPerPhysical",
+                info.GetLogicalProcessorsPerPhysical());
+  xml.Attribute("ProcessorClockFrequency", info.GetProcessorClockFrequency());
+
+  std::string changeId = this->GetCTestConfiguration("ChangeId");
+  if (!changeId.empty()) {
+    xml.Attribute("ChangeId", changeId);
+  }
+
+  this->AddSiteProperties(xml);
+}
+
+void cmCTest::AddSiteProperties(cmXMLWriter& xml)
+{
+  cmCTestScriptHandler* ch =
+    static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+  cmake* cm = ch->GetCMake();
+  // if no CMake then this is the old style script and props like
+  // this will not work anyway.
+  if (!cm) {
+    return;
+  }
+  // This code should go when cdash is changed to use labels only
+  const char* subproject = cm->GetState()->GetGlobalProperty("SubProject");
+  if (subproject) {
+    xml.StartElement("Subproject");
+    xml.Attribute("name", subproject);
+    const char* labels =
+      ch->GetCMake()->GetState()->GetGlobalProperty("SubProjectLabels");
+    if (labels) {
+      xml.StartElement("Labels");
+      std::string l = labels;
+      std::vector<std::string> args;
+      cmSystemTools::ExpandListArgument(l, args);
+      for (std::string const& i : args) {
+        xml.Element("Label", i);
+      }
+      xml.EndElement();
+    }
+    xml.EndElement();
+  }
+
+  // This code should stay when cdash only does label based sub-projects
+  const char* label = cm->GetState()->GetGlobalProperty("Label");
+  if (label) {
+    xml.StartElement("Labels");
+    xml.Element("Label", label);
+    xml.EndElement();
+  }
+}
+
+void cmCTest::GenerateSubprojectsOutput(cmXMLWriter& xml)
+{
+  for (std::string const& subproj : this->GetLabelsForSubprojects()) {
+    xml.StartElement("Subproject");
+    xml.Attribute("name", subproj);
+    xml.Element("Label", subproj);
+    xml.EndElement(); // Subproject
+  }
+}
+
+std::vector<std::string> cmCTest::GetLabelsForSubprojects()
+{
+  std::string labelsForSubprojects =
+    this->GetCTestConfiguration("LabelsForSubprojects");
+  std::vector<std::string> subprojects;
+  cmSystemTools::ExpandListArgument(labelsForSubprojects, subprojects);
+
+  // sort the array
+  std::sort(subprojects.begin(), subprojects.end());
+  // remove duplicates
+  std::vector<std::string>::iterator new_end =
+    std::unique(subprojects.begin(), subprojects.end());
+  subprojects.erase(new_end, subprojects.end());
+
+  return subprojects;
+}
+
+void cmCTest::EndXML(cmXMLWriter& xml)
+{
+  xml.EndElement(); // Site
+  xml.EndDocument();
+}
+
+int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
+                                      const cmCTest::VectorOfStrings& files)
+{
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"));
+  xml.StartDocument();
+  xml.ProcessingInstruction("xml-stylesheet",
+                            "type=\"text/xsl\" "
+                            "href=\"Dart/Source/Server/XSL/Build.xsl "
+                            "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
+  xml.StartElement("Site");
+  xml.Attribute("BuildName", buildname);
+  xml.Attribute("BuildStamp",
+                this->CurrentTag + "-" + this->GetTestModelString());
+  xml.Attribute("Name", this->GetCTestConfiguration("Site"));
+  xml.Attribute("Generator",
+                std::string("ctest") + cmVersion::GetCMakeVersion());
+  this->AddSiteProperties(xml);
+  xml.StartElement("Notes");
+
+  for (cmsys::String const& file : files) {
+    cmCTestLog(this, OUTPUT, "\tAdd file: " << file << std::endl);
+    std::string note_time = this->CurrentTime();
+    xml.StartElement("Note");
+    xml.Attribute("Name", file);
+    xml.Element("Time", std::chrono::system_clock::now());
+    xml.Element("DateTime", note_time);
+    xml.StartElement("Text");
+    cmsys::ifstream ifs(file.c_str());
+    if (ifs) {
+      std::string line;
+      while (cmSystemTools::GetLineFromStream(ifs, line)) {
+        xml.Content(line);
+        xml.Content("\n");
+      }
+      ifs.close();
+    } else {
+      xml.Content("Problem reading file: " + file + "\n");
+      cmCTestLog(this, ERROR_MESSAGE, "Problem reading file: "
+                   << file << " while creating notes" << std::endl);
+    }
+    xml.EndElement(); // Text
+    xml.EndElement(); // Note
+  }
+  xml.EndElement(); // Notes
+  xml.EndElement(); // Site
+  xml.EndDocument();
+  return 1;
+}
+
+int cmCTest::GenerateNotesFile(const VectorOfStrings& files)
+{
+  cmGeneratedFileStream ofs;
+  if (!this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs)) {
+    cmCTestLog(this, ERROR_MESSAGE, "Cannot open notes file" << std::endl);
+    return 1;
+  }
+  cmXMLWriter xml(ofs);
+  this->GenerateCTestNotesOutput(xml, files);
+  return 0;
+}
+
+int cmCTest::GenerateNotesFile(const char* cfiles)
+{
+  if (!cfiles) {
+    return 1;
+  }
+
+  VectorOfStrings files;
+
+  cmCTestLog(this, OUTPUT, "Create notes file" << std::endl);
+
+  files = cmSystemTools::SplitString(cfiles, ';');
+  if (files.empty()) {
+    return 1;
+  }
+
+  return this->GenerateNotesFile(files);
+}
+
+std::string cmCTest::Base64GzipEncodeFile(std::string const& file)
+{
+  std::string tarFile = file + "_temp.tar.gz";
+  std::vector<std::string> files;
+  files.push_back(file);
+
+  if (!cmSystemTools::CreateTar(tarFile.c_str(), files,
+                                cmSystemTools::TarCompressGZip, false)) {
+    cmCTestLog(this, ERROR_MESSAGE, "Error creating tar while "
+                                    "encoding file: "
+                 << file << std::endl);
+    return "";
+  }
+  std::string base64 = this->Base64EncodeFile(tarFile);
+  cmSystemTools::RemoveFile(tarFile);
+  return base64;
+}
+
+std::string cmCTest::Base64EncodeFile(std::string const& file)
+{
+  size_t const len = cmSystemTools::FileLength(file);
+  cmsys::ifstream ifs(file.c_str(), std::ios::in
+#ifdef _WIN32
+                        | std::ios::binary
+#endif
+                      );
+  std::vector<char> file_buffer(len + 1);
+  ifs.read(&file_buffer[0], len);
+  ifs.close();
+
+  std::vector<char> encoded_buffer((len * 3) / 2 + 5);
+
+  size_t const rlen = cmsysBase64_Encode(
+    reinterpret_cast<unsigned char*>(&file_buffer[0]), len,
+    reinterpret_cast<unsigned char*>(&encoded_buffer[0]), 1);
+
+  return std::string(&encoded_buffer[0], rlen);
+}
+
+bool cmCTest::SubmitExtraFiles(const VectorOfStrings& files)
+{
+  for (cmsys::String const& file : files) {
+    if (!cmSystemTools::FileExists(file.c_str())) {
+      cmCTestLog(this, ERROR_MESSAGE, "Cannot find extra file: "
+                   << file << " to submit." << std::endl;);
+      return false;
+    }
+    this->AddSubmitFile(PartExtraFiles, file.c_str());
+  }
+  return true;
+}
+
+bool cmCTest::SubmitExtraFiles(const char* cfiles)
+{
+  if (!cfiles) {
+    return true;
+  }
+
+  VectorOfStrings files;
+
+  cmCTestLog(this, OUTPUT, "Submit extra files" << std::endl);
+
+  files = cmSystemTools::SplitString(cfiles, ';');
+  if (files.empty()) {
+    return true;
+  }
+
+  return this->SubmitExtraFiles(files);
+}
+
+// for a -D argument convert the next argument into
+// the proper list of dashboard steps via SetTest
+bool cmCTest::AddTestsForDashboardType(std::string& targ)
+{
+  if (targ == "Experimental") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Start");
+    this->SetTest("Configure");
+    this->SetTest("Build");
+    this->SetTest("Test");
+    this->SetTest("Coverage");
+    this->SetTest("Submit");
+  } else if (targ == "ExperimentalStart") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Start");
+  } else if (targ == "ExperimentalUpdate") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Update");
+  } else if (targ == "ExperimentalConfigure") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Configure");
+  } else if (targ == "ExperimentalBuild") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Build");
+  } else if (targ == "ExperimentalTest") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Test");
+  } else if (targ == "ExperimentalMemCheck" || targ == "ExperimentalPurify") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("MemCheck");
+  } else if (targ == "ExperimentalCoverage") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Coverage");
+  } else if (targ == "ExperimentalSubmit") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Submit");
+  } else if (targ == "Continuous") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Start");
+    this->SetTest("Update");
+    this->SetTest("Configure");
+    this->SetTest("Build");
+    this->SetTest("Test");
+    this->SetTest("Coverage");
+    this->SetTest("Submit");
+  } else if (targ == "ContinuousStart") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Start");
+  } else if (targ == "ContinuousUpdate") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Update");
+  } else if (targ == "ContinuousConfigure") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Configure");
+  } else if (targ == "ContinuousBuild") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Build");
+  } else if (targ == "ContinuousTest") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Test");
+  } else if (targ == "ContinuousMemCheck" || targ == "ContinuousPurify") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("MemCheck");
+  } else if (targ == "ContinuousCoverage") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Coverage");
+  } else if (targ == "ContinuousSubmit") {
+    this->SetTestModel(cmCTest::CONTINUOUS);
+    this->SetTest("Submit");
+  } else if (targ == "Nightly") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Start");
+    this->SetTest("Update");
+    this->SetTest("Configure");
+    this->SetTest("Build");
+    this->SetTest("Test");
+    this->SetTest("Coverage");
+    this->SetTest("Submit");
+  } else if (targ == "NightlyStart") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Start");
+  } else if (targ == "NightlyUpdate") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Update");
+  } else if (targ == "NightlyConfigure") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Configure");
+  } else if (targ == "NightlyBuild") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Build");
+  } else if (targ == "NightlyTest") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Test");
+  } else if (targ == "NightlyMemCheck" || targ == "NightlyPurify") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("MemCheck");
+  } else if (targ == "NightlyCoverage") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Coverage");
+  } else if (targ == "NightlySubmit") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Submit");
+  } else if (targ == "MemoryCheck") {
+    this->SetTestModel(cmCTest::EXPERIMENTAL);
+    this->SetTest("Start");
+    this->SetTest("Configure");
+    this->SetTest("Build");
+    this->SetTest("MemCheck");
+    this->SetTest("Coverage");
+    this->SetTest("Submit");
+  } else if (targ == "NightlyMemoryCheck") {
+    this->SetTestModel(cmCTest::NIGHTLY);
+    this->SetTest("Start");
+    this->SetTest("Update");
+    this->SetTest("Configure");
+    this->SetTest("Build");
+    this->SetTest("MemCheck");
+    this->SetTest("Coverage");
+    this->SetTest("Submit");
+  } else {
+    return false;
+  }
+  return true;
+}
+
+void cmCTest::ErrorMessageUnknownDashDValue(std::string& val)
+{
+  cmCTestLog(this, ERROR_MESSAGE,
+             "CTest -D called with incorrect option: " << val << std::endl);
+
+  cmCTestLog(
+    this, ERROR_MESSAGE, "Available options are:"
+      << std::endl
+      << "  ctest -D Continuous" << std::endl
+      << "  ctest -D Continuous(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D Experimental" << std::endl
+      << "  ctest -D Experimental(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Experimental(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D Nightly" << std::endl
+      << "  ctest -D Nightly(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D NightlyMemoryCheck" << std::endl);
+}
+
+bool cmCTest::CheckArgument(const std::string& arg, const char* varg1,
+                            const char* varg2)
+{
+  return (varg1 && arg == varg1) || (varg2 && arg == varg2);
+}
+
+// Processes one command line argument (and its arguments if any)
+// for many simple options and then returns
+bool cmCTest::HandleCommandLineArguments(size_t& i,
+                                         std::vector<std::string>& args,
+                                         std::string& errormsg)
+{
+  std::string arg = args[i];
+  if (this->CheckArgument(arg, "-F")) {
+    this->Failover = true;
+  }
+  if (this->CheckArgument(arg, "-j", "--parallel") && i < args.size() - 1) {
+    i++;
+    int plevel = atoi(args[i].c_str());
+    this->SetParallelLevel(plevel);
+    this->ParallelLevelSetInCli = true;
+  } else if (arg.find("-j") == 0) {
+    int plevel = atoi(arg.substr(2).c_str());
+    this->SetParallelLevel(plevel);
+    this->ParallelLevelSetInCli = true;
+  }
+  if (this->CheckArgument(arg, "--repeat-until-fail")) {
+    if (i >= args.size() - 1) {
+      errormsg = "'--repeat-until-fail' requires an argument";
+      return false;
+    }
+    i++;
+    long repeat = 1;
+    if (!cmSystemTools::StringToLong(args[i].c_str(), &repeat)) {
+      errormsg =
+        "'--repeat-until-fail' given non-integer value '" + args[i] + "'";
+      return false;
+    }
+    this->RepeatTests = static_cast<int>(repeat);
+    if (repeat > 1) {
+      this->RepeatUntilFail = true;
+    }
+  }
+
+  if (this->CheckArgument(arg, "--test-load") && i < args.size() - 1) {
+    i++;
+    unsigned long load;
+    if (cmSystemTools::StringToULong(args[i].c_str(), &load)) {
+      this->SetTestLoad(load);
+    } else {
+      cmCTestLog(this, WARNING,
+                 "Invalid value for 'Test Load' : " << args[i] << std::endl);
+    }
+  }
+
+  if (this->CheckArgument(arg, "--no-compress-output")) {
+    this->CompressTestOutput = false;
+  }
+
+  if (this->CheckArgument(arg, "--print-labels")) {
+    this->PrintLabels = true;
+  }
+
+  if (this->CheckArgument(arg, "--http1.0")) {
+    this->UseHTTP10 = true;
+  }
+
+  if (this->CheckArgument(arg, "--timeout") && i < args.size() - 1) {
+    i++;
+    auto timeout = std::chrono::duration<double>(atof(args[i].c_str()));
+    this->GlobalTimeout = timeout;
+  }
+
+  if (this->CheckArgument(arg, "--stop-time") && i < args.size() - 1) {
+    i++;
+    this->SetStopTime(args[i]);
+  }
+
+  if (this->CheckArgument(arg, "-C", "--build-config") &&
+      i < args.size() - 1) {
+    i++;
+    this->SetConfigType(args[i].c_str());
+  }
+
+  if (this->CheckArgument(arg, "--debug")) {
+    this->Debug = true;
+    this->ShowLineNumbers = true;
+  }
+  if (this->CheckArgument(arg, "--track") && i < args.size() - 1) {
+    i++;
+    this->SpecificTrack = args[i];
+  }
+  if (this->CheckArgument(arg, "--show-line-numbers")) {
+    this->ShowLineNumbers = true;
+  }
+  if (this->CheckArgument(arg, "--no-label-summary")) {
+    this->LabelSummary = false;
+  }
+  if (this->CheckArgument(arg, "--no-subproject-summary")) {
+    this->SubprojectSummary = false;
+  }
+  if (this->CheckArgument(arg, "-Q", "--quiet")) {
+    this->Quiet = true;
+  }
+  if (this->CheckArgument(arg, "-V", "--verbose")) {
+    this->Verbose = true;
+  }
+  if (this->CheckArgument(arg, "-VV", "--extra-verbose")) {
+    this->ExtraVerbose = true;
+    this->Verbose = true;
+  }
+  if (this->CheckArgument(arg, "--output-on-failure")) {
+    this->OutputTestOutputOnTestFailure = true;
+  }
+  if (this->CheckArgument(arg, "--test-output-size-passed") &&
+      i < args.size() - 1) {
+    i++;
+    long outputSize;
+    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) {
+      if (cmCTestTestHandler* pCTestTestHandler =
+            static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) {
+        pCTestTestHandler->SetTestOutputSizePassed(int(outputSize));
+      }
+    } else {
+      cmCTestLog(this, WARNING,
+                 "Invalid value for '--test-output-size-passed': " << args[i]
+                                                                   << "\n");
+    }
+  }
+  if (this->CheckArgument(arg, "--test-output-size-failed") &&
+      i < args.size() - 1) {
+    i++;
+    long outputSize;
+    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) {
+      if (cmCTestTestHandler* pCTestTestHandler =
+            static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) {
+        pCTestTestHandler->SetTestOutputSizeFailed(int(outputSize));
+      }
+    } else {
+      cmCTestLog(this, WARNING,
+                 "Invalid value for '--test-output-size-failed': " << args[i]
+                                                                   << "\n");
+    }
+  }
+  if (this->CheckArgument(arg, "-N", "--show-only")) {
+    this->ShowOnly = true;
+  }
+
+  if (this->CheckArgument(arg, "-O", "--output-log") && i < args.size() - 1) {
+    i++;
+    this->SetOutputLogFileName(args[i].c_str());
+  }
+
+  if (this->CheckArgument(arg, "--tomorrow-tag")) {
+    this->TomorrowTag = true;
+  }
+  if (this->CheckArgument(arg, "--force-new-ctest-process")) {
+    this->ForceNewCTestProcess = true;
+  }
+  if (this->CheckArgument(arg, "-W", "--max-width") && i < args.size() - 1) {
+    i++;
+    this->MaxTestNameWidth = atoi(args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "--interactive-debug-mode") &&
+      i < args.size() - 1) {
+    i++;
+    this->InteractiveDebugMode = cmSystemTools::IsOn(args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "--submit-index") && i < args.size() - 1) {
+    i++;
+    this->SubmitIndex = atoi(args[i].c_str());
+    if (this->SubmitIndex < 0) {
+      this->SubmitIndex = 0;
+    }
+  }
+
+  if (this->CheckArgument(arg, "--overwrite") && i < args.size() - 1) {
+    i++;
+    this->AddCTestConfigurationOverwrite(args[i]);
+  }
+  if (this->CheckArgument(arg, "-A", "--add-notes") && i < args.size() - 1) {
+    this->ProduceXML = true;
+    this->SetTest("Notes");
+    i++;
+    this->SetNotesFiles(args[i].c_str());
+  }
+
+  // options that control what tests are run
+  if (this->CheckArgument(arg, "-I", "--tests-information") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption("TestsToRunInformation",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("TestsToRunInformation", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-U", "--union")) {
+    this->GetHandler("test")->SetPersistentOption("UseUnion", "true");
+    this->GetHandler("memcheck")->SetPersistentOption("UseUnion", "true");
+  }
+  if (this->CheckArgument(arg, "-R", "--tests-regex") && i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption("IncludeRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("IncludeRegularExpression", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-L", "--label-regex") && i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption("LabelRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("LabelRegularExpression", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-LE", "--label-exclude") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption(
+      "ExcludeLabelRegularExpression", args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeLabelRegularExpression", args[i].c_str());
+  }
+
+  if (this->CheckArgument(arg, "-E", "--exclude-regex") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption("ExcludeRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeRegularExpression", args[i].c_str());
+  }
+
+  if (this->CheckArgument(arg, "-FA", "--fixture-exclude-any") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption(
+      "ExcludeFixtureRegularExpression", args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeFixtureRegularExpression",
+                            args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-FS", "--fixture-exclude-setup") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption(
+      "ExcludeFixtureSetupRegularExpression", args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeFixtureSetupRegularExpression",
+                            args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-FC", "--fixture-exclude-cleanup") &&
+      i < args.size() - 1) {
+    i++;
+    this->GetHandler("test")->SetPersistentOption(
+      "ExcludeFixtureCleanupRegularExpression", args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeFixtureCleanupRegularExpression",
+                            args[i].c_str());
+  }
+
+  if (this->CheckArgument(arg, "--rerun-failed")) {
+    this->GetHandler("test")->SetPersistentOption("RerunFailed", "true");
+    this->GetHandler("memcheck")->SetPersistentOption("RerunFailed", "true");
+  }
+  return true;
+}
+
+// handle the -S -SR and -SP arguments
+void cmCTest::HandleScriptArguments(size_t& i, std::vector<std::string>& args,
+                                    bool& SRArgumentSpecified)
+{
+  std::string arg = args[i];
+  if (this->CheckArgument(arg, "-SP", "--script-new-process") &&
+      i < args.size() - 1) {
+    this->RunConfigurationScript = true;
+    i++;
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    // -SR is an internal argument, -SP should be ignored when it is passed
+    if (!SRArgumentSpecified) {
+      ch->AddConfigurationScript(args[i].c_str(), false);
+    }
+  }
+
+  if (this->CheckArgument(arg, "-SR", "--script-run") && i < args.size() - 1) {
+    SRArgumentSpecified = true;
+    this->RunConfigurationScript = true;
+    i++;
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    ch->AddConfigurationScript(args[i].c_str(), true);
+  }
+
+  if (this->CheckArgument(arg, "-S", "--script") && i < args.size() - 1) {
+    this->RunConfigurationScript = true;
+    i++;
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    // -SR is an internal argument, -S should be ignored when it is passed
+    if (!SRArgumentSpecified) {
+      ch->AddConfigurationScript(args[i].c_str(), true);
+    }
+  }
+}
+
+bool cmCTest::AddVariableDefinition(const std::string& arg)
+{
+  std::string name;
+  std::string value;
+  cmStateEnums::CacheEntryType type = cmStateEnums::UNINITIALIZED;
+
+  if (cmake::ParseCacheEntry(arg, name, value, type)) {
+    this->Definitions[name] = value;
+    return true;
+  }
+
+  return false;
+}
+
+// the main entry point of ctest, called from main
+int cmCTest::Run(std::vector<std::string>& args, std::string* output)
+{
+  const char* ctestExec = "ctest";
+  bool cmakeAndTest = false;
+  bool executeTests = true;
+  bool SRArgumentSpecified = false;
+
+  // copy the command line
+  this->InitialCommandLineArguments.insert(
+    this->InitialCommandLineArguments.end(), args.begin(), args.end());
+
+  // process the command line arguments
+  for (size_t i = 1; i < args.size(); ++i) {
+    // handle the simple commandline arguments
+    std::string errormsg;
+    if (!this->HandleCommandLineArguments(i, args, errormsg)) {
+      cmSystemTools::Error(errormsg.c_str());
+      return 1;
+    }
+
+    // handle the script arguments -S -SR -SP
+    this->HandleScriptArguments(i, args, SRArgumentSpecified);
+
+    // --dashboard: handle a request for a dashboard
+    std::string arg = args[i];
+    if (this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1) {
+      this->ProduceXML = true;
+      i++;
+      std::string targ = args[i];
+      // AddTestsForDashboard parses the dashboard type and converts it
+      // into the separate stages
+      if (!this->AddTestsForDashboardType(targ)) {
+        if (!this->AddVariableDefinition(targ)) {
+          this->ErrorMessageUnknownDashDValue(targ);
+          executeTests = false;
+        }
+      }
+    }
+
+    // If it's not exactly -D, but it starts with -D, then try to parse out
+    // a variable definition from it, same as CMake does. Unsuccessful
+    // attempts are simply ignored since previous ctest versions ignore
+    // this too. (As well as many other unknown command line args.)
+    //
+    if (arg != "-D" && cmSystemTools::StringStartsWith(arg.c_str(), "-D")) {
+      std::string input = arg.substr(2);
+      this->AddVariableDefinition(input);
+    }
+
+    // --test-action: calls SetTest(<stage>, /*report=*/ false) to enable
+    // the corresponding stage
+    if (!this->HandleTestActionArgument(ctestExec, i, args)) {
+      executeTests = false;
+    }
+
+    // --test-model: what type of test model
+    if (!this->HandleTestModelArgument(ctestExec, i, args)) {
+      executeTests = false;
+    }
+
+    // --extra-submit
+    if (this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1) {
+      this->ProduceXML = true;
+      this->SetTest("Submit");
+      i++;
+      if (!this->SubmitExtraFiles(args[i].c_str())) {
+        return 0;
+      }
+    }
+
+    // --build-and-test options
+    if (this->CheckArgument(arg, "--build-and-test") && i < args.size() - 1) {
+      cmakeAndTest = true;
+    }
+
+    // --schedule-random
+    if (this->CheckArgument(arg, "--schedule-random")) {
+      this->ScheduleType = "Random";
+    }
+
+    // pass the argument to all the handlers as well, but i may no longer be
+    // set to what it was originally so I'm not sure this is working as
+    // intended
+    for (auto& handler : this->TestingHandlers) {
+      if (!handler.second->ProcessCommandLineArguments(arg, i, args)) {
+        cmCTestLog(this, ERROR_MESSAGE,
+                   "Problem parsing command line arguments within a handler");
+        return 0;
+      }
+    }
+  } // the close of the for argument loop
+
+  // handle CTEST_PARALLEL_LEVEL environment variable
+  if (!this->ParallelLevelSetInCli) {
+    std::string parallel;
+    if (cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL", parallel)) {
+      int plevel = atoi(parallel.c_str());
+      this->SetParallelLevel(plevel);
+    }
+  }
+
+  // now what should cmake do? if --build-and-test was specified then
+  // we run the build and test handler and return
+  if (cmakeAndTest) {
+    return this->RunCMakeAndTest(output);
+  }
+
+  if (executeTests) {
+    return this->ExecuteTests();
+  }
+
+  return 1;
+}
+
+bool cmCTest::HandleTestActionArgument(const char* ctestExec, size_t& i,
+                                       const std::vector<std::string>& args)
+{
+  bool success = true;
+  std::string arg = args[i];
+  if (this->CheckArgument(arg, "-T", "--test-action") &&
+      (i < args.size() - 1)) {
+    this->ProduceXML = true;
+    i++;
+    if (!this->SetTest(args[i].c_str(), false)) {
+      success = false;
+      cmCTestLog(this, ERROR_MESSAGE, "CTest -T called with incorrect option: "
+                   << args[i] << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+                   << std::endl
+                   << "  " << ctestExec << " -T all" << std::endl
+                   << "  " << ctestExec << " -T start" << std::endl
+                   << "  " << ctestExec << " -T update" << std::endl
+                   << "  " << ctestExec << " -T configure" << std::endl
+                   << "  " << ctestExec << " -T build" << std::endl
+                   << "  " << ctestExec << " -T test" << std::endl
+                   << "  " << ctestExec << " -T coverage" << std::endl
+                   << "  " << ctestExec << " -T memcheck" << std::endl
+                   << "  " << ctestExec << " -T notes" << std::endl
+                   << "  " << ctestExec << " -T submit" << std::endl);
+    }
+  }
+  return success;
+}
+
+bool cmCTest::HandleTestModelArgument(const char* ctestExec, size_t& i,
+                                      const std::vector<std::string>& args)
+{
+  bool success = true;
+  std::string arg = args[i];
+  if (this->CheckArgument(arg, "-M", "--test-model") &&
+      (i < args.size() - 1)) {
+    i++;
+    std::string const& str = args[i];
+    if (cmSystemTools::LowerCase(str) == "nightly") {
+      this->SetTestModel(cmCTest::NIGHTLY);
+    } else if (cmSystemTools::LowerCase(str) == "continuous") {
+      this->SetTestModel(cmCTest::CONTINUOUS);
+    } else if (cmSystemTools::LowerCase(str) == "experimental") {
+      this->SetTestModel(cmCTest::EXPERIMENTAL);
+    } else {
+      success = false;
+      cmCTestLog(this, ERROR_MESSAGE, "CTest -M called with incorrect option: "
+                   << str << std::endl);
+      cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+                   << std::endl
+                   << "  " << ctestExec << " -M Continuous" << std::endl
+                   << "  " << ctestExec << " -M Experimental" << std::endl
+                   << "  " << ctestExec << " -M Nightly" << std::endl);
+    }
+  }
+  return success;
+}
+
+int cmCTest::ExecuteTests()
+{
+  int res;
+  // call process directory
+  if (this->RunConfigurationScript) {
+    if (this->ExtraVerbose) {
+      cmCTestLog(this, OUTPUT, "* Extra verbosity turned on" << std::endl);
+    }
+    for (auto& handler : this->TestingHandlers) {
+      handler.second->SetVerbose(this->ExtraVerbose);
+      handler.second->SetSubmitIndex(this->SubmitIndex);
+    }
+    this->GetHandler("script")->SetVerbose(this->Verbose);
+    res = this->GetHandler("script")->ProcessHandler();
+    if (res != 0) {
+      cmCTestLog(this, DEBUG,
+                 "running script failing returning: " << res << std::endl);
+    }
+
+  } else {
+    // What is this?  -V seems to be the same as -VV,
+    // and Verbose is always on in this case
+    this->ExtraVerbose = this->Verbose;
+    this->Verbose = true;
+    for (auto& handler : this->TestingHandlers) {
+      handler.second->SetVerbose(this->Verbose);
+      handler.second->SetSubmitIndex(this->SubmitIndex);
+    }
+    std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
+    if (!this->Initialize(cwd.c_str(), nullptr)) {
+      res = 12;
+      cmCTestLog(this, ERROR_MESSAGE, "Problem initializing the dashboard."
+                   << std::endl);
+    } else {
+      res = this->ProcessSteps();
+    }
+    this->Finalize();
+  }
+  if (res != 0) {
+    cmCTestLog(this, DEBUG,
+               "Running a test(s) failed returning : " << res << std::endl);
+  }
+  return res;
+}
+
+int cmCTest::RunCMakeAndTest(std::string* output)
+{
+  this->Verbose = true;
+  cmCTestBuildAndTestHandler* handler =
+    static_cast<cmCTestBuildAndTestHandler*>(this->GetHandler("buildtest"));
+  int retv = handler->ProcessHandler();
+  *output = handler->GetOutput();
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  cmDynamicLoader::FlushCache();
+#endif
+  if (retv != 0) {
+    cmCTestLog(this, DEBUG, "build and test failing returning: " << retv
+                                                                 << std::endl);
+  }
+  return retv;
+}
+
+void cmCTest::SetNotesFiles(const char* notes)
+{
+  if (!notes) {
+    return;
+  }
+  this->NotesFiles = notes;
+}
+
+void cmCTest::SetStopTime(std::string const& time_str)
+{
+
+  struct tm* lctime;
+  time_t current_time = time(nullptr);
+  lctime = gmtime(&current_time);
+  int gm_hour = lctime->tm_hour;
+  time_t gm_time = mktime(lctime);
+  lctime = localtime(&current_time);
+  int local_hour = lctime->tm_hour;
+
+  int tzone_offset = local_hour - gm_hour;
+  if (gm_time > current_time && gm_hour < local_hour) {
+    // this means gm_time is on the next day
+    tzone_offset -= 24;
+  } else if (gm_time < current_time && gm_hour > local_hour) {
+    // this means gm_time is on the previous day
+    tzone_offset += 24;
+  }
+
+  tzone_offset *= 100;
+  char buf[1024];
+  sprintf(buf, "%d%02d%02d %s %+05i", lctime->tm_year + 1900,
+          lctime->tm_mon + 1, lctime->tm_mday, time_str.c_str(), tzone_offset);
+
+  time_t stop_time = curl_getdate(buf, &current_time);
+  if (stop_time == -1) {
+    this->StopTime = std::chrono::system_clock::time_point();
+    return;
+  }
+  this->StopTime = std::chrono::system_clock::from_time_t(stop_time);
+
+  if (stop_time < current_time) {
+    this->StopTime += std::chrono::hours(24);
+  }
+}
+
+int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
+{
+  bool found = false;
+  VectorOfStrings dirs;
+  VectorOfStrings ndirs;
+  cmCTestLog(this, DEBUG, "* Read custom CTest configuration directory: "
+               << dir << std::endl);
+
+  std::string fname = dir;
+  fname += "/CTestCustom.cmake";
+  cmCTestLog(this, DEBUG, "* Check for file: " << fname << std::endl);
+  if (cmSystemTools::FileExists(fname.c_str())) {
+    cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
+                 << fname << std::endl);
+    bool erroroc = cmSystemTools::GetErrorOccuredFlag();
+    cmSystemTools::ResetErrorOccuredFlag();
+
+    if (!mf->ReadListFile(fname.c_str()) ||
+        cmSystemTools::GetErrorOccuredFlag()) {
+      cmCTestLog(this, ERROR_MESSAGE, "Problem reading custom configuration: "
+                   << fname << std::endl);
+    }
+    found = true;
+    if (erroroc) {
+      cmSystemTools::SetErrorOccured();
+    }
+  }
+
+  std::string rexpr = dir;
+  rexpr += "/CTestCustom.ctest";
+  cmCTestLog(this, DEBUG, "* Check for file: " << rexpr << std::endl);
+  if (!found && cmSystemTools::FileExists(rexpr.c_str())) {
+    cmsys::Glob gl;
+    gl.RecurseOn();
+    gl.FindFiles(rexpr);
+    std::vector<std::string>& files = gl.GetFiles();
+    std::vector<std::string>::iterator fileIt;
+    for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
+      cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
+                   << *fileIt << std::endl);
+      if (!mf->ReadListFile(fileIt->c_str()) ||
+          cmSystemTools::GetErrorOccuredFlag()) {
+        cmCTestLog(this, ERROR_MESSAGE,
+                   "Problem reading custom configuration: " << *fileIt
+                                                            << std::endl);
+      }
+    }
+    found = true;
+  }
+
+  if (found) {
+    for (auto& handler : this->TestingHandlers) {
+      cmCTestLog(
+        this, DEBUG, "* Read custom CTest configuration vectors for handler: "
+          << handler.first << " (" << handler.second << ")" << std::endl);
+      handler.second->PopulateCustomVectors(mf);
+    }
+  }
+
+  return 1;
+}
+
+void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
+                                   std::vector<std::string>& vec)
+{
+  const char* dval = mf->GetDefinition(def);
+  if (!dval) {
+    return;
+  }
+  cmCTestLog(this, DEBUG, "PopulateCustomVector: " << def << std::endl);
+
+  vec.clear();
+  cmSystemTools::ExpandListArgument(dval, vec);
+
+  for (std::string const& it : vec) {
+    cmCTestLog(this, DEBUG, "  -- " << it << std::endl);
+  }
+}
+
+void cmCTest::PopulateCustomInteger(cmMakefile* mf, const std::string& def,
+                                    int& val)
+{
+  const char* dval = mf->GetDefinition(def);
+  if (!dval) {
+    return;
+  }
+  val = atoi(dval);
+}
+
+std::string cmCTest::GetShortPathToFile(const char* cfname)
+{
+  const std::string& sourceDir = cmSystemTools::CollapseFullPath(
+    this->GetCTestConfiguration("SourceDirectory"));
+  const std::string& buildDir = cmSystemTools::CollapseFullPath(
+    this->GetCTestConfiguration("BuildDirectory"));
+  std::string fname = cmSystemTools::CollapseFullPath(cfname);
+
+  // Find relative paths to both directories
+  std::string srcRelpath =
+    cmSystemTools::RelativePath(sourceDir.c_str(), fname.c_str());
+  std::string bldRelpath =
+    cmSystemTools::RelativePath(buildDir.c_str(), fname.c_str());
+
+  // If any contains "." it is not parent directory
+  bool inSrc = srcRelpath.find("..") == std::string::npos;
+  bool inBld = bldRelpath.find("..") == std::string::npos;
+  // TODO: Handle files with .. in their name
+
+  std::string* res = nullptr;
+
+  if (inSrc && inBld) {
+    // If both have relative path with no dots, pick the shorter one
+    if (srcRelpath.size() < bldRelpath.size()) {
+      res = &srcRelpath;
+    } else {
+      res = &bldRelpath;
+    }
+  } else if (inSrc) {
+    res = &srcRelpath;
+  } else if (inBld) {
+    res = &bldRelpath;
+  }
+
+  std::string path;
+
+  if (!res) {
+    path = fname;
+  } else {
+    cmSystemTools::ConvertToUnixSlashes(*res);
+
+    path = "./" + *res;
+    if (path[path.size() - 1] == '/') {
+      path = path.substr(0, path.size() - 1);
+    }
+  }
+
+  cmsys::SystemTools::ReplaceString(path, ":", "_");
+  cmsys::SystemTools::ReplaceString(path, " ", "_");
+  return path;
+}
+
+std::string cmCTest::GetCTestConfiguration(const std::string& name)
+{
+  if (this->CTestConfigurationOverwrites.find(name) !=
+      this->CTestConfigurationOverwrites.end()) {
+    return this->CTestConfigurationOverwrites[name];
+  }
+  return this->CTestConfiguration[name];
+}
+
+void cmCTest::EmptyCTestConfiguration()
+{
+  this->CTestConfiguration.clear();
+}
+
+void cmCTest::SetCTestConfiguration(const char* name, const char* value,
+                                    bool suppress)
+{
+  cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT, "SetCTestConfiguration:"
+                       << name << ":" << (value ? value : "(null)") << "\n",
+                     suppress);
+
+  if (!name) {
+    return;
+  }
+  if (!value) {
+    this->CTestConfiguration.erase(name);
+    return;
+  }
+  this->CTestConfiguration[name] = value;
+}
+
+std::string cmCTest::GetCurrentTag()
+{
+  return this->CurrentTag;
+}
+
+std::string cmCTest::GetBinaryDir()
+{
+  return this->BinaryDir;
+}
+
+std::string const& cmCTest::GetConfigType()
+{
+  return this->ConfigType;
+}
+
+bool cmCTest::GetShowOnly()
+{
+  return this->ShowOnly;
+}
+
+int cmCTest::GetMaxTestNameWidth() const
+{
+  return this->MaxTestNameWidth;
+}
+
+void cmCTest::SetProduceXML(bool v)
+{
+  this->ProduceXML = v;
+}
+
+bool cmCTest::GetProduceXML()
+{
+  return this->ProduceXML;
+}
+
+const char* cmCTest::GetSpecificTrack()
+{
+  if (this->SpecificTrack.empty()) {
+    return nullptr;
+  }
+  return this->SpecificTrack.c_str();
+}
+
+void cmCTest::SetSpecificTrack(const char* track)
+{
+  if (!track) {
+    this->SpecificTrack.clear();
+    return;
+  }
+  this->SpecificTrack = track;
+}
+
+void cmCTest::AddSubmitFile(Part part, const char* name)
+{
+  this->Parts[part].SubmitFiles.push_back(name);
+}
+
+void cmCTest::AddCTestConfigurationOverwrite(const std::string& overStr)
+{
+  size_t epos = overStr.find('=');
+  if (epos == std::string::npos) {
+    cmCTestLog(this, ERROR_MESSAGE,
+               "CTest configuration overwrite specified in the wrong format."
+                 << std::endl
+                 << "Valid format is: --overwrite key=value" << std::endl
+                 << "The specified was: --overwrite " << overStr << std::endl);
+    return;
+  }
+  std::string key = overStr.substr(0, epos);
+  std::string value = overStr.substr(epos + 1);
+  this->CTestConfigurationOverwrites[key] = value;
+}
+
+void cmCTest::SetConfigType(const char* ct)
+{
+  this->ConfigType = ct ? ct : "";
+  cmSystemTools::ReplaceString(this->ConfigType, ".\\", "");
+  std::string confTypeEnv = "CMAKE_CONFIG_TYPE=" + this->ConfigType;
+  cmSystemTools::PutEnv(confTypeEnv);
+}
+
+bool cmCTest::SetCTestConfigurationFromCMakeVariable(
+  cmMakefile* mf, const char* dconfig, const std::string& cmake_var,
+  bool suppress)
+{
+  const char* ctvar;
+  ctvar = mf->GetDefinition(cmake_var);
+  if (!ctvar) {
+    return false;
+  }
+  cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT,
+                     "SetCTestConfigurationFromCMakeVariable:"
+                       << dconfig << ":" << cmake_var << std::endl,
+                     suppress);
+  this->SetCTestConfiguration(dconfig, ctvar, suppress);
+  return true;
+}
+
+bool cmCTest::RunCommand(std::vector<std::string> const& args,
+                         std::string* stdOut, std::string* stdErr, int* retVal,
+                         const char* dir,
+                         std::chrono::duration<double> timeout,
+                         Encoding encoding)
+{
+  std::vector<const char*> argv;
+  argv.reserve(args.size() + 1);
+  for (std::string const& a : args) {
+    argv.push_back(a.c_str());
+  }
+  argv.push_back(nullptr);
+
+  stdOut->clear();
+  stdErr->clear();
+
+  cmsysProcess* cp = cmsysProcess_New();
+  cmsysProcess_SetCommand(cp, &*argv.begin());
+  cmsysProcess_SetWorkingDirectory(cp, dir);
+  if (cmSystemTools::GetRunCommandHideConsole()) {
+    cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  }
+  cmsysProcess_SetTimeout(cp, timeout.count());
+  cmsysProcess_Execute(cp);
+
+  std::vector<char> tempOutput;
+  std::vector<char> tempError;
+  char* data;
+  int length;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  int res;
+  bool done = false;
+  while (!done) {
+    res = cmsysProcess_WaitForData(cp, &data, &length, nullptr);
+    switch (res) {
+      case cmsysProcess_Pipe_STDOUT:
+        tempOutput.insert(tempOutput.end(), data, data + length);
+        break;
+      case cmsysProcess_Pipe_STDERR:
+        tempError.insert(tempError.end(), data, data + length);
+        break;
+      default:
+        done = true;
+    }
+    if ((res == cmsysProcess_Pipe_STDOUT || res == cmsysProcess_Pipe_STDERR) &&
+        this->ExtraVerbose) {
+      processOutput.DecodeText(data, length, strdata);
+      cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+    }
+  }
+  if (this->ExtraVerbose) {
+    processOutput.DecodeText(std::string(), strdata);
+    if (!strdata.empty()) {
+      cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+    }
+  }
+
+  cmsysProcess_WaitForExit(cp, nullptr);
+  if (!tempOutput.empty()) {
+    processOutput.DecodeText(tempOutput, tempOutput);
+    stdOut->append(&*tempOutput.begin(), tempOutput.size());
+  }
+  if (!tempError.empty()) {
+    processOutput.DecodeText(tempError, tempError);
+    stdErr->append(&*tempError.begin(), tempError.size());
+  }
+
+  bool result = true;
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
+    if (retVal) {
+      *retVal = cmsysProcess_GetExitValue(cp);
+    } else {
+      if (cmsysProcess_GetExitValue(cp) != 0) {
+        result = false;
+      }
+    }
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
+    const char* exception_str = cmsysProcess_GetExceptionString(cp);
+    cmCTestLog(this, ERROR_MESSAGE, exception_str << std::endl);
+    stdErr->append(exception_str, strlen(exception_str));
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
+    const char* error_str = cmsysProcess_GetErrorString(cp);
+    cmCTestLog(this, ERROR_MESSAGE, error_str << std::endl);
+    stdErr->append(error_str, strlen(error_str));
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
+    const char* error_str = "Process terminated due to timeout\n";
+    cmCTestLog(this, ERROR_MESSAGE, error_str << std::endl);
+    stdErr->append(error_str, strlen(error_str));
+    result = false;
+  }
+
+  cmsysProcess_Delete(cp);
+  return result;
+}
+
+void cmCTest::SetOutputLogFileName(const char* name)
+{
+  if (this->OutputLogFile) {
+    delete this->OutputLogFile;
+    this->OutputLogFile = nullptr;
+  }
+  if (name) {
+    this->OutputLogFile = new cmGeneratedFileStream(name);
+  }
+}
+
+static const char* cmCTestStringLogType[] = { "DEBUG",
+                                              "OUTPUT",
+                                              "HANDLER_OUTPUT",
+                                              "HANDLER_PROGRESS_OUTPUT",
+                                              "HANDLER_VERBOSE_OUTPUT",
+                                              "WARNING",
+                                              "ERROR_MESSAGE",
+                                              nullptr };
+
+#define cmCTestLogOutputFileLine(stream)                                      \
+  if (this->ShowLineNumbers) {                                                \
+    (stream) << std::endl << file << ":" << line << " ";                      \
+  }
+
+void cmCTest::InitStreams()
+{
+  // By default we write output to the process output streams.
+  this->StreamOut = &std::cout;
+  this->StreamErr = &std::cerr;
+}
+
+void cmCTest::Log(int logType, const char* file, int line, const char* msg,
+                  bool suppress)
+{
+  if (!msg || !*msg) {
+    return;
+  }
+  if (suppress && logType != cmCTest::ERROR_MESSAGE) {
+    return;
+  }
+  if (logType == cmCTest::HANDLER_PROGRESS_OUTPUT &&
+      (this->Debug || this->ExtraVerbose)) {
+    return;
+  }
+  if (this->OutputLogFile) {
+    bool display = true;
+    if (logType == cmCTest::DEBUG && !this->Debug) {
+      display = false;
+    }
+    if (logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !this->Debug &&
+        !this->ExtraVerbose) {
+      display = false;
+    }
+    if (display) {
+      cmCTestLogOutputFileLine(*this->OutputLogFile);
+      if (logType != this->OutputLogFileLastTag) {
+        *this->OutputLogFile << "[";
+        if (logType >= OTHER || logType < 0) {
+          *this->OutputLogFile << "OTHER";
+        } else {
+          *this->OutputLogFile << cmCTestStringLogType[logType];
+        }
+        *this->OutputLogFile << "] " << std::endl << std::flush;
+      }
+      *this->OutputLogFile << msg << std::flush;
+      if (logType != this->OutputLogFileLastTag) {
+        *this->OutputLogFile << std::endl << std::flush;
+        this->OutputLogFileLastTag = logType;
+      }
+    }
+  }
+  if (!this->Quiet) {
+    std::ostream& out = *this->StreamOut;
+    std::ostream& err = *this->StreamErr;
+    switch (logType) {
+      case DEBUG:
+        if (this->Debug) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
+        }
+        break;
+      case OUTPUT:
+      case HANDLER_OUTPUT:
+        if (this->Debug || this->Verbose) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
+        }
+        break;
+      case HANDLER_VERBOSE_OUTPUT:
+        if (this->Debug || this->ExtraVerbose) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
+        }
+        break;
+      case WARNING:
+        cmCTestLogOutputFileLine(err);
+        err << msg;
+        err.flush();
+        break;
+      case ERROR_MESSAGE:
+        cmCTestLogOutputFileLine(err);
+        err << msg;
+        err.flush();
+        cmSystemTools::SetErrorOccured();
+        break;
+      default:
+        cmCTestLogOutputFileLine(out);
+        out << msg;
+        out.flush();
+    }
+  }
+}
+
+std::chrono::duration<double> cmCTest::GetRemainingTimeAllowed()
+{
+  if (!this->GetHandler("script")) {
+    return cmCTest::MaxDuration();
+  }
+
+  cmCTestScriptHandler* ch =
+    static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+
+  return ch->GetRemainingTimeAllowed();
+}
+
+std::chrono::duration<double> cmCTest::MaxDuration()
+{
+  return std::chrono::duration<double>(1.0e7);
+}
+
+void cmCTest::OutputTestErrors(std::vector<char> const& process_output)
+{
+  std::string test_outputs("\n*** Test Failed:\n");
+  if (!process_output.empty()) {
+    test_outputs.append(&*process_output.begin(), process_output.size());
+  }
+  cmCTestLog(this, HANDLER_OUTPUT, test_outputs << std::endl << std::flush);
+}
+
+bool cmCTest::CompressString(std::string& str)
+{
+  int ret;
+  z_stream strm;
+
+  strm.zalloc = Z_NULL;
+  strm.zfree = Z_NULL;
+  strm.opaque = Z_NULL;
+  ret = deflateInit(&strm, -1); // default compression level
+  if (ret != Z_OK) {
+    return false;
+  }
+
+  unsigned char* in =
+    reinterpret_cast<unsigned char*>(const_cast<char*>(str.c_str()));
+  // zlib makes the guarantee that this is the maximum output size
+  int outSize =
+    static_cast<int>(static_cast<double>(str.size()) * 1.001 + 13.0);
+  std::vector<unsigned char> out(outSize);
+
+  strm.avail_in = static_cast<uInt>(str.size());
+  strm.next_in = in;
+  strm.avail_out = outSize;
+  strm.next_out = &out[0];
+  ret = deflate(&strm, Z_FINISH);
+
+  if (ret != Z_STREAM_END) {
+    cmCTestLog(this, ERROR_MESSAGE, "Error during gzip compression."
+                 << std::endl);
+    return false;
+  }
+
+  (void)deflateEnd(&strm);
+
+  // Now base64 encode the resulting binary string
+  std::vector<unsigned char> base64EncodedBuffer((outSize * 3) / 2);
+
+  size_t rlen =
+    cmsysBase64_Encode(&out[0], strm.total_out, &base64EncodedBuffer[0], 1);
+
+  str.assign(reinterpret_cast<char*>(&base64EncodedBuffer[0]), rlen);
+
+  return true;
+}
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
new file mode 100644
index 0000000..61487f1
--- /dev/null
+++ b/Source/cmCTest.h
@@ -0,0 +1,653 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCTest_h
+#define cmCTest_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmProcessOutput.h"
+#include "cmsys/String.hxx"
+#include <chrono>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <time.h>
+#include <vector>
+
+class cmCTestGenericHandler;
+class cmCTestStartCommand;
+class cmGeneratedFileStream;
+class cmMakefile;
+class cmXMLWriter;
+
+/** \class cmCTest
+ * \brief Represents a ctest invocation.
+ *
+ * This class represents a ctest invocation. It is the top level class when
+ * running ctest.
+ *
+ */
+class cmCTest
+{
+  friend class cmCTestRunTest;
+  friend class cmCTestMultiProcessHandler;
+
+public:
+  typedef cmProcessOutput::Encoding Encoding;
+  /** Enumerate parts of the testing and submission process.  */
+  enum Part
+  {
+    PartStart,
+    PartUpdate,
+    PartConfigure,
+    PartBuild,
+    PartTest,
+    PartCoverage,
+    PartMemCheck,
+    PartSubmit,
+    PartNotes,
+    PartExtraFiles,
+    PartUpload,
+    PartCount // Update names in constructor when adding a part
+  };
+
+  /** Representation of one part.  */
+  struct PartInfo
+  {
+    PartInfo()
+      : Enabled(false)
+    {
+    }
+
+    void SetName(const std::string& name) { this->Name = name; }
+    const std::string& GetName() const { return this->Name; }
+
+    void Enable() { this->Enabled = true; }
+    operator bool() const { return this->Enabled; }
+
+    std::vector<std::string> SubmitFiles;
+
+  private:
+    bool Enabled;
+    std::string Name;
+  };
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  enum HTTPMethod
+  {
+    HTTP_GET,
+    HTTP_POST,
+    HTTP_PUT
+  };
+
+  /**
+   * Perform an HTTP request.
+   */
+  static int HTTPRequest(std::string url, HTTPMethod method,
+                         std::string& response, std::string const& fields = "",
+                         std::string const& putFile = "", int timeout = 0);
+#endif
+
+  /** Get a testing part id from its string name.  Returns PartCount
+      if the string does not name a valid part.  */
+  Part GetPartFromName(const char* name);
+
+  typedef std::vector<cmsys::String> VectorOfStrings;
+  typedef std::set<std::string> SetOfStrings;
+
+  /** Process Command line arguments */
+  int Run(std::vector<std::string>&, std::string* output = nullptr);
+
+  /**
+   * Initialize and finalize testing
+   */
+  bool InitializeFromCommand(cmCTestStartCommand* command);
+  void Finalize();
+
+  /**
+   * Process the dashboard client steps.
+   *
+   * Steps are enabled using SetTest()
+   *
+   * The execution of the steps (or #Part) should look like this:
+   *
+   * /code
+   * ctest foo;
+   * foo.Initialize();
+   * // Set some things on foo
+   * foo.ProcessSteps();
+   * foo.Finalize();
+   * /endcode
+   *
+   * \sa Initialize(), Finalize(), Part, PartInfo, SetTest()
+   */
+  int ProcessSteps();
+
+  /**
+   * A utility function that returns the nightly time
+   */
+  struct tm* GetNightlyTime(std::string const& str, bool tomorrowtag);
+
+  /**
+   * Is the tomorrow tag set?
+   */
+  bool GetTomorrowTag() { return this->TomorrowTag; }
+
+  /**
+   * Try to run tests of the project
+   */
+  int TestDirectory(bool memcheck);
+
+  /** what is the configuraiton type, e.g. Debug, Release etc. */
+  std::string const& GetConfigType();
+  std::chrono::duration<double> GetTimeOut() { return this->TimeOut; }
+  void SetTimeOut(std::chrono::duration<double> t) { this->TimeOut = t; }
+
+  std::chrono::duration<double> GetGlobalTimeout()
+  {
+    return this->GlobalTimeout;
+  }
+
+  /** how many test to run at the same time */
+  int GetParallelLevel() { return this->ParallelLevel; }
+  void SetParallelLevel(int);
+
+  unsigned long GetTestLoad() { return this->TestLoad; }
+  void SetTestLoad(unsigned long);
+
+  /**
+   * Check if CTest file exists
+   */
+  bool CTestFileExists(const std::string& filename);
+  bool AddIfExists(Part part, const char* file);
+
+  /**
+   * Set the cmake test
+   */
+  bool SetTest(const char*, bool report = true);
+
+  /**
+   * Set the cmake test mode (experimental, nightly, continuous).
+   */
+  void SetTestModel(int mode);
+  int GetTestModel() { return this->TestModel; }
+
+  std::string GetTestModelString();
+  static int GetTestModelFromString(const char* str);
+  static std::string CleanString(const std::string& str);
+  std::string GetCTestConfiguration(const std::string& name);
+  void SetCTestConfiguration(const char* name, const char* value,
+                             bool suppress = false);
+  void EmptyCTestConfiguration();
+
+  /**
+   * constructor and destructor
+   */
+  cmCTest();
+  ~cmCTest();
+
+  /** Set the notes files to be created. */
+  void SetNotesFiles(const char* notes);
+
+  void PopulateCustomVector(cmMakefile* mf, const std::string& definition,
+                            std::vector<std::string>& vec);
+  void PopulateCustomInteger(cmMakefile* mf, const std::string& def, int& val);
+
+  /** Get the current time as string */
+  std::string CurrentTime();
+
+  /** tar/gzip and then base 64 encode a file */
+  std::string Base64GzipEncodeFile(std::string const& file);
+  /** base64 encode a file */
+  std::string Base64EncodeFile(std::string const& file);
+
+  /**
+   * Return the time remaining that the script is allowed to run in
+   * seconds if the user has set the variable CTEST_TIME_LIMIT. If that has
+   * not been set it returns a very large duration.
+   */
+  std::chrono::duration<double> GetRemainingTimeAllowed();
+
+  static std::chrono::duration<double> MaxDuration();
+
+  /**
+   * Open file in the output directory and set the stream
+   */
+  bool OpenOutputFile(const std::string& path, const std::string& name,
+                      cmGeneratedFileStream& stream, bool compress = false);
+
+  /** Should we only show what we would do? */
+  bool GetShowOnly();
+
+  bool ShouldUseHTTP10() { return this->UseHTTP10; }
+
+  bool ShouldPrintLabels() { return this->PrintLabels; }
+
+  bool ShouldCompressTestOutput();
+  bool CompressString(std::string& str);
+
+  std::chrono::system_clock::time_point GetStopTime()
+  {
+    return this->StopTime;
+  }
+  void SetStopTime(std::string const& time);
+
+  /** Used for parallel ctest job scheduling */
+  std::string GetScheduleType() { return this->ScheduleType; }
+  void SetScheduleType(std::string const& type) { this->ScheduleType = type; }
+
+  /** The max output width */
+  int GetMaxTestNameWidth() const;
+  void SetMaxTestNameWidth(int w) { this->MaxTestNameWidth = w; }
+
+  /**
+   * Run a single executable command and put the stdout and stderr
+   * in output.
+   *
+   * If verbose is false, no user-viewable output from the program
+   * being run will be generated.
+   *
+   * If timeout is specified, the command will be terminated after
+   * timeout expires. Timeout is specified in seconds.
+   *
+   * Argument retVal should be a pointer to the location where the
+   * exit code will be stored. If the retVal is not specified and
+   * the program exits with a code other than 0, then the this
+   * function will return false.
+   */
+  bool RunCommand(std::vector<std::string> const& args, std::string* stdOut,
+                  std::string* stdErr, int* retVal = nullptr,
+                  const char* dir = nullptr,
+                  std::chrono::duration<double> timeout =
+                    std::chrono::duration<double>::zero(),
+                  Encoding encoding = cmProcessOutput::Auto);
+
+  /**
+   * Clean/make safe for xml the given value such that it may be used as
+   * one of the key fields by CDash when computing the buildid.
+   */
+  static std::string SafeBuildIdField(const std::string& value);
+
+  /** Start CTest XML output file */
+  void StartXML(cmXMLWriter& xml, bool append);
+
+  /** End CTest XML output file */
+  void EndXML(cmXMLWriter& xml);
+
+  /**
+   * Run command specialized for make and configure. Returns process status
+   * and retVal is return value or exception.
+   */
+  int RunMakeCommand(const char* command, std::string& output, int* retVal,
+                     const char* dir, std::chrono::duration<double> timeout,
+                     std::ostream& ofs,
+                     Encoding encoding = cmProcessOutput::Auto);
+
+  /** Return the current tag */
+  std::string GetCurrentTag();
+
+  /** Get the path to the build tree */
+  std::string GetBinaryDir();
+
+  /**
+   * Get the short path to the file.
+   *
+   * This means if the file is in binary or
+   * source directory, it will become /.../relative/path/to/file
+   */
+  std::string GetShortPathToFile(const char* fname);
+
+  enum
+  {
+    EXPERIMENTAL,
+    NIGHTLY,
+    CONTINUOUS
+  };
+
+  /** provide some more detailed info on the return code for ctest */
+  enum
+  {
+    UPDATE_ERRORS = 0x01,
+    CONFIGURE_ERRORS = 0x02,
+    BUILD_ERRORS = 0x04,
+    TEST_ERRORS = 0x08,
+    MEMORY_ERRORS = 0x10,
+    COVERAGE_ERRORS = 0x20,
+    SUBMIT_ERRORS = 0x40
+  };
+
+  /** Are we producing XML */
+  bool GetProduceXML();
+  void SetProduceXML(bool v);
+
+  /**
+   * Run command specialized for tests. Returns process status and retVal is
+   * return value or exception. If environment is non-null, it is used to set
+   * environment variables prior to running the test. After running the test,
+   * environment variables are restored to their previous values.
+   */
+  int RunTest(std::vector<const char*> args, std::string* output, int* retVal,
+              std::ostream* logfile, std::chrono::duration<double> testTimeOut,
+              std::vector<std::string>* environment,
+              Encoding encoding = cmProcessOutput::Auto);
+
+  /**
+   * Execute handler and return its result. If the handler fails, it returns
+   * negative value.
+   */
+  int ExecuteHandler(const char* handler);
+
+  /**
+   * Get the handler object
+   */
+  cmCTestGenericHandler* GetHandler(const char* handler);
+  cmCTestGenericHandler* GetInitializedHandler(const char* handler);
+
+  /**
+   * Set the CTest variable from CMake variable
+   */
+  bool SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
+                                              const char* dconfig,
+                                              const std::string& cmake_var,
+                                              bool suppress = false);
+
+  /** Make string safe to be send as an URL */
+  static std::string MakeURLSafe(const std::string&);
+
+  /** Decode a URL to the original string.  */
+  static std::string DecodeURL(const std::string&);
+
+  /**
+   * Should ctect configuration be updated. When using new style ctest
+   * script, this should be true.
+   */
+  void SetSuppressUpdatingCTestConfiguration(bool val)
+  {
+    this->SuppressUpdatingCTestConfiguration = val;
+  }
+
+  /**
+   * Add overwrite to ctest configuration.
+   *
+   * The format is key=value
+   */
+  void AddCTestConfigurationOverwrite(const std::string& encstr);
+
+  /** Create XML file that contains all the notes specified */
+  int GenerateNotesFile(const VectorOfStrings& files);
+
+  /** Submit extra files to the server */
+  bool SubmitExtraFiles(const char* files);
+  bool SubmitExtraFiles(const VectorOfStrings& files);
+
+  /** Set the output log file name */
+  void SetOutputLogFileName(const char* name);
+
+  /** Set the visual studio or Xcode config type */
+  void SetConfigType(const char* ct);
+
+  /** Various log types */
+  enum
+  {
+    DEBUG = 0,
+    OUTPUT,
+    HANDLER_OUTPUT,
+    HANDLER_PROGRESS_OUTPUT,
+    HANDLER_VERBOSE_OUTPUT,
+    WARNING,
+    ERROR_MESSAGE,
+    OTHER
+  };
+
+  /** Add log to the output */
+  void Log(int logType, const char* file, int line, const char* msg,
+           bool suppress = false);
+
+  /** Get the version of dart server */
+  int GetDartVersion() { return this->DartVersion; }
+  int GetDropSiteCDash() { return this->DropSiteCDash; }
+
+  /** Add file to be submitted */
+  void AddSubmitFile(Part part, const char* name);
+  std::vector<std::string> const& GetSubmitFiles(Part part)
+  {
+    return this->Parts[part].SubmitFiles;
+  }
+  void ClearSubmitFiles(Part part) { this->Parts[part].SubmitFiles.clear(); }
+
+  /**
+   * Read the custom configuration files and apply them to the current ctest
+   */
+  int ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf);
+
+  std::vector<std::string>& GetInitialCommandLineArguments()
+  {
+    return this->InitialCommandLineArguments;
+  }
+
+  /** Set the track to submit to */
+  void SetSpecificTrack(const char* track);
+  const char* GetSpecificTrack();
+
+  void SetFailover(bool failover) { this->Failover = failover; }
+  bool GetFailover() { return this->Failover; }
+
+  bool GetVerbose() { return this->Verbose; }
+  bool GetExtraVerbose() { return this->ExtraVerbose; }
+
+  /** Direct process output to given streams.  */
+  void SetStreams(std::ostream* out, std::ostream* err)
+  {
+    this->StreamOut = out;
+    this->StreamErr = err;
+  }
+  void AddSiteProperties(cmXMLWriter& xml);
+
+  bool GetLabelSummary() { return this->LabelSummary; }
+  bool GetSubprojectSummary() { return this->SubprojectSummary; }
+
+  std::string GetCostDataFile();
+
+  const std::map<std::string, std::string>& GetDefinitions()
+  {
+    return this->Definitions;
+  }
+
+  /** Return the number of times a test should be run */
+  int GetTestRepeat() { return this->RepeatTests; }
+
+  /** Return true if test should run until fail */
+  bool GetRepeatUntilFail() { return this->RepeatUntilFail; }
+
+  void GenerateSubprojectsOutput(cmXMLWriter& xml);
+  std::vector<std::string> GetLabelsForSubprojects();
+
+private:
+  int RepeatTests;
+  bool RepeatUntilFail;
+  std::string ConfigType;
+  std::string ScheduleType;
+  std::chrono::system_clock::time_point StopTime;
+  bool Verbose;
+  bool ExtraVerbose;
+  bool ProduceXML;
+  bool LabelSummary;
+  bool SubprojectSummary;
+  bool UseHTTP10;
+  bool PrintLabels;
+  bool Failover;
+
+  bool ForceNewCTestProcess;
+
+  bool RunConfigurationScript;
+
+  int GenerateNotesFile(const char* files);
+
+  // these are helper classes
+  typedef std::map<std::string, cmCTestGenericHandler*> t_TestingHandlers;
+  t_TestingHandlers TestingHandlers;
+
+  bool ShowOnly;
+
+  /** Map of configuration properties */
+  typedef std::map<std::string, std::string> CTestConfigurationMap;
+
+  // TODO: The ctest configuration should be a hierarchy of
+  // configuration option sources: command-line, script, ini file.
+  // Then the ini file can get re-loaded whenever it changes without
+  // affecting any higher-precedence settings.
+  CTestConfigurationMap CTestConfiguration;
+  CTestConfigurationMap CTestConfigurationOverwrites;
+  PartInfo Parts[PartCount];
+  typedef std::map<std::string, Part> PartMapType;
+  PartMapType PartMap;
+
+  std::string CurrentTag;
+  bool TomorrowTag;
+
+  int TestModel;
+  std::string SpecificTrack;
+
+  std::chrono::duration<double> TimeOut;
+
+  std::chrono::duration<double> GlobalTimeout;
+
+  int MaxTestNameWidth;
+
+  int ParallelLevel;
+  bool ParallelLevelSetInCli;
+
+  unsigned long TestLoad;
+
+  int CompatibilityMode;
+
+  // information for the --build-and-test options
+  std::string BinaryDir;
+
+  std::string NotesFiles;
+
+  bool InteractiveDebugMode;
+
+  bool ShortDateFormat;
+
+  bool CompressXMLFiles;
+  bool CompressTestOutput;
+
+  void InitStreams();
+  std::ostream* StreamOut;
+  std::ostream* StreamErr;
+
+  void BlockTestErrorDiagnostics();
+
+  /**
+   * Initialize a dashboard run in the given build tree.  The "command"
+   * argument is non-NULL when running from a command-driven (ctest_start)
+   * dashboard script, and NULL when running from the CTest command
+   * line.  Note that a declarative dashboard script does not actually
+   * call this method because it sets CTEST_COMMAND to drive a build
+   * through the ctest command line.
+   */
+  int Initialize(const char* binary_dir, cmCTestStartCommand* command);
+
+  /** parse the option after -D and convert it into the appropriate steps */
+  bool AddTestsForDashboardType(std::string& targ);
+
+  /** read as "emit an error message for an unknown -D value" */
+  void ErrorMessageUnknownDashDValue(std::string& val);
+
+  /** add a variable definition from a command line -D value */
+  bool AddVariableDefinition(const std::string& arg);
+
+  /** parse and process most common command line arguments */
+  bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
+                                  std::string& errormsg);
+
+  /** hande the -S -SP and -SR arguments */
+  void HandleScriptArguments(size_t& i, std::vector<std::string>& args,
+                             bool& SRArgumentSpecified);
+
+  /** Reread the configuration file */
+  bool UpdateCTestConfiguration();
+
+  /** Create note from files. */
+  int GenerateCTestNotesOutput(cmXMLWriter& xml, const VectorOfStrings& files);
+
+  /** Check if the argument is the one specified */
+  bool CheckArgument(const std::string& arg, const char* varg1,
+                     const char* varg2 = nullptr);
+
+  /** Output errors from a test */
+  void OutputTestErrors(std::vector<char> const& process_output);
+
+  /** Handle the --test-action command line argument */
+  bool HandleTestActionArgument(const char* ctestExec, size_t& i,
+                                const std::vector<std::string>& args);
+
+  /** Handle the --test-model command line argument */
+  bool HandleTestModelArgument(const char* ctestExec, size_t& i,
+                               const std::vector<std::string>& args);
+
+  int RunCMakeAndTest(std::string* output);
+  int ExecuteTests();
+
+  bool SuppressUpdatingCTestConfiguration;
+
+  bool Debug;
+  bool ShowLineNumbers;
+  bool Quiet;
+
+  int DartVersion;
+  bool DropSiteCDash;
+
+  std::vector<std::string> InitialCommandLineArguments;
+
+  int SubmitIndex;
+
+  cmGeneratedFileStream* OutputLogFile;
+  int OutputLogFileLastTag;
+
+  bool OutputTestOutputOnTestFailure;
+
+  std::map<std::string, std::string> Definitions;
+};
+
+class cmCTestLogWrite
+{
+public:
+  cmCTestLogWrite(const char* data, size_t length)
+    : Data(data)
+    , Length(length)
+  {
+  }
+
+  const char* Data;
+  size_t Length;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const cmCTestLogWrite& c)
+{
+  if (!c.Length) {
+    return os;
+  }
+  os.write(c.Data, c.Length);
+  os.flush();
+  return os;
+}
+
+#define cmCTestLog(ctSelf, logType, msg)                                      \
+  do {                                                                        \
+    std::ostringstream cmCTestLog_msg;                                        \
+    cmCTestLog_msg << msg;                                                    \
+    (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,                       \
+                  cmCTestLog_msg.str().c_str());                              \
+  } while (false)
+
+#define cmCTestOptionalLog(ctSelf, logType, msg, suppress)                    \
+  do {                                                                        \
+    std::ostringstream cmCTestLog_msg;                                        \
+    cmCTestLog_msg << msg;                                                    \
+    (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,                       \
+                  cmCTestLog_msg.str().c_str(), suppress);                    \
+  } while (false)
+
+#endif
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
new file mode 100644
index 0000000..64aa46e
--- /dev/null
+++ b/Source/cmCacheManager.cxx
@@ -0,0 +1,712 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCacheManager.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include <algorithm>
+#include <sstream>
+#include <stdio.h>
+#include <string.h>
+
+#include "cmGeneratedFileStream.h"
+#include "cmMessenger.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+#include "cmake.h"
+
+cmCacheManager::cmCacheManager()
+{
+  this->CacheMajorVersion = 0;
+  this->CacheMinorVersion = 0;
+}
+
+void cmCacheManager::CleanCMakeFiles(const std::string& path)
+{
+  std::string glob = path;
+  glob += cmake::GetCMakeFilesDirectory();
+  glob += "/*.cmake";
+  cmsys::Glob globIt;
+  globIt.FindFiles(glob);
+  std::vector<std::string> files = globIt.GetFiles();
+  std::for_each(files.begin(), files.end(), cmSystemTools::RemoveFile);
+}
+
+bool cmCacheManager::LoadCache(const std::string& path, bool internal,
+                               std::set<std::string>& excludes,
+                               std::set<std::string>& includes)
+{
+  std::string cacheFile = path;
+  cacheFile += "/CMakeCache.txt";
+  // clear the old cache, if we are reading in internal values
+  if (internal) {
+    this->Cache.clear();
+  }
+  if (!cmSystemTools::FileExists(cacheFile.c_str())) {
+    this->CleanCMakeFiles(path);
+    return false;
+  }
+
+  cmsys::ifstream fin(cacheFile.c_str());
+  if (!fin) {
+    return false;
+  }
+  const char* realbuffer;
+  std::string buffer;
+  std::string entryKey;
+  unsigned int lineno = 0;
+  while (fin) {
+    // Format is key:type=value
+    std::string helpString;
+    CacheEntry e;
+    cmSystemTools::GetLineFromStream(fin, buffer);
+    lineno++;
+    realbuffer = buffer.c_str();
+    while (*realbuffer != '0' &&
+           (*realbuffer == ' ' || *realbuffer == '\t' || *realbuffer == '\r' ||
+            *realbuffer == '\n')) {
+      if (*realbuffer == '\n') {
+        lineno++;
+      }
+      realbuffer++;
+    }
+    // skip blank lines and comment lines
+    if (realbuffer[0] == '#' || realbuffer[0] == 0) {
+      continue;
+    }
+    while (realbuffer[0] == '/' && realbuffer[1] == '/') {
+      if ((realbuffer[2] == '\\') && (realbuffer[3] == 'n')) {
+        helpString += "\n";
+        helpString += &realbuffer[4];
+      } else {
+        helpString += &realbuffer[2];
+      }
+      cmSystemTools::GetLineFromStream(fin, buffer);
+      lineno++;
+      realbuffer = buffer.c_str();
+      if (!fin) {
+        continue;
+      }
+    }
+    e.SetProperty("HELPSTRING", helpString.c_str());
+    if (cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type)) {
+      if (excludes.find(entryKey) == excludes.end()) {
+        // Load internal values if internal is set.
+        // If the entry is not internal to the cache being loaded
+        // or if it is in the list of internal entries to be
+        // imported, load it.
+        if (internal || (e.Type != cmStateEnums::INTERNAL) ||
+            (includes.find(entryKey) != includes.end())) {
+          // If we are loading the cache from another project,
+          // make all loaded entries internal so that it is
+          // not visible in the gui
+          if (!internal) {
+            e.Type = cmStateEnums::INTERNAL;
+            helpString = "DO NOT EDIT, ";
+            helpString += entryKey;
+            helpString += " loaded from external file.  "
+                          "To change this value edit this file: ";
+            helpString += path;
+            helpString += "/CMakeCache.txt";
+            e.SetProperty("HELPSTRING", helpString.c_str());
+          }
+          if (!this->ReadPropertyEntry(entryKey, e)) {
+            e.Initialized = true;
+            this->Cache[entryKey] = e;
+          }
+        }
+      }
+    } else {
+      std::ostringstream error;
+      error << "Parse error in cache file " << cacheFile;
+      error << " on line " << lineno << ". Offending entry: " << realbuffer;
+      cmSystemTools::Error(error.str().c_str());
+    }
+  }
+  this->CacheMajorVersion = 0;
+  this->CacheMinorVersion = 0;
+  if (const char* cmajor =
+        this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION")) {
+    unsigned int v = 0;
+    if (sscanf(cmajor, "%u", &v) == 1) {
+      this->CacheMajorVersion = v;
+    }
+    if (const char* cminor =
+          this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION")) {
+      if (sscanf(cminor, "%u", &v) == 1) {
+        this->CacheMinorVersion = v;
+      }
+    }
+  } else {
+    // CMake version not found in the list file.
+    // Set as version 0.0
+    this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", "0",
+                        "Minor version of cmake used to create the "
+                        "current loaded cache",
+                        cmStateEnums::INTERNAL);
+    this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
+                        "Major version of cmake used to create the "
+                        "current loaded cache",
+                        cmStateEnums::INTERNAL);
+  }
+  // check to make sure the cache directory has not
+  // been moved
+  const char* oldDir = this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR");
+  if (internal && oldDir) {
+    std::string currentcwd = path;
+    std::string oldcwd = oldDir;
+    cmSystemTools::ConvertToUnixSlashes(currentcwd);
+    currentcwd += "/CMakeCache.txt";
+    oldcwd += "/CMakeCache.txt";
+    if (!cmSystemTools::SameFile(oldcwd, currentcwd)) {
+      std::string message =
+        std::string("The current CMakeCache.txt directory ") + currentcwd +
+        std::string(" is different than the directory ") +
+        std::string(this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) +
+        std::string(" where CMakeCache.txt was created. This may result "
+                    "in binaries being created in the wrong place. If you "
+                    "are not sure, reedit the CMakeCache.txt");
+      cmSystemTools::Error(message.c_str());
+    }
+  }
+  return true;
+}
+
+const char* cmCacheManager::PersistentProperties[] = { "ADVANCED", "MODIFIED",
+                                                       "STRINGS", nullptr };
+
+bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
+                                       CacheEntry& e)
+{
+  // All property entries are internal.
+  if (e.Type != cmStateEnums::INTERNAL) {
+    return false;
+  }
+
+  const char* end = entryKey.c_str() + entryKey.size();
+  for (const char** p = this->PersistentProperties; *p; ++p) {
+    std::string::size_type plen = strlen(*p) + 1;
+    if (entryKey.size() > plen && *(end - plen) == '-' &&
+        strcmp(end - plen + 1, *p) == 0) {
+      std::string key = entryKey.substr(0, entryKey.size() - plen);
+      cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
+      if (it.IsAtEnd()) {
+        // Create an entry and store the property.
+        CacheEntry& ne = this->Cache[key];
+        ne.Type = cmStateEnums::UNINITIALIZED;
+        ne.SetProperty(*p, e.Value.c_str());
+      } else {
+        // Store this property on its entry.
+        it.SetProperty(*p, e.Value.c_str());
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+void cmCacheManager::WritePropertyEntries(std::ostream& os, CacheIterator i,
+                                          cmMessenger* messenger)
+{
+  for (const char** p = this->PersistentProperties; *p; ++p) {
+    if (const char* value = i.GetProperty(*p)) {
+      std::string helpstring = *p;
+      helpstring += " property for variable: ";
+      helpstring += i.GetName();
+      cmCacheManager::OutputHelpString(os, helpstring);
+
+      std::string key = i.GetName();
+      key += "-";
+      key += *p;
+      this->OutputKey(os, key);
+      os << ":INTERNAL=";
+      this->OutputValue(os, value);
+      os << "\n";
+      cmCacheManager::OutputNewlineTruncationWarning(os, key, value,
+                                                     messenger);
+    }
+  }
+}
+
+bool cmCacheManager::SaveCache(const std::string& path, cmMessenger* messenger)
+{
+  std::string cacheFile = path;
+  cacheFile += "/CMakeCache.txt";
+  cmGeneratedFileStream fout(cacheFile.c_str());
+  fout.SetCopyIfDifferent(true);
+  if (!fout) {
+    cmSystemTools::Error("Unable to open cache file for save. ",
+                         cacheFile.c_str());
+    cmSystemTools::ReportLastSystemError("");
+    return false;
+  }
+  // before writing the cache, update the version numbers
+  // to the
+  char temp[1024];
+  sprintf(temp, "%d", cmVersion::GetMinorVersion());
+  this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", temp,
+                      "Minor version of cmake used to create the "
+                      "current loaded cache",
+                      cmStateEnums::INTERNAL);
+  sprintf(temp, "%d", cmVersion::GetMajorVersion());
+  this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
+                      "Major version of cmake used to create the "
+                      "current loaded cache",
+                      cmStateEnums::INTERNAL);
+  sprintf(temp, "%d", cmVersion::GetPatchVersion());
+  this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
+                      "Patch version of cmake used to create the "
+                      "current loaded cache",
+                      cmStateEnums::INTERNAL);
+
+  // Let us store the current working directory so that if somebody
+  // Copies it, he will not be surprised
+  std::string currentcwd = path;
+  if (currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' && currentcwd[1] == ':') {
+    // Cast added to avoid compiler warning. Cast is ok because
+    // value is guaranteed to fit in char by the above if...
+    currentcwd[0] = static_cast<char>(currentcwd[0] - 'A' + 'a');
+  }
+  cmSystemTools::ConvertToUnixSlashes(currentcwd);
+  this->AddCacheEntry("CMAKE_CACHEFILE_DIR", currentcwd.c_str(),
+                      "This is the directory where this CMakeCache.txt"
+                      " was created",
+                      cmStateEnums::INTERNAL);
+
+  /* clang-format off */
+  fout << "# This is the CMakeCache file.\n"
+       << "# For build in directory: " << currentcwd << "\n"
+       << "# It was generated by CMake: "
+       << cmSystemTools::GetCMakeCommand() << std::endl;
+  /* clang-format on */
+
+  /* clang-format off */
+  fout << "# You can edit this file to change values found and used by cmake."
+       << std::endl
+       << "# If you do not want to change any of the values, simply exit the "
+       "editor." << std::endl
+       << "# If you do want to change a value, simply edit, save, and exit "
+       "the editor." << std::endl
+       << "# The syntax for the file is as follows:\n"
+       << "# KEY:TYPE=VALUE\n"
+       << "# KEY is the name of a variable in the cache.\n"
+       << "# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT "
+       "TYPE!." << std::endl
+       << "# VALUE is the current value for the KEY.\n\n";
+  /* clang-format on */
+
+  fout << "########################\n";
+  fout << "# EXTERNAL cache entries\n";
+  fout << "########################\n";
+  fout << "\n";
+
+  for (auto const& i : this->Cache) {
+    CacheEntry const& ce = i.second;
+    cmStateEnums::CacheEntryType t = ce.Type;
+    if (!ce.Initialized) {
+      /*
+        // This should be added in, but is not for now.
+      cmSystemTools::Error("Cache entry \"", (*i).first.c_str(),
+                           "\" is uninitialized");
+      */
+    } else if (t != cmStateEnums::INTERNAL) {
+      // Format is key:type=value
+      if (const char* help = ce.GetProperty("HELPSTRING")) {
+        cmCacheManager::OutputHelpString(fout, help);
+      } else {
+        cmCacheManager::OutputHelpString(fout, "Missing description");
+      }
+      this->OutputKey(fout, i.first);
+      fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
+      this->OutputValue(fout, ce.Value);
+      fout << "\n";
+      cmCacheManager::OutputNewlineTruncationWarning(fout, i.first, ce.Value,
+                                                     messenger);
+      fout << "\n";
+    }
+  }
+
+  fout << "\n";
+  fout << "########################\n";
+  fout << "# INTERNAL cache entries\n";
+  fout << "########################\n";
+  fout << "\n";
+
+  for (cmCacheManager::CacheIterator i = this->NewIterator(); !i.IsAtEnd();
+       i.Next()) {
+    if (!i.Initialized()) {
+      continue;
+    }
+
+    cmStateEnums::CacheEntryType t = i.GetType();
+    this->WritePropertyEntries(fout, i, messenger);
+    if (t == cmStateEnums::INTERNAL) {
+      // Format is key:type=value
+      if (const char* help = i.GetProperty("HELPSTRING")) {
+        this->OutputHelpString(fout, help);
+      }
+      this->OutputKey(fout, i.GetName());
+      fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
+      this->OutputValue(fout, i.GetValue());
+      fout << "\n";
+      cmCacheManager::OutputNewlineTruncationWarning(fout, i.GetName(),
+                                                     i.GetValue(), messenger);
+    }
+  }
+  fout << "\n";
+  fout.Close();
+  std::string checkCacheFile = path;
+  checkCacheFile += cmake::GetCMakeFilesDirectory();
+  cmSystemTools::MakeDirectory(checkCacheFile.c_str());
+  checkCacheFile += "/cmake.check_cache";
+  cmsys::ofstream checkCache(checkCacheFile.c_str());
+  if (!checkCache) {
+    cmSystemTools::Error("Unable to open check cache file for write. ",
+                         checkCacheFile.c_str());
+    return false;
+  }
+  checkCache << "# This file is generated by cmake for dependency checking "
+                "of the CMakeCache.txt file\n";
+  return true;
+}
+
+bool cmCacheManager::DeleteCache(const std::string& path)
+{
+  std::string cacheFile = path;
+  cmSystemTools::ConvertToUnixSlashes(cacheFile);
+  std::string cmakeFiles = cacheFile;
+  cacheFile += "/CMakeCache.txt";
+  if (cmSystemTools::FileExists(cacheFile.c_str())) {
+    cmSystemTools::RemoveFile(cacheFile);
+    // now remove the files in the CMakeFiles directory
+    // this cleans up language cache files
+    cmakeFiles += cmake::GetCMakeFilesDirectory();
+    if (cmSystemTools::FileIsDirectory(cmakeFiles)) {
+      cmSystemTools::RemoveADirectory(cmakeFiles);
+    }
+  }
+  return true;
+}
+
+void cmCacheManager::OutputKey(std::ostream& fout, std::string const& key)
+{
+  // support : in key name by double quoting
+  const char* q =
+    (key.find(':') != std::string::npos || key.find("//") == 0) ? "\"" : "";
+  fout << q << key << q;
+}
+
+void cmCacheManager::OutputValue(std::ostream& fout, std::string const& value)
+{
+  // look for and truncate newlines
+  std::string::size_type newline = value.find('\n');
+  if (newline != std::string::npos) {
+    std::string truncated = value.substr(0, newline);
+    OutputValueNoNewlines(fout, truncated);
+  } else {
+    OutputValueNoNewlines(fout, value);
+  }
+}
+
+void cmCacheManager::OutputValueNoNewlines(std::ostream& fout,
+                                           std::string const& value)
+{
+  // if value has trailing space or tab, enclose it in single quotes
+  if (!value.empty() &&
+      (value[value.size() - 1] == ' ' || value[value.size() - 1] == '\t')) {
+    fout << '\'' << value << '\'';
+  } else {
+    fout << value;
+  }
+}
+
+void cmCacheManager::OutputHelpString(std::ostream& fout,
+                                      const std::string& helpString)
+{
+  std::string::size_type end = helpString.size();
+  if (end == 0) {
+    return;
+  }
+  std::string oneLine;
+  std::string::size_type pos = 0;
+  for (std::string::size_type i = 0; i <= end; i++) {
+    if ((i == end) || (helpString[i] == '\n') ||
+        ((i - pos >= 60) && (helpString[i] == ' '))) {
+      fout << "//";
+      if (helpString[pos] == '\n') {
+        pos++;
+        fout << "\\n";
+      }
+      oneLine = helpString.substr(pos, i - pos);
+      fout << oneLine << "\n";
+      pos = i;
+    }
+  }
+}
+
+void cmCacheManager::OutputWarningComment(std::ostream& fout,
+                                          std::string const& message,
+                                          bool wrapSpaces)
+{
+  std::string::size_type end = message.size();
+  std::string oneLine;
+  std::string::size_type pos = 0;
+  for (std::string::size_type i = 0; i <= end; i++) {
+    if ((i == end) || (message[i] == '\n') ||
+        ((i - pos >= 60) && (message[i] == ' ') && wrapSpaces)) {
+      fout << "# ";
+      if (message[pos] == '\n') {
+        pos++;
+        fout << "\\n";
+      }
+      oneLine = message.substr(pos, i - pos);
+      fout << oneLine << "\n";
+      pos = i;
+    }
+  }
+}
+
+void cmCacheManager::OutputNewlineTruncationWarning(std::ostream& fout,
+                                                    std::string const& key,
+                                                    std::string const& value,
+                                                    cmMessenger* messenger)
+{
+  if (value.find('\n') != std::string::npos) {
+    if (messenger) {
+      std::string message = "Value of ";
+      message += key;
+      message += " contained a newline; truncating";
+      messenger->IssueMessage(cmake::WARNING, message);
+    }
+
+    std::string comment = "WARNING: Value of ";
+    comment += key;
+    comment += " contained a newline and was truncated. Original value:";
+
+    OutputWarningComment(fout, comment, true);
+    OutputWarningComment(fout, value, false);
+  }
+}
+
+void cmCacheManager::RemoveCacheEntry(const std::string& key)
+{
+  CacheEntryMap::iterator i = this->Cache.find(key);
+  if (i != this->Cache.end()) {
+    this->Cache.erase(i);
+  }
+}
+
+cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
+  const std::string& key)
+{
+  CacheEntryMap::iterator i = this->Cache.find(key);
+  if (i != this->Cache.end()) {
+    return &i->second;
+  }
+  return nullptr;
+}
+
+cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(const char* key)
+{
+  return CacheIterator(*this, key);
+}
+
+const char* cmCacheManager::GetInitializedCacheValue(
+  const std::string& key) const
+{
+  CacheEntryMap::const_iterator i = this->Cache.find(key);
+  if (i != this->Cache.end() && i->second.Initialized) {
+    return i->second.Value.c_str();
+  }
+  return nullptr;
+}
+
+void cmCacheManager::PrintCache(std::ostream& out) const
+{
+  out << "=================================================" << std::endl;
+  out << "CMakeCache Contents:" << std::endl;
+  for (auto const& i : this->Cache) {
+    if (i.second.Type != cmStateEnums::INTERNAL) {
+      out << i.first << " = " << i.second.Value << std::endl;
+    }
+  }
+  out << "\n\n";
+  out << "To change values in the CMakeCache, " << std::endl
+      << "edit CMakeCache.txt in your output directory.\n";
+  out << "=================================================" << std::endl;
+}
+
+void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
+                                   const char* helpString,
+                                   cmStateEnums::CacheEntryType type)
+{
+  CacheEntry& e = this->Cache[key];
+  if (value) {
+    e.Value = value;
+    e.Initialized = true;
+  } else {
+    e.Value.clear();
+  }
+  e.Type = type;
+  // make sure we only use unix style paths
+  if (type == cmStateEnums::FILEPATH || type == cmStateEnums::PATH) {
+    if (e.Value.find(';') != std::string::npos) {
+      std::vector<std::string> paths;
+      cmSystemTools::ExpandListArgument(e.Value, paths);
+      const char* sep = "";
+      e.Value = "";
+      for (std::string& i : paths) {
+        cmSystemTools::ConvertToUnixSlashes(i);
+        e.Value += sep;
+        e.Value += i;
+        sep = ";";
+      }
+    } else {
+      cmSystemTools::ConvertToUnixSlashes(e.Value);
+    }
+  }
+  e.SetProperty("HELPSTRING", helpString
+                  ? helpString
+                  : "(This variable does not exist and should not be used)");
+}
+
+bool cmCacheManager::CacheIterator::IsAtEnd() const
+{
+  return this->Position == this->Container.Cache.end();
+}
+
+void cmCacheManager::CacheIterator::Begin()
+{
+  this->Position = this->Container.Cache.begin();
+}
+
+bool cmCacheManager::CacheIterator::Find(const std::string& key)
+{
+  this->Position = this->Container.Cache.find(key);
+  return !this->IsAtEnd();
+}
+
+void cmCacheManager::CacheIterator::Next()
+{
+  if (!this->IsAtEnd()) {
+    ++this->Position;
+  }
+}
+
+std::vector<std::string> cmCacheManager::CacheIterator::GetPropertyList() const
+{
+  return this->GetEntry().GetPropertyList();
+}
+
+void cmCacheManager::CacheIterator::SetValue(const char* value)
+{
+  if (this->IsAtEnd()) {
+    return;
+  }
+  CacheEntry* entry = &this->GetEntry();
+  if (value) {
+    entry->Value = value;
+    entry->Initialized = true;
+  } else {
+    entry->Value.clear();
+  }
+}
+
+bool cmCacheManager::CacheIterator::GetValueAsBool() const
+{
+  return cmSystemTools::IsOn(this->GetEntry().Value.c_str());
+}
+
+std::vector<std::string> cmCacheManager::CacheEntry::GetPropertyList() const
+{
+  return this->Properties.GetPropertyList();
+}
+
+const char* cmCacheManager::CacheEntry::GetProperty(
+  const std::string& prop) const
+{
+  if (prop == "TYPE") {
+    return cmState::CacheEntryTypeToString(this->Type);
+  }
+  if (prop == "VALUE") {
+    return this->Value.c_str();
+  }
+  return this->Properties.GetPropertyValue(prop);
+}
+
+void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
+                                             const char* value)
+{
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    this->Value = value ? value : "";
+  } else {
+    this->Properties.SetProperty(prop, value);
+  }
+}
+
+void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
+                                                const char* value,
+                                                bool asString)
+{
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    if (value) {
+      if (!this->Value.empty() && *value && !asString) {
+        this->Value += ";";
+      }
+      this->Value += value;
+    }
+  } else {
+    this->Properties.AppendProperty(prop, value, asString);
+  }
+}
+
+const char* cmCacheManager::CacheIterator::GetProperty(
+  const std::string& prop) const
+{
+  if (!this->IsAtEnd()) {
+    return this->GetEntry().GetProperty(prop);
+  }
+  return nullptr;
+}
+
+void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
+                                                const char* v)
+{
+  if (!this->IsAtEnd()) {
+    this->GetEntry().SetProperty(p, v);
+  }
+}
+
+void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
+                                                   const char* v,
+                                                   bool asString)
+{
+  if (!this->IsAtEnd()) {
+    this->GetEntry().AppendProperty(p, v, asString);
+  }
+}
+
+bool cmCacheManager::CacheIterator::GetPropertyAsBool(
+  const std::string& prop) const
+{
+  if (const char* value = this->GetProperty(prop)) {
+    return cmSystemTools::IsOn(value);
+  }
+  return false;
+}
+
+void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v)
+{
+  this->SetProperty(p, v ? "ON" : "OFF");
+}
+
+bool cmCacheManager::CacheIterator::PropertyExists(
+  const std::string& prop) const
+{
+  return this->GetProperty(prop) != nullptr;
+}
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
new file mode 100644
index 0000000..73923d1
--- /dev/null
+++ b/Source/cmCacheManager.h
@@ -0,0 +1,248 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCacheManager_h
+#define cmCacheManager_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "cmPropertyMap.h"
+#include "cmStateTypes.h"
+
+class cmMessenger;
+
+/** \class cmCacheManager
+ * \brief Control class for cmake's cache
+ *
+ * Load and Save CMake cache files.
+ *
+ */
+class cmCacheManager
+{
+public:
+  cmCacheManager();
+  class CacheIterator;
+  friend class cmCacheManager::CacheIterator;
+
+private:
+  struct CacheEntry
+  {
+    std::string Value;
+    cmStateEnums::CacheEntryType Type;
+    cmPropertyMap Properties;
+    std::vector<std::string> GetPropertyList() const;
+    const char* GetProperty(const std::string&) const;
+    void SetProperty(const std::string& property, const char* value);
+    void AppendProperty(const std::string& property, const char* value,
+                        bool asString = false);
+    bool Initialized;
+    CacheEntry()
+      : Value("")
+      , Type(cmStateEnums::UNINITIALIZED)
+      , Initialized(false)
+    {
+    }
+  };
+
+public:
+  class CacheIterator
+  {
+  public:
+    void Begin();
+    bool Find(const std::string&);
+    bool IsAtEnd() const;
+    void Next();
+    std::string GetName() const { return this->Position->first; }
+    std::vector<std::string> GetPropertyList() const;
+    const char* GetProperty(const std::string&) const;
+    bool GetPropertyAsBool(const std::string&) const;
+    bool PropertyExists(const std::string&) const;
+    void SetProperty(const std::string& property, const char* value);
+    void AppendProperty(const std::string& property, const char* value,
+                        bool asString = false);
+    void SetProperty(const std::string& property, bool value);
+    const char* GetValue() const { return this->GetEntry().Value.c_str(); }
+    bool GetValueAsBool() const;
+    void SetValue(const char*);
+    cmStateEnums::CacheEntryType GetType() const
+    {
+      return this->GetEntry().Type;
+    }
+    void SetType(cmStateEnums::CacheEntryType ty)
+    {
+      this->GetEntry().Type = ty;
+    }
+    bool Initialized() { return this->GetEntry().Initialized; }
+    cmCacheManager& Container;
+    std::map<std::string, CacheEntry>::iterator Position;
+    CacheIterator(cmCacheManager& cm)
+      : Container(cm)
+    {
+      this->Begin();
+    }
+    CacheIterator(cmCacheManager& cm, const char* key)
+      : Container(cm)
+    {
+      if (key) {
+        this->Find(key);
+      }
+    }
+
+  private:
+    CacheEntry const& GetEntry() const { return this->Position->second; }
+    CacheEntry& GetEntry() { return this->Position->second; }
+  };
+
+  ///! return an iterator to iterate through the cache map
+  cmCacheManager::CacheIterator NewIterator() { return CacheIterator(*this); }
+
+  ///! Load a cache for given makefile.  Loads from path/CMakeCache.txt.
+  bool LoadCache(const std::string& path, bool internal,
+                 std::set<std::string>& excludes,
+                 std::set<std::string>& includes);
+
+  ///! Save cache for given makefile.  Saves to output path/CMakeCache.txt
+  bool SaveCache(const std::string& path, cmMessenger* messenger);
+
+  ///! Delete the cache given
+  bool DeleteCache(const std::string& path);
+
+  ///! Print the cache to a stream
+  void PrintCache(std::ostream&) const;
+
+  ///! Get the iterator for an entry with a given key.
+  cmCacheManager::CacheIterator GetCacheIterator(const char* key = nullptr);
+
+  ///! Remove an entry from the cache
+  void RemoveCacheEntry(const std::string& key);
+
+  ///! Get the number of entries in the cache
+  int GetSize() { return static_cast<int>(this->Cache.size()); }
+
+  ///! Get a value from the cache given a key
+  const char* GetInitializedCacheValue(const std::string& key) const;
+
+  const char* GetCacheEntryValue(const std::string& key)
+  {
+    cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
+    if (it.IsAtEnd()) {
+      return nullptr;
+    }
+    return it.GetValue();
+  }
+
+  const char* GetCacheEntryProperty(std::string const& key,
+                                    std::string const& propName)
+  {
+    return this->GetCacheIterator(key.c_str()).GetProperty(propName);
+  }
+
+  cmStateEnums::CacheEntryType GetCacheEntryType(std::string const& key)
+  {
+    return this->GetCacheIterator(key.c_str()).GetType();
+  }
+
+  bool GetCacheEntryPropertyAsBool(std::string const& key,
+                                   std::string const& propName)
+  {
+    return this->GetCacheIterator(key.c_str()).GetPropertyAsBool(propName);
+  }
+
+  void SetCacheEntryProperty(std::string const& key,
+                             std::string const& propName,
+                             std::string const& value)
+  {
+    this->GetCacheIterator(key.c_str()).SetProperty(propName, value.c_str());
+  }
+
+  void SetCacheEntryBoolProperty(std::string const& key,
+                                 std::string const& propName, bool value)
+  {
+    this->GetCacheIterator(key.c_str()).SetProperty(propName, value);
+  }
+
+  void SetCacheEntryValue(std::string const& key, std::string const& value)
+  {
+    this->GetCacheIterator(key.c_str()).SetValue(value.c_str());
+  }
+
+  void RemoveCacheEntryProperty(std::string const& key,
+                                std::string const& propName)
+  {
+    this->GetCacheIterator(key.c_str()).SetProperty(propName, nullptr);
+  }
+
+  void AppendCacheEntryProperty(std::string const& key,
+                                std::string const& propName,
+                                std::string const& value,
+                                bool asString = false)
+  {
+    this->GetCacheIterator(key.c_str())
+      .AppendProperty(propName, value.c_str(), asString);
+  }
+
+  std::vector<std::string> GetCacheEntryKeys()
+  {
+    std::vector<std::string> definitions;
+    definitions.reserve(this->GetSize());
+    cmCacheManager::CacheIterator cit = this->GetCacheIterator();
+    for (cit.Begin(); !cit.IsAtEnd(); cit.Next()) {
+      definitions.push_back(cit.GetName());
+    }
+    return definitions;
+  }
+
+  /** Get the version of CMake that wrote the cache.  */
+  unsigned int GetCacheMajorVersion() const { return this->CacheMajorVersion; }
+  unsigned int GetCacheMinorVersion() const { return this->CacheMinorVersion; }
+
+protected:
+  ///! Add an entry into the cache
+  void AddCacheEntry(const std::string& key, const char* value,
+                     const char* helpString,
+                     cmStateEnums::CacheEntryType type);
+
+  ///! Get a cache entry object for a key
+  CacheEntry* GetCacheEntry(const std::string& key);
+  ///! Clean out the CMakeFiles directory if no CMakeCache.txt
+  void CleanCMakeFiles(const std::string& path);
+
+  // Cache version info
+  unsigned int CacheMajorVersion;
+  unsigned int CacheMinorVersion;
+
+private:
+  typedef std::map<std::string, CacheEntry> CacheEntryMap;
+  static void OutputHelpString(std::ostream& fout,
+                               const std::string& helpString);
+  static void OutputWarningComment(std::ostream& fout,
+                                   std::string const& message,
+                                   bool wrapSpaces);
+  static void OutputNewlineTruncationWarning(std::ostream& fout,
+                                             std::string const& key,
+                                             std::string const& value,
+                                             cmMessenger* messenger);
+  static void OutputKey(std::ostream& fout, std::string const& key);
+  static void OutputValue(std::ostream& fout, std::string const& value);
+  static void OutputValueNoNewlines(std::ostream& fout,
+                                    std::string const& value);
+
+  static const char* PersistentProperties[];
+  bool ReadPropertyEntry(std::string const& key, CacheEntry& e);
+  void WritePropertyEntries(std::ostream& os, CacheIterator i,
+                            cmMessenger* messenger);
+
+  CacheEntryMap Cache;
+  // Only cmake and cmState should be able to add cache values
+  // the commands should never use the cmCacheManager directly
+  friend class cmState; // allow access to add cache values
+  friend class cmake;   // allow access to add cache values
+};
+
+#endif
diff --git a/Source/cmCallVisualStudioMacro.cxx b/Source/cmCallVisualStudioMacro.cxx
new file mode 100644
index 0000000..99fe587
--- /dev/null
+++ b/Source/cmCallVisualStudioMacro.cxx
@@ -0,0 +1,453 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCallVisualStudioMacro.h"
+
+#include <sstream>
+
+#include "cmSystemTools.h"
+
+#if defined(_MSC_VER)
+#define HAVE_COMDEF_H
+#endif
+
+// Just for this file:
+//
+static bool LogErrorsAsMessages;
+
+#if defined(HAVE_COMDEF_H)
+
+#include <comdef.h>
+
+// Copied from a correct comdef.h to avoid problems with deficient versions
+// of comdef.h that exist in the wild... Fixes issue #7533.
+//
+#ifdef _NATIVE_WCHAR_T_DEFINED
+#ifdef _DEBUG
+#pragma comment(lib, "comsuppwd.lib")
+#else
+#pragma comment(lib, "comsuppw.lib")
+#endif
+#else
+#ifdef _DEBUG
+#pragma comment(lib, "comsuppd.lib")
+#else
+#pragma comment(lib, "comsupp.lib")
+#endif
+#endif
+
+///! Use ReportHRESULT to make a cmSystemTools::Message after calling
+///! a COM method that may have failed.
+#define ReportHRESULT(hr, context)                                            \
+  if (FAILED(hr)) {                                                           \
+    if (LogErrorsAsMessages) {                                                \
+      std::ostringstream _hresult_oss;                                        \
+      _hresult_oss.flags(std::ios::hex);                                      \
+      _hresult_oss << context << " failed HRESULT, hr = 0x" << hr             \
+                   << std::endl;                                              \
+      _hresult_oss.flags(std::ios::dec);                                      \
+      _hresult_oss << __FILE__ << "(" << __LINE__ << ")";                     \
+      cmSystemTools::Message(_hresult_oss.str().c_str());                     \
+    }                                                                         \
+  }
+
+///! Using the given instance of Visual Studio, call the named macro
+HRESULT InstanceCallMacro(IDispatch* vsIDE, const std::string& macro,
+                          const std::string& args)
+{
+  HRESULT hr = E_POINTER;
+
+  _bstr_t macroName(macro.c_str());
+  _bstr_t macroArgs(args.c_str());
+
+  if (0 != vsIDE) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"ExecuteCommand";
+
+    hr =
+      vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
+    ReportHRESULT(hr, "GetIDsOfNames(ExecuteCommand)");
+
+    if (SUCCEEDED(hr)) {
+      VARIANTARG vargs[2];
+      DISPPARAMS params;
+      VARIANT result;
+      EXCEPINFO excep;
+      UINT arg = (UINT)-1;
+
+      // No VariantInit or VariantClear calls are necessary for
+      // these two vargs. They are both local _bstr_t variables
+      // that remain in scope for the duration of the Invoke call.
+      //
+      V_VT(&vargs[1]) = VT_BSTR;
+      V_BSTR(&vargs[1]) = macroName;
+      V_VT(&vargs[0]) = VT_BSTR;
+      V_BSTR(&vargs[0]) = macroArgs;
+
+      params.rgvarg = &vargs[0];
+      params.rgdispidNamedArgs = 0;
+      params.cArgs = sizeof(vargs) / sizeof(vargs[0]);
+      params.cNamedArgs = 0;
+
+      VariantInit(&result);
+
+      memset(&excep, 0, sizeof(excep));
+
+      hr = vsIDE->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
+                         DISPATCH_METHOD, &params, &result, &excep, &arg);
+
+      std::ostringstream oss;
+      oss << std::endl;
+      oss << "Invoke(ExecuteCommand)" << std::endl;
+      oss << "  Macro: " << macro << std::endl;
+      oss << "  Args: " << args << std::endl;
+
+      if (DISP_E_EXCEPTION == hr) {
+        oss << "DISP_E_EXCEPTION EXCEPINFO:" << excep.wCode << std::endl;
+        oss << "  wCode: " << excep.wCode << std::endl;
+        oss << "  wReserved: " << excep.wReserved << std::endl;
+        if (excep.bstrSource) {
+          oss << "  bstrSource: " << (const char*)(_bstr_t)excep.bstrSource
+              << std::endl;
+        }
+        if (excep.bstrDescription) {
+          oss << "  bstrDescription: "
+              << (const char*)(_bstr_t)excep.bstrDescription << std::endl;
+        }
+        if (excep.bstrHelpFile) {
+          oss << "  bstrHelpFile: " << (const char*)(_bstr_t)excep.bstrHelpFile
+              << std::endl;
+        }
+        oss << "  dwHelpContext: " << excep.dwHelpContext << std::endl;
+        oss << "  pvReserved: " << excep.pvReserved << std::endl;
+        oss << "  pfnDeferredFillIn: " << excep.pfnDeferredFillIn << std::endl;
+        oss << "  scode: " << excep.scode << std::endl;
+      }
+
+      std::string exstr(oss.str());
+      ReportHRESULT(hr, exstr.c_str());
+
+      VariantClear(&result);
+    }
+  }
+
+  return hr;
+}
+
+///! Get the Solution object from the IDE object
+HRESULT GetSolutionObject(IDispatch* vsIDE, IDispatchPtr& vsSolution)
+{
+  HRESULT hr = E_POINTER;
+
+  if (0 != vsIDE) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"Solution";
+
+    hr =
+      vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
+    ReportHRESULT(hr, "GetIDsOfNames(Solution)");
+
+    if (SUCCEEDED(hr)) {
+      DISPPARAMS params;
+      VARIANT result;
+      EXCEPINFO excep;
+      UINT arg = (UINT)-1;
+
+      params.rgvarg = 0;
+      params.rgdispidNamedArgs = 0;
+      params.cArgs = 0;
+      params.cNamedArgs = 0;
+
+      VariantInit(&result);
+
+      memset(&excep, 0, sizeof(excep));
+
+      hr = vsIDE->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
+                         DISPATCH_PROPERTYGET, &params, &result, &excep, &arg);
+      ReportHRESULT(hr, "Invoke(Solution)");
+
+      if (SUCCEEDED(hr)) {
+        vsSolution = V_DISPATCH(&result);
+      }
+
+      VariantClear(&result);
+    }
+  }
+
+  return hr;
+}
+
+///! Get the FullName property from the Solution object
+HRESULT GetSolutionFullName(IDispatch* vsSolution, std::string& fullName)
+{
+  HRESULT hr = E_POINTER;
+
+  if (0 != vsSolution) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"FullName";
+
+    hr = vsSolution->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT,
+                                   &dispid);
+    ReportHRESULT(hr, "GetIDsOfNames(FullName)");
+
+    if (SUCCEEDED(hr)) {
+      DISPPARAMS params;
+      VARIANT result;
+      EXCEPINFO excep;
+      UINT arg = (UINT)-1;
+
+      params.rgvarg = 0;
+      params.rgdispidNamedArgs = 0;
+      params.cArgs = 0;
+      params.cNamedArgs = 0;
+
+      VariantInit(&result);
+
+      memset(&excep, 0, sizeof(excep));
+
+      hr = vsSolution->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
+                              DISPATCH_PROPERTYGET, &params, &result, &excep,
+                              &arg);
+      ReportHRESULT(hr, "Invoke(FullName)");
+
+      if (SUCCEEDED(hr)) {
+        fullName = (std::string)(_bstr_t)V_BSTR(&result);
+      }
+
+      VariantClear(&result);
+    }
+  }
+
+  return hr;
+}
+
+///! Get the FullName property from the Solution object, given the IDE object
+HRESULT GetIDESolutionFullName(IDispatch* vsIDE, std::string& fullName)
+{
+  IDispatchPtr vsSolution;
+  HRESULT hr = GetSolutionObject(vsIDE, vsSolution);
+  ReportHRESULT(hr, "GetSolutionObject");
+
+  if (SUCCEEDED(hr)) {
+    GetSolutionFullName(vsSolution, fullName);
+    ReportHRESULT(hr, "GetSolutionFullName");
+  }
+
+  return hr;
+}
+
+///! Get all running objects from the Windows running object table.
+///! Save them in a map by their display names.
+HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
+{
+  // mrot == Map of the Running Object Table
+
+  IRunningObjectTablePtr runningObjectTable;
+  IEnumMonikerPtr monikerEnumerator;
+  IMonikerPtr moniker;
+  ULONG numFetched = 0;
+
+  HRESULT hr = GetRunningObjectTable(0, &runningObjectTable);
+  ReportHRESULT(hr, "GetRunningObjectTable");
+
+  if (SUCCEEDED(hr)) {
+    hr = runningObjectTable->EnumRunning(&monikerEnumerator);
+    ReportHRESULT(hr, "EnumRunning");
+  }
+
+  if (SUCCEEDED(hr)) {
+    hr = monikerEnumerator->Reset();
+    ReportHRESULT(hr, "Reset");
+  }
+
+  if (SUCCEEDED(hr)) {
+    while (S_OK == monikerEnumerator->Next(1, &moniker, &numFetched)) {
+      std::string runningObjectName;
+      IUnknownPtr runningObjectVal;
+      IBindCtxPtr ctx;
+
+      hr = CreateBindCtx(0, &ctx);
+      ReportHRESULT(hr, "CreateBindCtx");
+
+      if (SUCCEEDED(hr)) {
+        LPOLESTR displayName = 0;
+        hr = moniker->GetDisplayName(ctx, 0, &displayName);
+        ReportHRESULT(hr, "GetDisplayName");
+        if (displayName) {
+          runningObjectName = (std::string)(_bstr_t)displayName;
+          CoTaskMemFree(displayName);
+        }
+
+        hr = runningObjectTable->GetObject(moniker, &runningObjectVal);
+        ReportHRESULT(hr, "GetObject");
+        if (SUCCEEDED(hr)) {
+          mrot.insert(std::make_pair(runningObjectName, runningObjectVal));
+        }
+      }
+
+      numFetched = 0;
+      moniker = 0;
+    }
+  }
+
+  return hr;
+}
+
+///! Do the two file names refer to the same Visual Studio solution? Or are
+///! we perhaps looking for any and all solutions?
+bool FilesSameSolution(const std::string& slnFile, const std::string& slnName)
+{
+  if (slnFile == "ALL" || slnName == "ALL") {
+    return true;
+  }
+
+  // Otherwise, make lowercase local copies, convert to Unix slashes, and
+  // see if the resulting strings are the same:
+  std::string s1 = cmSystemTools::LowerCase(slnFile);
+  std::string s2 = cmSystemTools::LowerCase(slnName);
+  cmSystemTools::ConvertToUnixSlashes(s1);
+  cmSystemTools::ConvertToUnixSlashes(s2);
+
+  return s1 == s2;
+}
+
+///! Find instances of Visual Studio with the given solution file
+///! open. Pass "ALL" for slnFile to gather all running instances
+///! of Visual Studio.
+HRESULT FindVisualStudioInstances(const std::string& slnFile,
+                                  std::vector<IDispatchPtr>& instances)
+{
+  std::map<std::string, IUnknownPtr> mrot;
+
+  HRESULT hr = GetRunningInstances(mrot);
+  ReportHRESULT(hr, "GetRunningInstances");
+
+  if (SUCCEEDED(hr)) {
+    std::map<std::string, IUnknownPtr>::iterator it;
+    for (it = mrot.begin(); it != mrot.end(); ++it) {
+      if (cmSystemTools::StringStartsWith(it->first.c_str(),
+                                          "!VisualStudio.DTE.")) {
+        IDispatchPtr disp(it->second);
+        if (disp != (IDispatch*)0) {
+          std::string slnName;
+          hr = GetIDESolutionFullName(disp, slnName);
+          ReportHRESULT(hr, "GetIDESolutionFullName");
+
+          if (FilesSameSolution(slnFile, slnName)) {
+            instances.push_back(disp);
+
+            // std::cout << "Found Visual Studio instance." << std::endl;
+            // std::cout << "  ROT entry name: " << it->first << std::endl;
+            // std::cout << "  ROT entry object: "
+            //          << (IUnknown*) it->second << std::endl;
+            // std::cout << "  slnFile: " << slnFile << std::endl;
+            // std::cout << "  slnName: " << slnName << std::endl;
+          }
+        }
+      }
+    }
+  }
+
+  return hr;
+}
+
+#endif // defined(HAVE_COMDEF_H)
+
+int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
+  const std::string& slnFile)
+{
+  int count = 0;
+
+  LogErrorsAsMessages = false;
+
+#if defined(HAVE_COMDEF_H)
+  HRESULT hr = CoInitialize(0);
+  ReportHRESULT(hr, "CoInitialize");
+
+  if (SUCCEEDED(hr)) {
+    std::vector<IDispatchPtr> instances;
+    hr = FindVisualStudioInstances(slnFile, instances);
+    ReportHRESULT(hr, "FindVisualStudioInstances");
+
+    if (SUCCEEDED(hr)) {
+      count = static_cast<int>(instances.size());
+    }
+
+    // Force release all COM pointers before CoUninitialize:
+    instances.clear();
+
+    CoUninitialize();
+  }
+#else
+  (void)slnFile;
+#endif
+
+  return count;
+}
+
+///! Get all running objects from the Windows running object table.
+///! Save them in a map by their display names.
+int cmCallVisualStudioMacro::CallMacro(const std::string& slnFile,
+                                       const std::string& macro,
+                                       const std::string& args,
+                                       const bool logErrorsAsMessages)
+{
+  int err = 1; // no comdef.h
+
+  LogErrorsAsMessages = logErrorsAsMessages;
+
+#if defined(HAVE_COMDEF_H)
+  err = 2; // error initializing
+
+  HRESULT hr = CoInitialize(0);
+  ReportHRESULT(hr, "CoInitialize");
+
+  if (SUCCEEDED(hr)) {
+    std::vector<IDispatchPtr> instances;
+    hr = FindVisualStudioInstances(slnFile, instances);
+    ReportHRESULT(hr, "FindVisualStudioInstances");
+
+    if (SUCCEEDED(hr)) {
+      err = 0; // no error
+
+      std::vector<IDispatchPtr>::iterator it;
+      for (it = instances.begin(); it != instances.end(); ++it) {
+        hr = InstanceCallMacro(*it, macro, args);
+        ReportHRESULT(hr, "InstanceCallMacro");
+
+        if (FAILED(hr)) {
+          err = 3; // error attempting to call the macro
+        }
+      }
+
+      if (instances.empty()) {
+        // no instances to call
+
+        // cmSystemTools::Message(
+        //  "cmCallVisualStudioMacro::CallMacro no instances found to call",
+        //  "Warning");
+      }
+    }
+
+    // Force release all COM pointers before CoUninitialize:
+    instances.clear();
+
+    CoUninitialize();
+  }
+#else
+  (void)slnFile;
+  (void)macro;
+  (void)args;
+  if (LogErrorsAsMessages) {
+    cmSystemTools::Message("cmCallVisualStudioMacro::CallMacro is not "
+                           "supported on this platform");
+  }
+#endif
+
+  if (err && LogErrorsAsMessages) {
+    std::ostringstream oss;
+    oss << "cmCallVisualStudioMacro::CallMacro failed, err = " << err;
+    cmSystemTools::Message(oss.str().c_str());
+  }
+
+  return 0;
+}
diff --git a/Source/cmCallVisualStudioMacro.h b/Source/cmCallVisualStudioMacro.h
new file mode 100644
index 0000000..fdc9e66
--- /dev/null
+++ b/Source/cmCallVisualStudioMacro.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCallVisualStudioMacro_h
+#define cmCallVisualStudioMacro_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+/** \class cmCallVisualStudioMacro
+ * \brief Control class for communicating with CMake's Visual Studio macros
+ *
+ * Find running instances of Visual Studio by full path solution name.
+ * Call a Visual Studio IDE macro in any of those instances.
+ */
+class cmCallVisualStudioMacro
+{
+public:
+  ///! Call the named macro in instances of Visual Studio with the
+  ///! given solution file open. Pass "ALL" for slnFile to call the
+  ///! macro in each Visual Studio instance.
+  static int CallMacro(const std::string& slnFile, const std::string& macro,
+                       const std::string& args,
+                       const bool logErrorsAsMessages);
+
+  ///! Count the number of running instances of Visual Studio with the
+  ///! given solution file open. Pass "ALL" for slnFile to count all
+  ///! running Visual Studio instances.
+  static int GetNumberOfRunningVisualStudioInstances(
+    const std::string& slnFile);
+
+protected:
+private:
+};
+
+#endif
diff --git a/Source/cmCommand.cxx b/Source/cmCommand.cxx
new file mode 100644
index 0000000..d349c91
--- /dev/null
+++ b/Source/cmCommand.cxx
@@ -0,0 +1,33 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+struct cmListFileArgument;
+
+bool cmCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                                  cmExecutionStatus& status)
+{
+  std::vector<std::string> expandedArguments;
+  if (!this->Makefile->ExpandArguments(args, expandedArguments)) {
+    // There was an error expanding arguments.  It was already
+    // reported, so we can skip this command without error.
+    return true;
+  }
+  return this->InitialPass(expandedArguments, status);
+}
+
+const char* cmCommand::GetError()
+{
+  if (this->Error.empty()) {
+    return "unknown error.";
+  }
+  return this->Error.c_str();
+}
+
+void cmCommand::SetError(const std::string& e)
+{
+  this->Error = e;
+}
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
new file mode 100644
index 0000000..2cc0b88
--- /dev/null
+++ b/Source/cmCommand.h
@@ -0,0 +1,99 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCommand_h
+#define cmCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmExecutionStatus;
+class cmMakefile;
+struct cmListFileArgument;
+
+/** \class cmCommand
+ * \brief Superclass for all commands in CMake.
+ *
+ * cmCommand is the base class for all commands in CMake. A command
+ * manifests as an entry in CMakeLists.txt and produces one or
+ * more makefile rules. Commands are associated with a particular
+ * makefile. This base class cmCommand defines the API for commands
+ * to support such features as enable/disable, inheritance,
+ * documentation, and construction.
+ */
+class cmCommand
+{
+  CM_DISABLE_COPY(cmCommand)
+
+public:
+  /**
+   * Construct the command. By default it has no makefile.
+   */
+  cmCommand()
+    : Makefile(nullptr)
+  {
+  }
+
+  /**
+   * Need virtual destructor to destroy real command type.
+   */
+  virtual ~cmCommand() {}
+
+  /**
+   * Specify the makefile.
+   */
+  void SetMakefile(cmMakefile* m) { this->Makefile = m; }
+  cmMakefile* GetMakefile() { return this->Makefile; }
+
+  /**
+   * This is called by the cmMakefile when the command is first
+   * encountered in the CMakeLists.txt file.  It expands the command's
+   * arguments and then invokes the InitialPass.
+   */
+  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                                 cmExecutionStatus& status);
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool InitialPass(std::vector<std::string> const& args,
+                           cmExecutionStatus&) = 0;
+
+  /**
+   * This is called at the end after all the information
+   * specified by the command is accumulated. Most commands do
+   * not implement this method.  At this point, reading and
+   * writing to the cache can be done.
+   */
+  virtual void FinalPass() {}
+
+  /**
+   * Does this command have a final pass?  Query after InitialPass.
+   */
+  virtual bool HasFinalPass() const { return false; }
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() = 0;
+
+  /**
+   * Return the last error string.
+   */
+  const char* GetError();
+
+  /**
+   * Set the error message
+   */
+  void SetError(const std::string& e);
+
+protected:
+  cmMakefile* Makefile;
+
+private:
+  std::string Error;
+};
+
+#endif
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
new file mode 100644
index 0000000..bf314bd
--- /dev/null
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -0,0 +1,308 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCommandArgumentParserHelper.h"
+
+#include "cmCommandArgumentLexer.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <iostream>
+#include <sstream>
+#include <string.h>
+
+int cmCommandArgument_yyparse(yyscan_t yyscanner);
+//
+cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
+{
+  this->WarnUninitialized = false;
+  this->CheckSystemVars = false;
+  this->FileLine = -1;
+  this->FileName = nullptr;
+  this->RemoveEmpty = true;
+
+  this->NoEscapeMode = false;
+  this->ReplaceAtSyntax = false;
+}
+
+cmCommandArgumentParserHelper::~cmCommandArgumentParserHelper()
+{
+  this->CleanupParser();
+}
+
+void cmCommandArgumentParserHelper::SetLineFile(long line, const char* file)
+{
+  this->FileLine = line;
+  this->FileName = file;
+}
+
+const char* cmCommandArgumentParserHelper::AddString(const std::string& str)
+{
+  if (str.empty()) {
+    return "";
+  }
+  char* stVal = new char[str.size() + 1];
+  strcpy(stVal, str.c_str());
+  this->Variables.push_back(stVal);
+  return stVal;
+}
+
+const char* cmCommandArgumentParserHelper::ExpandSpecialVariable(
+  const char* key, const char* var)
+{
+  if (!key) {
+    return this->ExpandVariable(var);
+  }
+  if (!var) {
+    return "";
+  }
+  if (strcmp(key, "ENV") == 0) {
+    std::string str;
+    if (cmSystemTools::GetEnv(var, str)) {
+      if (this->EscapeQuotes) {
+        return this->AddString(cmSystemTools::EscapeQuotes(str));
+      }
+      return this->AddString(str);
+    }
+    return "";
+  }
+  if (strcmp(key, "CACHE") == 0) {
+    if (const char* c =
+          this->Makefile->GetState()->GetInitializedCacheValue(var)) {
+      if (this->EscapeQuotes) {
+        return this->AddString(cmSystemTools::EscapeQuotes(c));
+      }
+      return this->AddString(c);
+    }
+    return "";
+  }
+  std::ostringstream e;
+  e << "Syntax $" << key << "{} is not supported.  "
+    << "Only ${}, $ENV{}, and $CACHE{} are allowed.";
+  this->SetError(e.str());
+  return nullptr;
+}
+
+const char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
+{
+  if (!var) {
+    return nullptr;
+  }
+  if (this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0) {
+    std::ostringstream ostr;
+    ostr << this->FileLine;
+    return this->AddString(ostr.str());
+  }
+  const char* value = this->Makefile->GetDefinition(var);
+  if (!value && !this->RemoveEmpty) {
+    // check to see if we need to print a warning
+    // if strict mode is on and the variable has
+    // not been "cleared"/initialized with a set(foo ) call
+    if (this->WarnUninitialized && !this->Makefile->VariableInitialized(var)) {
+      if (this->CheckSystemVars ||
+          cmSystemTools::IsSubDirectory(this->FileName,
+                                        this->Makefile->GetHomeDirectory()) ||
+          cmSystemTools::IsSubDirectory(
+            this->FileName, this->Makefile->GetHomeOutputDirectory())) {
+        std::ostringstream msg;
+        msg << "uninitialized variable \'" << var << "\'";
+        this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, msg.str());
+      }
+    }
+    return nullptr;
+  }
+  if (this->EscapeQuotes && value) {
+    return this->AddString(cmSystemTools::EscapeQuotes(value));
+  }
+  return this->AddString(value ? value : "");
+}
+
+const char* cmCommandArgumentParserHelper::ExpandVariableForAt(const char* var)
+{
+  if (this->ReplaceAtSyntax) {
+    // try to expand the variable
+    const char* ret = this->ExpandVariable(var);
+    // if the return was 0 and we want to replace empty strings
+    // then return an empty string
+    if (!ret && this->RemoveEmpty) {
+      return this->AddString("");
+    }
+    // if the ret was not 0, then return it
+    if (ret) {
+      return ret;
+    }
+  }
+  // at this point we want to put it back because of one of these cases:
+  // - this->ReplaceAtSyntax is false
+  // - this->ReplaceAtSyntax is true, but this->RemoveEmpty is false,
+  //   and the variable was not defined
+  std::string ref = "@";
+  ref += var;
+  ref += "@";
+  return this->AddString(ref);
+}
+
+const char* cmCommandArgumentParserHelper::CombineUnions(const char* in1,
+                                                         const char* in2)
+{
+  if (!in1) {
+    return in2;
+  }
+  if (!in2) {
+    return in1;
+  }
+  size_t len = strlen(in1) + strlen(in2) + 1;
+  char* out = new char[len];
+  strcpy(out, in1);
+  strcat(out, in2);
+  this->Variables.push_back(out);
+  return out;
+}
+
+void cmCommandArgumentParserHelper::AllocateParserType(
+  cmCommandArgumentParserHelper::ParserType* pt, const char* str, int len)
+{
+  pt->str = nullptr;
+  if (len == 0) {
+    len = static_cast<int>(strlen(str));
+  }
+  if (len == 0) {
+    return;
+  }
+  char* out = new char[len + 1];
+  strncpy(out, str, len);
+  out[len] = 0;
+  pt->str = out;
+  this->Variables.push_back(out);
+}
+
+bool cmCommandArgumentParserHelper::HandleEscapeSymbol(
+  cmCommandArgumentParserHelper::ParserType* pt, char symbol)
+{
+  switch (symbol) {
+    case '\\':
+    case '"':
+    case ' ':
+    case '#':
+    case '(':
+    case ')':
+    case '$':
+    case '@':
+    case '^':
+      this->AllocateParserType(pt, &symbol, 1);
+      break;
+    case ';':
+      this->AllocateParserType(pt, "\\;", 2);
+      break;
+    case 't':
+      this->AllocateParserType(pt, "\t", 1);
+      break;
+    case 'n':
+      this->AllocateParserType(pt, "\n", 1);
+      break;
+    case 'r':
+      this->AllocateParserType(pt, "\r", 1);
+      break;
+    case '0':
+      this->AllocateParserType(pt, "\0", 1);
+      break;
+    default: {
+      std::ostringstream e;
+      e << "Invalid escape sequence \\" << symbol;
+      this->SetError(e.str());
+    }
+      return false;
+  }
+  return true;
+}
+
+void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes);
+
+int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
+{
+  if (!str) {
+    return 0;
+  }
+  this->Verbose = verb;
+  this->InputBuffer = str;
+  this->InputBufferPos = 0;
+  this->CurrentLine = 0;
+
+  this->Result.clear();
+
+  yyscan_t yyscanner;
+  cmCommandArgument_yylex_init(&yyscanner);
+  cmCommandArgument_yyset_extra(this, yyscanner);
+  cmCommandArgument_SetupEscapes(yyscanner, this->NoEscapeMode);
+  int res = cmCommandArgument_yyparse(yyscanner);
+  cmCommandArgument_yylex_destroy(yyscanner);
+  if (res != 0) {
+    return 0;
+  }
+
+  this->CleanupParser();
+
+  if (Verbose) {
+    std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
+              << std::endl;
+  }
+  return 1;
+}
+
+void cmCommandArgumentParserHelper::CleanupParser()
+{
+  std::vector<char*>::iterator sit;
+  for (char* var : this->Variables) {
+    delete[] var;
+  }
+  this->Variables.erase(this->Variables.begin(), this->Variables.end());
+}
+
+int cmCommandArgumentParserHelper::LexInput(char* buf, int maxlen)
+{
+  if (maxlen < 1) {
+    return 0;
+  }
+  if (this->InputBufferPos < this->InputBuffer.size()) {
+    buf[0] = this->InputBuffer[this->InputBufferPos++];
+    if (buf[0] == '\n') {
+      this->CurrentLine++;
+    }
+    return (1);
+  }
+  buf[0] = '\n';
+  return (0);
+}
+
+void cmCommandArgumentParserHelper::Error(const char* str)
+{
+  unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
+  std::ostringstream ostr;
+  ostr << str << " (" << pos << ")";
+  this->SetError(ostr.str());
+}
+
+void cmCommandArgumentParserHelper::SetMakefile(const cmMakefile* mf)
+{
+  this->Makefile = mf;
+  this->WarnUninitialized = mf->GetCMakeInstance()->GetWarnUninitialized();
+  this->CheckSystemVars = mf->GetCMakeInstance()->GetCheckSystemVars();
+}
+
+void cmCommandArgumentParserHelper::SetResult(const char* value)
+{
+  if (!value) {
+    this->Result.clear();
+    return;
+  }
+  this->Result = value;
+}
+
+void cmCommandArgumentParserHelper::SetError(std::string const& msg)
+{
+  // Keep only the first error.
+  if (this->ErrorString.empty()) {
+    this->ErrorString = msg;
+  }
+}
diff --git a/Source/cmCommandArgumentParserHelper.h b/Source/cmCommandArgumentParserHelper.h
new file mode 100644
index 0000000..098c000
--- /dev/null
+++ b/Source/cmCommandArgumentParserHelper.h
@@ -0,0 +1,92 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCommandArgumentParserHelper_h
+#define cmCommandArgumentParserHelper_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+class cmMakefile;
+
+class cmCommandArgumentParserHelper
+{
+  CM_DISABLE_COPY(cmCommandArgumentParserHelper)
+
+public:
+  struct ParserType
+  {
+    const char* str;
+  };
+
+  cmCommandArgumentParserHelper();
+  ~cmCommandArgumentParserHelper();
+
+  int ParseString(const char* str, int verb);
+
+  // For the lexer:
+  void AllocateParserType(cmCommandArgumentParserHelper::ParserType* pt,
+                          const char* str, int len = 0);
+  bool HandleEscapeSymbol(cmCommandArgumentParserHelper::ParserType* pt,
+                          char symbol);
+
+  int LexInput(char* buf, int maxlen);
+  void Error(const char* str);
+
+  // For yacc
+  const char* CombineUnions(const char* in1, const char* in2);
+
+  const char* ExpandSpecialVariable(const char* key, const char* var);
+  const char* ExpandVariable(const char* var);
+  const char* ExpandVariableForAt(const char* var);
+  void SetResult(const char* value);
+
+  void SetMakefile(const cmMakefile* mf);
+
+  std::string& GetResult() { return this->Result; }
+
+  void SetLineFile(long line, const char* file);
+  void SetEscapeQuotes(bool b) { this->EscapeQuotes = b; }
+  void SetNoEscapeMode(bool b) { this->NoEscapeMode = b; }
+  void SetReplaceAtSyntax(bool b) { this->ReplaceAtSyntax = b; }
+  void SetRemoveEmpty(bool b) { this->RemoveEmpty = b; }
+
+  const char* GetError() { return this->ErrorString.c_str(); }
+
+private:
+  std::string::size_type InputBufferPos;
+  std::string InputBuffer;
+  std::vector<char> OutputBuffer;
+
+  void Print(const char* place, const char* str);
+  void SafePrintMissing(const char* str, int line, int cnt);
+
+  const char* AddString(const std::string& str);
+
+  void CleanupParser();
+  void SetError(std::string const& msg);
+
+  std::vector<char*> Variables;
+  const cmMakefile* Makefile;
+  std::string Result;
+  std::string ErrorString;
+  const char* FileName;
+  long FileLine;
+  int CurrentLine;
+  int Verbose;
+  bool WarnUninitialized;
+  bool CheckSystemVars;
+  bool EscapeQuotes;
+  bool NoEscapeMode;
+  bool ReplaceAtSyntax;
+  bool RemoveEmpty;
+};
+
+#define YYSTYPE cmCommandArgumentParserHelper::ParserType
+#define YYSTYPE_IS_DECLARED
+#define YY_EXTRA_TYPE cmCommandArgumentParserHelper*
+#define YY_DECL                                                               \
+  int cmCommandArgument_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
+
+#endif
diff --git a/Source/cmCommandArgumentsHelper.cxx b/Source/cmCommandArgumentsHelper.cxx
new file mode 100644
index 0000000..968b17c
--- /dev/null
+++ b/Source/cmCommandArgumentsHelper.cxx
@@ -0,0 +1,233 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCommandArgumentsHelper.h"
+
+cmCommandArgument::cmCommandArgument(cmCommandArgumentsHelper* args,
+                                     const char* key,
+                                     cmCommandArgumentGroup* group)
+  : Key(key)
+  , Group(group)
+  , WasActive(false)
+  , ArgumentsBeforeEmpty(true)
+  , CurrentIndex(0)
+{
+  if (args != nullptr) {
+    args->AddArgument(this);
+  }
+
+  if (this->Group != nullptr) {
+    this->Group->ContainedArguments.push_back(this);
+  }
+}
+
+void cmCommandArgument::Reset()
+{
+  this->WasActive = false;
+  this->CurrentIndex = 0;
+  this->DoReset();
+}
+
+void cmCommandArgument::Follows(const cmCommandArgument* arg)
+{
+  this->ArgumentsBeforeEmpty = false;
+  this->ArgumentsBefore.insert(arg);
+}
+
+void cmCommandArgument::FollowsGroup(const cmCommandArgumentGroup* group)
+{
+  if (group != nullptr) {
+    this->ArgumentsBeforeEmpty = false;
+    this->ArgumentsBefore.insert(group->ContainedArguments.begin(),
+                                 group->ContainedArguments.end());
+  }
+}
+
+bool cmCommandArgument::MayFollow(const cmCommandArgument* current) const
+{
+  if (this->ArgumentsBeforeEmpty) {
+    return true;
+  }
+  return this->ArgumentsBefore.find(current) != this->ArgumentsBefore.end();
+}
+
+bool cmCommandArgument::KeyMatches(const std::string& key) const
+{
+  if ((this->Key == nullptr) || (this->Key[0] == '\0')) {
+    return true;
+  }
+  return (key == this->Key);
+}
+
+void cmCommandArgument::ApplyOwnGroup()
+{
+  if (this->Group != nullptr) {
+    for (cmCommandArgument* cargs : this->Group->ContainedArguments) {
+      if (cargs != this) {
+        this->ArgumentsBefore.insert(cargs);
+      }
+    }
+  }
+}
+
+void cmCommandArgument::Activate()
+{
+  this->WasActive = true;
+  this->CurrentIndex = 0;
+}
+
+bool cmCommandArgument::Consume(const std::string& arg)
+{
+  bool res = this->DoConsume(arg, this->CurrentIndex);
+  this->CurrentIndex++;
+  return res;
+}
+
+cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args,
+                                   const char* key,
+                                   cmCommandArgumentGroup* group)
+  : cmCommandArgument(args, key, group)
+  , Ignore(nullptr)
+{
+  if ((key == nullptr) || (*key == 0)) {
+    this->DataStart = 0;
+  } else {
+    this->DataStart = 1;
+  }
+}
+
+bool cmCAStringVector::DoConsume(const std::string& arg, unsigned int index)
+{
+  if (index >= this->DataStart) {
+    if ((this->Ignore == nullptr) || (arg != this->Ignore)) {
+      this->Vector.push_back(arg);
+    }
+  }
+
+  return false;
+}
+
+void cmCAStringVector::DoReset()
+{
+  this->Vector.clear();
+}
+
+cmCAString::cmCAString(cmCommandArgumentsHelper* args, const char* key,
+                       cmCommandArgumentGroup* group)
+  : cmCommandArgument(args, key, group)
+{
+  if ((key == nullptr) || (*key == 0)) {
+    this->DataStart = 0;
+  } else {
+    this->DataStart = 1;
+  }
+}
+
+bool cmCAString::DoConsume(const std::string& arg, unsigned int index)
+{
+  if (index == this->DataStart) {
+    this->String = arg;
+  }
+
+  return index >= this->DataStart;
+}
+
+void cmCAString::DoReset()
+{
+  this->String.clear();
+}
+
+cmCAEnabler::cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
+                         cmCommandArgumentGroup* group)
+  : cmCommandArgument(args, key, group)
+  , Enabled(false)
+{
+}
+
+bool cmCAEnabler::DoConsume(const std::string&, unsigned int index)
+{
+  if (index == 0) {
+    this->Enabled = true;
+  }
+  return true;
+}
+
+void cmCAEnabler::DoReset()
+{
+  this->Enabled = false;
+}
+
+cmCADisabler::cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
+                           cmCommandArgumentGroup* group)
+  : cmCommandArgument(args, key, group)
+  , Enabled(true)
+{
+}
+
+bool cmCADisabler::DoConsume(const std::string&, unsigned int index)
+{
+  if (index == 0) {
+    this->Enabled = false;
+  }
+  return true;
+}
+
+void cmCADisabler::DoReset()
+{
+  this->Enabled = true;
+}
+
+void cmCommandArgumentGroup::Follows(const cmCommandArgument* arg)
+{
+  for (cmCommandArgument* ca : this->ContainedArguments) {
+    ca->Follows(arg);
+  }
+}
+
+void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group)
+{
+  for (cmCommandArgument* ca : this->ContainedArguments) {
+    ca->FollowsGroup(group);
+  }
+}
+
+void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args,
+                                     std::vector<std::string>* unconsumedArgs)
+{
+  if (args == nullptr) {
+    return;
+  }
+
+  for (cmCommandArgument* ca : this->Arguments) {
+    ca->ApplyOwnGroup();
+    ca->Reset();
+  }
+
+  cmCommandArgument* activeArgument = nullptr;
+  const cmCommandArgument* previousArgument = nullptr;
+  for (std::string const& it : *args) {
+    for (cmCommandArgument* ca : this->Arguments) {
+      if (ca->KeyMatches(it) && (ca->MayFollow(previousArgument))) {
+        activeArgument = ca;
+        activeArgument->Activate();
+        break;
+      }
+    }
+
+    if (activeArgument) {
+      bool argDone = activeArgument->Consume(it);
+      previousArgument = activeArgument;
+      if (argDone) {
+        activeArgument = nullptr;
+      }
+    } else {
+      if (unconsumedArgs != nullptr) {
+        unconsumedArgs->push_back(it);
+      }
+    }
+  }
+}
+
+void cmCommandArgumentsHelper::AddArgument(cmCommandArgument* arg)
+{
+  this->Arguments.push_back(arg);
+}
diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h
new file mode 100644
index 0000000..d3f102c
--- /dev/null
+++ b/Source/cmCommandArgumentsHelper.h
@@ -0,0 +1,196 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCommandArgumentsHelper_h
+#define cmCommandArgumentsHelper_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <set>
+#include <string>
+#include <vector>
+
+class cmCommandArgumentGroup;
+class cmCommandArgumentsHelper;
+
+/* cmCommandArgumentsHelper, cmCommandArgumentGroup and cmCommandArgument (i.e.
+its derived classes cmCAXXX can be used to simplify the processing of
+arguments to cmake commands. Maybe they can also be used to generate
+documentation.
+
+For every argument supported by a command one cmCommandArgument is created
+and added to cmCommandArgumentsHelper. cmCommand has a cmCommandArgumentsHelper
+as member variable so this should be used.
+
+The order of the arguments is defined using the Follows(arg) method. It says
+that this argument follows immediateley the given argument. It can be used
+with multiple arguments if the argument can follow after different arguments.
+
+Arguments can be arranged in groups using cmCommandArgumentGroup. Every
+member of a group can follow any other member of the group. These groups
+can also be used to define the order.
+
+Once all arguments and groups are set up, cmCommandArgumentsHelper::Parse()
+is called and afterwards the values of the arguments can be evaluated.
+
+For an example see cmExportCommand.cxx.
+*/
+class cmCommandArgument
+{
+public:
+  cmCommandArgument(cmCommandArgumentsHelper* args, const char* key,
+                    cmCommandArgumentGroup* group = nullptr);
+  virtual ~cmCommandArgument() {}
+
+  /// this argument may follow after arg. 0 means it comes first.
+  void Follows(const cmCommandArgument* arg);
+
+  /// this argument may follow after any of the arguments in the given group
+  void FollowsGroup(const cmCommandArgumentGroup* group);
+
+  /// Returns true if the argument was found in the argument list
+  bool WasFound() const { return this->WasActive; }
+
+  // The following methods are only called from
+  // cmCommandArgumentsHelper::Parse(), but making this a friend would
+  // give it access to everything
+
+  /// Make the current argument the currently active argument
+  void Activate();
+  /// Consume the current string
+  bool Consume(const std::string& arg);
+
+  /// Return true if this argument may follow after the given argument.
+  bool MayFollow(const cmCommandArgument* current) const;
+
+  /** Returns true if the given key matches the key for this argument.
+  If this argument has an empty key everything matches. */
+  bool KeyMatches(const std::string& key) const;
+
+  /// Make this argument follow all members of the own group
+  void ApplyOwnGroup();
+
+  /// Reset argument, so it's back to its initial state
+  void Reset();
+
+private:
+  const char* Key;
+  std::set<const cmCommandArgument*> ArgumentsBefore;
+  cmCommandArgumentGroup* Group;
+  bool WasActive;
+  bool ArgumentsBeforeEmpty;
+  unsigned int CurrentIndex;
+
+  virtual bool DoConsume(const std::string& arg, unsigned int index) = 0;
+  virtual void DoReset() = 0;
+};
+
+/** cmCAStringVector is to be used for arguments which can consist of more
+than one string, e.g. the FILES argument in INSTALL(FILES f1 f2 f3 ...). */
+class cmCAStringVector : public cmCommandArgument
+{
+public:
+  cmCAStringVector(cmCommandArgumentsHelper* args, const char* key,
+                   cmCommandArgumentGroup* group = nullptr);
+
+  /// Return the vector of strings
+  const std::vector<std::string>& GetVector() const { return this->Vector; }
+
+  /** Is there a keyword which should be skipped in
+  the arguments (e.g. ARGS for ADD_CUSTOM_COMMAND) ? */
+  void SetIgnore(const char* ignore) { this->Ignore = ignore; }
+private:
+  std::vector<std::string> Vector;
+  unsigned int DataStart;
+  const char* Ignore;
+  cmCAStringVector();
+  bool DoConsume(const std::string& arg, unsigned int index) override;
+  void DoReset() override;
+};
+
+/** cmCAString is to be used for arguments which consist of one value,
+e.g. the executable name in ADD_EXECUTABLE(). */
+class cmCAString : public cmCommandArgument
+{
+public:
+  cmCAString(cmCommandArgumentsHelper* args, const char* key,
+             cmCommandArgumentGroup* group = nullptr);
+
+  /// Return the string
+  const std::string& GetString() const { return this->String; }
+  const char* GetCString() const { return this->String.c_str(); }
+private:
+  std::string String;
+  unsigned int DataStart;
+  bool DoConsume(const std::string& arg, unsigned int index) override;
+  void DoReset() override;
+  cmCAString();
+};
+
+/** cmCAEnabler is to be used for options which are off by default and can be
+enabled using a special argument, e.g. EXCLUDE_FROM_ALL in ADD_EXECUTABLE(). */
+class cmCAEnabler : public cmCommandArgument
+{
+public:
+  cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
+              cmCommandArgumentGroup* group = nullptr);
+
+  /// Has it been enabled ?
+  bool IsEnabled() const { return this->Enabled; }
+private:
+  bool Enabled;
+  bool DoConsume(const std::string& arg, unsigned int index) override;
+  void DoReset() override;
+  cmCAEnabler();
+};
+
+/** cmCADisable is to be used for options which are on by default and can be
+disabled using a special argument.*/
+class cmCADisabler : public cmCommandArgument
+{
+public:
+  cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
+               cmCommandArgumentGroup* group = nullptr);
+
+  /// Is it still enabled ?
+  bool IsEnabled() const { return this->Enabled; }
+private:
+  bool Enabled;
+  bool DoConsume(const std::string& arg, unsigned int index) override;
+  void DoReset() override;
+  cmCADisabler();
+};
+
+/** Group of arguments, needed for ordering. E.g. WIN32, EXCLUDE_FROM_ALL and
+MACSOX_BUNDLE from ADD_EXECUTABLE() are a group.
+*/
+class cmCommandArgumentGroup
+{
+  friend class cmCommandArgument;
+
+public:
+  cmCommandArgumentGroup() {}
+
+  /// All members of this group may follow the given argument
+  void Follows(const cmCommandArgument* arg);
+
+  /// All members of this group may follow all members of the given group
+  void FollowsGroup(const cmCommandArgumentGroup* group);
+
+private:
+  std::vector<cmCommandArgument*> ContainedArguments;
+};
+
+class cmCommandArgumentsHelper
+{
+public:
+  /// Parse the argument list
+  void Parse(const std::vector<std::string>* args,
+             std::vector<std::string>* unconsumedArgs);
+  /// Add an argument.
+  void AddArgument(cmCommandArgument* arg);
+
+private:
+  std::vector<cmCommandArgument*> Arguments;
+};
+
+#endif
diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx
new file mode 100644
index 0000000..a1de8b1
--- /dev/null
+++ b/Source/cmCommands.cxx
@@ -0,0 +1,355 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCommands.h"
+#include "cmPolicies.h"
+#include "cmState.h"
+
+#include "cmAddCustomCommandCommand.h"
+#include "cmAddCustomTargetCommand.h"
+#include "cmAddDefinitionsCommand.h"
+#include "cmAddDependenciesCommand.h"
+#include "cmAddExecutableCommand.h"
+#include "cmAddLibraryCommand.h"
+#include "cmAddSubDirectoryCommand.h"
+#include "cmAddTestCommand.h"
+#include "cmBreakCommand.h"
+#include "cmBuildCommand.h"
+#include "cmCMakeMinimumRequired.h"
+#include "cmCMakePolicyCommand.h"
+#include "cmConfigureFileCommand.h"
+#include "cmContinueCommand.h"
+#include "cmCreateTestSourceList.h"
+#include "cmDefinePropertyCommand.h"
+#include "cmEnableLanguageCommand.h"
+#include "cmEnableTestingCommand.h"
+#include "cmExecProgramCommand.h"
+#include "cmExecuteProcessCommand.h"
+#include "cmFileCommand.h"
+#include "cmFindFileCommand.h"
+#include "cmFindLibraryCommand.h"
+#include "cmFindPackageCommand.h"
+#include "cmFindPathCommand.h"
+#include "cmFindProgramCommand.h"
+#include "cmForEachCommand.h"
+#include "cmFunctionCommand.h"
+#include "cmGetCMakePropertyCommand.h"
+#include "cmGetDirectoryPropertyCommand.h"
+#include "cmGetFilenameComponentCommand.h"
+#include "cmGetPropertyCommand.h"
+#include "cmGetSourceFilePropertyCommand.h"
+#include "cmGetTargetPropertyCommand.h"
+#include "cmGetTestPropertyCommand.h"
+#include "cmIfCommand.h"
+#include "cmIncludeCommand.h"
+#include "cmIncludeDirectoryCommand.h"
+#include "cmIncludeGuardCommand.h"
+#include "cmIncludeRegularExpressionCommand.h"
+#include "cmInstallCommand.h"
+#include "cmInstallFilesCommand.h"
+#include "cmInstallTargetsCommand.h"
+#include "cmLinkDirectoriesCommand.h"
+#include "cmListCommand.h"
+#include "cmMacroCommand.h"
+#include "cmMakeDirectoryCommand.h"
+#include "cmMarkAsAdvancedCommand.h"
+#include "cmMathCommand.h"
+#include "cmMessageCommand.h"
+#include "cmOptionCommand.h"
+#include "cmParseArgumentsCommand.h"
+#include "cmProjectCommand.h"
+#include "cmReturnCommand.h"
+#include "cmSeparateArgumentsCommand.h"
+#include "cmSetCommand.h"
+#include "cmSetDirectoryPropertiesCommand.h"
+#include "cmSetPropertyCommand.h"
+#include "cmSetSourceFilesPropertiesCommand.h"
+#include "cmSetTargetPropertiesCommand.h"
+#include "cmSetTestsPropertiesCommand.h"
+#include "cmSiteNameCommand.h"
+#include "cmStringCommand.h"
+#include "cmSubdirCommand.h"
+#include "cmTargetCompileDefinitionsCommand.h"
+#include "cmTargetCompileFeaturesCommand.h"
+#include "cmTargetCompileOptionsCommand.h"
+#include "cmTargetIncludeDirectoriesCommand.h"
+#include "cmTargetLinkLibrariesCommand.h"
+#include "cmTargetSourcesCommand.h"
+#include "cmTryCompileCommand.h"
+#include "cmTryRunCommand.h"
+#include "cmUnsetCommand.h"
+#include "cmWhileCommand.h"
+
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+#include "cmAddCompileOptionsCommand.h"
+#include "cmAuxSourceDirectoryCommand.h"
+#include "cmBuildNameCommand.h"
+#include "cmCMakeHostSystemInformationCommand.h"
+#include "cmExportCommand.h"
+#include "cmExportLibraryDependenciesCommand.h"
+#include "cmFLTKWrapUICommand.h"
+#include "cmIncludeExternalMSProjectCommand.h"
+#include "cmInstallProgramsCommand.h"
+#include "cmLinkLibrariesCommand.h"
+#include "cmLoadCacheCommand.h"
+#include "cmLoadCommandCommand.h"
+#include "cmOutputRequiredFilesCommand.h"
+#include "cmQTWrapCPPCommand.h"
+#include "cmQTWrapUICommand.h"
+#include "cmRemoveCommand.h"
+#include "cmRemoveDefinitionsCommand.h"
+#include "cmSourceGroupCommand.h"
+#include "cmSubdirDependsCommand.h"
+#include "cmUseMangledMesaCommand.h"
+#include "cmUtilitySourceCommand.h"
+#include "cmVariableRequiresCommand.h"
+#include "cmVariableWatchCommand.h"
+#include "cmWriteFileCommand.h"
+#endif
+
+void GetScriptingCommands(cmState* state)
+{
+  state->AddBuiltinCommand("break", new cmBreakCommand);
+  state->AddBuiltinCommand("cmake_minimum_required",
+                           new cmCMakeMinimumRequired);
+  state->AddBuiltinCommand("cmake_policy", new cmCMakePolicyCommand);
+  state->AddBuiltinCommand("configure_file", new cmConfigureFileCommand);
+  state->AddBuiltinCommand("continue", new cmContinueCommand);
+  state->AddBuiltinCommand("exec_program", new cmExecProgramCommand);
+  state->AddBuiltinCommand("execute_process", new cmExecuteProcessCommand);
+  state->AddBuiltinCommand("file", new cmFileCommand);
+  state->AddBuiltinCommand("find_file", new cmFindFileCommand);
+  state->AddBuiltinCommand("find_library", new cmFindLibraryCommand);
+  state->AddBuiltinCommand("find_package", new cmFindPackageCommand);
+  state->AddBuiltinCommand("find_path", new cmFindPathCommand);
+  state->AddBuiltinCommand("find_program", new cmFindProgramCommand);
+  state->AddBuiltinCommand("foreach", new cmForEachCommand);
+  state->AddBuiltinCommand("function", new cmFunctionCommand);
+  state->AddBuiltinCommand("get_cmake_property",
+                           new cmGetCMakePropertyCommand);
+  state->AddBuiltinCommand("get_directory_property",
+                           new cmGetDirectoryPropertyCommand);
+  state->AddBuiltinCommand("get_filename_component",
+                           new cmGetFilenameComponentCommand);
+  state->AddBuiltinCommand("get_property", new cmGetPropertyCommand);
+  state->AddBuiltinCommand("if", new cmIfCommand);
+  state->AddBuiltinCommand("include", new cmIncludeCommand);
+  state->AddBuiltinCommand("include_guard", new cmIncludeGuardCommand);
+  state->AddBuiltinCommand("list", new cmListCommand);
+  state->AddBuiltinCommand("macro", new cmMacroCommand);
+  state->AddBuiltinCommand("make_directory", new cmMakeDirectoryCommand);
+  state->AddBuiltinCommand("mark_as_advanced", new cmMarkAsAdvancedCommand);
+  state->AddBuiltinCommand("math", new cmMathCommand);
+  state->AddBuiltinCommand("message", new cmMessageCommand);
+  state->AddBuiltinCommand("option", new cmOptionCommand);
+  state->AddBuiltinCommand("cmake_parse_arguments",
+                           new cmParseArgumentsCommand);
+  state->AddBuiltinCommand("return", new cmReturnCommand);
+  state->AddBuiltinCommand("separate_arguments",
+                           new cmSeparateArgumentsCommand);
+  state->AddBuiltinCommand("set", new cmSetCommand);
+  state->AddBuiltinCommand("set_property", new cmSetPropertyCommand);
+  state->AddBuiltinCommand("site_name", new cmSiteNameCommand);
+  state->AddBuiltinCommand("string", new cmStringCommand);
+  state->AddBuiltinCommand("unset", new cmUnsetCommand);
+  state->AddBuiltinCommand("while", new cmWhileCommand);
+
+  state->AddUnexpectedCommand(
+    "else", "An ELSE command was found outside of a proper "
+            "IF ENDIF structure. Or its arguments did not match "
+            "the opening IF command.");
+  state->AddUnexpectedCommand(
+    "elseif", "An ELSEIF command was found outside of a proper "
+              "IF ENDIF structure.");
+  state->AddUnexpectedCommand(
+    "endforeach", "An ENDFOREACH command was found outside of a proper "
+                  "FOREACH ENDFOREACH structure. Or its arguments did "
+                  "not match the opening FOREACH command.");
+  state->AddUnexpectedCommand(
+    "endfunction", "An ENDFUNCTION command was found outside of a proper "
+                   "FUNCTION ENDFUNCTION structure. Or its arguments did not "
+                   "match the opening FUNCTION command.");
+  state->AddUnexpectedCommand(
+    "endif", "An ENDIF command was found outside of a proper "
+             "IF ENDIF structure. Or its arguments did not match "
+             "the opening IF command.");
+  state->AddUnexpectedCommand(
+    "endmacro", "An ENDMACRO command was found outside of a proper "
+                "MACRO ENDMACRO structure. Or its arguments did not "
+                "match the opening MACRO command.");
+  state->AddUnexpectedCommand(
+    "endwhile", "An ENDWHILE command was found outside of a proper "
+                "WHILE ENDWHILE structure. Or its arguments did not "
+                "match the opening WHILE command.");
+
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+  state->AddBuiltinCommand("cmake_host_system_information",
+                           new cmCMakeHostSystemInformationCommand);
+  state->AddBuiltinCommand("remove", new cmRemoveCommand);
+  state->AddBuiltinCommand("variable_watch", new cmVariableWatchCommand);
+  state->AddBuiltinCommand("write_file", new cmWriteFileCommand);
+
+  state->AddDisallowedCommand(
+    "build_name", new cmBuildNameCommand, cmPolicies::CMP0036,
+    "The build_name command should not be called; see CMP0036.");
+  state->AddDisallowedCommand(
+    "use_mangled_mesa", new cmUseMangledMesaCommand, cmPolicies::CMP0030,
+    "The use_mangled_mesa command should not be called; see CMP0030.");
+
+#endif
+}
+
+void GetProjectCommands(cmState* state)
+{
+  state->AddBuiltinCommand("add_custom_command",
+                           new cmAddCustomCommandCommand);
+  state->AddBuiltinCommand("add_custom_target", new cmAddCustomTargetCommand);
+  state->AddBuiltinCommand("add_definitions", new cmAddDefinitionsCommand);
+  state->AddBuiltinCommand("add_dependencies", new cmAddDependenciesCommand);
+  state->AddBuiltinCommand("add_executable", new cmAddExecutableCommand);
+  state->AddBuiltinCommand("add_library", new cmAddLibraryCommand);
+  state->AddBuiltinCommand("add_subdirectory", new cmAddSubDirectoryCommand);
+  state->AddBuiltinCommand("add_test", new cmAddTestCommand);
+  state->AddBuiltinCommand("build_command", new cmBuildCommand);
+  state->AddBuiltinCommand("create_test_sourcelist",
+                           new cmCreateTestSourceList);
+  state->AddBuiltinCommand("define_property", new cmDefinePropertyCommand);
+  state->AddBuiltinCommand("enable_language", new cmEnableLanguageCommand);
+  state->AddBuiltinCommand("enable_testing", new cmEnableTestingCommand);
+  state->AddBuiltinCommand("get_source_file_property",
+                           new cmGetSourceFilePropertyCommand);
+  state->AddBuiltinCommand("get_target_property",
+                           new cmGetTargetPropertyCommand);
+  state->AddBuiltinCommand("get_test_property", new cmGetTestPropertyCommand);
+  state->AddBuiltinCommand("include_directories",
+                           new cmIncludeDirectoryCommand);
+  state->AddBuiltinCommand("include_regular_expression",
+                           new cmIncludeRegularExpressionCommand);
+  state->AddBuiltinCommand("install", new cmInstallCommand);
+  state->AddBuiltinCommand("install_files", new cmInstallFilesCommand);
+  state->AddBuiltinCommand("install_targets", new cmInstallTargetsCommand);
+  state->AddBuiltinCommand("link_directories", new cmLinkDirectoriesCommand);
+  state->AddBuiltinCommand("project", new cmProjectCommand);
+  state->AddBuiltinCommand("set_directory_properties",
+                           new cmSetDirectoryPropertiesCommand);
+  state->AddBuiltinCommand("set_source_files_properties",
+                           new cmSetSourceFilesPropertiesCommand);
+  state->AddBuiltinCommand("set_target_properties",
+                           new cmSetTargetPropertiesCommand);
+  state->AddBuiltinCommand("set_tests_properties",
+                           new cmSetTestsPropertiesCommand);
+  state->AddBuiltinCommand("subdirs", new cmSubdirCommand);
+  state->AddBuiltinCommand("target_compile_definitions",
+                           new cmTargetCompileDefinitionsCommand);
+  state->AddBuiltinCommand("target_compile_features",
+                           new cmTargetCompileFeaturesCommand);
+  state->AddBuiltinCommand("target_compile_options",
+                           new cmTargetCompileOptionsCommand);
+  state->AddBuiltinCommand("target_include_directories",
+                           new cmTargetIncludeDirectoriesCommand);
+  state->AddBuiltinCommand("target_link_libraries",
+                           new cmTargetLinkLibrariesCommand);
+  state->AddBuiltinCommand("target_sources", new cmTargetSourcesCommand);
+  state->AddBuiltinCommand("try_compile", new cmTryCompileCommand);
+  state->AddBuiltinCommand("try_run", new cmTryRunCommand);
+
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+  state->AddBuiltinCommand("add_compile_options",
+                           new cmAddCompileOptionsCommand);
+  state->AddBuiltinCommand("aux_source_directory",
+                           new cmAuxSourceDirectoryCommand);
+  state->AddBuiltinCommand("export", new cmExportCommand);
+  state->AddBuiltinCommand("fltk_wrap_ui", new cmFLTKWrapUICommand);
+  state->AddBuiltinCommand("include_external_msproject",
+                           new cmIncludeExternalMSProjectCommand);
+  state->AddBuiltinCommand("install_programs", new cmInstallProgramsCommand);
+  state->AddBuiltinCommand("link_libraries", new cmLinkLibrariesCommand);
+  state->AddBuiltinCommand("load_cache", new cmLoadCacheCommand);
+  state->AddBuiltinCommand("qt_wrap_cpp", new cmQTWrapCPPCommand);
+  state->AddBuiltinCommand("qt_wrap_ui", new cmQTWrapUICommand);
+  state->AddBuiltinCommand("remove_definitions",
+                           new cmRemoveDefinitionsCommand);
+  state->AddBuiltinCommand("source_group", new cmSourceGroupCommand);
+
+  state->AddDisallowedCommand(
+    "export_library_dependencies", new cmExportLibraryDependenciesCommand,
+    cmPolicies::CMP0033,
+    "The export_library_dependencies command should not be called; "
+    "see CMP0033.");
+  state->AddDisallowedCommand(
+    "load_command", new cmLoadCommandCommand, cmPolicies::CMP0031,
+    "The load_command command should not be called; see CMP0031.");
+  state->AddDisallowedCommand(
+    "output_required_files", new cmOutputRequiredFilesCommand,
+    cmPolicies::CMP0032,
+    "The output_required_files command should not be called; see CMP0032.");
+  state->AddDisallowedCommand(
+    "subdir_depends", new cmSubdirDependsCommand, cmPolicies::CMP0029,
+    "The subdir_depends command should not be called; see CMP0029.");
+  state->AddDisallowedCommand(
+    "utility_source", new cmUtilitySourceCommand, cmPolicies::CMP0034,
+    "The utility_source command should not be called; see CMP0034.");
+  state->AddDisallowedCommand(
+    "variable_requires", new cmVariableRequiresCommand, cmPolicies::CMP0035,
+    "The variable_requires command should not be called; see CMP0035.");
+#endif
+}
+
+void GetProjectCommandsInScriptMode(cmState* state)
+{
+#define CM_UNEXPECTED_PROJECT_COMMAND(NAME)                                   \
+  state->AddUnexpectedCommand(NAME, "command is not scriptable")
+
+  CM_UNEXPECTED_PROJECT_COMMAND("add_compile_options");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_custom_command");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_custom_target");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_definitions");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_dependencies");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_executable");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_library");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_subdirectory");
+  CM_UNEXPECTED_PROJECT_COMMAND("add_test");
+  CM_UNEXPECTED_PROJECT_COMMAND("aux_source_directory");
+  CM_UNEXPECTED_PROJECT_COMMAND("build_command");
+  CM_UNEXPECTED_PROJECT_COMMAND("create_test_sourcelist");
+  CM_UNEXPECTED_PROJECT_COMMAND("define_property");
+  CM_UNEXPECTED_PROJECT_COMMAND("enable_language");
+  CM_UNEXPECTED_PROJECT_COMMAND("enable_testing");
+  CM_UNEXPECTED_PROJECT_COMMAND("export");
+  CM_UNEXPECTED_PROJECT_COMMAND("fltk_wrap_ui");
+  CM_UNEXPECTED_PROJECT_COMMAND("get_source_file_property");
+  CM_UNEXPECTED_PROJECT_COMMAND("get_target_property");
+  CM_UNEXPECTED_PROJECT_COMMAND("get_test_property");
+  CM_UNEXPECTED_PROJECT_COMMAND("include_directories");
+  CM_UNEXPECTED_PROJECT_COMMAND("include_external_msproject");
+  CM_UNEXPECTED_PROJECT_COMMAND("include_regular_expression");
+  CM_UNEXPECTED_PROJECT_COMMAND("install");
+  CM_UNEXPECTED_PROJECT_COMMAND("link_directories");
+  CM_UNEXPECTED_PROJECT_COMMAND("link_libraries");
+  CM_UNEXPECTED_PROJECT_COMMAND("load_cache");
+  CM_UNEXPECTED_PROJECT_COMMAND("project");
+  CM_UNEXPECTED_PROJECT_COMMAND("qt_wrap_cpp");
+  CM_UNEXPECTED_PROJECT_COMMAND("qt_wrap_ui");
+  CM_UNEXPECTED_PROJECT_COMMAND("remove_definitions");
+  CM_UNEXPECTED_PROJECT_COMMAND("set_source_files_properties");
+  CM_UNEXPECTED_PROJECT_COMMAND("set_target_properties");
+  CM_UNEXPECTED_PROJECT_COMMAND("set_tests_properties");
+  CM_UNEXPECTED_PROJECT_COMMAND("source_group");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_compile_definitions");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_compile_features");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_compile_options");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_include_directories");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_link_libraries");
+  CM_UNEXPECTED_PROJECT_COMMAND("target_sources");
+  CM_UNEXPECTED_PROJECT_COMMAND("try_compile");
+  CM_UNEXPECTED_PROJECT_COMMAND("try_run");
+
+  // deprecated commands
+  CM_UNEXPECTED_PROJECT_COMMAND("export_library_dependencies");
+  CM_UNEXPECTED_PROJECT_COMMAND("load_command");
+  CM_UNEXPECTED_PROJECT_COMMAND("output_required_files");
+  CM_UNEXPECTED_PROJECT_COMMAND("subdir_depends");
+  CM_UNEXPECTED_PROJECT_COMMAND("utility_source");
+  CM_UNEXPECTED_PROJECT_COMMAND("variable_requires");
+
+#undef CM_UNEXPECTED_PROJECT_COMMAND
+}
diff --git a/Source/cmCommands.h b/Source/cmCommands.h
new file mode 100644
index 0000000..1f8fafb
--- /dev/null
+++ b/Source/cmCommands.h
@@ -0,0 +1,17 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCommands_h
+#define cmCommands_h
+
+class cmState;
+
+/**
+ * Global function to register all compiled in commands.
+ * To add a new command edit cmCommands.cxx and add your command.
+ * It is up to the caller to delete the commands created by this call.
+ */
+void GetScriptingCommands(cmState* state);
+void GetProjectCommands(cmState* state);
+void GetProjectCommandsInScriptMode(cmState* state);
+
+#endif
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
new file mode 100644
index 0000000..1189606
--- /dev/null
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -0,0 +1,237 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCommonTargetGenerator.h"
+
+#include <set>
+#include <sstream>
+#include <utility>
+
+#include "cmAlgorithms.h"
+#include "cmComputeLinkInformation.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalCommonGenerator.h"
+#include "cmLinkLineComputer.h"
+#include "cmLocalCommonGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmSourceFile.h"
+#include "cmStateTypes.h"
+
+cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt)
+  : GeneratorTarget(gt)
+  , Makefile(gt->Makefile)
+  , LocalCommonGenerator(
+      static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator))
+  , GlobalCommonGenerator(static_cast<cmGlobalCommonGenerator*>(
+      gt->LocalGenerator->GetGlobalGenerator()))
+  , ConfigName(LocalCommonGenerator->GetConfigName())
+{
+}
+
+cmCommonTargetGenerator::~cmCommonTargetGenerator()
+{
+}
+
+std::string const& cmCommonTargetGenerator::GetConfigName() const
+{
+  return this->ConfigName;
+}
+
+const char* cmCommonTargetGenerator::GetFeature(const std::string& feature)
+{
+  return this->GeneratorTarget->GetFeature(feature, this->ConfigName);
+}
+
+void cmCommonTargetGenerator::AddModuleDefinitionFlag(
+  cmLinkLineComputer* linkLineComputer, std::string& flags)
+{
+  cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
+    this->GeneratorTarget->GetModuleDefinitionInfo(this->GetConfigName());
+  if (!mdi || mdi->DefFile.empty()) {
+    return;
+  }
+
+  // TODO: Create a per-language flag variable.
+  const char* defFileFlag =
+    this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
+  if (!defFileFlag) {
+    return;
+  }
+
+  // Append the flag and value.  Use ConvertToLinkReference to help
+  // vs6's "cl -link" pass it to the linker.
+  std::string flag = defFileFlag;
+  flag += this->LocalCommonGenerator->ConvertToOutputFormat(
+    linkLineComputer->ConvertToLinkReference(mdi->DefFile),
+    cmOutputConverter::SHELL);
+  this->LocalCommonGenerator->AppendFlags(flags, flag);
+}
+
+void cmCommonTargetGenerator::AppendFortranFormatFlags(
+  std::string& flags, cmSourceFile const& source)
+{
+  const char* srcfmt = source.GetProperty("Fortran_FORMAT");
+  cmOutputConverter::FortranFormat format =
+    cmOutputConverter::GetFortranFormat(srcfmt);
+  if (format == cmOutputConverter::FortranFormatNone) {
+    const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT");
+    format = cmOutputConverter::GetFortranFormat(tgtfmt);
+  }
+  const char* var = nullptr;
+  switch (format) {
+    case cmOutputConverter::FortranFormatFixed:
+      var = "CMAKE_Fortran_FORMAT_FIXED_FLAG";
+      break;
+    case cmOutputConverter::FortranFormatFree:
+      var = "CMAKE_Fortran_FORMAT_FREE_FLAG";
+      break;
+    default:
+      break;
+  }
+  if (var) {
+    this->LocalCommonGenerator->AppendFlags(
+      flags, this->Makefile->GetDefinition(var));
+  }
+}
+
+std::string cmCommonTargetGenerator::GetFlags(const std::string& l)
+{
+  ByLanguageMap::iterator i = this->FlagsByLanguage.find(l);
+  if (i == this->FlagsByLanguage.end()) {
+    std::string flags;
+
+    this->LocalCommonGenerator->GetTargetCompileFlags(
+      this->GeneratorTarget, this->ConfigName, l, flags);
+
+    ByLanguageMap::value_type entry(l, flags);
+    i = this->FlagsByLanguage.insert(entry).first;
+  }
+  return i->second;
+}
+
+std::string cmCommonTargetGenerator::GetDefines(const std::string& l)
+{
+  ByLanguageMap::iterator i = this->DefinesByLanguage.find(l);
+  if (i == this->DefinesByLanguage.end()) {
+    std::set<std::string> defines;
+    this->LocalCommonGenerator->GetTargetDefines(this->GeneratorTarget,
+                                                 this->ConfigName, l, defines);
+
+    std::string definesString;
+    this->LocalCommonGenerator->JoinDefines(defines, definesString, l);
+
+    ByLanguageMap::value_type entry(l, definesString);
+    i = this->DefinesByLanguage.insert(entry).first;
+  }
+  return i->second;
+}
+
+std::string cmCommonTargetGenerator::GetIncludes(std::string const& l)
+{
+  ByLanguageMap::iterator i = this->IncludesByLanguage.find(l);
+  if (i == this->IncludesByLanguage.end()) {
+    std::string includes;
+    this->AddIncludeFlags(includes, l);
+    ByLanguageMap::value_type entry(l, includes);
+    i = this->IncludesByLanguage.insert(entry).first;
+  }
+  return i->second;
+}
+
+std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories()
+  const
+{
+  std::vector<std::string> dirs;
+  std::set<cmGeneratorTarget const*> emitted;
+  if (cmComputeLinkInformation* cli =
+        this->GeneratorTarget->GetLinkInformation(this->ConfigName)) {
+    cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
+    for (auto const& item : items) {
+      cmGeneratorTarget const* linkee = item.Target;
+      if (linkee && !linkee->IsImported()
+          // We can ignore the INTERFACE_LIBRARY items because
+          // Target->GetLinkInformation already processed their
+          // link interface and they don't have any output themselves.
+          && linkee->GetType() != cmStateEnums::INTERFACE_LIBRARY &&
+          emitted.insert(linkee).second) {
+        cmLocalGenerator* lg = linkee->GetLocalGenerator();
+        std::string di = lg->GetCurrentBinaryDirectory();
+        di += "/";
+        di += lg->GetTargetDirectory(linkee);
+        dirs.push_back(di);
+      }
+    }
+  }
+  return dirs;
+}
+
+std::string cmCommonTargetGenerator::ComputeTargetCompilePDB() const
+{
+  std::string compilePdbPath;
+  if (this->GeneratorTarget->GetType() > cmStateEnums::OBJECT_LIBRARY) {
+    return compilePdbPath;
+  }
+  compilePdbPath =
+    this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
+  if (compilePdbPath.empty()) {
+    // Match VS default: `$(IntDir)vc$(PlatformToolsetVersion).pdb`.
+    // A trailing slash tells the toolchain to add its default file name.
+    compilePdbPath = this->GeneratorTarget->GetSupportDirectory() + "/";
+    if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY) {
+      // Match VS default for static libs: `$(IntDir)$(ProjectName).pdb`.
+      compilePdbPath += this->GeneratorTarget->GetName();
+      compilePdbPath += ".pdb";
+    }
+  }
+
+  return compilePdbPath;
+}
+
+std::string cmCommonTargetGenerator::GetManifests()
+{
+  std::vector<cmSourceFile const*> manifest_srcs;
+  this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
+
+  std::vector<std::string> manifests;
+  manifests.reserve(manifest_srcs.size());
+  for (cmSourceFile const* manifest_src : manifest_srcs) {
+    manifests.push_back(this->LocalCommonGenerator->ConvertToOutputFormat(
+      this->LocalCommonGenerator->ConvertToRelativePath(
+        this->LocalCommonGenerator->GetWorkingDirectory(),
+        manifest_src->GetFullPath()),
+      cmOutputConverter::SHELL));
+  }
+
+  return cmJoin(manifests, " ");
+}
+
+void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
+                                               const std::string& lang,
+                                               const char* name, bool so)
+{
+  // Lookup the flag to specify the version.
+  std::string fvar = "CMAKE_";
+  fvar += lang;
+  fvar += "_OSX_";
+  fvar += name;
+  fvar += "_VERSION_FLAG";
+  const char* flag = this->Makefile->GetDefinition(fvar);
+
+  // Skip if no such flag.
+  if (!flag) {
+    return;
+  }
+
+  // Lookup the target version information.
+  int major;
+  int minor;
+  int patch;
+  this->GeneratorTarget->GetTargetVersion(so, major, minor, patch);
+  if (major > 0 || minor > 0 || patch > 0) {
+    // Append the flag since a non-zero version is specified.
+    std::ostringstream vflag;
+    vflag << flag << major << "." << minor << "." << patch;
+    this->LocalCommonGenerator->AppendFlags(flags, vflag.str());
+  }
+}
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
new file mode 100644
index 0000000..6b0f74e
--- /dev/null
+++ b/Source/cmCommonTargetGenerator.h
@@ -0,0 +1,66 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCommonTargetGenerator_h
+#define cmCommonTargetGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <map>
+#include <string>
+#include <vector>
+
+class cmGeneratorTarget;
+class cmGlobalCommonGenerator;
+class cmLinkLineComputer;
+class cmLocalCommonGenerator;
+class cmMakefile;
+class cmSourceFile;
+
+/** \class cmCommonTargetGenerator
+ * \brief Common infrastructure for Makefile and Ninja per-target generators
+ */
+class cmCommonTargetGenerator
+{
+public:
+  cmCommonTargetGenerator(cmGeneratorTarget* gt);
+  virtual ~cmCommonTargetGenerator();
+
+  std::string const& GetConfigName() const;
+
+protected:
+  // Feature query methods.
+  const char* GetFeature(const std::string& feature);
+
+  // Helper to add flag for windows .def file.
+  void AddModuleDefinitionFlag(cmLinkLineComputer* linkLineComputer,
+                               std::string& flags);
+
+  cmGeneratorTarget* GeneratorTarget;
+  cmMakefile* Makefile;
+  cmLocalCommonGenerator* LocalCommonGenerator;
+  cmGlobalCommonGenerator* GlobalCommonGenerator;
+  std::string ConfigName;
+
+  void AppendFortranFormatFlags(std::string& flags,
+                                cmSourceFile const& source);
+
+  virtual void AddIncludeFlags(std::string& flags,
+                               std::string const& lang) = 0;
+
+  void AppendOSXVerFlag(std::string& flags, const std::string& lang,
+                        const char* name, bool so);
+
+  typedef std::map<std::string, std::string> ByLanguageMap;
+  std::string GetFlags(const std::string& l);
+  ByLanguageMap FlagsByLanguage;
+  std::string GetDefines(const std::string& l);
+  ByLanguageMap DefinesByLanguage;
+  std::string GetIncludes(std::string const& l);
+  ByLanguageMap IncludesByLanguage;
+  std::string GetManifests();
+
+  std::vector<std::string> GetLinkedTargetDirectories() const;
+  std::string ComputeTargetCompilePDB() const;
+};
+
+#endif
diff --git a/Source/cmComputeComponentGraph.cxx b/Source/cmComputeComponentGraph.cxx
new file mode 100644
index 0000000..9ec98ae
--- /dev/null
+++ b/Source/cmComputeComponentGraph.cxx
@@ -0,0 +1,133 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmComputeComponentGraph.h"
+
+#include <algorithm>
+
+#include <assert.h>
+
+cmComputeComponentGraph::cmComputeComponentGraph(Graph const& input)
+  : InputGraph(input)
+{
+  // Identify components.
+  this->Tarjan();
+
+  // Compute the component graph.
+  this->ComponentGraph.resize(0);
+  this->ComponentGraph.resize(this->Components.size());
+  this->TransferEdges();
+}
+
+cmComputeComponentGraph::~cmComputeComponentGraph()
+{
+}
+
+void cmComputeComponentGraph::Tarjan()
+{
+  int n = static_cast<int>(this->InputGraph.size());
+  TarjanEntry entry = { 0, 0 };
+  this->TarjanEntries.resize(0);
+  this->TarjanEntries.resize(n, entry);
+  this->TarjanComponents.resize(0);
+  this->TarjanComponents.resize(n, -1);
+  this->TarjanWalkId = 0;
+  this->TarjanVisited.resize(0);
+  this->TarjanVisited.resize(n, 0);
+  for (int i = 0; i < n; ++i) {
+    // Start a new DFS from this node if it has never been visited.
+    if (!this->TarjanVisited[i]) {
+      assert(this->TarjanStack.empty());
+      ++this->TarjanWalkId;
+      this->TarjanIndex = 0;
+      this->TarjanVisit(i);
+    }
+  }
+}
+
+void cmComputeComponentGraph::TarjanVisit(int i)
+{
+  // We are now visiting this node.
+  this->TarjanVisited[i] = this->TarjanWalkId;
+
+  // Initialize the entry.
+  this->TarjanEntries[i].Root = i;
+  this->TarjanComponents[i] = -1;
+  this->TarjanEntries[i].VisitIndex = ++this->TarjanIndex;
+  this->TarjanStack.push(i);
+
+  // Follow outgoing edges.
+  EdgeList const& nl = this->InputGraph[i];
+  for (cmGraphEdge const& ni : nl) {
+    int j = ni;
+
+    // Ignore edges to nodes that have been reached by a previous DFS
+    // walk.  Since we did not reach the current node from that walk
+    // it must not belong to the same component and it has already
+    // been assigned to a component.
+    if (this->TarjanVisited[j] > 0 &&
+        this->TarjanVisited[j] < this->TarjanWalkId) {
+      continue;
+    }
+
+    // Visit the destination if it has not yet been visited.
+    if (!this->TarjanVisited[j]) {
+      this->TarjanVisit(j);
+    }
+
+    // If the destination has not yet been assigned to a component,
+    // check if it has a better root for the current object.
+    if (this->TarjanComponents[j] < 0) {
+      if (this->TarjanEntries[this->TarjanEntries[j].Root].VisitIndex <
+          this->TarjanEntries[this->TarjanEntries[i].Root].VisitIndex) {
+        this->TarjanEntries[i].Root = this->TarjanEntries[j].Root;
+      }
+    }
+  }
+
+  // Check if we have found a component.
+  if (this->TarjanEntries[i].Root == i) {
+    // Yes.  Create it.
+    int c = static_cast<int>(this->Components.size());
+    this->Components.push_back(NodeList());
+    NodeList& component = this->Components[c];
+
+    // Populate the component list.
+    int j;
+    do {
+      // Get the next member of the component.
+      j = this->TarjanStack.top();
+      this->TarjanStack.pop();
+
+      // Assign the member to the component.
+      this->TarjanComponents[j] = c;
+      this->TarjanEntries[j].Root = i;
+
+      // Store the node in its component.
+      component.push_back(j);
+    } while (j != i);
+
+    // Sort the component members for clarity.
+    std::sort(component.begin(), component.end());
+  }
+}
+
+void cmComputeComponentGraph::TransferEdges()
+{
+  // Map inter-component edges in the original graph to edges in the
+  // component graph.
+  int n = static_cast<int>(this->InputGraph.size());
+  for (int i = 0; i < n; ++i) {
+    int i_component = this->TarjanComponents[i];
+    EdgeList const& nl = this->InputGraph[i];
+    for (cmGraphEdge const& ni : nl) {
+      int j = ni;
+      int j_component = this->TarjanComponents[j];
+      if (i_component != j_component) {
+        // We do not attempt to combine duplicate edges, but instead
+        // store the inter-component edges with suitable multiplicity.
+        this->ComponentGraph[i_component].push_back(
+          cmGraphEdge(j_component, ni.IsStrong()));
+      }
+    }
+  }
+}
diff --git a/Source/cmComputeComponentGraph.h b/Source/cmComputeComponentGraph.h
new file mode 100644
index 0000000..8cd4fe7
--- /dev/null
+++ b/Source/cmComputeComponentGraph.h
@@ -0,0 +1,79 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmComputeComponentGraph_h
+#define cmComputeComponentGraph_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmGraphAdjacencyList.h"
+
+#include <stack>
+#include <vector>
+
+/** \class cmComputeComponentGraph
+ * \brief Analyze a graph to determine strongly connected components.
+ *
+ * Convert a directed graph into a directed acyclic graph whose nodes
+ * correspond to strongly connected components of the original graph.
+ *
+ * We use Tarjan's algorithm to enumerate the components efficiently.
+ * An advantage of this approach is that the components are identified
+ * in a topologically sorted order.
+ */
+class cmComputeComponentGraph
+{
+public:
+  // Represent the graph with an adjacency list.
+  typedef cmGraphNodeList NodeList;
+  typedef cmGraphEdgeList EdgeList;
+  typedef cmGraphAdjacencyList Graph;
+
+  cmComputeComponentGraph(Graph const& input);
+  ~cmComputeComponentGraph();
+
+  /** Get the adjacency list of the component graph.  */
+  Graph const& GetComponentGraph() const { return this->ComponentGraph; }
+  EdgeList const& GetComponentGraphEdges(int c) const
+  {
+    return this->ComponentGraph[c];
+  }
+
+  /** Get map from component index to original node indices.  */
+  std::vector<NodeList> const& GetComponents() const
+  {
+    return this->Components;
+  }
+  NodeList const& GetComponent(int c) const { return this->Components[c]; }
+
+  /** Get map from original node index to component index.  */
+  std::vector<int> const& GetComponentMap() const
+  {
+    return this->TarjanComponents;
+  }
+
+private:
+  void TransferEdges();
+
+  Graph const& InputGraph;
+  Graph ComponentGraph;
+
+  // Tarjan's algorithm.
+  struct TarjanEntry
+  {
+    int Root;
+    int VisitIndex;
+  };
+  std::vector<int> TarjanVisited;
+  std::vector<int> TarjanComponents;
+  std::vector<TarjanEntry> TarjanEntries;
+  std::vector<NodeList> Components;
+  std::stack<int> TarjanStack;
+  int TarjanWalkId;
+  int TarjanIndex;
+  void Tarjan();
+  void TarjanVisit(int i);
+
+  // Connected components.
+};
+
+#endif
diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
new file mode 100644
index 0000000..d9efc2e
--- /dev/null
+++ b/Source/cmComputeLinkDepends.cxx
@@ -0,0 +1,846 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmComputeLinkDepends.h"
+
+#include "cmAlgorithms.h"
+#include "cmComputeComponentGraph.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+#include <algorithm>
+#include <assert.h>
+#include <iterator>
+#include <sstream>
+#include <stdio.h>
+#include <string.h>
+#include <utility>
+
+/*
+
+This file computes an ordered list of link items to use when linking a
+single target in one configuration.  Each link item is identified by
+the string naming it.  A graph of dependencies is created in which
+each node corresponds to one item and directed edges lead from nodes to
+those which must *follow* them on the link line.  For example, the
+graph
+
+  A -> B -> C
+
+will lead to the link line order
+
+  A B C
+
+The set of items placed in the graph is formed with a breadth-first
+search of the link dependencies starting from the main target.
+
+There are two types of items: those with known direct dependencies and
+those without known dependencies.  We will call the two types "known
+items" and "unknown items", respectively.  Known items are those whose
+names correspond to targets (built or imported) and those for which an
+old-style <item>_LIB_DEPENDS variable is defined.  All other items are
+unknown and we must infer dependencies for them.  For items that look
+like flags (beginning with '-') we trivially infer no dependencies,
+and do not include them in the dependencies of other items.
+
+Known items have dependency lists ordered based on how the user
+specified them.  We can use this order to infer potential dependencies
+of unknown items.  For example, if link items A and B are unknown and
+items X and Y are known, then we might have the following dependency
+lists:
+
+  X: Y A B
+  Y: A B
+
+The explicitly known dependencies form graph edges
+
+  X -> Y  ,  X -> A  ,  X -> B  ,  Y -> A  ,  Y -> B
+
+We can also infer the edge
+
+  A -> B
+
+because *every* time A appears B is seen on its right.  We do not know
+whether A really needs symbols from B to link, but it *might* so we
+must preserve their order.  This is the case also for the following
+explicit lists:
+
+  X: A B Y
+  Y: A B
+
+Here, A is followed by the set {B,Y} in one list, and {B} in the other
+list.  The intersection of these sets is {B}, so we can infer that A
+depends on at most B.  Meanwhile B is followed by the set {Y} in one
+list and {} in the other.  The intersection is {} so we can infer that
+B has no dependencies.
+
+Let's make a more complex example by adding unknown item C and
+considering these dependency lists:
+
+  X: A B Y C
+  Y: A C B
+
+The explicit edges are
+
+  X -> Y  ,  X -> A  ,  X -> B  ,  X -> C  ,  Y -> A  ,  Y -> B  ,  Y -> C
+
+For the unknown items, we infer dependencies by looking at the
+"follow" sets:
+
+  A: intersect( {B,Y,C} , {C,B} ) = {B,C} ; infer edges  A -> B  ,  A -> C
+  B: intersect( {Y,C}   , {}    ) = {}    ; infer no edges
+  C: intersect( {}      , {B}   ) = {}    ; infer no edges
+
+Note that targets are never inferred as dependees because outside
+libraries should not depend on them.
+
+------------------------------------------------------------------------------
+
+The initial exploration of dependencies using a BFS associates an
+integer index with each link item.  When the graph is built outgoing
+edges are sorted by this index.
+
+After the initial exploration of the link interface tree, any
+transitive (dependent) shared libraries that were encountered and not
+included in the interface are processed in their own BFS.  This BFS
+follows only the dependent library lists and not the link interfaces.
+They are added to the link items with a mark indicating that the are
+transitive dependencies.  Then cmComputeLinkInformation deals with
+them on a per-platform basis.
+
+The complete graph formed from all known and inferred dependencies may
+not be acyclic, so an acyclic version must be created.
+The original graph is converted to a directed acyclic graph in which
+each node corresponds to a strongly connected component of the
+original graph.  For example, the dependency graph
+
+  X -> A -> B -> C -> A -> Y
+
+contains strongly connected components {X}, {A,B,C}, and {Y}.  The
+implied directed acyclic graph (DAG) is
+
+  {X} -> {A,B,C} -> {Y}
+
+We then compute a topological order for the DAG nodes to serve as a
+reference for satisfying dependencies efficiently.  We perform the DFS
+in reverse order and assign topological order indices counting down so
+that the result is as close to the original BFS order as possible
+without violating dependencies.
+
+------------------------------------------------------------------------------
+
+The final link entry order is constructed as follows.  We first walk
+through and emit the *original* link line as specified by the user.
+As each item is emitted, a set of pending nodes in the component DAG
+is maintained.  When a pending component has been completely seen, it
+is removed from the pending set and its dependencies (following edges
+of the DAG) are added.  A trivial component (those with one item) is
+complete as soon as its item is seen.  A non-trivial component (one
+with more than one item; assumed to be static libraries) is complete
+when *all* its entries have been seen *twice* (all entries seen once,
+then all entries seen again, not just each entry twice).  A pending
+component tracks which items have been seen and a count of how many
+times the component needs to be seen (once for trivial components,
+twice for non-trivial).  If at any time another component finishes and
+re-adds an already pending component, the pending component is reset
+so that it needs to be seen in its entirety again.  This ensures that
+all dependencies of a component are satisfied no matter where it
+appears.
+
+After the original link line has been completed, we append to it the
+remaining pending components and their dependencies.  This is done by
+repeatedly emitting the first item from the first pending component
+and following the same update rules as when traversing the original
+link line.  Since the pending components are kept in topological order
+they are emitted with minimal repeats (we do not want to emit a
+component just to have it added again when another component is
+completed later).  This process continues until no pending components
+remain.  We know it will terminate because the component graph is
+guaranteed to be acyclic.
+
+The final list of items produced by this procedure consists of the
+original user link line followed by minimal additional items needed to
+satisfy dependencies.  The final list is then filtered to de-duplicate
+items that we know the linker will re-use automatically (shared libs).
+
+*/
+
+cmComputeLinkDepends::cmComputeLinkDepends(const cmGeneratorTarget* target,
+                                           const std::string& config)
+{
+  // Store context information.
+  this->Target = target;
+  this->Makefile = this->Target->Target->GetMakefile();
+  this->GlobalGenerator =
+    this->Target->GetLocalGenerator()->GetGlobalGenerator();
+  this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
+
+  // The configuration being linked.
+  this->HasConfig = !config.empty();
+  this->Config = (this->HasConfig) ? config : std::string();
+  std::vector<std::string> debugConfigs =
+    this->Makefile->GetCMakeInstance()->GetDebugConfigs();
+  this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs);
+
+  // Enable debug mode if requested.
+  this->DebugMode = this->Makefile->IsOn("CMAKE_LINK_DEPENDS_DEBUG_MODE");
+
+  // Assume no compatibility until set.
+  this->OldLinkDirMode = false;
+
+  // No computation has been done.
+  this->CCG = nullptr;
+}
+
+cmComputeLinkDepends::~cmComputeLinkDepends()
+{
+  cmDeleteAll(this->InferredDependSets);
+  delete this->CCG;
+}
+
+void cmComputeLinkDepends::SetOldLinkDirMode(bool b)
+{
+  this->OldLinkDirMode = b;
+}
+
+std::vector<cmComputeLinkDepends::LinkEntry> const&
+cmComputeLinkDepends::Compute()
+{
+  // Follow the link dependencies of the target to be linked.
+  this->AddDirectLinkEntries();
+
+  // Complete the breadth-first search of dependencies.
+  while (!this->BFSQueue.empty()) {
+    // Get the next entry.
+    BFSEntry qe = this->BFSQueue.front();
+    this->BFSQueue.pop();
+
+    // Follow the entry's dependencies.
+    this->FollowLinkEntry(qe);
+  }
+
+  // Complete the search of shared library dependencies.
+  while (!this->SharedDepQueue.empty()) {
+    // Handle the next entry.
+    this->HandleSharedDependency(this->SharedDepQueue.front());
+    this->SharedDepQueue.pop();
+  }
+
+  // Infer dependencies of targets for which they were not known.
+  this->InferDependencies();
+
+  // Cleanup the constraint graph.
+  this->CleanConstraintGraph();
+
+  // Display the constraint graph.
+  if (this->DebugMode) {
+    fprintf(stderr, "---------------------------------------"
+                    "---------------------------------------\n");
+    fprintf(stderr, "Link dependency analysis for target %s, config %s\n",
+            this->Target->GetName().c_str(),
+            this->HasConfig ? this->Config.c_str() : "noconfig");
+    this->DisplayConstraintGraph();
+  }
+
+  // Compute the final ordering.
+  this->OrderLinkEntires();
+
+  // Compute the final set of link entries.
+  // Iterate in reverse order so we can keep only the last occurrence
+  // of a shared library.
+  std::set<int> emmitted;
+  for (std::vector<int>::const_reverse_iterator
+         li = this->FinalLinkOrder.rbegin(),
+         le = this->FinalLinkOrder.rend();
+       li != le; ++li) {
+    int i = *li;
+    LinkEntry const& e = this->EntryList[i];
+    cmGeneratorTarget const* t = e.Target;
+    // Entries that we know the linker will re-use do not need to be repeated.
+    bool uniquify = t && t->GetType() == cmStateEnums::SHARED_LIBRARY;
+    if (!uniquify || emmitted.insert(i).second) {
+      this->FinalLinkEntries.push_back(e);
+    }
+  }
+  // Reverse the resulting order since we iterated in reverse.
+  std::reverse(this->FinalLinkEntries.begin(), this->FinalLinkEntries.end());
+
+  // Display the final set.
+  if (this->DebugMode) {
+    this->DisplayFinalEntries();
+  }
+
+  return this->FinalLinkEntries;
+}
+
+std::map<std::string, int>::iterator cmComputeLinkDepends::AllocateLinkEntry(
+  std::string const& item)
+{
+  std::map<std::string, int>::value_type index_entry(
+    item, static_cast<int>(this->EntryList.size()));
+  std::map<std::string, int>::iterator lei =
+    this->LinkEntryIndex.insert(index_entry).first;
+  this->EntryList.push_back(LinkEntry());
+  this->InferredDependSets.push_back(nullptr);
+  this->EntryConstraintGraph.push_back(EdgeList());
+  return lei;
+}
+
+int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
+{
+  // Check if the item entry has already been added.
+  std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item);
+  if (lei != this->LinkEntryIndex.end()) {
+    // Yes.  We do not need to follow the item's dependencies again.
+    return lei->second;
+  }
+
+  // Allocate a spot for the item entry.
+  lei = this->AllocateLinkEntry(item);
+
+  // Initialize the item entry.
+  int index = lei->second;
+  LinkEntry& entry = this->EntryList[index];
+  entry.Item = item;
+  entry.Target = item.Target;
+  entry.IsFlag = (!entry.Target && item[0] == '-' && item[1] != 'l' &&
+                  item.substr(0, 10) != "-framework");
+
+  // If the item has dependencies queue it to follow them.
+  if (entry.Target) {
+    // Target dependencies are always known.  Follow them.
+    BFSEntry qe = { index, nullptr };
+    this->BFSQueue.push(qe);
+  } else {
+    // Look for an old-style <item>_LIB_DEPENDS variable.
+    std::string var = entry.Item;
+    var += "_LIB_DEPENDS";
+    if (const char* val = this->Makefile->GetDefinition(var)) {
+      // The item dependencies are known.  Follow them.
+      BFSEntry qe = { index, val };
+      this->BFSQueue.push(qe);
+    } else if (!entry.IsFlag) {
+      // The item dependencies are not known.  We need to infer them.
+      this->InferredDependSets[index] = new DependSetList;
+    }
+  }
+
+  return index;
+}
+
+void cmComputeLinkDepends::FollowLinkEntry(BFSEntry qe)
+{
+  // Get this entry representation.
+  int depender_index = qe.Index;
+  LinkEntry const& entry = this->EntryList[depender_index];
+
+  // Follow the item's dependencies.
+  if (entry.Target) {
+    // Follow the target dependencies.
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
+      const bool isIface =
+        entry.Target->GetType() == cmStateEnums::INTERFACE_LIBRARY;
+      // This target provides its own link interface information.
+      this->AddLinkEntries(depender_index, iface->Libraries);
+
+      if (isIface) {
+        return;
+      }
+
+      // Handle dependent shared libraries.
+      this->FollowSharedDeps(depender_index, iface);
+
+      // Support for CMP0003.
+      for (cmLinkItem const& oi : iface->WrongConfigLibraries) {
+        this->CheckWrongConfigItem(oi);
+      }
+    }
+  } else {
+    // Follow the old-style dependency list.
+    this->AddVarLinkEntries(depender_index, qe.LibDepends);
+  }
+}
+
+void cmComputeLinkDepends::FollowSharedDeps(int depender_index,
+                                            cmLinkInterface const* iface,
+                                            bool follow_interface)
+{
+  // Follow dependencies if we have not followed them already.
+  if (this->SharedDepFollowed.insert(depender_index).second) {
+    if (follow_interface) {
+      this->QueueSharedDependencies(depender_index, iface->Libraries);
+    }
+    this->QueueSharedDependencies(depender_index, iface->SharedDeps);
+  }
+}
+
+void cmComputeLinkDepends::QueueSharedDependencies(
+  int depender_index, std::vector<cmLinkItem> const& deps)
+{
+  for (cmLinkItem const& li : deps) {
+    SharedDepEntry qe;
+    qe.Item = li;
+    qe.DependerIndex = depender_index;
+    this->SharedDepQueue.push(qe);
+  }
+}
+
+void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
+{
+  // Check if the target already has an entry.
+  std::map<std::string, int>::iterator lei =
+    this->LinkEntryIndex.find(dep.Item);
+  if (lei == this->LinkEntryIndex.end()) {
+    // Allocate a spot for the item entry.
+    lei = this->AllocateLinkEntry(dep.Item);
+
+    // Initialize the item entry.
+    LinkEntry& entry = this->EntryList[lei->second];
+    entry.Item = dep.Item;
+    entry.Target = dep.Item.Target;
+
+    // This item was added specifically because it is a dependent
+    // shared library.  It may get special treatment
+    // in cmComputeLinkInformation.
+    entry.IsSharedDep = true;
+  }
+
+  // Get the link entry for this target.
+  int index = lei->second;
+  LinkEntry& entry = this->EntryList[index];
+
+  // This shared library dependency must follow the item that listed
+  // it.
+  this->EntryConstraintGraph[dep.DependerIndex].push_back(index);
+
+  // Target items may have their own dependencies.
+  if (entry.Target) {
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
+      // Follow public and private dependencies transitively.
+      this->FollowSharedDeps(index, iface, true);
+    }
+  }
+}
+
+void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
+                                             const char* value)
+{
+  // This is called to add the dependencies named by
+  // <item>_LIB_DEPENDS.  The variable contains a semicolon-separated
+  // list.  The list contains link-type;item pairs and just items.
+  std::vector<std::string> deplist;
+  cmSystemTools::ExpandListArgument(value, deplist);
+
+  // Look for entries meant for this configuration.
+  std::vector<cmLinkItem> actual_libs;
+  cmTargetLinkLibraryType llt = GENERAL_LibraryType;
+  bool haveLLT = false;
+  for (std::string const& d : deplist) {
+    if (d == "debug") {
+      llt = DEBUG_LibraryType;
+      haveLLT = true;
+    } else if (d == "optimized") {
+      llt = OPTIMIZED_LibraryType;
+      haveLLT = true;
+    } else if (d == "general") {
+      llt = GENERAL_LibraryType;
+      haveLLT = true;
+    } else if (!d.empty()) {
+      // If no explicit link type was given prior to this entry then
+      // check if the entry has its own link type variable.  This is
+      // needed for compatibility with dependency files generated by
+      // the export_library_dependencies command from CMake 2.4 and
+      // lower.
+      if (!haveLLT) {
+        std::string var = d;
+        var += "_LINK_TYPE";
+        if (const char* val = this->Makefile->GetDefinition(var)) {
+          if (strcmp(val, "debug") == 0) {
+            llt = DEBUG_LibraryType;
+          } else if (strcmp(val, "optimized") == 0) {
+            llt = OPTIMIZED_LibraryType;
+          }
+        }
+      }
+
+      // If the library is meant for this link type then use it.
+      if (llt == GENERAL_LibraryType || llt == this->LinkType) {
+        cmLinkItem item(d, this->FindTargetToLink(depender_index, d));
+        actual_libs.push_back(item);
+      } else if (this->OldLinkDirMode) {
+        cmLinkItem item(d, this->FindTargetToLink(depender_index, d));
+        this->CheckWrongConfigItem(item);
+      }
+
+      // Reset the link type until another explicit type is given.
+      llt = GENERAL_LibraryType;
+      haveLLT = false;
+    }
+  }
+
+  // Add the entries from this list.
+  this->AddLinkEntries(depender_index, actual_libs);
+}
+
+void cmComputeLinkDepends::AddDirectLinkEntries()
+{
+  // Add direct link dependencies in this configuration.
+  cmLinkImplementation const* impl =
+    this->Target->GetLinkImplementation(this->Config);
+  this->AddLinkEntries(-1, impl->Libraries);
+  for (cmLinkItem const& wi : impl->WrongConfigLibraries) {
+    this->CheckWrongConfigItem(wi);
+  }
+}
+
+template <typename T>
+void cmComputeLinkDepends::AddLinkEntries(int depender_index,
+                                          std::vector<T> const& libs)
+{
+  // Track inferred dependency sets implied by this list.
+  std::map<int, DependSet> dependSets;
+
+  // Loop over the libraries linked directly by the depender.
+  for (T const& l : libs) {
+    // Skip entries that will resolve to the target getting linked or
+    // are empty.
+    cmLinkItem const& item = l;
+    if (item == this->Target->GetName() || item.empty()) {
+      continue;
+    }
+
+    // Add a link entry for this item.
+    int dependee_index = this->AddLinkEntry(l);
+
+    // The dependee must come after the depender.
+    if (depender_index >= 0) {
+      this->EntryConstraintGraph[depender_index].push_back(dependee_index);
+    } else {
+      // This is a direct dependency of the target being linked.
+      this->OriginalEntries.push_back(dependee_index);
+    }
+
+    // Update the inferred dependencies for earlier items.
+    for (auto& dependSet : dependSets) {
+      // Add this item to the inferred dependencies of other items.
+      // Target items are never inferred dependees because unknown
+      // items are outside libraries that should not be depending on
+      // targets.
+      if (!this->EntryList[dependee_index].Target &&
+          !this->EntryList[dependee_index].IsFlag &&
+          dependee_index != dependSet.first) {
+        dependSet.second.insert(dependee_index);
+      }
+    }
+
+    // If this item needs to have dependencies inferred, do so.
+    if (this->InferredDependSets[dependee_index]) {
+      // Make sure an entry exists to hold the set for the item.
+      dependSets[dependee_index];
+    }
+  }
+
+  // Store the inferred dependency sets discovered for this list.
+  for (auto const& dependSet : dependSets) {
+    this->InferredDependSets[dependSet.first]->push_back(dependSet.second);
+  }
+}
+
+cmGeneratorTarget const* cmComputeLinkDepends::FindTargetToLink(
+  int depender_index, const std::string& name)
+{
+  // Look for a target in the scope of the depender.
+  cmGeneratorTarget const* from = this->Target;
+  if (depender_index >= 0) {
+    if (cmGeneratorTarget const* depender =
+          this->EntryList[depender_index].Target) {
+      from = depender;
+    }
+  }
+  return from->FindTargetToLink(name);
+}
+
+void cmComputeLinkDepends::InferDependencies()
+{
+  // The inferred dependency sets for each item list the possible
+  // dependencies.  The intersection of the sets for one item form its
+  // inferred dependencies.
+  for (unsigned int depender_index = 0;
+       depender_index < this->InferredDependSets.size(); ++depender_index) {
+    // Skip items for which dependencies do not need to be inferred or
+    // for which the inferred dependency sets are empty.
+    DependSetList* sets = this->InferredDependSets[depender_index];
+    if (!sets || sets->empty()) {
+      continue;
+    }
+
+    // Intersect the sets for this item.
+    DependSetList::const_iterator i = sets->begin();
+    DependSet common = *i;
+    for (++i; i != sets->end(); ++i) {
+      DependSet intersection;
+      std::set_intersection(common.begin(), common.end(), i->begin(), i->end(),
+                            std::inserter(intersection, intersection.begin()));
+      common = intersection;
+    }
+
+    // Add the inferred dependencies to the graph.
+    cmGraphEdgeList& edges = this->EntryConstraintGraph[depender_index];
+    edges.insert(edges.end(), common.begin(), common.end());
+  }
+}
+
+void cmComputeLinkDepends::CleanConstraintGraph()
+{
+  for (cmGraphEdgeList& edgeList : this->EntryConstraintGraph) {
+    // Sort the outgoing edges for each graph node so that the
+    // original order will be preserved as much as possible.
+    std::sort(edgeList.begin(), edgeList.end());
+
+    // Make the edge list unique.
+    edgeList.erase(std::unique(edgeList.begin(), edgeList.end()),
+                   edgeList.end());
+  }
+}
+
+void cmComputeLinkDepends::DisplayConstraintGraph()
+{
+  // Display the graph nodes and their edges.
+  std::ostringstream e;
+  for (unsigned int i = 0; i < this->EntryConstraintGraph.size(); ++i) {
+    EdgeList const& nl = this->EntryConstraintGraph[i];
+    e << "item " << i << " is [" << this->EntryList[i].Item << "]\n";
+    e << cmWrap("  item ", nl, " must follow it", "\n") << "\n";
+  }
+  fprintf(stderr, "%s\n", e.str().c_str());
+}
+
+void cmComputeLinkDepends::OrderLinkEntires()
+{
+  // Compute the DAG of strongly connected components.  The algorithm
+  // used by cmComputeComponentGraph should identify the components in
+  // the same order in which the items were originally discovered in
+  // the BFS.  This should preserve the original order when no
+  // constraints disallow it.
+  this->CCG = new cmComputeComponentGraph(this->EntryConstraintGraph);
+
+  // The component graph is guaranteed to be acyclic.  Start a DFS
+  // from every entry to compute a topological order for the
+  // components.
+  Graph const& cgraph = this->CCG->GetComponentGraph();
+  int n = static_cast<int>(cgraph.size());
+  this->ComponentVisited.resize(cgraph.size(), 0);
+  this->ComponentOrder.resize(cgraph.size(), n);
+  this->ComponentOrderId = n;
+  // Run in reverse order so the topological order will preserve the
+  // original order where there are no constraints.
+  for (int c = n - 1; c >= 0; --c) {
+    this->VisitComponent(c);
+  }
+
+  // Display the component graph.
+  if (this->DebugMode) {
+    this->DisplayComponents();
+  }
+
+  // Start with the original link line.
+  for (int originalEntry : this->OriginalEntries) {
+    this->VisitEntry(originalEntry);
+  }
+
+  // Now explore anything left pending.  Since the component graph is
+  // guaranteed to be acyclic we know this will terminate.
+  while (!this->PendingComponents.empty()) {
+    // Visit one entry from the first pending component.  The visit
+    // logic will update the pending components accordingly.  Since
+    // the pending components are kept in topological order this will
+    // not repeat one.
+    int e = *this->PendingComponents.begin()->second.Entries.begin();
+    this->VisitEntry(e);
+  }
+}
+
+void cmComputeLinkDepends::DisplayComponents()
+{
+  fprintf(stderr, "The strongly connected components are:\n");
+  std::vector<NodeList> const& components = this->CCG->GetComponents();
+  for (unsigned int c = 0; c < components.size(); ++c) {
+    fprintf(stderr, "Component (%u):\n", c);
+    NodeList const& nl = components[c];
+    for (int i : nl) {
+      fprintf(stderr, "  item %d [%s]\n", i, this->EntryList[i].Item.c_str());
+    }
+    EdgeList const& ol = this->CCG->GetComponentGraphEdges(c);
+    for (cmGraphEdge const& oi : ol) {
+      int i = oi;
+      fprintf(stderr, "  followed by Component (%d)\n", i);
+    }
+    fprintf(stderr, "  topo order index %d\n", this->ComponentOrder[c]);
+  }
+  fprintf(stderr, "\n");
+}
+
+void cmComputeLinkDepends::VisitComponent(unsigned int c)
+{
+  // Check if the node has already been visited.
+  if (this->ComponentVisited[c]) {
+    return;
+  }
+
+  // We are now visiting this component so mark it.
+  this->ComponentVisited[c] = 1;
+
+  // Visit the neighbors of the component first.
+  // Run in reverse order so the topological order will preserve the
+  // original order where there are no constraints.
+  EdgeList const& nl = this->CCG->GetComponentGraphEdges(c);
+  for (EdgeList::const_reverse_iterator ni = nl.rbegin(); ni != nl.rend();
+       ++ni) {
+    this->VisitComponent(*ni);
+  }
+
+  // Assign an ordering id to this component.
+  this->ComponentOrder[c] = --this->ComponentOrderId;
+}
+
+void cmComputeLinkDepends::VisitEntry(int index)
+{
+  // Include this entry on the link line.
+  this->FinalLinkOrder.push_back(index);
+
+  // This entry has now been seen.  Update its component.
+  bool completed = false;
+  int component = this->CCG->GetComponentMap()[index];
+  std::map<int, PendingComponent>::iterator mi =
+    this->PendingComponents.find(this->ComponentOrder[component]);
+  if (mi != this->PendingComponents.end()) {
+    // The entry is in an already pending component.
+    PendingComponent& pc = mi->second;
+
+    // Remove the entry from those pending in its component.
+    pc.Entries.erase(index);
+    if (pc.Entries.empty()) {
+      // The complete component has been seen since it was last needed.
+      --pc.Count;
+
+      if (pc.Count == 0) {
+        // The component has been completed.
+        this->PendingComponents.erase(mi);
+        completed = true;
+      } else {
+        // The whole component needs to be seen again.
+        NodeList const& nl = this->CCG->GetComponent(component);
+        assert(nl.size() > 1);
+        pc.Entries.insert(nl.begin(), nl.end());
+      }
+    }
+  } else {
+    // The entry is not in an already pending component.
+    NodeList const& nl = this->CCG->GetComponent(component);
+    if (nl.size() > 1) {
+      // This is a non-trivial component.  It is now pending.
+      PendingComponent& pc = this->MakePendingComponent(component);
+
+      // The starting entry has already been seen.
+      pc.Entries.erase(index);
+    } else {
+      // This is a trivial component, so it is already complete.
+      completed = true;
+    }
+  }
+
+  // If the entry completed a component, the component's dependencies
+  // are now pending.
+  if (completed) {
+    EdgeList const& ol = this->CCG->GetComponentGraphEdges(component);
+    for (cmGraphEdge const& oi : ol) {
+      // This entire component is now pending no matter whether it has
+      // been partially seen already.
+      this->MakePendingComponent(oi);
+    }
+  }
+}
+
+cmComputeLinkDepends::PendingComponent&
+cmComputeLinkDepends::MakePendingComponent(unsigned int component)
+{
+  // Create an entry (in topological order) for the component.
+  PendingComponent& pc =
+    this->PendingComponents[this->ComponentOrder[component]];
+  pc.Id = component;
+  NodeList const& nl = this->CCG->GetComponent(component);
+
+  if (nl.size() == 1) {
+    // Trivial components need be seen only once.
+    pc.Count = 1;
+  } else {
+    // This is a non-trivial strongly connected component of the
+    // original graph.  It consists of two or more libraries
+    // (archives) that mutually require objects from one another.  In
+    // the worst case we may have to repeat the list of libraries as
+    // many times as there are object files in the biggest archive.
+    // For now we just list them twice.
+    //
+    // The list of items in the component has been sorted by the order
+    // of discovery in the original BFS of dependencies.  This has the
+    // advantage that the item directly linked by a target requiring
+    // this component will come first which minimizes the number of
+    // repeats needed.
+    pc.Count = this->ComputeComponentCount(nl);
+  }
+
+  // Store the entries to be seen.
+  pc.Entries.insert(nl.begin(), nl.end());
+
+  return pc;
+}
+
+int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
+{
+  unsigned int count = 2;
+  for (int ni : nl) {
+    if (cmGeneratorTarget const* target = this->EntryList[ni].Target) {
+      if (cmLinkInterface const* iface =
+            target->GetLinkInterface(this->Config, this->Target)) {
+        if (iface->Multiplicity > count) {
+          count = iface->Multiplicity;
+        }
+      }
+    }
+  }
+  return count;
+}
+
+void cmComputeLinkDepends::DisplayFinalEntries()
+{
+  fprintf(stderr, "target [%s] links to:\n", this->Target->GetName().c_str());
+  for (LinkEntry const& lei : this->FinalLinkEntries) {
+    if (lei.Target) {
+      fprintf(stderr, "  target [%s]\n", lei.Target->GetName().c_str());
+    } else {
+      fprintf(stderr, "  item [%s]\n", lei.Item.c_str());
+    }
+  }
+  fprintf(stderr, "\n");
+}
+
+void cmComputeLinkDepends::CheckWrongConfigItem(cmLinkItem const& item)
+{
+  if (!this->OldLinkDirMode) {
+    return;
+  }
+
+  // For CMake 2.4 bug-compatibility we need to consider the output
+  // directories of targets linked in another configuration as link
+  // directories.
+  if (item.Target && !item.Target->IsImported()) {
+    this->OldWrongConfigItems.insert(item.Target);
+  }
+}
diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h
new file mode 100644
index 0000000..dd0e029
--- /dev/null
+++ b/Source/cmComputeLinkDepends.h
@@ -0,0 +1,173 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmComputeLinkDepends_h
+#define cmComputeLinkDepends_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmGraphAdjacencyList.h"
+#include "cmLinkItem.h"
+#include "cmTargetLinkLibraryType.h"
+
+#include <map>
+#include <queue>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmComputeComponentGraph;
+class cmGeneratorTarget;
+class cmGlobalGenerator;
+class cmMakefile;
+class cmake;
+
+/** \class cmComputeLinkDepends
+ * \brief Compute link dependencies for targets.
+ */
+class cmComputeLinkDepends
+{
+public:
+  cmComputeLinkDepends(cmGeneratorTarget const* target,
+                       const std::string& config);
+  ~cmComputeLinkDepends();
+
+  // Basic information about each link item.
+  struct LinkEntry
+  {
+    std::string Item;
+    cmGeneratorTarget const* Target;
+    bool IsSharedDep;
+    bool IsFlag;
+    LinkEntry()
+      : Item()
+      , Target(nullptr)
+      , IsSharedDep(false)
+      , IsFlag(false)
+    {
+    }
+    LinkEntry(LinkEntry const& r)
+      : Item(r.Item)
+      , Target(r.Target)
+      , IsSharedDep(r.IsSharedDep)
+      , IsFlag(r.IsFlag)
+    {
+    }
+  };
+
+  typedef std::vector<LinkEntry> EntryVector;
+  EntryVector const& Compute();
+
+  void SetOldLinkDirMode(bool b);
+  std::set<cmGeneratorTarget const*> const& GetOldWrongConfigItems() const
+  {
+    return this->OldWrongConfigItems;
+  }
+
+private:
+  // Context information.
+  cmGeneratorTarget const* Target;
+  cmMakefile* Makefile;
+  cmGlobalGenerator const* GlobalGenerator;
+  cmake* CMakeInstance;
+  std::string Config;
+  EntryVector FinalLinkEntries;
+
+  std::map<std::string, int>::iterator AllocateLinkEntry(
+    std::string const& item);
+  int AddLinkEntry(cmLinkItem const& item);
+  void AddVarLinkEntries(int depender_index, const char* value);
+  void AddDirectLinkEntries();
+  template <typename T>
+  void AddLinkEntries(int depender_index, std::vector<T> const& libs);
+  cmGeneratorTarget const* FindTargetToLink(int depender_index,
+                                            const std::string& name);
+
+  // One entry for each unique item.
+  std::vector<LinkEntry> EntryList;
+  std::map<std::string, int> LinkEntryIndex;
+
+  // BFS of initial dependencies.
+  struct BFSEntry
+  {
+    int Index;
+    const char* LibDepends;
+  };
+  std::queue<BFSEntry> BFSQueue;
+  void FollowLinkEntry(BFSEntry qe);
+
+  // Shared libraries that are included only because they are
+  // dependencies of other shared libraries, not because they are part
+  // of the interface.
+  struct SharedDepEntry
+  {
+    cmLinkItem Item;
+    int DependerIndex;
+  };
+  std::queue<SharedDepEntry> SharedDepQueue;
+  std::set<int> SharedDepFollowed;
+  void FollowSharedDeps(int depender_index, cmLinkInterface const* iface,
+                        bool follow_interface = false);
+  void QueueSharedDependencies(int depender_index,
+                               std::vector<cmLinkItem> const& deps);
+  void HandleSharedDependency(SharedDepEntry const& dep);
+
+  // Dependency inferral for each link item.
+  struct DependSet : public std::set<int>
+  {
+  };
+  struct DependSetList : public std::vector<DependSet>
+  {
+  };
+  std::vector<DependSetList*> InferredDependSets;
+  void InferDependencies();
+
+  // Ordering constraint graph adjacency list.
+  typedef cmGraphNodeList NodeList;
+  typedef cmGraphEdgeList EdgeList;
+  typedef cmGraphAdjacencyList Graph;
+  Graph EntryConstraintGraph;
+  void CleanConstraintGraph();
+  void DisplayConstraintGraph();
+
+  // Ordering algorithm.
+  void OrderLinkEntires();
+  std::vector<char> ComponentVisited;
+  std::vector<int> ComponentOrder;
+
+  struct PendingComponent
+  {
+    // The real component id.  Needed because the map is indexed by
+    // component topological index.
+    int Id;
+
+    // The number of times the component needs to be seen.  This is
+    // always 1 for trivial components and is initially 2 for
+    // non-trivial components.
+    int Count;
+
+    // The entries yet to be seen to complete the component.
+    std::set<int> Entries;
+  };
+  std::map<int, PendingComponent> PendingComponents;
+  cmComputeComponentGraph* CCG;
+  std::vector<int> FinalLinkOrder;
+  void DisplayComponents();
+  void VisitComponent(unsigned int c);
+  void VisitEntry(int index);
+  PendingComponent& MakePendingComponent(unsigned int component);
+  int ComputeComponentCount(NodeList const& nl);
+  void DisplayFinalEntries();
+
+  // Record of the original link line.
+  std::vector<int> OriginalEntries;
+  std::set<cmGeneratorTarget const*> OldWrongConfigItems;
+  void CheckWrongConfigItem(cmLinkItem const& item);
+
+  int ComponentOrderId;
+  cmTargetLinkLibraryType LinkType;
+  bool HasConfig;
+  bool DebugMode;
+  bool OldLinkDirMode;
+};
+
+#endif
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
new file mode 100644
index 0000000..18cca5a
--- /dev/null
+++ b/Source/cmComputeLinkInformation.cxx
@@ -0,0 +1,1831 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmComputeLinkInformation.h"
+
+#include "cmAlgorithms.h"
+#include "cmComputeLinkDepends.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOrderDirectories.h"
+#include "cmOutputConverter.h"
+#include "cmPolicies.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+#include <algorithm>
+#include <ctype.h>
+#include <sstream>
+#include <string.h>
+#include <utility>
+
+//#define CM_COMPUTE_LINK_INFO_DEBUG
+
+/*
+Notes about linking on various platforms:
+
+------------------------------------------------------------------------------
+
+Linux, FreeBSD, Mac OS X, IRIX, Sun, Windows:
+
+Linking to libraries using the full path works fine.
+
+------------------------------------------------------------------------------
+
+On AIX, more work is needed.
+
+  The "-bnoipath" option is needed.  From "man ld":
+
+    Note: If you specify a shared object, or an archive file
+    containing a shared object, with an absolute or relative path
+    name, instead of with the -lName flag, the path name is
+    included in the import file ID string in the loader section of
+    the output file. You can override this behavior with the
+    -bnoipath option.
+
+      noipath
+
+        For shared objects listed on the command-line, rather than
+        specified with the -l flag, use a null path component when
+        listing the shared object in the loader section of the
+        output file. A null path component is always used for
+        shared objects specified with the -l flag. This option
+        does not affect the specification of a path component by
+        using a line beginning with #! in an import file. The
+        default is the ipath option.
+
+  This prevents the full path specified on the compile line from being
+  compiled directly into the binary.
+
+  By default the linker places -L paths in the embedded runtime path.
+  In order to implement CMake's RPATH interface correctly, we need the
+  -blibpath:Path option.  From "man ld":
+
+      libpath:Path
+
+        Uses Path as the library path when writing the loader section
+        of the output file. Path is neither checked for validity nor
+        used when searching for libraries specified by the -l flag.
+        Path overrides any library paths generated when the -L flag is
+        used.
+
+        If you do not specify any -L flags, or if you specify the
+        nolibpath option, the default library path information is
+        written in the loader section of the output file. The default
+        library path information is the value of the LIBPATH
+        environment variable if it is defined, and /usr/lib:/lib,
+        otherwise.
+
+  We can pass -Wl,-blibpath:/usr/lib:/lib always to avoid the -L stuff
+  and not break when the user sets LIBPATH.  Then if we want to add an
+  rpath we insert it into the option before /usr/lib.
+
+------------------------------------------------------------------------------
+
+On HP-UX, more work is needed.  There are differences between
+versions.
+
+ld: 92453-07 linker linker ld B.10.33 990520
+
+  Linking with a full path works okay for static and shared libraries.
+  The linker seems to always put the full path to where the library
+  was found in the binary whether using a full path or -lfoo syntax.
+  Transitive link dependencies work just fine due to the full paths.
+
+  It has the "-l:libfoo.sl" option.  The +nodefaultrpath is accepted
+  but not documented and does not seem to do anything.  There is no
+  +forceload option.
+
+ld: 92453-07 linker ld HP Itanium(R) B.12.41  IPF/IPF
+
+  Linking with a full path works okay for static libraries.
+
+  Linking with a full path works okay for shared libraries.  However
+  dependent (transitive) libraries of those linked directly must be
+  either found with an rpath stored in the direct dependencies or
+  found in -L paths as if they were specified with "-l:libfoo.sl"
+  (really "-l:<soname>").  The search matches that of the dynamic
+  loader but only with -L paths.  In other words, if we have an
+  executable that links to shared library bar which links to shared
+  library foo, the link line for the exe must contain
+
+    /dir/with/bar/libbar.sl -L/dir/with/foo
+
+  It does not matter whether the exe wants to link to foo directly or
+  whether /dir/with/foo/libfoo.sl is listed.  The -L path must still
+  be present.  It should match the runtime path computed for the
+  executable taking all directly and transitively linked libraries
+  into account.
+
+  The "+nodefaultrpath" option should be used to avoid getting -L
+  paths in the rpath unless we add our own rpath with +b.  This means
+  that skip-build-rpath should use this option.
+
+  See documentation in "man ld", "man dld.so", and
+  http://docs.hp.com/en/B2355-90968/creatingandusinglibraries.htm
+
+    +[no]defaultrpath
+      +defaultrpath is the default.  Include any paths that are
+      specified with -L in the embedded path, unless you specify the
+      +b option.  If you use +b, only the path list specified by +b is
+      in the embedded path.
+
+      The +nodefaultrpath option removes all library paths that were
+      specified with the -L option from the embedded path.  The linker
+      searches the library paths specified by the -L option at link
+      time.  At run time, the only library paths searched are those
+      specified by the environment variables LD_LIBRARY_PATH and
+      SHLIB_PATH, library paths specified by the +b linker option, and
+      finally the default library paths.
+
+    +rpathfirst
+      This option will cause the paths specified in RPATH (embedded
+      path) to be used before the paths specified in LD_LIBRARY_PATH
+      or SHLIB_PATH, in searching for shared libraries.  This changes
+      the default search order of LD_LIBRARY_PATH, SHLIB_PATH, and
+      RPATH (embedded path).
+
+------------------------------------------------------------------------------
+Notes about dependent (transitive) shared libraries:
+
+On non-Windows systems shared libraries may have transitive
+dependencies.  In order to support LINK_INTERFACE_LIBRARIES we must
+support linking to a shared library without listing all the libraries
+to which it links.  Some linkers want to be able to find the
+transitive dependencies (dependent libraries) of shared libraries
+listed on the command line.
+
+  - On Windows, DLLs are not directly linked, and the import libraries
+    have no transitive dependencies.
+
+  - On Mac OS X 10.5 and above transitive dependencies are not needed.
+
+  - On Mac OS X 10.4 and below we need to actually list the dependencies.
+    Otherwise when using -isysroot for universal binaries it cannot
+    find the dependent libraries.  Listing them on the command line
+    tells the linker where to find them, but unfortunately also links
+    the library.
+
+  - On HP-UX, the linker wants to find the transitive dependencies of
+    shared libraries in the -L paths even if the dependent libraries
+    are given on the link line.
+
+  - On AIX the transitive dependencies are not needed.
+
+  - On SGI, the linker wants to find the transitive dependencies of
+    shared libraries in the -L paths if they are not given on the link
+    line.  Transitive linking can be disabled using the options
+
+      -no_transitive_link -Wl,-no_transitive_link
+
+    which disable it.  Both options must be given when invoking the
+    linker through the compiler.
+
+  - On Sun, the linker wants to find the transitive dependencies of
+    shared libraries in the -L paths if they are not given on the link
+    line.
+
+  - On Linux, FreeBSD, and QNX:
+
+    The linker wants to find the transitive dependencies of shared
+    libraries in the "-rpath-link" paths option if they have not been
+    given on the link line.  The option is like rpath but just for
+    link time:
+
+      -Wl,-rpath-link,"/path1:/path2"
+
+For -rpath-link, we need a separate runtime path ordering pass
+including just the dependent libraries that are not linked.
+
+For -L paths on non-HP, we can do the same thing as with rpath-link
+but put the results in -L paths.  The paths should be listed at the
+end to avoid conflicting with user search paths (?).
+
+For -L paths on HP, we should do a runtime path ordering pass with
+all libraries, both linked and non-linked.  Even dependent
+libraries that are also linked need to be listed in -L paths.
+
+In our implementation we add all dependent libraries to the runtime
+path computation.  Then the auto-generated RPATH will find everything.
+
+------------------------------------------------------------------------------
+Notes about shared libraries with not builtin soname:
+
+Some UNIX shared libraries may be created with no builtin soname.  On
+some platforms such libraries cannot be linked using the path to their
+location because the linker will copy the path into the field used to
+find the library at runtime.
+
+  Apple:    ../libfoo.dylib  ==>  libfoo.dylib  # ok, uses install_name
+  SGI:      ../libfoo.so     ==>  libfoo.so     # ok
+  AIX:      ../libfoo.so     ==>  libfoo.so     # ok
+  Linux:    ../libfoo.so     ==>  ../libfoo.so  # bad
+  HP-UX:    ../libfoo.so     ==>  ../libfoo.so  # bad
+  Sun:      ../libfoo.so     ==>  ../libfoo.so  # bad
+  FreeBSD:  ../libfoo.so     ==>  ../libfoo.so  # bad
+
+In order to link these libraries we need to use the old-style split
+into -L.. and -lfoo options.  This should be fairly safe because most
+problems with -lfoo options were related to selecting shared libraries
+instead of static but in this case we want the shared lib.  Link
+directory ordering needs to be done to make sure these shared
+libraries are found first.  There should be very few restrictions
+because this need be done only for shared libraries without soname-s.
+
+*/
+
+cmComputeLinkInformation::cmComputeLinkInformation(
+  const cmGeneratorTarget* target, const std::string& config)
+{
+  // Store context information.
+  this->Target = target;
+  this->Makefile = this->Target->Target->GetMakefile();
+  this->GlobalGenerator =
+    this->Target->GetLocalGenerator()->GetGlobalGenerator();
+  this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
+
+  // Check whether to recognize OpenBSD-style library versioned names.
+  this->OpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool(
+    "FIND_LIBRARY_USE_OPENBSD_VERSIONING");
+
+  // The configuration being linked.
+  this->Config = config;
+
+  // Allocate internals.
+  this->OrderLinkerSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "linker search path");
+  this->OrderRuntimeSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "runtime search path");
+  this->OrderDependentRPath = nullptr;
+
+  // Get the language used for linking this target.
+  this->LinkLanguage = this->Target->GetLinkerLanguage(config);
+  if (this->LinkLanguage.empty()) {
+    // The Compute method will do nothing, so skip the rest of the
+    // initialization.
+    return;
+  }
+
+  // Check whether we should use an import library for linking a target.
+  this->UseImportLibrary =
+    this->Makefile->IsDefinitionSet("CMAKE_IMPORT_LIBRARY_SUFFIX");
+
+  // Check whether we should skip dependencies on shared library files.
+  this->LinkDependsNoShared =
+    this->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED");
+
+  // On platforms without import libraries there may be a special flag
+  // to use when creating a plugin (module) that obtains symbols from
+  // the program that will load it.
+  this->LoaderFlag = nullptr;
+  if (!this->UseImportLibrary &&
+      this->Target->GetType() == cmStateEnums::MODULE_LIBRARY) {
+    std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_";
+    loader_flag_var += this->LinkLanguage;
+    loader_flag_var += "_FLAG";
+    this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var);
+  }
+
+  // Get options needed to link libraries.
+  this->LibLinkFlag =
+    this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
+  this->LibLinkFileFlag =
+    this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FILE_FLAG");
+  this->LibLinkSuffix =
+    this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX");
+
+  // Get options needed to specify RPATHs.
+  this->RuntimeUseChrpath = false;
+  if (this->Target->GetType() != cmStateEnums::STATIC_LIBRARY) {
+    const char* tType = ((this->Target->GetType() == cmStateEnums::EXECUTABLE)
+                           ? "EXECUTABLE"
+                           : "SHARED_LIBRARY");
+    std::string rtVar = "CMAKE_";
+    rtVar += tType;
+    rtVar += "_RUNTIME_";
+    rtVar += this->LinkLanguage;
+    rtVar += "_FLAG";
+    std::string rtSepVar = rtVar + "_SEP";
+    this->RuntimeFlag = this->Makefile->GetSafeDefinition(rtVar);
+    this->RuntimeSep = this->Makefile->GetSafeDefinition(rtSepVar);
+    this->RuntimeAlways = (this->Makefile->GetSafeDefinition(
+      "CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));
+
+    this->RuntimeUseChrpath = this->Target->IsChrpathUsed(config);
+
+    // Get options needed to help find dependent libraries.
+    std::string rlVar = "CMAKE_";
+    rlVar += tType;
+    rlVar += "_RPATH_LINK_";
+    rlVar += this->LinkLanguage;
+    rlVar += "_FLAG";
+    this->RPathLinkFlag = this->Makefile->GetSafeDefinition(rlVar);
+  }
+
+  // Check if we need to include the runtime search path at link time.
+  {
+    std::string var = "CMAKE_SHARED_LIBRARY_LINK_";
+    var += this->LinkLanguage;
+    var += "_WITH_RUNTIME_PATH";
+    this->LinkWithRuntimePath = this->Makefile->IsOn(var);
+  }
+
+  // Check the platform policy for missing soname case.
+  this->NoSONameUsesPath =
+    this->Makefile->IsOn("CMAKE_PLATFORM_USES_PATH_WHEN_NO_SONAME");
+
+  // Get link type information.
+  this->ComputeLinkTypeInfo();
+
+  // Setup the link item parser.
+  this->ComputeItemParserInfo();
+
+  // Setup framework support.
+  this->ComputeFrameworkInfo();
+
+  // Choose a mode for dealing with shared library dependencies.
+  this->SharedDependencyMode = SharedDepModeNone;
+  if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) {
+    this->SharedDependencyMode = SharedDepModeLink;
+  } else if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) {
+    this->SharedDependencyMode = SharedDepModeLibDir;
+  } else if (!this->RPathLinkFlag.empty()) {
+    this->SharedDependencyMode = SharedDepModeDir;
+    this->OrderDependentRPath = new cmOrderDirectories(
+      this->GlobalGenerator, target, "dependent library path");
+  }
+
+  // Add the search path entries requested by the user to path ordering.
+  this->OrderLinkerSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
+  this->OrderRuntimeSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
+
+  // Set up the implicit link directories.
+  this->LoadImplicitLinkInfo();
+  this->OrderLinkerSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  this->OrderRuntimeSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  if (this->OrderDependentRPath) {
+    this->OrderDependentRPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+    this->OrderDependentRPath->AddLanguageDirectories(this->RuntimeLinkDirs);
+  }
+
+  // Decide whether to enable compatible library search path mode.
+  // There exists code that effectively does
+  //
+  //    /path/to/libA.so -lB
+  //
+  // where -lB is meant to link to /path/to/libB.so.  This is broken
+  // because it specified -lB without specifying a link directory (-L)
+  // in which to search for B.  This worked in CMake 2.4 and below
+  // because -L/path/to would be added by the -L/-l split for A.  In
+  // order to support such projects we need to add the directories
+  // containing libraries linked with a full path to the -L path.
+  this->OldLinkDirMode =
+    this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW;
+  if (this->OldLinkDirMode) {
+    // Construct a mask to not bother with this behavior for link
+    // directories already specified by the user.
+    std::vector<std::string> const& dirs = this->Target->GetLinkDirectories();
+    this->OldLinkDirMask.insert(dirs.begin(), dirs.end());
+  }
+
+  this->CMP0060Warn = this->Makefile->PolicyOptionalWarningEnabled(
+    "CMAKE_POLICY_WARNING_CMP0060");
+}
+
+cmComputeLinkInformation::~cmComputeLinkInformation()
+{
+  delete this->OrderLinkerSearchPath;
+  delete this->OrderRuntimeSearchPath;
+  delete this->OrderDependentRPath;
+}
+
+cmComputeLinkInformation::ItemVector const&
+cmComputeLinkInformation::GetItems()
+{
+  return this->Items;
+}
+
+std::vector<std::string> const& cmComputeLinkInformation::GetDirectories()
+{
+  return this->OrderLinkerSearchPath->GetOrderedDirectories();
+}
+
+std::string cmComputeLinkInformation::GetRPathLinkString()
+{
+  // If there is no separate linker runtime search flag (-rpath-link)
+  // there is no reason to compute a string.
+  if (!this->OrderDependentRPath) {
+    return "";
+  }
+
+  // Construct the linker runtime search path.
+  return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");
+}
+
+std::vector<std::string> const& cmComputeLinkInformation::GetDepends()
+{
+  return this->Depends;
+}
+
+std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths()
+{
+  return this->FrameworkPaths;
+}
+
+const std::set<const cmGeneratorTarget*>&
+cmComputeLinkInformation::GetSharedLibrariesLinked()
+{
+  return this->SharedLibrariesLinked;
+}
+
+bool cmComputeLinkInformation::Compute()
+{
+  // Skip targets that do not link.
+  if (!(this->Target->GetType() == cmStateEnums::EXECUTABLE ||
+        this->Target->GetType() == cmStateEnums::SHARED_LIBRARY ||
+        this->Target->GetType() == cmStateEnums::MODULE_LIBRARY ||
+        this->Target->GetType() == cmStateEnums::STATIC_LIBRARY)) {
+    return false;
+  }
+
+  // We require a link language for the target.
+  if (this->LinkLanguage.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      this->Target->GetName().c_str());
+    return false;
+  }
+
+  // Compute the ordered link line items.
+  cmComputeLinkDepends cld(this->Target, this->Config);
+  cld.SetOldLinkDirMode(this->OldLinkDirMode);
+  cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
+
+  // Add the link line items.
+  for (cmComputeLinkDepends::LinkEntry const& linkEntry : linkEntries) {
+    if (linkEntry.IsSharedDep) {
+      this->AddSharedDepItem(linkEntry.Item, linkEntry.Target);
+    } else {
+      this->AddItem(linkEntry.Item, linkEntry.Target);
+    }
+  }
+
+  // Restore the target link type so the correct system runtime
+  // libraries are found.
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_END_STATIC");
+  if (cmSystemTools::IsOn(lss)) {
+    this->SetCurrentLinkType(LinkStatic);
+  } else {
+    this->SetCurrentLinkType(this->StartLinkType);
+  }
+
+  // Finish listing compatibility paths.
+  if (this->OldLinkDirMode) {
+    // For CMake 2.4 bug-compatibility we need to consider the output
+    // directories of targets linked in another configuration as link
+    // directories.
+    std::set<cmGeneratorTarget const*> const& wrongItems =
+      cld.GetOldWrongConfigItems();
+    for (cmGeneratorTarget const* tgt : wrongItems) {
+      bool implib = (this->UseImportLibrary &&
+                     (tgt->GetType() == cmStateEnums::SHARED_LIBRARY));
+      cmStateEnums::ArtifactType artifact = implib
+        ? cmStateEnums::ImportLibraryArtifact
+        : cmStateEnums::RuntimeBinaryArtifact;
+      std::string lib = tgt->GetFullPath(this->Config, artifact, true);
+      this->OldLinkDirItems.push_back(lib);
+    }
+  }
+
+  // Finish setting up linker search directories.
+  if (!this->FinishLinkerSearchDirectories()) {
+    return false;
+  }
+
+  // Add implicit language runtime libraries and directories.
+  this->AddImplicitLinkInfo();
+
+  if (!this->CMP0060WarnItems.empty()) {
+    std::ostringstream w;
+    /* clang-format off */
+    w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0060) << "\n"
+      "Some library files are in directories implicitly searched by "
+      "the linker when invoked for " << this->LinkLanguage << ":\n"
+      " " << cmJoin(this->CMP0060WarnItems, "\n ") << "\n"
+      "For compatibility with older versions of CMake, the generated "
+      "link line will ask the linker to search for these by library "
+      "name."
+      ;
+    /* clang-format on */
+    this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
+                                      this->Target->GetBacktrace());
+  }
+
+  return true;
+}
+
+void cmComputeLinkInformation::AddImplicitLinkInfo()
+{
+  // The link closure lists all languages whose implicit info is needed.
+  cmGeneratorTarget::LinkClosure const* lc =
+    this->Target->GetLinkClosure(this->Config);
+  for (std::string const& li : lc->Languages) {
+    // Skip those of the linker language.  They are implicit.
+    if (li != this->LinkLanguage) {
+      this->AddImplicitLinkInfo(li);
+    }
+  }
+}
+
+void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
+{
+  // Add libraries for this language that are not implied by the
+  // linker language.
+  std::string libVar = "CMAKE_";
+  libVar += lang;
+  libVar += "_IMPLICIT_LINK_LIBRARIES";
+  if (const char* libs = this->Makefile->GetDefinition(libVar)) {
+    std::vector<std::string> libsVec;
+    cmSystemTools::ExpandListArgument(libs, libsVec);
+    for (std::string const& i : libsVec) {
+      if (this->ImplicitLinkLibs.find(i) == this->ImplicitLinkLibs.end()) {
+        this->AddItem(i, nullptr);
+      }
+    }
+  }
+
+  // Add linker search paths for this language that are not
+  // implied by the linker language.
+  std::string dirVar = "CMAKE_";
+  dirVar += lang;
+  dirVar += "_IMPLICIT_LINK_DIRECTORIES";
+  if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
+    std::vector<std::string> dirsVec;
+    cmSystemTools::ExpandListArgument(dirs, dirsVec);
+    this->OrderLinkerSearchPath->AddLanguageDirectories(dirsVec);
+  }
+}
+
+void cmComputeLinkInformation::AddItem(std::string const& item,
+                                       cmGeneratorTarget const* tgt)
+{
+  // Compute the proper name to use to link this library.
+  const std::string& config = this->Config;
+  bool impexe = (tgt && tgt->IsExecutableWithExports());
+  if (impexe && !this->UseImportLibrary && !this->LoaderFlag) {
+    // Skip linking to executables on platforms with no import
+    // libraries or loader flags.
+    return;
+  }
+
+  if (tgt && tgt->IsLinkable()) {
+    // This is a CMake target.  Ask the target for its real name.
+    if (impexe && this->LoaderFlag) {
+      // This link item is an executable that may provide symbols
+      // used by this target.  A special flag is needed on this
+      // platform.  Add it now.
+      std::string linkItem;
+      linkItem = this->LoaderFlag;
+      cmStateEnums::ArtifactType artifact = this->UseImportLibrary
+        ? cmStateEnums::ImportLibraryArtifact
+        : cmStateEnums::RuntimeBinaryArtifact;
+
+      std::string exe = tgt->GetFullPath(config, artifact, true);
+      linkItem += exe;
+      this->Items.push_back(Item(linkItem, true, tgt));
+      this->Depends.push_back(exe);
+    } else if (tgt->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+      // Add the interface library as an item so it can be considered as part
+      // of COMPATIBLE_INTERFACE_ enforcement.  The generators will ignore
+      // this for the actual link line.
+      this->Items.push_back(Item(std::string(), false, tgt));
+
+      // Also add the item the interface specifies to be used in its place.
+      std::string const& libName = tgt->GetImportedLibName(config);
+      if (!libName.empty()) {
+        this->AddItem(libName, nullptr);
+      }
+    } else {
+      // Decide whether to use an import library.
+      bool implib =
+        (this->UseImportLibrary &&
+         (impexe || tgt->GetType() == cmStateEnums::SHARED_LIBRARY));
+      cmStateEnums::ArtifactType artifact = implib
+        ? cmStateEnums::ImportLibraryArtifact
+        : cmStateEnums::RuntimeBinaryArtifact;
+
+      // Pass the full path to the target file.
+      std::string lib = tgt->GetFullPath(config, artifact, true);
+      if (!this->LinkDependsNoShared ||
+          tgt->GetType() != cmStateEnums::SHARED_LIBRARY) {
+        this->Depends.push_back(lib);
+      }
+
+      this->AddTargetItem(lib, tgt);
+      this->AddLibraryRuntimeInfo(lib, tgt);
+    }
+  } else {
+    // This is not a CMake target.  Use the name given.
+    if (cmSystemTools::FileIsFullPath(item.c_str())) {
+      if (cmSystemTools::FileIsDirectory(item)) {
+        // This is a directory.
+        this->AddDirectoryItem(item);
+      } else {
+        // Use the full path given to the library file.
+        this->Depends.push_back(item);
+        this->AddFullItem(item);
+        this->AddLibraryRuntimeInfo(item);
+      }
+    } else {
+      // This is a library or option specified by the user.
+      this->AddUserItem(item, true);
+    }
+  }
+}
+
+void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
+                                                const cmGeneratorTarget* tgt)
+{
+  // If dropping shared library dependencies, ignore them.
+  if (this->SharedDependencyMode == SharedDepModeNone) {
+    return;
+  }
+
+  // The user may have incorrectly named an item.  Skip items that are
+  // not full paths to shared libraries.
+  if (tgt) {
+    // The target will provide a full path.  Make sure it is a shared
+    // library.
+    if (tgt->GetType() != cmStateEnums::SHARED_LIBRARY) {
+      return;
+    }
+  } else {
+    // Skip items that are not full paths.  We will not be able to
+    // reliably specify them.
+    if (!cmSystemTools::FileIsFullPath(item.c_str())) {
+      return;
+    }
+
+    // Get the name of the library from the file name.
+    std::string file = cmSystemTools::GetFilenameName(item);
+    if (!this->ExtractSharedLibraryName.find(file.c_str())) {
+      // This is not the name of a shared library.
+      return;
+    }
+  }
+
+  // If in linking mode, just link to the shared library.
+  if (this->SharedDependencyMode == SharedDepModeLink) {
+    this->AddItem(item, tgt);
+    return;
+  }
+
+  // Get a full path to the dependent shared library.
+  // Add it to the runtime path computation so that the target being
+  // linked will be able to find it.
+  std::string lib;
+  if (tgt) {
+    cmStateEnums::ArtifactType artifact = this->UseImportLibrary
+      ? cmStateEnums::ImportLibraryArtifact
+      : cmStateEnums::RuntimeBinaryArtifact;
+    lib = tgt->GetFullPath(this->Config, artifact);
+    this->AddLibraryRuntimeInfo(lib, tgt);
+  } else {
+    lib = item;
+    this->AddLibraryRuntimeInfo(lib);
+  }
+
+  // Check if we need to include the dependent shared library in other
+  // path ordering.
+  cmOrderDirectories* order = nullptr;
+  if (this->SharedDependencyMode == SharedDepModeLibDir &&
+      !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) {
+    // Add the item to the linker search path.
+    order = this->OrderLinkerSearchPath;
+  } else if (this->SharedDependencyMode == SharedDepModeDir) {
+    // Add the item to the separate dependent library search path.
+    order = this->OrderDependentRPath;
+  }
+  if (order) {
+    if (tgt) {
+      std::string soName = tgt->GetSOName(this->Config);
+      const char* soname = soName.empty() ? nullptr : soName.c_str();
+      order->AddRuntimeLibrary(lib, soname);
+    } else {
+      order->AddRuntimeLibrary(lib);
+    }
+  }
+}
+
+void cmComputeLinkInformation::ComputeLinkTypeInfo()
+{
+  // Check whether archives may actually be shared libraries.
+  this->ArchivesMayBeShared =
+    this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+      "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
+
+  // First assume we cannot do link type stuff.
+  this->LinkTypeEnabled = false;
+
+  // Lookup link type selection flags.
+  const char* static_link_type_flag = nullptr;
+  const char* shared_link_type_flag = nullptr;
+  const char* target_type_str = nullptr;
+  switch (this->Target->GetType()) {
+    case cmStateEnums::EXECUTABLE:
+      target_type_str = "EXE";
+      break;
+    case cmStateEnums::SHARED_LIBRARY:
+      target_type_str = "SHARED_LIBRARY";
+      break;
+    case cmStateEnums::MODULE_LIBRARY:
+      target_type_str = "SHARED_MODULE";
+      break;
+    default:
+      break;
+  }
+  if (target_type_str) {
+    std::string static_link_type_flag_var = "CMAKE_";
+    static_link_type_flag_var += target_type_str;
+    static_link_type_flag_var += "_LINK_STATIC_";
+    static_link_type_flag_var += this->LinkLanguage;
+    static_link_type_flag_var += "_FLAGS";
+    static_link_type_flag =
+      this->Makefile->GetDefinition(static_link_type_flag_var);
+
+    std::string shared_link_type_flag_var = "CMAKE_";
+    shared_link_type_flag_var += target_type_str;
+    shared_link_type_flag_var += "_LINK_DYNAMIC_";
+    shared_link_type_flag_var += this->LinkLanguage;
+    shared_link_type_flag_var += "_FLAGS";
+    shared_link_type_flag =
+      this->Makefile->GetDefinition(shared_link_type_flag_var);
+  }
+
+  // We can support link type switching only if all needed flags are
+  // known.
+  if (static_link_type_flag && *static_link_type_flag &&
+      shared_link_type_flag && *shared_link_type_flag) {
+    this->LinkTypeEnabled = true;
+    this->StaticLinkTypeFlag = static_link_type_flag;
+    this->SharedLinkTypeFlag = shared_link_type_flag;
+  }
+
+  // Lookup the starting link type from the target (linked statically?).
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_START_STATIC");
+  this->StartLinkType = cmSystemTools::IsOn(lss) ? LinkStatic : LinkShared;
+  this->CurrentLinkType = this->StartLinkType;
+}
+
+void cmComputeLinkInformation::ComputeItemParserInfo()
+{
+  // Get possible library name prefixes.
+  cmMakefile* mf = this->Makefile;
+  this->AddLinkPrefix(mf->GetDefinition("CMAKE_STATIC_LIBRARY_PREFIX"));
+  this->AddLinkPrefix(mf->GetDefinition("CMAKE_SHARED_LIBRARY_PREFIX"));
+
+  // Import library names should be matched and treated as shared
+  // libraries for the purposes of linking.
+  this->AddLinkExtension(mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"),
+                         LinkShared);
+  this->AddLinkExtension(mf->GetDefinition("CMAKE_STATIC_LIBRARY_SUFFIX"),
+                         LinkStatic);
+  this->AddLinkExtension(mf->GetDefinition("CMAKE_SHARED_LIBRARY_SUFFIX"),
+                         LinkShared);
+  this->AddLinkExtension(mf->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"),
+                         LinkUnknown);
+  if (const char* linkSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
+    std::vector<std::string> linkSuffixVec;
+    cmSystemTools::ExpandListArgument(linkSuffixes, linkSuffixVec);
+    for (std::string const& i : linkSuffixVec) {
+      this->AddLinkExtension(i.c_str(), LinkUnknown);
+    }
+  }
+  if (const char* sharedSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) {
+    std::vector<std::string> sharedSuffixVec;
+    cmSystemTools::ExpandListArgument(sharedSuffixes, sharedSuffixVec);
+    for (std::string const& i : sharedSuffixVec) {
+      this->AddLinkExtension(i.c_str(), LinkShared);
+    }
+  }
+
+  // Compute a regex to match link extensions.
+  std::string libext =
+    this->CreateExtensionRegex(this->LinkExtensions, LinkUnknown);
+
+  // Create regex to remove any library extension.
+  std::string reg("(.*)");
+  reg += libext;
+  this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions, reg);
+
+  // Create a regex to match a library name.  Match index 1 will be
+  // the prefix if it exists and empty otherwise.  Match index 2 will
+  // be the library name.  Match index 3 will be the library
+  // extension.
+  reg = "^(";
+  for (std::string const& p : this->LinkPrefixes) {
+    reg += p;
+    reg += "|";
+  }
+  reg += ")";
+  reg += "([^/:]*)";
+
+  // Create a regex to match any library name.
+  std::string reg_any = reg;
+  reg_any += libext;
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+  fprintf(stderr, "any regex [%s]\n", reg_any.c_str());
+#endif
+  this->ExtractAnyLibraryName.compile(reg_any.c_str());
+
+  // Create a regex to match static library names.
+  if (!this->StaticLinkExtensions.empty()) {
+    std::string reg_static = reg;
+    reg_static +=
+      this->CreateExtensionRegex(this->StaticLinkExtensions, LinkStatic);
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+    fprintf(stderr, "static regex [%s]\n", reg_static.c_str());
+#endif
+    this->ExtractStaticLibraryName.compile(reg_static.c_str());
+  }
+
+  // Create a regex to match shared library names.
+  if (!this->SharedLinkExtensions.empty()) {
+    std::string reg_shared = reg;
+    this->SharedRegexString =
+      this->CreateExtensionRegex(this->SharedLinkExtensions, LinkShared);
+    reg_shared += this->SharedRegexString;
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+    fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str());
+#endif
+    this->ExtractSharedLibraryName.compile(reg_shared.c_str());
+  }
+}
+
+void cmComputeLinkInformation::AddLinkPrefix(const char* p)
+{
+  if (p && *p) {
+    this->LinkPrefixes.insert(p);
+  }
+}
+
+void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type)
+{
+  if (e && *e) {
+    if (type == LinkStatic) {
+      this->StaticLinkExtensions.push_back(e);
+    }
+    if (type == LinkShared) {
+      this->SharedLinkExtensions.push_back(e);
+    }
+    this->LinkExtensions.push_back(e);
+  }
+}
+
+std::string cmComputeLinkInformation::CreateExtensionRegex(
+  std::vector<std::string> const& exts, LinkType type)
+{
+  // Build a list of extension choices.
+  std::string libext = "(";
+  const char* sep = "";
+  for (std::string const& i : exts) {
+    // Separate this choice from the previous one.
+    libext += sep;
+    sep = "|";
+
+    // Store this extension choice with the "." escaped.
+    libext += "\\";
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    libext += this->NoCaseExpression(i.c_str());
+#else
+    libext += i;
+#endif
+  }
+
+  // Finish the list.
+  libext += ")";
+
+  // Add an optional OpenBSD-style version or major.minor.version component.
+  if (this->OpenBSD || type == LinkShared) {
+    libext += "(\\.[0-9]+)*";
+  }
+
+  libext += "$";
+  return libext;
+}
+
+std::string cmComputeLinkInformation::NoCaseExpression(const char* str)
+{
+  std::string ret;
+  const char* s = str;
+  while (*s) {
+    if (*s == '.') {
+      ret += *s;
+    } else {
+      ret += "[";
+      ret += static_cast<char>(tolower(*s));
+      ret += static_cast<char>(toupper(*s));
+      ret += "]";
+    }
+    s++;
+  }
+  return ret;
+}
+
+void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
+{
+  // If we are changing the current link type add the flag to tell the
+  // linker about it.
+  if (this->CurrentLinkType != lt) {
+    this->CurrentLinkType = lt;
+
+    if (this->LinkTypeEnabled) {
+      switch (this->CurrentLinkType) {
+        case LinkStatic:
+          this->Items.push_back(Item(this->StaticLinkTypeFlag, false));
+          break;
+        case LinkShared:
+          this->Items.push_back(Item(this->SharedLinkTypeFlag, false));
+          break;
+        default:
+          break;
+      }
+    }
+  }
+}
+
+void cmComputeLinkInformation::AddTargetItem(std::string const& item,
+                                             cmGeneratorTarget const* target)
+{
+  // This is called to handle a link item that is a full path to a target.
+  // If the target is not a static library make sure the link type is
+  // shared.  This is because dynamic-mode linking can handle both
+  // shared and static libraries but static-mode can handle only
+  // static libraries.  If a previous user item changed the link type
+  // to static we need to make sure it is back to shared.
+  if (target->GetType() != cmStateEnums::STATIC_LIBRARY) {
+    this->SetCurrentLinkType(LinkShared);
+  }
+
+  // Keep track of shared library targets linked.
+  if (target->GetType() == cmStateEnums::SHARED_LIBRARY) {
+    this->SharedLibrariesLinked.insert(target);
+  }
+
+  // Handle case of an imported shared library with no soname.
+  if (this->NoSONameUsesPath &&
+      target->IsImportedSharedLibWithoutSOName(this->Config)) {
+    this->AddSharedLibNoSOName(item);
+    return;
+  }
+
+  // If this platform wants a flag before the full path, add it.
+  if (!this->LibLinkFileFlag.empty()) {
+    this->Items.push_back(Item(this->LibLinkFileFlag, false));
+  }
+
+  // For compatibility with CMake 2.4 include the item's directory in
+  // the linker search path.
+  if (this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
+    this->OldLinkDirItems.push_back(item);
+  }
+
+  // Now add the full path to the library.
+  this->Items.push_back(Item(item, true, target));
+}
+
+void cmComputeLinkInformation::AddFullItem(std::string const& item)
+{
+  // Check for the implicit link directory special case.
+  if (this->CheckImplicitDirItem(item)) {
+    return;
+  }
+
+  // Check for case of shared library with no builtin soname.
+  if (this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item)) {
+    return;
+  }
+
+  // Full path libraries should specify a valid library file name.
+  // See documentation of CMP0008.
+  std::string generator = this->GlobalGenerator->GetName();
+  if (this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
+      (generator.find("Visual Studio") != std::string::npos ||
+       generator.find("Xcode") != std::string::npos)) {
+    std::string file = cmSystemTools::GetFilenameName(item);
+    if (!this->ExtractAnyLibraryName.find(file.c_str())) {
+      this->HandleBadFullItem(item, file);
+      return;
+    }
+  }
+
+  // This is called to handle a link item that is a full path.
+  // If the target is not a static library make sure the link type is
+  // shared.  This is because dynamic-mode linking can handle both
+  // shared and static libraries but static-mode can handle only
+  // static libraries.  If a previous user item changed the link type
+  // to static we need to make sure it is back to shared.
+  if (this->LinkTypeEnabled) {
+    std::string name = cmSystemTools::GetFilenameName(item);
+    if (this->ExtractSharedLibraryName.find(name)) {
+      this->SetCurrentLinkType(LinkShared);
+    } else if (!this->ExtractStaticLibraryName.find(item)) {
+      // We cannot determine the type.  Assume it is the target's
+      // default type.
+      this->SetCurrentLinkType(this->StartLinkType);
+    }
+  }
+
+  // For compatibility with CMake 2.4 include the item's directory in
+  // the linker search path.
+  if (this->OldLinkDirMode &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
+    this->OldLinkDirItems.push_back(item);
+  }
+
+  // If this platform wants a flag before the full path, add it.
+  if (!this->LibLinkFileFlag.empty()) {
+    this->Items.push_back(Item(this->LibLinkFileFlag, false));
+  }
+
+  // Now add the full path to the library.
+  this->Items.push_back(Item(item, true));
+}
+
+bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
+{
+  // We only switch to a pathless item if the link type may be
+  // enforced.  Fortunately only platforms that support link types
+  // seem to have magic per-architecture implicit link directories.
+  if (!this->LinkTypeEnabled) {
+    return false;
+  }
+
+  // Check if this item is in an implicit link directory.
+  std::string dir = cmSystemTools::GetFilenamePath(item);
+  if (this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end()) {
+    // Only libraries in implicit link directories are converted to
+    // pathless items.
+    return false;
+  }
+
+  // Only apply the policy below if the library file is one that can
+  // be found by the linker.
+  std::string file = cmSystemTools::GetFilenameName(item);
+  if (!this->ExtractAnyLibraryName.find(file)) {
+    return false;
+  }
+
+  // Check the policy for whether we should use the approach below.
+  switch (this->Target->GetPolicyStatusCMP0060()) {
+    case cmPolicies::WARN:
+      if (this->CMP0060Warn) {
+        // Print the warning at most once for this item.
+        std::string const& wid = "CMP0060-WARNING-GIVEN-" + item;
+        if (!this->CMakeInstance->GetPropertyAsBool(wid)) {
+          this->CMakeInstance->SetProperty(wid, "1");
+          this->CMP0060WarnItems.insert(item);
+        }
+      }
+    case cmPolicies::OLD:
+      break;
+    case cmPolicies::REQUIRED_ALWAYS:
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::NEW:
+      return false;
+  }
+
+  // Many system linkers support multiple architectures by
+  // automatically selecting the implicit linker search path for the
+  // current architecture.  If the library appears in an implicit link
+  // directory then just report the file name without the directory
+  // portion.  This will allow the system linker to locate the proper
+  // library for the architecture at link time.
+  this->AddUserItem(file, false);
+
+  // Make sure the link directory ordering will find the library.
+  this->OrderLinkerSearchPath->AddLinkLibrary(item);
+
+  return true;
+}
+
+void cmComputeLinkInformation::AddUserItem(std::string const& item,
+                                           bool pathNotKnown)
+{
+  // This is called to handle a link item that does not match a CMake
+  // target and is not a full path.  We check here if it looks like a
+  // library file name to automatically request the proper link type
+  // from the linker.  For example:
+  //
+  //   foo       ==>  -lfoo
+  //   libfoo.a  ==>  -Wl,-Bstatic -lfoo
+
+  // Pass flags through untouched.
+  if (item[0] == '-' || item[0] == '$' || item[0] == '`') {
+    // if this is a -l option then we might need to warn about
+    // CMP0003 so put it in OldUserFlagItems, if it is not a -l
+    // or -Wl,-l (-framework -pthread), then allow it without a
+    // CMP0003 as -L will not affect those other linker flags
+    if (item.find("-l") == 0 || item.find("-Wl,-l") == 0) {
+      // This is a linker option provided by the user.
+      this->OldUserFlagItems.push_back(item);
+    }
+
+    // Restore the target link type since this item does not specify
+    // one.
+    this->SetCurrentLinkType(this->StartLinkType);
+
+    // Use the item verbatim.
+    this->Items.push_back(Item(item, false));
+    return;
+  }
+
+  // Parse out the prefix, base, and suffix components of the
+  // library name.  If the name matches that of a shared or static
+  // library then set the link type accordingly.
+  //
+  // Search for shared library names first because some platforms
+  // have shared libraries with names that match the static library
+  // pattern.  For example cygwin and msys use the convention
+  // libfoo.dll.a for import libraries and libfoo.a for static
+  // libraries.  On AIX a library with the name libfoo.a can be
+  // shared!
+  std::string lib;
+  if (this->ExtractSharedLibraryName.find(item)) {
+// This matches a shared library file name.
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+    fprintf(stderr, "shared regex matched [%s] [%s] [%s]\n",
+            this->ExtractSharedLibraryName.match(1).c_str(),
+            this->ExtractSharedLibraryName.match(2).c_str(),
+            this->ExtractSharedLibraryName.match(3).c_str());
+#endif
+    // Set the link type to shared.
+    this->SetCurrentLinkType(LinkShared);
+
+    // Use just the library name so the linker will search.
+    lib = this->ExtractSharedLibraryName.match(2);
+  } else if (this->ExtractStaticLibraryName.find(item)) {
+// This matches a static library file name.
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+    fprintf(stderr, "static regex matched [%s] [%s] [%s]\n",
+            this->ExtractStaticLibraryName.match(1).c_str(),
+            this->ExtractStaticLibraryName.match(2).c_str(),
+            this->ExtractStaticLibraryName.match(3).c_str());
+#endif
+    // Set the link type to static.
+    this->SetCurrentLinkType(LinkStatic);
+
+    // Use just the library name so the linker will search.
+    lib = this->ExtractStaticLibraryName.match(2);
+  } else if (this->ExtractAnyLibraryName.find(item)) {
+// This matches a library file name.
+#ifdef CM_COMPUTE_LINK_INFO_DEBUG
+    fprintf(stderr, "any regex matched [%s] [%s] [%s]\n",
+            this->ExtractAnyLibraryName.match(1).c_str(),
+            this->ExtractAnyLibraryName.match(2).c_str(),
+            this->ExtractAnyLibraryName.match(3).c_str());
+#endif
+    // Restore the target link type since this item does not specify
+    // one.
+    this->SetCurrentLinkType(this->StartLinkType);
+
+    // Use just the library name so the linker will search.
+    lib = this->ExtractAnyLibraryName.match(2);
+  } else {
+    // This is a name specified by the user.
+    if (pathNotKnown) {
+      this->OldUserFlagItems.push_back(item);
+    }
+
+    // We must ask the linker to search for a library with this name.
+    // Restore the target link type since this item does not specify
+    // one.
+    this->SetCurrentLinkType(this->StartLinkType);
+    lib = item;
+  }
+
+  // Create an option to ask the linker to search for the library.
+  std::string out = this->LibLinkFlag;
+  out += lib;
+  out += this->LibLinkSuffix;
+  this->Items.push_back(Item(out, false));
+
+  // Here we could try to find the library the linker will find and
+  // add a runtime information entry for it.  It would probably not be
+  // reliable and we want to encourage use of full paths for library
+  // specification.
+}
+
+void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
+{
+  // Try to separate the framework name and path.
+  if (!this->SplitFramework.find(item.c_str())) {
+    std::ostringstream e;
+    e << "Could not parse framework path \"" << item << "\" "
+      << "linked by target " << this->Target->GetName() << ".";
+    cmSystemTools::Error(e.str().c_str());
+    return;
+  }
+
+  std::string fw_path = this->SplitFramework.match(1);
+  std::string fw = this->SplitFramework.match(2);
+  std::string full_fw = fw_path;
+  full_fw += "/";
+  full_fw += fw;
+  full_fw += ".framework";
+  full_fw += "/";
+  full_fw += fw;
+
+  // Add the directory portion to the framework search path.
+  this->AddFrameworkPath(fw_path);
+
+  // add runtime information
+  this->AddLibraryRuntimeInfo(full_fw);
+
+  // Add the item using the -framework option.
+  this->Items.push_back(Item("-framework", false));
+  cmOutputConverter converter(this->Makefile->GetStateSnapshot());
+  fw = converter.EscapeForShell(fw);
+  this->Items.push_back(Item(fw, false));
+}
+
+void cmComputeLinkInformation::AddDirectoryItem(std::string const& item)
+{
+  if (this->Makefile->IsOn("APPLE") &&
+      cmSystemTools::IsPathToFramework(item.c_str())) {
+    this->AddFrameworkItem(item);
+  } else {
+    this->DropDirectoryItem(item);
+  }
+}
+
+void cmComputeLinkInformation::DropDirectoryItem(std::string const& item)
+{
+  // A full path to a directory was found as a link item.  Warn the
+  // user.
+  std::ostringstream e;
+  e << "WARNING: Target \"" << this->Target->GetName()
+    << "\" requests linking to directory \"" << item << "\".  "
+    << "Targets may link only to libraries.  "
+    << "CMake is dropping the item.";
+  cmSystemTools::Message(e.str().c_str());
+}
+
+void cmComputeLinkInformation::ComputeFrameworkInfo()
+{
+  // Avoid adding implicit framework paths.
+  std::vector<std::string> implicitDirVec;
+
+  // Get platform-wide implicit directories.
+  if (const char* implicitLinks = this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES")) {
+    cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
+  }
+
+  // Get language-specific implicit directories.
+  std::string implicitDirVar = "CMAKE_";
+  implicitDirVar += this->LinkLanguage;
+  implicitDirVar += "_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES";
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
+    cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
+  }
+
+  this->FrameworkPathsEmmitted.insert(implicitDirVec.begin(),
+                                      implicitDirVec.end());
+
+  // Regular expression to extract a framework path and name.
+  this->SplitFramework.compile("(.*)/(.*)\\.framework$");
+}
+
+void cmComputeLinkInformation::AddFrameworkPath(std::string const& p)
+{
+  if (this->FrameworkPathsEmmitted.insert(p).second) {
+    this->FrameworkPaths.push_back(p);
+  }
+}
+
+bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
+{
+  // This platform will use the path to a library as its soname if the
+  // library is given via path and was not built with an soname.  If
+  // this is a shared library that might be the case.
+  std::string file = cmSystemTools::GetFilenameName(item);
+  if (this->ExtractSharedLibraryName.find(file)) {
+    // If we can guess the soname fairly reliably then assume the
+    // library has one.  Otherwise assume the library has no builtin
+    // soname.
+    std::string soname;
+    if (!cmSystemTools::GuessLibrarySOName(item, soname)) {
+      this->AddSharedLibNoSOName(item);
+      return true;
+    }
+  }
+  return false;
+}
+
+void cmComputeLinkInformation::AddSharedLibNoSOName(std::string const& item)
+{
+  // We have a full path to a shared library with no soname.  We need
+  // to ask the linker to locate the item because otherwise the path
+  // we give to it will be embedded in the target linked.  Then at
+  // runtime the dynamic linker will search for the library using the
+  // path instead of just the name.
+  std::string file = cmSystemTools::GetFilenameName(item);
+  this->AddUserItem(file, false);
+
+  // Make sure the link directory ordering will find the library.
+  this->OrderLinkerSearchPath->AddLinkLibrary(item);
+}
+
+void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
+                                                 std::string const& file)
+{
+  // Do not depend on things that do not exist.
+  std::vector<std::string>::iterator i =
+    std::find(this->Depends.begin(), this->Depends.end(), item);
+  if (i != this->Depends.end()) {
+    this->Depends.erase(i);
+  }
+
+  // Tell the linker to search for the item and provide the proper
+  // path for it.  Do not contribute to any CMP0003 warning (do not
+  // put in OldLinkDirItems or OldUserFlagItems).
+  this->AddUserItem(file, false);
+  this->OrderLinkerSearchPath->AddLinkLibrary(item);
+
+  // Produce any needed message.
+  switch (this->Target->GetPolicyStatusCMP0008()) {
+    case cmPolicies::WARN: {
+      // Print the warning at most once for this item.
+      std::string wid = "CMP0008-WARNING-GIVEN-";
+      wid += item;
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(wid)) {
+        this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1");
+        std::ostringstream w;
+        /* clang-format off */
+        w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0008) << "\n"
+          << "Target \"" << this->Target->GetName() << "\" links to item\n"
+          << "  " << item << "\n"
+          << "which is a full-path but not a valid library file name.";
+        /* clang-format on */
+        this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
+                                          this->Target->GetBacktrace());
+      }
+    }
+    case cmPolicies::OLD:
+      // OLD behavior does not warn.
+      break;
+    case cmPolicies::NEW:
+      // NEW behavior will not get here.
+      break;
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::REQUIRED_ALWAYS: {
+      std::ostringstream e;
+      /* clang-format off */
+      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n"
+          << "Target \"" << this->Target->GetName() << "\" links to item\n"
+          << "  " << item << "\n"
+          << "which is a full-path but not a valid library file name.";
+      /* clang-format on */
+      this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                        this->Target->GetBacktrace());
+    } break;
+  }
+}
+
+bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
+{
+  // Support broken projects if necessary.
+  if (this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() ||
+      !this->OldLinkDirMode) {
+    return true;
+  }
+
+  // Enforce policy constraints.
+  switch (this->Target->GetPolicyStatusCMP0003()) {
+    case cmPolicies::WARN:
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+            "CMP0003-WARNING-GIVEN")) {
+        this->CMakeInstance->GetState()->SetGlobalProperty(
+          "CMP0003-WARNING-GIVEN", "1");
+        std::ostringstream w;
+        this->PrintLinkPolicyDiagnosis(w);
+        this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
+                                          this->Target->GetBacktrace());
+      }
+    case cmPolicies::OLD:
+      // OLD behavior is to add the paths containing libraries with
+      // known full paths as link directories.
+      break;
+    case cmPolicies::NEW:
+      // Should never happen due to assignment of OldLinkDirMode
+      return true;
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::REQUIRED_ALWAYS: {
+      std::ostringstream e;
+      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n";
+      this->PrintLinkPolicyDiagnosis(e);
+      this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                        this->Target->GetBacktrace());
+      return false;
+    }
+  }
+
+  // Add the link directories for full path items.
+  for (std::string const& i : this->OldLinkDirItems) {
+    this->OrderLinkerSearchPath->AddLinkLibrary(i);
+  }
+  return true;
+}
+
+void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
+{
+  // Tell the user what to do.
+  /* clang-format off */
+  os << "Policy CMP0003 should be set before this line.  "
+     << "Add code such as\n"
+     << "  if(COMMAND cmake_policy)\n"
+     << "    cmake_policy(SET CMP0003 NEW)\n"
+     << "  endif(COMMAND cmake_policy)\n"
+     << "as early as possible but after the most recent call to "
+     << "cmake_minimum_required or cmake_policy(VERSION).  ";
+  /* clang-format on */
+
+  // List the items that might need the old-style paths.
+  os << "This warning appears because target \"" << this->Target->GetName()
+     << "\" "
+     << "links to some libraries for which the linker must search:\n";
+  {
+    // Format the list of unknown items to be as short as possible while
+    // still fitting in the allowed width (a true solution would be the
+    // bin packing problem if we were allowed to change the order).
+    std::string::size_type max_size = 76;
+    std::string line;
+    const char* sep = "  ";
+    for (std::string const& i : this->OldUserFlagItems) {
+      // If the addition of another item will exceed the limit then
+      // output the current line and reset it.  Note that the separator
+      // is either " " or ", " which is always 2 characters.
+      if (!line.empty() && (line.size() + i.size() + 2) > max_size) {
+        os << line << "\n";
+        sep = "  ";
+        line.clear();
+      }
+      line += sep;
+      line += i;
+      // Convert to the other separator.
+      sep = ", ";
+    }
+    if (!line.empty()) {
+      os << line << "\n";
+    }
+  }
+
+  // List the paths old behavior is adding.
+  os << "and other libraries with known full path:\n";
+  std::set<std::string> emitted;
+  for (std::string const& i : this->OldLinkDirItems) {
+    if (emitted.insert(cmSystemTools::GetFilenamePath(i)).second) {
+      os << "  " << i << "\n";
+    }
+  }
+
+  // Explain.
+  os << "CMake is adding directories in the second list to the linker "
+     << "search path in case they are needed to find libraries from the "
+     << "first list (for backwards compatibility with CMake 2.4).  "
+     << "Set policy CMP0003 to OLD or NEW to enable or disable this "
+     << "behavior explicitly.  "
+     << "Run \"cmake --help-policy CMP0003\" for more information.";
+}
+
+void cmComputeLinkInformation::LoadImplicitLinkInfo()
+{
+  std::vector<std::string> implicitDirVec;
+
+  // Get platform-wide implicit directories.
+  if (const char* implicitLinks = (this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES"))) {
+    cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
+  }
+
+  // Append library architecture to all implicit platform directories
+  // and add them to the set
+  if (const char* libraryArch =
+        this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
+    for (std::string const& i : implicitDirVec) {
+      this->ImplicitLinkDirs.insert(i + "/" + libraryArch);
+    }
+  }
+
+  // Get language-specific implicit directories.
+  std::string implicitDirVar = "CMAKE_";
+  implicitDirVar += this->LinkLanguage;
+  implicitDirVar += "_IMPLICIT_LINK_DIRECTORIES";
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
+    cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
+  }
+
+  // Store implicit link directories.
+  this->ImplicitLinkDirs.insert(implicitDirVec.begin(), implicitDirVec.end());
+
+  // Get language-specific implicit libraries.
+  std::vector<std::string> implicitLibVec;
+  std::string implicitLibVar = "CMAKE_";
+  implicitLibVar += this->LinkLanguage;
+  implicitLibVar += "_IMPLICIT_LINK_LIBRARIES";
+  if (const char* implicitLibs =
+        this->Makefile->GetDefinition(implicitLibVar)) {
+    cmSystemTools::ExpandListArgument(implicitLibs, implicitLibVec);
+  }
+
+  // Store implicit link libraries.
+  for (std::string const& item : implicitLibVec) {
+    // Items starting in '-' but not '-l' are flags, not libraries,
+    // and should not be filtered by this implicit list.
+    if (item[0] != '-' || item[1] == 'l') {
+      this->ImplicitLinkLibs.insert(item);
+    }
+  }
+
+  // Get platform specific rpath link directories
+  if (const char* rpathDirs =
+        (this->Makefile->GetDefinition("CMAKE_PLATFORM_RUNTIME_PATH"))) {
+    cmSystemTools::ExpandListArgument(rpathDirs, this->RuntimeLinkDirs);
+  }
+}
+
+std::vector<std::string> const&
+cmComputeLinkInformation::GetRuntimeSearchPath()
+{
+  return this->OrderRuntimeSearchPath->GetOrderedDirectories();
+}
+
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath, cmGeneratorTarget const* target)
+{
+  // Ignore targets on Apple where install_name is not @rpath.
+  // The dependenty library can be found with other means such as
+  // @loader_path or full paths.
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    if (!target->HasMacOSXRpathInstallNameDir(this->Config)) {
+      return;
+    }
+  }
+
+  // Libraries with unknown type must be handled using just the file
+  // on disk.
+  if (target->GetType() == cmStateEnums::UNKNOWN_LIBRARY) {
+    this->AddLibraryRuntimeInfo(fullPath);
+    return;
+  }
+
+  // Skip targets that are not shared libraries (modules cannot be linked).
+  if (target->GetType() != cmStateEnums::SHARED_LIBRARY) {
+    return;
+  }
+
+  // Try to get the soname of the library.  Only files with this name
+  // could possibly conflict.
+  std::string soName = target->GetSOName(this->Config);
+  const char* soname = soName.empty() ? nullptr : soName.c_str();
+
+  // Include this library in the runtime path ordering.
+  this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath, soname);
+  if (this->LinkWithRuntimePath) {
+    this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath, soname);
+  }
+}
+
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath)
+{
+  // Get the name of the library from the file name.
+  bool is_shared_library = false;
+  std::string file = cmSystemTools::GetFilenameName(fullPath);
+
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    // Check that @rpath is part of the install name.
+    // If it isn't, return.
+    std::string soname;
+    if (!cmSystemTools::GuessLibraryInstallName(fullPath, soname)) {
+      return;
+    }
+
+    if (soname.find("@rpath") == std::string::npos) {
+      return;
+    }
+  }
+
+  is_shared_library = this->ExtractSharedLibraryName.find(file);
+
+  if (!is_shared_library) {
+    // On some platforms (AIX) a shared library may look static.
+    if (this->ArchivesMayBeShared) {
+      if (this->ExtractStaticLibraryName.find(file.c_str())) {
+        // This is the name of a shared library or archive.
+        is_shared_library = true;
+      }
+    }
+  }
+
+  // It could be an Apple framework
+  if (!is_shared_library) {
+    if (fullPath.find(".framework") != std::string::npos) {
+      static cmsys::RegularExpression splitFramework(
+        "^(.*)/(.*).framework/(.*)$");
+      if (splitFramework.find(fullPath) &&
+          (std::string::npos !=
+           splitFramework.match(3).find(splitFramework.match(2)))) {
+        is_shared_library = true;
+      }
+    }
+  }
+
+  if (!is_shared_library) {
+    return;
+  }
+
+  // Include this library in the runtime path ordering.
+  this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath);
+  if (this->LinkWithRuntimePath) {
+    this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath);
+  }
+}
+
+static void cmCLI_ExpandListUnique(const char* str,
+                                   std::vector<std::string>& out,
+                                   std::set<std::string>& emitted)
+{
+  std::vector<std::string> tmp;
+  cmSystemTools::ExpandListArgument(str, tmp);
+  for (std::string const& i : tmp) {
+    if (emitted.insert(i).second) {
+      out.push_back(i);
+    }
+  }
+}
+
+void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
+                                        bool for_install)
+{
+  // Select whether to generate runtime search directories.
+  bool outputRuntime =
+    !this->Makefile->IsOn("CMAKE_SKIP_RPATH") && !this->RuntimeFlag.empty();
+
+  // Select whether to generate an rpath for the install tree or the
+  // build tree.
+  bool linking_for_install =
+    (for_install ||
+     this->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"));
+  bool use_install_rpath =
+    (outputRuntime && this->Target->HaveInstallTreeRPATH() &&
+     linking_for_install);
+  bool use_build_rpath =
+    (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) &&
+     !linking_for_install);
+  bool use_link_rpath = outputRuntime && linking_for_install &&
+    !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") &&
+    this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH");
+
+  // Construct the RPATH.
+  std::set<std::string> emitted;
+  if (use_install_rpath) {
+    const char* install_rpath = this->Target->GetProperty("INSTALL_RPATH");
+    cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted);
+  }
+  if (use_build_rpath) {
+    // Add directories explicitly specified by user
+    if (const char* build_rpath = this->Target->GetProperty("BUILD_RPATH")) {
+      cmCLI_ExpandListUnique(build_rpath, runtimeDirs, emitted);
+    }
+  }
+  if (use_build_rpath || use_link_rpath) {
+    std::string rootPath;
+    if (const char* sysrootLink =
+          this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK")) {
+      rootPath = sysrootLink;
+    } else {
+      rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
+    }
+    const char* stagePath =
+      this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
+    const char* installPrefix =
+      this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+    cmSystemTools::ConvertToUnixSlashes(rootPath);
+    std::vector<std::string> const& rdirs = this->GetRuntimeSearchPath();
+    for (std::string const& ri : rdirs) {
+      // Put this directory in the rpath if using build-tree rpath
+      // support or if using the link path as an rpath.
+      if (use_build_rpath) {
+        std::string d = ri;
+        if (!rootPath.empty() && d.find(rootPath) == 0) {
+          d = d.substr(rootPath.size());
+        } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
+          std::string suffix = d.substr(strlen(stagePath));
+          d = installPrefix;
+          d += "/";
+          d += suffix;
+          cmSystemTools::ConvertToUnixSlashes(d);
+        }
+        if (emitted.insert(d).second) {
+          runtimeDirs.push_back(d);
+        }
+      } else if (use_link_rpath) {
+        // Do not add any path inside the source or build tree.
+        const char* topSourceDir = this->CMakeInstance->GetHomeDirectory();
+        const char* topBinaryDir =
+          this->CMakeInstance->GetHomeOutputDirectory();
+        if (!cmSystemTools::ComparePath(ri, topSourceDir) &&
+            !cmSystemTools::ComparePath(ri, topBinaryDir) &&
+            !cmSystemTools::IsSubDirectory(ri, topSourceDir) &&
+            !cmSystemTools::IsSubDirectory(ri, topBinaryDir)) {
+          std::string d = ri;
+          if (!rootPath.empty() && d.find(rootPath) == 0) {
+            d = d.substr(rootPath.size());
+          } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
+            std::string suffix = d.substr(strlen(stagePath));
+            d = installPrefix;
+            d += "/";
+            d += suffix;
+            cmSystemTools::ConvertToUnixSlashes(d);
+          }
+          if (emitted.insert(d).second) {
+            runtimeDirs.push_back(d);
+          }
+        }
+      }
+    }
+  }
+
+  // Add runtime paths required by the languages to always be
+  // present.  This is done even when skipping rpath support.
+  {
+    cmGeneratorTarget::LinkClosure const* lc =
+      this->Target->GetLinkClosure(this->Config);
+    for (std::string const& li : lc->Languages) {
+      std::string useVar =
+        "CMAKE_" + li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
+      if (this->Makefile->IsOn(useVar)) {
+        std::string dirVar = "CMAKE_" + li + "_IMPLICIT_LINK_DIRECTORIES";
+        if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
+          cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
+        }
+      }
+    }
+  }
+
+  // Add runtime paths required by the platform to always be
+  // present.  This is done even when skipping rpath support.
+  cmCLI_ExpandListUnique(this->RuntimeAlways.c_str(), runtimeDirs, emitted);
+}
+
+std::string cmComputeLinkInformation::GetRPathString(bool for_install)
+{
+  // Get the directories to use.
+  std::vector<std::string> runtimeDirs;
+  this->GetRPath(runtimeDirs, for_install);
+
+  // Concatenate the paths.
+  std::string rpath = cmJoin(runtimeDirs, this->GetRuntimeSep());
+
+  // If the rpath will be replaced at install time, prepare space.
+  if (!for_install && this->RuntimeUseChrpath) {
+    if (!rpath.empty()) {
+      // Add one trailing separator so the linker does not re-use the
+      // rpath .dynstr entry for a symbol name that happens to match
+      // the end of the rpath string.
+      rpath += this->GetRuntimeSep();
+    }
+
+    // Make sure it is long enough to hold the replacement value.
+    std::string::size_type minLength = this->GetChrpathString().length();
+    while (rpath.length() < minLength) {
+      rpath += this->GetRuntimeSep();
+    }
+  }
+
+  return rpath;
+}
+
+std::string cmComputeLinkInformation::GetChrpathString()
+{
+  if (!this->RuntimeUseChrpath) {
+    return "";
+  }
+
+  return this->GetRPathString(true);
+}
diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h
new file mode 100644
index 0000000..f8c6214
--- /dev/null
+++ b/Source/cmComputeLinkInformation.h
@@ -0,0 +1,199 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmComputeLinkInformation_h
+#define cmComputeLinkInformation_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/RegularExpression.hxx"
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmGeneratorTarget;
+class cmGlobalGenerator;
+class cmMakefile;
+class cmOrderDirectories;
+class cmake;
+
+/** \class cmComputeLinkInformation
+ * \brief Compute link information for a target in one configuration.
+ */
+class cmComputeLinkInformation
+{
+public:
+  cmComputeLinkInformation(cmGeneratorTarget const* target,
+                           const std::string& config);
+  ~cmComputeLinkInformation();
+  bool Compute();
+
+  struct Item
+  {
+    Item()
+      : Value()
+      , IsPath(true)
+      , Target(nullptr)
+    {
+    }
+    Item(std::string const& v, bool p,
+         cmGeneratorTarget const* target = nullptr)
+      : Value(v)
+      , IsPath(p)
+      , Target(target)
+    {
+    }
+    std::string Value;
+    bool IsPath;
+    cmGeneratorTarget const* Target;
+  };
+  typedef std::vector<Item> ItemVector;
+  ItemVector const& GetItems();
+  std::vector<std::string> const& GetDirectories();
+  std::vector<std::string> const& GetDepends();
+  std::vector<std::string> const& GetFrameworkPaths();
+  std::string GetLinkLanguage() const { return this->LinkLanguage; }
+  std::vector<std::string> const& GetRuntimeSearchPath();
+  std::string const& GetRuntimeFlag() const { return this->RuntimeFlag; }
+  std::string const& GetRuntimeSep() const { return this->RuntimeSep; }
+  void GetRPath(std::vector<std::string>& runtimeDirs, bool for_install);
+  std::string GetRPathString(bool for_install);
+  std::string GetChrpathString();
+  std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked();
+
+  std::string const& GetRPathLinkFlag() const { return this->RPathLinkFlag; }
+  std::string GetRPathLinkString();
+
+  std::string GetConfig() const { return this->Config; }
+private:
+  void AddItem(std::string const& item, const cmGeneratorTarget* tgt);
+  void AddSharedDepItem(std::string const& item, cmGeneratorTarget const* tgt);
+
+  // Output information.
+  ItemVector Items;
+  std::vector<std::string> Directories;
+  std::vector<std::string> Depends;
+  std::vector<std::string> FrameworkPaths;
+  std::vector<std::string> RuntimeSearchPath;
+  std::set<cmGeneratorTarget const*> SharedLibrariesLinked;
+
+  // Context information.
+  cmGeneratorTarget const* Target;
+  cmMakefile* Makefile;
+  cmGlobalGenerator* GlobalGenerator;
+  cmake* CMakeInstance;
+
+  // Configuration information.
+  std::string Config;
+  std::string LinkLanguage;
+
+  // Modes for dealing with dependent shared libraries.
+  enum SharedDepMode
+  {
+    SharedDepModeNone,   // Drop
+    SharedDepModeDir,    // List dir in -rpath-link flag
+    SharedDepModeLibDir, // List dir in linker search path
+    SharedDepModeLink    // List file on link line
+  };
+
+  const char* LoaderFlag;
+  std::string LibLinkFlag;
+  std::string LibLinkFileFlag;
+  std::string LibLinkSuffix;
+  std::string RuntimeFlag;
+  std::string RuntimeSep;
+  std::string RuntimeAlways;
+  std::string RPathLinkFlag;
+  SharedDepMode SharedDependencyMode;
+
+  enum LinkType
+  {
+    LinkUnknown,
+    LinkStatic,
+    LinkShared
+  };
+  void SetCurrentLinkType(LinkType lt);
+
+  // Link type adjustment.
+  void ComputeLinkTypeInfo();
+  LinkType StartLinkType;
+  LinkType CurrentLinkType;
+  std::string StaticLinkTypeFlag;
+  std::string SharedLinkTypeFlag;
+
+  // Link item parsing.
+  void ComputeItemParserInfo();
+  std::vector<std::string> StaticLinkExtensions;
+  std::vector<std::string> SharedLinkExtensions;
+  std::vector<std::string> LinkExtensions;
+  std::set<std::string> LinkPrefixes;
+  cmsys::RegularExpression ExtractStaticLibraryName;
+  cmsys::RegularExpression ExtractSharedLibraryName;
+  cmsys::RegularExpression ExtractAnyLibraryName;
+  std::string SharedRegexString;
+  void AddLinkPrefix(const char* p);
+  void AddLinkExtension(const char* e, LinkType type);
+  std::string CreateExtensionRegex(std::vector<std::string> const& exts,
+                                   LinkType type);
+  std::string NoCaseExpression(const char* str);
+
+  // Handling of link items.
+  void AddTargetItem(std::string const& item, const cmGeneratorTarget* target);
+  void AddFullItem(std::string const& item);
+  bool CheckImplicitDirItem(std::string const& item);
+  void AddUserItem(std::string const& item, bool pathNotKnown);
+  void AddDirectoryItem(std::string const& item);
+  void AddFrameworkItem(std::string const& item);
+  void DropDirectoryItem(std::string const& item);
+  bool CheckSharedLibNoSOName(std::string const& item);
+  void AddSharedLibNoSOName(std::string const& item);
+  void HandleBadFullItem(std::string const& item, std::string const& file);
+
+  // Framework info.
+  void ComputeFrameworkInfo();
+  void AddFrameworkPath(std::string const& p);
+  std::set<std::string> FrameworkPathsEmmitted;
+  cmsys::RegularExpression SplitFramework;
+
+  // Linker search path computation.
+  cmOrderDirectories* OrderLinkerSearchPath;
+  bool FinishLinkerSearchDirectories();
+  void PrintLinkPolicyDiagnosis(std::ostream&);
+
+  // Implicit link libraries and directories for linker language.
+  void LoadImplicitLinkInfo();
+  void AddImplicitLinkInfo();
+  void AddImplicitLinkInfo(std::string const& lang);
+  std::set<std::string> ImplicitLinkDirs;
+  std::set<std::string> ImplicitLinkLibs;
+
+  // Additional paths configured by the runtime linker
+  std::vector<std::string> RuntimeLinkDirs;
+
+  // Linker search path compatibility mode.
+  std::set<std::string> OldLinkDirMask;
+  std::vector<std::string> OldLinkDirItems;
+  std::vector<std::string> OldUserFlagItems;
+  std::set<std::string> CMP0060WarnItems;
+  // Dependent library path computation.
+  cmOrderDirectories* OrderDependentRPath;
+  // Runtime path computation.
+  cmOrderDirectories* OrderRuntimeSearchPath;
+
+  bool OldLinkDirMode;
+  bool OpenBSD;
+  bool LinkDependsNoShared;
+  bool UseImportLibrary;
+  bool RuntimeUseChrpath;
+  bool NoSONameUsesPath;
+  bool LinkWithRuntimePath;
+  bool LinkTypeEnabled;
+  bool ArchivesMayBeShared;
+  bool CMP0060Warn;
+
+  void AddLibraryRuntimeInfo(std::string const& fullPath,
+                             const cmGeneratorTarget* target);
+  void AddLibraryRuntimeInfo(std::string const& fullPath);
+};
+
+#endif
diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx
new file mode 100644
index 0000000..963c2df
--- /dev/null
+++ b/Source/cmComputeTargetDepends.cxx
@@ -0,0 +1,571 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmComputeTargetDepends.h"
+
+#include "cmComputeComponentGraph.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalGenerator.h"
+#include "cmLinkItem.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmSourceFile.h"
+#include "cmState.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetDepend.h"
+#include "cmake.h"
+
+#include <assert.h>
+#include <sstream>
+#include <stdio.h>
+#include <utility>
+
+class cmListFileBacktrace;
+
+/*
+
+This class is meant to analyze inter-target dependencies globally
+during the generation step.  The goal is to produce a set of direct
+dependencies for each target such that no cycles are left and the
+build order is safe.
+
+For most target types cyclic dependencies are not allowed.  However
+STATIC libraries may depend on each other in a cyclic fashion.  In
+general the directed dependency graph forms a directed-acyclic-graph
+of strongly connected components.  All strongly connected components
+should consist of only STATIC_LIBRARY targets.
+
+In order to safely break dependency cycles we must preserve all other
+dependencies passing through the corresponding strongly connected component.
+The approach taken by this class is as follows:
+
+  - Collect all targets and form the original dependency graph
+  - Run Tarjan's algorithm to extract the strongly connected components
+    (error if any member of a non-trivial component is not STATIC)
+  - The original dependencies imply a DAG on the components.
+    Use the implied DAG to construct a final safe set of dependencies.
+
+The final dependency set is constructed as follows:
+
+  - For each connected component targets are placed in an arbitrary
+    order.  Each target depends on the target following it in the order.
+    The first target is designated the head and the last target the tail.
+    (most components will be just 1 target anyway)
+
+  - Original dependencies between targets in different components are
+    converted to connect the depender's component tail to the
+    dependee's component head.
+
+In most cases this will reproduce the original dependencies.  However
+when there are cycles of static libraries they will be broken in a
+safe manner.
+
+For example, consider targets A0, A1, A2, B0, B1, B2, and C with these
+dependencies:
+
+  A0 -> A1 -> A2 -> A0  ,  B0 -> B1 -> B2 -> B0 -> A0  ,  C -> B0
+
+Components may be identified as
+
+  Component 0: A0, A1, A2
+  Component 1: B0, B1, B2
+  Component 2: C
+
+Intra-component dependencies are:
+
+  0: A0 -> A1 -> A2   , head=A0, tail=A2
+  1: B0 -> B1 -> B2   , head=B0, tail=B2
+  2: head=C, tail=C
+
+The inter-component dependencies are converted as:
+
+  B0 -> A0  is component 1->0 and becomes  B2 -> A0
+  C  -> B0  is component 2->1 and becomes  C  -> B0
+
+This leads to the final target dependencies:
+
+  C -> B0 -> B1 -> B2 -> A0 -> A1 -> A2
+
+These produce a safe build order since C depends directly or
+transitively on all the static libraries it links.
+
+*/
+
+cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg)
+{
+  this->GlobalGenerator = gg;
+  cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+  this->DebugMode =
+    cm->GetState()->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE");
+  this->NoCycles =
+    cm->GetState()->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES");
+}
+
+cmComputeTargetDepends::~cmComputeTargetDepends()
+{
+}
+
+bool cmComputeTargetDepends::Compute()
+{
+  // Build the original graph.
+  this->CollectTargets();
+  this->CollectDepends();
+  if (this->DebugMode) {
+    this->DisplayGraph(this->InitialGraph, "initial");
+  }
+
+  // Identify components.
+  cmComputeComponentGraph ccg(this->InitialGraph);
+  if (this->DebugMode) {
+    this->DisplayComponents(ccg);
+  }
+  if (!this->CheckComponents(ccg)) {
+    return false;
+  }
+
+  // Compute the final dependency graph.
+  if (!this->ComputeFinalDepends(ccg)) {
+    return false;
+  }
+  if (this->DebugMode) {
+    this->DisplayGraph(this->FinalGraph, "final");
+  }
+
+  return true;
+}
+
+void cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
+                                                    cmTargetDependSet& deps)
+{
+  // Lookup the index for this target.  All targets should be known by
+  // this point.
+  std::map<cmGeneratorTarget const*, int>::const_iterator tii =
+    this->TargetIndex.find(t);
+  assert(tii != this->TargetIndex.end());
+  int i = tii->second;
+
+  // Get its final dependencies.
+  EdgeList const& nl = this->FinalGraph[i];
+  for (cmGraphEdge const& ni : nl) {
+    cmGeneratorTarget const* dep = this->Targets[ni];
+    cmTargetDependSet::iterator di = deps.insert(dep).first;
+    di->SetType(ni.IsStrong());
+  }
+}
+
+void cmComputeTargetDepends::CollectTargets()
+{
+  // Collect all targets from all generators.
+  std::vector<cmLocalGenerator*> const& lgens =
+    this->GlobalGenerator->GetLocalGenerators();
+  for (cmLocalGenerator* lgen : lgens) {
+    const std::vector<cmGeneratorTarget*>& targets =
+      lgen->GetGeneratorTargets();
+    for (cmGeneratorTarget const* ti : targets) {
+      int index = static_cast<int>(this->Targets.size());
+      this->TargetIndex[ti] = index;
+      this->Targets.push_back(ti);
+    }
+  }
+}
+
+void cmComputeTargetDepends::CollectDepends()
+{
+  // Allocate the dependency graph adjacency lists.
+  this->InitialGraph.resize(this->Targets.size());
+
+  // Compute each dependency list.
+  for (unsigned int i = 0; i < this->Targets.size(); ++i) {
+    this->CollectTargetDepends(i);
+  }
+}
+
+void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
+{
+  // Get the depender.
+  cmGeneratorTarget const* depender = this->Targets[depender_index];
+  if (depender->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+    return;
+  }
+
+  // Loop over all targets linked directly in all configs.
+  // We need to make targets depend on the union of all config-specific
+  // dependencies in all targets, because the generated build-systems can't
+  // deal with config-specific dependencies.
+  {
+    std::set<std::string> emitted;
+
+    std::vector<std::string> configs;
+    depender->Makefile->GetConfigurations(configs);
+    if (configs.empty()) {
+      configs.push_back("");
+    }
+    for (std::string const& it : configs) {
+      std::vector<cmSourceFile const*> objectFiles;
+      depender->GetExternalObjects(objectFiles, it);
+      for (cmSourceFile const* o : objectFiles) {
+        std::string objLib = o->GetObjectLibrary();
+        if (!objLib.empty() && emitted.insert(objLib).second) {
+          if (depender->GetType() != cmStateEnums::EXECUTABLE &&
+              depender->GetType() != cmStateEnums::STATIC_LIBRARY &&
+              depender->GetType() != cmStateEnums::SHARED_LIBRARY &&
+              depender->GetType() != cmStateEnums::MODULE_LIBRARY) {
+            this->GlobalGenerator->GetCMakeInstance()->IssueMessage(
+              cmake::FATAL_ERROR,
+              "Only executables and non-OBJECT libraries may "
+              "reference target objects.",
+              depender->GetBacktrace());
+            return;
+          }
+          const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib);
+        }
+      }
+
+      cmLinkImplementation const* impl = depender->GetLinkImplementation(it);
+
+      // A target should not depend on itself.
+      emitted.insert(depender->GetName());
+      for (cmLinkImplItem const& lib : impl->Libraries) {
+        // Don't emit the same library twice for this target.
+        if (emitted.insert(lib).second) {
+          this->AddTargetDepend(depender_index, lib, true);
+          this->AddInterfaceDepends(depender_index, lib, it, emitted);
+        }
+      }
+    }
+  }
+
+  // Loop over all utility dependencies.
+  {
+    std::set<cmLinkItem> const& tutils = depender->GetUtilityItems();
+    std::set<std::string> emitted;
+    // A target should not depend on itself.
+    emitted.insert(depender->GetName());
+    for (cmLinkItem const& litem : tutils) {
+      // Don't emit the same utility twice for this target.
+      if (emitted.insert(litem).second) {
+        this->AddTargetDepend(depender_index, litem, false);
+      }
+    }
+  }
+}
+
+void cmComputeTargetDepends::AddInterfaceDepends(
+  int depender_index, const cmGeneratorTarget* dependee,
+  const std::string& config, std::set<std::string>& emitted)
+{
+  cmGeneratorTarget const* depender = this->Targets[depender_index];
+  if (cmLinkInterface const* iface =
+        dependee->GetLinkInterface(config, depender)) {
+    for (cmLinkItem const& lib : iface->Libraries) {
+      // Don't emit the same library twice for this target.
+      if (emitted.insert(lib).second) {
+        this->AddTargetDepend(depender_index, lib, true);
+        this->AddInterfaceDepends(depender_index, lib, config, emitted);
+      }
+    }
+  }
+}
+
+void cmComputeTargetDepends::AddInterfaceDepends(
+  int depender_index, cmLinkItem const& dependee_name,
+  const std::string& config, std::set<std::string>& emitted)
+{
+  cmGeneratorTarget const* depender = this->Targets[depender_index];
+  cmGeneratorTarget const* dependee = dependee_name.Target;
+  // Skip targets that will not really be linked.  This is probably a
+  // name conflict between an external library and an executable
+  // within the project.
+  if (dependee && dependee->GetType() == cmStateEnums::EXECUTABLE &&
+      !dependee->IsExecutableWithExports()) {
+    dependee = nullptr;
+  }
+
+  if (dependee) {
+    // A target should not depend on itself.
+    emitted.insert(depender->GetName());
+    this->AddInterfaceDepends(depender_index, dependee, config, emitted);
+  }
+}
+
+void cmComputeTargetDepends::AddTargetDepend(int depender_index,
+                                             cmLinkItem const& dependee_name,
+                                             bool linking)
+{
+  // Get the depender.
+  cmGeneratorTarget const* depender = this->Targets[depender_index];
+
+  // Check the target's makefile first.
+  cmGeneratorTarget const* dependee = dependee_name.Target;
+
+  if (!dependee && !linking &&
+      (depender->GetType() != cmStateEnums::GLOBAL_TARGET)) {
+    cmake::MessageType messageType = cmake::AUTHOR_WARNING;
+    bool issueMessage = false;
+    std::ostringstream e;
+    switch (depender->GetPolicyStatusCMP0046()) {
+      case cmPolicies::WARN:
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n";
+        issueMessage = true;
+      case cmPolicies::OLD:
+        break;
+      case cmPolicies::NEW:
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::REQUIRED_ALWAYS:
+        issueMessage = true;
+        messageType = cmake::FATAL_ERROR;
+    }
+    if (issueMessage) {
+      cmake* cm = this->GlobalGenerator->GetCMakeInstance();
+
+      e << "The dependency target \"" << dependee_name << "\" of target \""
+        << depender->GetName() << "\" does not exist.";
+
+      cmListFileBacktrace const* backtrace =
+        depender->GetUtilityBacktrace(dependee_name);
+      if (backtrace) {
+        cm->IssueMessage(messageType, e.str(), *backtrace);
+      } else {
+        cm->IssueMessage(messageType, e.str());
+      }
+    }
+  }
+
+  // Skip targets that will not really be linked.  This is probably a
+  // name conflict between an external library and an executable
+  // within the project.
+  if (linking && dependee && dependee->GetType() == cmStateEnums::EXECUTABLE &&
+      !dependee->IsExecutableWithExports()) {
+    dependee = nullptr;
+  }
+
+  if (dependee) {
+    this->AddTargetDepend(depender_index, dependee, linking);
+  }
+}
+
+void cmComputeTargetDepends::AddTargetDepend(int depender_index,
+                                             const cmGeneratorTarget* dependee,
+                                             bool linking)
+{
+  if (dependee->IsImported() ||
+      dependee->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+    // Skip IMPORTED and INTERFACE targets but follow their utility
+    // dependencies.
+    std::set<cmLinkItem> const& utils = dependee->GetUtilityItems();
+    for (cmLinkItem const& i : utils) {
+      if (cmGeneratorTarget const* transitive_dependee = i.Target) {
+        this->AddTargetDepend(depender_index, transitive_dependee, false);
+      }
+    }
+  } else {
+    // Lookup the index for this target.  All targets should be known by
+    // this point.
+    std::map<cmGeneratorTarget const*, int>::const_iterator tii =
+      this->TargetIndex.find(dependee);
+    assert(tii != this->TargetIndex.end());
+    int dependee_index = tii->second;
+
+    // Add this entry to the dependency graph.
+    this->InitialGraph[depender_index].push_back(
+      cmGraphEdge(dependee_index, !linking));
+  }
+}
+
+void cmComputeTargetDepends::DisplayGraph(Graph const& graph,
+                                          const std::string& name)
+{
+  fprintf(stderr, "The %s target dependency graph is:\n", name.c_str());
+  int n = static_cast<int>(graph.size());
+  for (int depender_index = 0; depender_index < n; ++depender_index) {
+    EdgeList const& nl = graph[depender_index];
+    cmGeneratorTarget const* depender = this->Targets[depender_index];
+    fprintf(stderr, "target %d is [%s]\n", depender_index,
+            depender->GetName().c_str());
+    for (cmGraphEdge const& ni : nl) {
+      int dependee_index = ni;
+      cmGeneratorTarget const* dependee = this->Targets[dependee_index];
+      fprintf(stderr, "  depends on target %d [%s] (%s)\n", dependee_index,
+              dependee->GetName().c_str(), ni.IsStrong() ? "strong" : "weak");
+    }
+  }
+  fprintf(stderr, "\n");
+}
+
+void cmComputeTargetDepends::DisplayComponents(
+  cmComputeComponentGraph const& ccg)
+{
+  fprintf(stderr, "The strongly connected components are:\n");
+  std::vector<NodeList> const& components = ccg.GetComponents();
+  int n = static_cast<int>(components.size());
+  for (int c = 0; c < n; ++c) {
+    NodeList const& nl = components[c];
+    fprintf(stderr, "Component (%d):\n", c);
+    for (int i : nl) {
+      fprintf(stderr, "  contains target %d [%s]\n", i,
+              this->Targets[i]->GetName().c_str());
+    }
+  }
+  fprintf(stderr, "\n");
+}
+
+bool cmComputeTargetDepends::CheckComponents(
+  cmComputeComponentGraph const& ccg)
+{
+  // All non-trivial components should consist only of static
+  // libraries.
+  std::vector<NodeList> const& components = ccg.GetComponents();
+  int nc = static_cast<int>(components.size());
+  for (int c = 0; c < nc; ++c) {
+    // Get the current component.
+    NodeList const& nl = components[c];
+
+    // Skip trivial components.
+    if (nl.size() < 2) {
+      continue;
+    }
+
+    // Immediately complain if no cycles are allowed at all.
+    if (this->NoCycles) {
+      this->ComplainAboutBadComponent(ccg, c);
+      return false;
+    }
+
+    // Make sure the component is all STATIC_LIBRARY targets.
+    for (int ni : nl) {
+      if (this->Targets[ni]->GetType() != cmStateEnums::STATIC_LIBRARY) {
+        this->ComplainAboutBadComponent(ccg, c);
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void cmComputeTargetDepends::ComplainAboutBadComponent(
+  cmComputeComponentGraph const& ccg, int c, bool strong)
+{
+  // Construct the error message.
+  std::ostringstream e;
+  e << "The inter-target dependency graph contains the following "
+    << "strongly connected component (cycle):\n";
+  std::vector<NodeList> const& components = ccg.GetComponents();
+  std::vector<int> const& cmap = ccg.GetComponentMap();
+  NodeList const& cl = components[c];
+  for (int i : cl) {
+    // Get the depender.
+    cmGeneratorTarget const* depender = this->Targets[i];
+
+    // Describe the depender.
+    e << "  \"" << depender->GetName() << "\" of type "
+      << cmState::GetTargetTypeName(depender->GetType()) << "\n";
+
+    // List its dependencies that are inside the component.
+    EdgeList const& nl = this->InitialGraph[i];
+    for (cmGraphEdge const& ni : nl) {
+      int j = ni;
+      if (cmap[j] == c) {
+        cmGeneratorTarget const* dependee = this->Targets[j];
+        e << "    depends on \"" << dependee->GetName() << "\""
+          << " (" << (ni.IsStrong() ? "strong" : "weak") << ")\n";
+      }
+    }
+  }
+  if (strong) {
+    // Custom command executable dependencies cannot occur within a
+    // component of static libraries.  The cycle must appear in calls
+    // to add_dependencies.
+    e << "The component contains at least one cycle consisting of strong "
+      << "dependencies (created by add_dependencies) that cannot be broken.";
+  } else if (this->NoCycles) {
+    e << "The GLOBAL_DEPENDS_NO_CYCLES global property is enabled, so "
+      << "cyclic dependencies are not allowed even among static libraries.";
+  } else {
+    e << "At least one of these targets is not a STATIC_LIBRARY.  "
+      << "Cyclic dependencies are allowed only among static libraries.";
+  }
+  cmSystemTools::Error(e.str().c_str());
+}
+
+bool cmComputeTargetDepends::IntraComponent(std::vector<int> const& cmap,
+                                            int c, int i, int* head,
+                                            std::set<int>& emitted,
+                                            std::set<int>& visited)
+{
+  if (!visited.insert(i).second) {
+    // Cycle in utility depends!
+    return false;
+  }
+  if (emitted.insert(i).second) {
+    // Honor strong intra-component edges in the final order.
+    EdgeList const& el = this->InitialGraph[i];
+    for (cmGraphEdge const& edge : el) {
+      int j = edge;
+      if (cmap[j] == c && edge.IsStrong()) {
+        this->FinalGraph[i].push_back(cmGraphEdge(j, true));
+        if (!this->IntraComponent(cmap, c, j, head, emitted, visited)) {
+          return false;
+        }
+      }
+    }
+
+    // Prepend to a linear linked-list of intra-component edges.
+    if (*head >= 0) {
+      this->FinalGraph[i].push_back(cmGraphEdge(*head, false));
+    } else {
+      this->ComponentTail[c] = i;
+    }
+    *head = i;
+  }
+  return true;
+}
+
+bool cmComputeTargetDepends::ComputeFinalDepends(
+  cmComputeComponentGraph const& ccg)
+{
+  // Get the component graph information.
+  std::vector<NodeList> const& components = ccg.GetComponents();
+  Graph const& cgraph = ccg.GetComponentGraph();
+
+  // Allocate the final graph.
+  this->FinalGraph.resize(0);
+  this->FinalGraph.resize(this->InitialGraph.size());
+
+  // Choose intra-component edges to linearize dependencies.
+  std::vector<int> const& cmap = ccg.GetComponentMap();
+  this->ComponentHead.resize(components.size());
+  this->ComponentTail.resize(components.size());
+  int nc = static_cast<int>(components.size());
+  for (int c = 0; c < nc; ++c) {
+    int head = -1;
+    std::set<int> emitted;
+    NodeList const& nl = components[c];
+    for (NodeList::const_reverse_iterator ni = nl.rbegin(); ni != nl.rend();
+         ++ni) {
+      std::set<int> visited;
+      if (!this->IntraComponent(cmap, c, *ni, &head, emitted, visited)) {
+        // Cycle in add_dependencies within component!
+        this->ComplainAboutBadComponent(ccg, c, true);
+        return false;
+      }
+    }
+    this->ComponentHead[c] = head;
+  }
+
+  // Convert inter-component edges to connect component tails to heads.
+  int n = static_cast<int>(cgraph.size());
+  for (int depender_component = 0; depender_component < n;
+       ++depender_component) {
+    int depender_component_tail = this->ComponentTail[depender_component];
+    EdgeList const& nl = cgraph[depender_component];
+    for (cmGraphEdge const& ni : nl) {
+      int dependee_component = ni;
+      int dependee_component_head = this->ComponentHead[dependee_component];
+      this->FinalGraph[depender_component_tail].push_back(
+        cmGraphEdge(dependee_component_head, ni.IsStrong()));
+    }
+  }
+  return true;
+}
diff --git a/Source/cmComputeTargetDepends.h b/Source/cmComputeTargetDepends.h
new file mode 100644
index 0000000..e93e376
--- /dev/null
+++ b/Source/cmComputeTargetDepends.h
@@ -0,0 +1,89 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmComputeTargetDepends_h
+#define cmComputeTargetDepends_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmGraphAdjacencyList.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmComputeComponentGraph;
+class cmGeneratorTarget;
+class cmGlobalGenerator;
+class cmLinkItem;
+class cmTargetDependSet;
+
+/** \class cmComputeTargetDepends
+ * \brief Compute global interdependencies among targets.
+ *
+ * Static libraries may form cycles in the target dependency graph.
+ * This class evaluates target dependencies globally and adjusts them
+ * to remove cycles while preserving a safe build order.
+ */
+class cmComputeTargetDepends
+{
+public:
+  cmComputeTargetDepends(cmGlobalGenerator* gg);
+  ~cmComputeTargetDepends();
+
+  bool Compute();
+
+  std::vector<cmGeneratorTarget const*> const& GetTargets() const
+  {
+    return this->Targets;
+  }
+  void GetTargetDirectDepends(cmGeneratorTarget const* t,
+                              cmTargetDependSet& deps);
+
+private:
+  void CollectTargets();
+  void CollectDepends();
+  void CollectTargetDepends(int depender_index);
+  void AddTargetDepend(int depender_index, cmLinkItem const& dependee_name,
+                       bool linking);
+  void AddTargetDepend(int depender_index, cmGeneratorTarget const* dependee,
+                       bool linking);
+  bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
+  void AddInterfaceDepends(int depender_index, cmLinkItem const& dependee_name,
+                           const std::string& config,
+                           std::set<std::string>& emitted);
+  void AddInterfaceDepends(int depender_index,
+                           cmGeneratorTarget const* dependee,
+                           const std::string& config,
+                           std::set<std::string>& emitted);
+  cmGlobalGenerator* GlobalGenerator;
+  bool DebugMode;
+  bool NoCycles;
+
+  // Collect all targets.
+  std::vector<cmGeneratorTarget const*> Targets;
+  std::map<cmGeneratorTarget const*, int> TargetIndex;
+
+  // Represent the target dependency graph.  The entry at each
+  // top-level index corresponds to a depender whose dependencies are
+  // listed.
+  typedef cmGraphNodeList NodeList;
+  typedef cmGraphEdgeList EdgeList;
+  typedef cmGraphAdjacencyList Graph;
+  Graph InitialGraph;
+  Graph FinalGraph;
+  void DisplayGraph(Graph const& graph, const std::string& name);
+
+  // Deal with connected components.
+  void DisplayComponents(cmComputeComponentGraph const& ccg);
+  bool CheckComponents(cmComputeComponentGraph const& ccg);
+  void ComplainAboutBadComponent(cmComputeComponentGraph const& ccg, int c,
+                                 bool strong = false);
+
+  std::vector<int> ComponentHead;
+  std::vector<int> ComponentTail;
+  bool IntraComponent(std::vector<int> const& cmap, int c, int i, int* head,
+                      std::set<int>& emitted, std::set<int>& visited);
+};
+
+#endif
diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx
new file mode 100644
index 0000000..90b3f6d
--- /dev/null
+++ b/Source/cmConditionEvaluator.cxx
@@ -0,0 +1,755 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmConditionEvaluator.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <algorithm>
+#include <sstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmAlgorithms.h"
+#include "cmMakefile.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+
+class cmCommand;
+class cmTest;
+
+static std::string const keyAND = "AND";
+static std::string const keyCOMMAND = "COMMAND";
+static std::string const keyDEFINED = "DEFINED";
+static std::string const keyEQUAL = "EQUAL";
+static std::string const keyEXISTS = "EXISTS";
+static std::string const keyGREATER = "GREATER";
+static std::string const keyGREATER_EQUAL = "GREATER_EQUAL";
+static std::string const keyIN_LIST = "IN_LIST";
+static std::string const keyIS_ABSOLUTE = "IS_ABSOLUTE";
+static std::string const keyIS_DIRECTORY = "IS_DIRECTORY";
+static std::string const keyIS_NEWER_THAN = "IS_NEWER_THAN";
+static std::string const keyIS_SYMLINK = "IS_SYMLINK";
+static std::string const keyLESS = "LESS";
+static std::string const keyLESS_EQUAL = "LESS_EQUAL";
+static std::string const keyMATCHES = "MATCHES";
+static std::string const keyNOT = "NOT";
+static std::string const keyOR = "OR";
+static std::string const keyParenL = "(";
+static std::string const keyParenR = ")";
+static std::string const keyPOLICY = "POLICY";
+static std::string const keySTREQUAL = "STREQUAL";
+static std::string const keySTRGREATER = "STRGREATER";
+static std::string const keySTRGREATER_EQUAL = "STRGREATER_EQUAL";
+static std::string const keySTRLESS = "STRLESS";
+static std::string const keySTRLESS_EQUAL = "STRLESS_EQUAL";
+static std::string const keyTARGET = "TARGET";
+static std::string const keyTEST = "TEST";
+static std::string const keyVERSION_EQUAL = "VERSION_EQUAL";
+static std::string const keyVERSION_GREATER = "VERSION_GREATER";
+static std::string const keyVERSION_GREATER_EQUAL = "VERSION_GREATER_EQUAL";
+static std::string const keyVERSION_LESS = "VERSION_LESS";
+static std::string const keyVERSION_LESS_EQUAL = "VERSION_LESS_EQUAL";
+
+cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile,
+                                           const cmListFileContext& context,
+                                           const cmListFileBacktrace& bt)
+  : Makefile(makefile)
+  , ExecutionContext(context)
+  , Backtrace(bt)
+  , Policy12Status(makefile.GetPolicyStatus(cmPolicies::CMP0012))
+  , Policy54Status(makefile.GetPolicyStatus(cmPolicies::CMP0054))
+  , Policy57Status(makefile.GetPolicyStatus(cmPolicies::CMP0057))
+  , Policy64Status(makefile.GetPolicyStatus(cmPolicies::CMP0064))
+{
+}
+
+//=========================================================================
+// order of operations,
+// 1.   ( )   -- parenthetical groups
+// 2.  IS_DIRECTORY EXISTS COMMAND DEFINED etc predicates
+// 3. MATCHES LESS GREATER EQUAL STRLESS STRGREATER STREQUAL etc binary ops
+// 4. NOT
+// 5. AND OR
+//
+// There is an issue on whether the arguments should be values of references,
+// for example IF (FOO AND BAR) should that compare the strings FOO and BAR
+// or should it really do IF (${FOO} AND ${BAR}) Currently IS_DIRECTORY
+// EXISTS COMMAND and DEFINED all take values. EQUAL, LESS and GREATER can
+// take numeric values or variable names. STRLESS and STRGREATER take
+// variable names but if the variable name is not found it will use the name
+// directly. AND OR take variables or the values 0 or 1.
+
+bool cmConditionEvaluator::IsTrue(
+  const std::vector<cmExpandedCommandArgument>& args, std::string& errorString,
+  cmake::MessageType& status)
+{
+  errorString.clear();
+
+  // handle empty invocation
+  if (args.empty()) {
+    return false;
+  }
+
+  // store the reduced args in this vector
+  cmArgumentList newArgs;
+
+  // copy to the list structure
+  newArgs.insert(newArgs.end(), args.begin(), args.end());
+
+  // now loop through the arguments and see if we can reduce any of them
+  // we do this multiple times. Once for each level of precedence
+  // parens
+  if (!this->HandleLevel0(newArgs, errorString, status)) {
+    return false;
+  }
+  // predicates
+  if (!this->HandleLevel1(newArgs, errorString, status)) {
+    return false;
+  }
+  // binary ops
+  if (!this->HandleLevel2(newArgs, errorString, status)) {
+    return false;
+  }
+
+  // NOT
+  if (!this->HandleLevel3(newArgs, errorString, status)) {
+    return false;
+  }
+  // AND OR
+  if (!this->HandleLevel4(newArgs, errorString, status)) {
+    return false;
+  }
+
+  // now at the end there should only be one argument left
+  if (newArgs.size() != 1) {
+    errorString = "Unknown arguments specified";
+    status = cmake::FATAL_ERROR;
+    return false;
+  }
+
+  return this->GetBooleanValueWithAutoDereference(*(newArgs.begin()),
+                                                  errorString, status, true);
+}
+
+//=========================================================================
+const char* cmConditionEvaluator::GetDefinitionIfUnquoted(
+  cmExpandedCommandArgument const& argument) const
+{
+  if ((this->Policy54Status != cmPolicies::WARN &&
+       this->Policy54Status != cmPolicies::OLD) &&
+      argument.WasQuoted()) {
+    return nullptr;
+  }
+
+  const char* def = this->Makefile.GetDefinition(argument.GetValue());
+
+  if (def && argument.WasQuoted() &&
+      this->Policy54Status == cmPolicies::WARN) {
+    if (!this->Makefile.HasCMP0054AlreadyBeenReported(
+          this->ExecutionContext)) {
+      std::ostringstream e;
+      e << (cmPolicies::GetPolicyWarning(cmPolicies::CMP0054)) << "\n";
+      e << "Quoted variables like \"" << argument.GetValue()
+        << "\" will no longer be dereferenced "
+           "when the policy is set to NEW.  "
+           "Since the policy is not set the OLD behavior will be used.";
+
+      this->Makefile.GetCMakeInstance()->IssueMessage(
+        cmake::AUTHOR_WARNING, e.str(), this->Backtrace);
+    }
+  }
+
+  return def;
+}
+
+//=========================================================================
+const char* cmConditionEvaluator::GetVariableOrString(
+  const cmExpandedCommandArgument& argument) const
+{
+  const char* def = this->GetDefinitionIfUnquoted(argument);
+
+  if (!def) {
+    def = argument.c_str();
+  }
+
+  return def;
+}
+
+//=========================================================================
+bool cmConditionEvaluator::IsKeyword(std::string const& keyword,
+                                     cmExpandedCommandArgument& argument) const
+{
+  if ((this->Policy54Status != cmPolicies::WARN &&
+       this->Policy54Status != cmPolicies::OLD) &&
+      argument.WasQuoted()) {
+    return false;
+  }
+
+  bool isKeyword = argument.GetValue() == keyword;
+
+  if (isKeyword && argument.WasQuoted() &&
+      this->Policy54Status == cmPolicies::WARN) {
+    if (!this->Makefile.HasCMP0054AlreadyBeenReported(
+          this->ExecutionContext)) {
+      std::ostringstream e;
+      e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0054) << "\n";
+      e << "Quoted keywords like \"" << argument.GetValue()
+        << "\" will no longer be interpreted as keywords "
+           "when the policy is set to NEW.  "
+           "Since the policy is not set the OLD behavior will be used.";
+
+      this->Makefile.GetCMakeInstance()->IssueMessage(
+        cmake::AUTHOR_WARNING, e.str(), this->Backtrace);
+    }
+  }
+
+  return isKeyword;
+}
+
+//=========================================================================
+bool cmConditionEvaluator::GetBooleanValue(
+  cmExpandedCommandArgument& arg) const
+{
+  // Check basic constants.
+  if (arg == "0") {
+    return false;
+  }
+  if (arg == "1") {
+    return true;
+  }
+
+  // Check named constants.
+  if (cmSystemTools::IsOn(arg.c_str())) {
+    return true;
+  }
+  if (cmSystemTools::IsOff(arg.c_str())) {
+    return false;
+  }
+
+  // Check for numbers.
+  if (!arg.empty()) {
+    char* end;
+    double d = strtod(arg.c_str(), &end);
+    if (*end == '\0') {
+      // The whole string is a number.  Use C conversion to bool.
+      return static_cast<bool>(d);
+    }
+  }
+
+  // Check definition.
+  const char* def = this->GetDefinitionIfUnquoted(arg);
+  return !cmSystemTools::IsOff(def);
+}
+
+//=========================================================================
+// Boolean value behavior from CMake 2.6.4 and below.
+bool cmConditionEvaluator::GetBooleanValueOld(
+  cmExpandedCommandArgument const& arg, bool one) const
+{
+  if (one) {
+    // Old IsTrue behavior for single argument.
+    if (arg == "0") {
+      return false;
+    }
+    if (arg == "1") {
+      return true;
+    }
+    const char* def = this->GetDefinitionIfUnquoted(arg);
+    return !cmSystemTools::IsOff(def);
+  }
+  // Old GetVariableOrNumber behavior.
+  const char* def = this->GetDefinitionIfUnquoted(arg);
+  if (!def && atoi(arg.c_str())) {
+    def = arg.c_str();
+  }
+  return !cmSystemTools::IsOff(def);
+}
+
+//=========================================================================
+// returns the resulting boolean value
+bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
+  cmExpandedCommandArgument& newArg, std::string& errorString,
+  cmake::MessageType& status, bool oneArg) const
+{
+  // Use the policy if it is set.
+  if (this->Policy12Status == cmPolicies::NEW) {
+    return GetBooleanValue(newArg);
+  }
+  if (this->Policy12Status == cmPolicies::OLD) {
+    return GetBooleanValueOld(newArg, oneArg);
+  }
+
+  // Check policy only if old and new results differ.
+  bool newResult = this->GetBooleanValue(newArg);
+  bool oldResult = this->GetBooleanValueOld(newArg, oneArg);
+  if (newResult != oldResult) {
+    switch (this->Policy12Status) {
+      case cmPolicies::WARN:
+        errorString = "An argument named \"" + newArg.GetValue() +
+          "\" appears in a conditional statement.  " +
+          cmPolicies::GetPolicyWarning(cmPolicies::CMP0012);
+        status = cmake::AUTHOR_WARNING;
+        CM_FALLTHROUGH;
+      case cmPolicies::OLD:
+        return oldResult;
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::REQUIRED_ALWAYS: {
+        errorString = "An argument named \"" + newArg.GetValue() +
+          "\" appears in a conditional statement.  " +
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0012);
+        status = cmake::FATAL_ERROR;
+      }
+      case cmPolicies::NEW:
+        break;
+    }
+  }
+  return newResult;
+}
+
+//=========================================================================
+void cmConditionEvaluator::IncrementArguments(
+  cmArgumentList& newArgs, cmArgumentList::iterator& argP1,
+  cmArgumentList::iterator& argP2) const
+{
+  if (argP1 != newArgs.end()) {
+    argP1++;
+    argP2 = argP1;
+    if (argP1 != newArgs.end()) {
+      argP2++;
+    }
+  }
+}
+
+//=========================================================================
+// helper function to reduce code duplication
+void cmConditionEvaluator::HandlePredicate(
+  bool value, int& reducible, cmArgumentList::iterator& arg,
+  cmArgumentList& newArgs, cmArgumentList::iterator& argP1,
+  cmArgumentList::iterator& argP2) const
+{
+  if (value) {
+    *arg = cmExpandedCommandArgument("1", true);
+  } else {
+    *arg = cmExpandedCommandArgument("0", true);
+  }
+  newArgs.erase(argP1);
+  argP1 = arg;
+  this->IncrementArguments(newArgs, argP1, argP2);
+  reducible = 1;
+}
+
+//=========================================================================
+// helper function to reduce code duplication
+void cmConditionEvaluator::HandleBinaryOp(bool value, int& reducible,
+                                          cmArgumentList::iterator& arg,
+                                          cmArgumentList& newArgs,
+                                          cmArgumentList::iterator& argP1,
+                                          cmArgumentList::iterator& argP2)
+{
+  if (value) {
+    *arg = cmExpandedCommandArgument("1", true);
+  } else {
+    *arg = cmExpandedCommandArgument("0", true);
+  }
+  newArgs.erase(argP2);
+  newArgs.erase(argP1);
+  argP1 = arg;
+  this->IncrementArguments(newArgs, argP1, argP2);
+  reducible = 1;
+}
+
+//=========================================================================
+// level 0 processes parenthetical expressions
+bool cmConditionEvaluator::HandleLevel0(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
+{
+  int reducible;
+  do {
+    reducible = 0;
+    cmArgumentList::iterator arg = newArgs.begin();
+    while (arg != newArgs.end()) {
+      if (IsKeyword(keyParenL, *arg)) {
+        // search for the closing paren for this opening one
+        cmArgumentList::iterator argClose;
+        argClose = arg;
+        argClose++;
+        unsigned int depth = 1;
+        while (argClose != newArgs.end() && depth) {
+          if (this->IsKeyword(keyParenL, *argClose)) {
+            depth++;
+          }
+          if (this->IsKeyword(keyParenR, *argClose)) {
+            depth--;
+          }
+          argClose++;
+        }
+        if (depth) {
+          errorString = "mismatched parenthesis in condition";
+          status = cmake::FATAL_ERROR;
+          return false;
+        }
+        // store the reduced args in this vector
+        std::vector<cmExpandedCommandArgument> newArgs2;
+
+        // copy to the list structure
+        cmArgumentList::iterator argP1 = arg;
+        argP1++;
+        newArgs2.insert(newArgs2.end(), argP1, argClose);
+        newArgs2.pop_back();
+        // now recursively invoke IsTrue to handle the values inside the
+        // parenthetical expression
+        bool value = this->IsTrue(newArgs2, errorString, status);
+        if (value) {
+          *arg = cmExpandedCommandArgument("1", true);
+        } else {
+          *arg = cmExpandedCommandArgument("0", true);
+        }
+        argP1 = arg;
+        argP1++;
+        // remove the now evaluated parenthetical expression
+        newArgs.erase(argP1, argClose);
+      }
+      ++arg;
+    }
+  } while (reducible);
+  return true;
+}
+
+//=========================================================================
+// level one handles most predicates except for NOT
+bool cmConditionEvaluator::HandleLevel1(cmArgumentList& newArgs, std::string&,
+                                        cmake::MessageType&)
+{
+  int reducible;
+  do {
+    reducible = 0;
+    cmArgumentList::iterator arg = newArgs.begin();
+    cmArgumentList::iterator argP1;
+    cmArgumentList::iterator argP2;
+    while (arg != newArgs.end()) {
+      argP1 = arg;
+      this->IncrementArguments(newArgs, argP1, argP2);
+      // does a file exist
+      if (this->IsKeyword(keyEXISTS, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileExists(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
+      // does a directory with this name exist
+      if (this->IsKeyword(keyIS_DIRECTORY, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsDirectory(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
+      // does a symlink with this name exist
+      if (this->IsKeyword(keyIS_SYMLINK, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsSymlink(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
+      // is the given path an absolute path ?
+      if (this->IsKeyword(keyIS_ABSOLUTE, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsFullPath(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
+      // does a command exist
+      if (this->IsKeyword(keyCOMMAND, *arg) && argP1 != newArgs.end()) {
+        cmCommand* command =
+          this->Makefile.GetState()->GetCommand(argP1->c_str());
+        this->HandlePredicate(command != nullptr, reducible, arg, newArgs,
+                              argP1, argP2);
+      }
+      // does a policy exist
+      if (this->IsKeyword(keyPOLICY, *arg) && argP1 != newArgs.end()) {
+        cmPolicies::PolicyID pid;
+        this->HandlePredicate(cmPolicies::GetPolicyID(argP1->c_str(), pid),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
+      // does a target exist
+      if (this->IsKeyword(keyTARGET, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(
+          this->Makefile.FindTargetToUse(argP1->GetValue()) != nullptr,
+          reducible, arg, newArgs, argP1, argP2);
+      }
+      // does a test exist
+      if (this->Policy64Status != cmPolicies::OLD &&
+          this->Policy64Status != cmPolicies::WARN) {
+        if (this->IsKeyword(keyTEST, *arg) && argP1 != newArgs.end()) {
+          const cmTest* haveTest = this->Makefile.GetTest(argP1->c_str());
+          this->HandlePredicate(haveTest != nullptr, reducible, arg, newArgs,
+                                argP1, argP2);
+        }
+      } else if (this->Policy64Status == cmPolicies::WARN &&
+                 this->IsKeyword(keyTEST, *arg)) {
+        std::ostringstream e;
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0064) << "\n";
+        e << "TEST will be interpreted as an operator "
+             "when the policy is set to NEW.  "
+             "Since the policy is not set the OLD behavior will be used.";
+
+        this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str());
+      }
+      // is a variable defined
+      if (this->IsKeyword(keyDEFINED, *arg) && argP1 != newArgs.end()) {
+        size_t argP1len = argP1->GetValue().size();
+        bool bdef = false;
+        if (argP1len > 4 && argP1->GetValue().substr(0, 4) == "ENV{" &&
+            argP1->GetValue().operator[](argP1len - 1) == '}') {
+          std::string env = argP1->GetValue().substr(4, argP1len - 5);
+          bdef = cmSystemTools::HasEnv(env.c_str());
+        } else {
+          bdef = this->Makefile.IsDefinitionSet(argP1->GetValue());
+        }
+        this->HandlePredicate(bdef, reducible, arg, newArgs, argP1, argP2);
+      }
+      ++arg;
+    }
+  } while (reducible);
+  return true;
+}
+
+//=========================================================================
+// level two handles most binary operations except for AND  OR
+bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
+{
+  int reducible;
+  std::string def_buf;
+  const char* def;
+  const char* def2;
+  do {
+    reducible = 0;
+    cmArgumentList::iterator arg = newArgs.begin();
+    cmArgumentList::iterator argP1;
+    cmArgumentList::iterator argP2;
+    while (arg != newArgs.end()) {
+      argP1 = arg;
+      this->IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          IsKeyword(keyMATCHES, *argP1)) {
+        def = this->GetVariableOrString(*arg);
+        if (def != arg->c_str() // yes, we compare the pointer value
+            && cmHasLiteralPrefix(arg->GetValue(), "CMAKE_MATCH_")) {
+          // The string to match is owned by our match result variables.
+          // Move it to our own buffer before clearing them.
+          def_buf = def;
+          def = def_buf.c_str();
+        }
+        const char* rex = argP2->c_str();
+        this->Makefile.ClearMatches();
+        cmsys::RegularExpression regEntry;
+        if (!regEntry.compile(rex)) {
+          std::ostringstream error;
+          error << "Regular expression \"" << rex << "\" cannot compile";
+          errorString = error.str();
+          status = cmake::FATAL_ERROR;
+          return false;
+        }
+        if (regEntry.find(def)) {
+          this->Makefile.StoreMatches(regEntry);
+          *arg = cmExpandedCommandArgument("1", true);
+        } else {
+          *arg = cmExpandedCommandArgument("0", true);
+        }
+        newArgs.erase(argP2);
+        newArgs.erase(argP1);
+        argP1 = arg;
+        this->IncrementArguments(newArgs, argP1, argP2);
+        reducible = 1;
+      }
+
+      if (argP1 != newArgs.end() && this->IsKeyword(keyMATCHES, *arg)) {
+        *arg = cmExpandedCommandArgument("0", true);
+        newArgs.erase(argP1);
+        argP1 = arg;
+        this->IncrementArguments(newArgs, argP1, argP2);
+        reducible = 1;
+      }
+
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          (this->IsKeyword(keyLESS, *argP1) ||
+           this->IsKeyword(keyLESS_EQUAL, *argP1) ||
+           this->IsKeyword(keyGREATER, *argP1) ||
+           this->IsKeyword(keyGREATER_EQUAL, *argP1) ||
+           this->IsKeyword(keyEQUAL, *argP1))) {
+        def = this->GetVariableOrString(*arg);
+        def2 = this->GetVariableOrString(*argP2);
+        double lhs;
+        double rhs;
+        bool result;
+        if (sscanf(def, "%lg", &lhs) != 1 || sscanf(def2, "%lg", &rhs) != 1) {
+          result = false;
+        } else if (*(argP1) == keyLESS) {
+          result = (lhs < rhs);
+        } else if (*(argP1) == keyLESS_EQUAL) {
+          result = (lhs <= rhs);
+        } else if (*(argP1) == keyGREATER) {
+          result = (lhs > rhs);
+        } else if (*(argP1) == keyGREATER_EQUAL) {
+          result = (lhs >= rhs);
+        } else {
+          result = (lhs == rhs);
+        }
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
+
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          (this->IsKeyword(keySTRLESS, *argP1) ||
+           this->IsKeyword(keySTRLESS_EQUAL, *argP1) ||
+           this->IsKeyword(keySTRGREATER, *argP1) ||
+           this->IsKeyword(keySTRGREATER_EQUAL, *argP1) ||
+           this->IsKeyword(keySTREQUAL, *argP1))) {
+        def = this->GetVariableOrString(*arg);
+        def2 = this->GetVariableOrString(*argP2);
+        int val = strcmp(def, def2);
+        bool result;
+        if (*(argP1) == keySTRLESS) {
+          result = (val < 0);
+        } else if (*(argP1) == keySTRLESS_EQUAL) {
+          result = (val <= 0);
+        } else if (*(argP1) == keySTRGREATER) {
+          result = (val > 0);
+        } else if (*(argP1) == keySTRGREATER_EQUAL) {
+          result = (val >= 0);
+        } else // strequal
+        {
+          result = (val == 0);
+        }
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
+
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          (this->IsKeyword(keyVERSION_LESS, *argP1) ||
+           this->IsKeyword(keyVERSION_LESS_EQUAL, *argP1) ||
+           this->IsKeyword(keyVERSION_GREATER, *argP1) ||
+           this->IsKeyword(keyVERSION_GREATER_EQUAL, *argP1) ||
+           this->IsKeyword(keyVERSION_EQUAL, *argP1))) {
+        def = this->GetVariableOrString(*arg);
+        def2 = this->GetVariableOrString(*argP2);
+        cmSystemTools::CompareOp op;
+        if (*argP1 == keyVERSION_LESS) {
+          op = cmSystemTools::OP_LESS;
+        } else if (*argP1 == keyVERSION_LESS_EQUAL) {
+          op = cmSystemTools::OP_LESS_EQUAL;
+        } else if (*argP1 == keyVERSION_GREATER) {
+          op = cmSystemTools::OP_GREATER;
+        } else if (*argP1 == keyVERSION_GREATER_EQUAL) {
+          op = cmSystemTools::OP_GREATER_EQUAL;
+        } else { // version_equal
+          op = cmSystemTools::OP_EQUAL;
+        }
+        bool result = cmSystemTools::VersionCompare(op, def, def2);
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
+
+      // is file A newer than file B
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          this->IsKeyword(keyIS_NEWER_THAN, *argP1)) {
+        int fileIsNewer = 0;
+        bool success = cmSystemTools::FileTimeCompare(
+          arg->GetValue(), (argP2)->GetValue(), &fileIsNewer);
+        this->HandleBinaryOp(
+          (!success || fileIsNewer == 1 || fileIsNewer == 0), reducible, arg,
+          newArgs, argP1, argP2);
+      }
+
+      if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
+          this->IsKeyword(keyIN_LIST, *argP1)) {
+        if (this->Policy57Status != cmPolicies::OLD &&
+            this->Policy57Status != cmPolicies::WARN) {
+          bool result = false;
+
+          def = this->GetVariableOrString(*arg);
+          def2 = this->Makefile.GetDefinition(argP2->GetValue());
+
+          if (def2) {
+            std::vector<std::string> list;
+            cmSystemTools::ExpandListArgument(def2, list, true);
+
+            result = std::find(list.begin(), list.end(), def) != list.end();
+          }
+
+          this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+        } else if (this->Policy57Status == cmPolicies::WARN) {
+          std::ostringstream e;
+          e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0057) << "\n";
+          e << "IN_LIST will be interpreted as an operator "
+               "when the policy is set to NEW.  "
+               "Since the policy is not set the OLD behavior will be used.";
+
+          this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str());
+        }
+      }
+
+      ++arg;
+    }
+  } while (reducible);
+  return true;
+}
+
+//=========================================================================
+// level 3 handles NOT
+bool cmConditionEvaluator::HandleLevel3(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
+{
+  int reducible;
+  do {
+    reducible = 0;
+    cmArgumentList::iterator arg = newArgs.begin();
+    cmArgumentList::iterator argP1;
+    cmArgumentList::iterator argP2;
+    while (arg != newArgs.end()) {
+      argP1 = arg;
+      IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && IsKeyword(keyNOT, *arg)) {
+        bool rhs = this->GetBooleanValueWithAutoDereference(
+          *argP1, errorString, status);
+        this->HandlePredicate(!rhs, reducible, arg, newArgs, argP1, argP2);
+      }
+      ++arg;
+    }
+  } while (reducible);
+  return true;
+}
+
+//=========================================================================
+// level 4 handles AND OR
+bool cmConditionEvaluator::HandleLevel4(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
+{
+  int reducible;
+  bool lhs;
+  bool rhs;
+  do {
+    reducible = 0;
+    cmArgumentList::iterator arg = newArgs.begin();
+    cmArgumentList::iterator argP1;
+    cmArgumentList::iterator argP2;
+    while (arg != newArgs.end()) {
+      argP1 = arg;
+      IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && IsKeyword(keyAND, *argP1) &&
+          argP2 != newArgs.end()) {
+        lhs =
+          this->GetBooleanValueWithAutoDereference(*arg, errorString, status);
+        rhs = this->GetBooleanValueWithAutoDereference(*argP2, errorString,
+                                                       status);
+        this->HandleBinaryOp((lhs && rhs), reducible, arg, newArgs, argP1,
+                             argP2);
+      }
+
+      if (argP1 != newArgs.end() && this->IsKeyword(keyOR, *argP1) &&
+          argP2 != newArgs.end()) {
+        lhs =
+          this->GetBooleanValueWithAutoDereference(*arg, errorString, status);
+        rhs = this->GetBooleanValueWithAutoDereference(*argP2, errorString,
+                                                       status);
+        this->HandleBinaryOp((lhs || rhs), reducible, arg, newArgs, argP1,
+                             argP2);
+      }
+      ++arg;
+    }
+  } while (reducible);
+  return true;
+}
diff --git a/Source/cmConditionEvaluator.h b/Source/cmConditionEvaluator.h
new file mode 100644
index 0000000..50f4edc
--- /dev/null
+++ b/Source/cmConditionEvaluator.h
@@ -0,0 +1,92 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmConditionEvaluator_h
+#define cmConditionEvaluator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <list>
+#include <string>
+#include <vector>
+
+#include "cmExpandedCommandArgument.h"
+#include "cmListFileCache.h"
+#include "cmPolicies.h"
+#include "cmake.h"
+
+class cmMakefile;
+
+class cmConditionEvaluator
+{
+public:
+  typedef std::list<cmExpandedCommandArgument> cmArgumentList;
+
+  cmConditionEvaluator(cmMakefile& makefile, cmListFileContext const& context,
+                       cmListFileBacktrace const& bt);
+
+  // this is a shared function for both If and Else to determine if the
+  // arguments were valid, and if so, was the response true. If there is
+  // an error, the errorString will be set.
+  bool IsTrue(const std::vector<cmExpandedCommandArgument>& args,
+              std::string& errorString, cmake::MessageType& status);
+
+private:
+  // Filter the given variable definition based on policy CMP0054.
+  const char* GetDefinitionIfUnquoted(
+    const cmExpandedCommandArgument& argument) const;
+
+  const char* GetVariableOrString(
+    const cmExpandedCommandArgument& argument) const;
+
+  bool IsKeyword(std::string const& keyword,
+                 cmExpandedCommandArgument& argument) const;
+
+  bool GetBooleanValue(cmExpandedCommandArgument& arg) const;
+
+  bool GetBooleanValueOld(cmExpandedCommandArgument const& arg,
+                          bool one) const;
+
+  bool GetBooleanValueWithAutoDereference(cmExpandedCommandArgument& newArg,
+                                          std::string& errorString,
+                                          cmake::MessageType& status,
+                                          bool oneArg = false) const;
+
+  void IncrementArguments(cmArgumentList& newArgs,
+                          cmArgumentList::iterator& argP1,
+                          cmArgumentList::iterator& argP2) const;
+
+  void HandlePredicate(bool value, int& reducible,
+                       cmArgumentList::iterator& arg, cmArgumentList& newArgs,
+                       cmArgumentList::iterator& argP1,
+                       cmArgumentList::iterator& argP2) const;
+
+  void HandleBinaryOp(bool value, int& reducible,
+                      cmArgumentList::iterator& arg, cmArgumentList& newArgs,
+                      cmArgumentList::iterator& argP1,
+                      cmArgumentList::iterator& argP2);
+
+  bool HandleLevel0(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel1(cmArgumentList& newArgs, std::string&,
+                    cmake::MessageType&);
+
+  bool HandleLevel2(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel3(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel4(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  cmMakefile& Makefile;
+  cmListFileContext ExecutionContext;
+  cmListFileBacktrace Backtrace;
+  cmPolicies::PolicyStatus Policy12Status;
+  cmPolicies::PolicyStatus Policy54Status;
+  cmPolicies::PolicyStatus Policy57Status;
+  cmPolicies::PolicyStatus Policy64Status;
+};
+
+#endif
diff --git a/Source/cmConfigure.cmake.h.in b/Source/cmConfigure.cmake.h.in
new file mode 100644
index 0000000..c80439b
--- /dev/null
+++ b/Source/cmConfigure.cmake.h.in
@@ -0,0 +1,32 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmConfigure_h
+#define cmConfigure_h
+
+#include "cmsys/Configure.hxx" // IWYU pragma: export
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4786)
+#pragma warning(disable : 4503)
+#endif
+
+#ifdef __ICL
+#pragma warning(disable : 985)
+#pragma warning(disable : 1572) /* floating-point equality test */
+#endif
+
+#cmakedefine HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE
+#cmakedefine HAVE_UNSETENV
+#cmakedefine CMAKE_USE_ELF_PARSER
+#cmakedefine CMAKE_USE_MACH_PARSER
+#cmakedefine CMake_HAVE_CXX_MAKE_UNIQUE
+#define CMAKE_BIN_DIR "/@CMAKE_BIN_DIR@"
+#define CMAKE_DATA_DIR "/@CMAKE_DATA_DIR@"
+
+#define CM_FALLTHROUGH cmsys_FALLTHROUGH
+
+#define CM_DISABLE_COPY(Class)                                                \
+  Class(Class const&) = delete;                                               \
+  Class& operator=(Class const&) = delete;
+
+#endif
diff --git a/Source/cmConfigureFileCommand.cxx b/Source/cmConfigureFileCommand.cxx
new file mode 100644
index 0000000..18005f2
--- /dev/null
+++ b/Source/cmConfigureFileCommand.cxx
@@ -0,0 +1,114 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmConfigureFileCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+// cmConfigureFileCommand
+bool cmConfigureFileCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
+{
+  if (args.size() < 2) {
+    this->SetError("called with incorrect number of arguments, expected 2");
+    return false;
+  }
+
+  std::string const& inFile = args[0];
+  if (!cmSystemTools::FileIsFullPath(inFile)) {
+    this->InputFile = this->Makefile->GetCurrentSourceDirectory();
+    this->InputFile += "/";
+  }
+  this->InputFile += inFile;
+
+  // If the input location is a directory, error out.
+  if (cmSystemTools::FileIsDirectory(this->InputFile)) {
+    std::ostringstream e;
+    /* clang-format off */
+    e << "input location\n"
+      << "  " << this->InputFile << "\n"
+      << "is a directory but a file was expected.";
+    /* clang-format on */
+    this->SetError(e.str());
+    return false;
+  }
+
+  std::string const& outFile = args[1];
+  if (!cmSystemTools::FileIsFullPath(outFile)) {
+    this->OutputFile = this->Makefile->GetCurrentBinaryDirectory();
+    this->OutputFile += "/";
+  }
+  this->OutputFile += outFile;
+
+  // If the output location is already a directory put the file in it.
+  if (cmSystemTools::FileIsDirectory(this->OutputFile)) {
+    this->OutputFile += "/";
+    this->OutputFile += cmSystemTools::GetFilenameName(inFile);
+  }
+
+  if (!this->Makefile->CanIWriteThisFile(this->OutputFile.c_str())) {
+    std::string e = "attempted to configure a file: " + this->OutputFile +
+      " into a source directory.";
+    this->SetError(e);
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+  }
+  std::string errorMessage;
+  if (!this->NewLineStyle.ReadFromArguments(args, errorMessage)) {
+    this->SetError(errorMessage);
+    return false;
+  }
+  this->CopyOnly = false;
+  this->EscapeQuotes = false;
+
+  std::string unknown_args;
+  this->AtOnly = false;
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (args[i] == "COPYONLY") {
+      this->CopyOnly = true;
+      if (this->NewLineStyle.IsValid()) {
+        this->SetError("COPYONLY could not be used in combination "
+                       "with NEWLINE_STYLE");
+        return false;
+      }
+    } else if (args[i] == "ESCAPE_QUOTES") {
+      this->EscapeQuotes = true;
+    } else if (args[i] == "@ONLY") {
+      this->AtOnly = true;
+    } else if (args[i] == "IMMEDIATE") {
+      /* Ignore legacy option.  */
+    } else if (args[i] == "NEWLINE_STYLE" || args[i] == "LF" ||
+               args[i] == "UNIX" || args[i] == "CRLF" || args[i] == "WIN32" ||
+               args[i] == "DOS") {
+      /* Options handled by NewLineStyle member above.  */
+    } else {
+      unknown_args += " ";
+      unknown_args += args[i];
+      unknown_args += "\n";
+    }
+  }
+  if (!unknown_args.empty()) {
+    std::string msg = "configure_file called with unknown argument(s):\n";
+    msg += unknown_args;
+    this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, msg);
+  }
+
+  if (!this->ConfigureFile()) {
+    this->SetError("Problem configuring file");
+    return false;
+  }
+
+  return true;
+}
+
+int cmConfigureFileCommand::ConfigureFile()
+{
+  return this->Makefile->ConfigureFile(
+    this->InputFile.c_str(), this->OutputFile.c_str(), this->CopyOnly,
+    this->AtOnly, this->EscapeQuotes, this->NewLineStyle);
+}
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
new file mode 100644
index 0000000..cff934b
--- /dev/null
+++ b/Source/cmConfigureFileCommand.h
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmConfigureFileCommand_h
+#define cmConfigureFileCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+#include "cmNewLineStyle.h"
+
+class cmExecutionStatus;
+
+class cmConfigureFileCommand : public cmCommand
+{
+public:
+  cmCommand* Clone() override { return new cmConfigureFileCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the input file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  int ConfigureFile();
+
+  cmNewLineStyle NewLineStyle;
+
+  std::string InputFile;
+  std::string OutputFile;
+  bool CopyOnly;
+  bool EscapeQuotes;
+  bool AtOnly;
+};
+
+#endif
diff --git a/Source/cmConnection.cxx b/Source/cmConnection.cxx
new file mode 100644
index 0000000..50e1936
--- /dev/null
+++ b/Source/cmConnection.cxx
@@ -0,0 +1,165 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmConnection.h"
+
+#include "cmServer.h"
+#include "cm_uv.h"
+
+#include <cassert>
+#include <cstring>
+
+struct write_req_t
+{
+  uv_write_t req;
+  uv_buf_t buf;
+};
+
+void cmEventBasedConnection::on_alloc_buffer(uv_handle_t* handle,
+                                             size_t suggested_size,
+                                             uv_buf_t* buf)
+{
+  (void)(handle);
+  char* rawBuffer = new char[suggested_size];
+  *buf = uv_buf_init(rawBuffer, static_cast<unsigned int>(suggested_size));
+}
+
+void cmEventBasedConnection::on_read(uv_stream_t* stream, ssize_t nread,
+                                     const uv_buf_t* buf)
+{
+  auto conn = static_cast<cmEventBasedConnection*>(stream->data);
+  if (conn) {
+    if (nread >= 0) {
+      conn->ReadData(std::string(buf->base, buf->base + nread));
+    } else {
+      conn->OnDisconnect(static_cast<int>(nread));
+    }
+  }
+
+  delete[](buf->base);
+}
+
+void cmEventBasedConnection::on_close(uv_handle_t* /*handle*/)
+{
+}
+
+void cmEventBasedConnection::on_write(uv_write_t* req, int status)
+{
+  (void)(status);
+
+  // Free req and buffer
+  write_req_t* wr = reinterpret_cast<write_req_t*>(req);
+  delete[](wr->buf.base);
+  delete wr;
+}
+
+void cmEventBasedConnection::on_new_connection(uv_stream_t* stream, int status)
+{
+  (void)(status);
+  auto conn = static_cast<cmEventBasedConnection*>(stream->data);
+
+  if (conn) {
+    conn->Connect(stream);
+  }
+}
+
+bool cmEventBasedConnection::IsOpen() const
+{
+  return this->WriteStream != nullptr;
+}
+
+void cmEventBasedConnection::WriteData(const std::string& _data)
+{
+#ifndef NDEBUG
+  auto curr_thread_id = uv_thread_self();
+  assert(this->Server);
+  assert(uv_thread_equal(&curr_thread_id, &this->Server->ServeThreadId));
+#endif
+
+  auto data = _data;
+  assert(this->WriteStream.get());
+  if (BufferStrategy) {
+    data = BufferStrategy->BufferOutMessage(data);
+  }
+
+  auto ds = data.size();
+
+  write_req_t* req = new write_req_t;
+  req->req.data = this;
+  req->buf = uv_buf_init(new char[ds], static_cast<unsigned int>(ds));
+  memcpy(req->buf.base, data.c_str(), ds);
+  uv_write(reinterpret_cast<uv_write_t*>(req), this->WriteStream, &req->buf, 1,
+           on_write);
+}
+
+void cmEventBasedConnection::ReadData(const std::string& data)
+{
+  this->RawReadBuffer += data;
+  if (BufferStrategy) {
+    std::string packet = BufferStrategy->BufferMessage(this->RawReadBuffer);
+    while (!packet.empty()) {
+      ProcessRequest(packet);
+      packet = BufferStrategy->BufferMessage(this->RawReadBuffer);
+    }
+  } else {
+    ProcessRequest(this->RawReadBuffer);
+    this->RawReadBuffer.clear();
+  }
+}
+
+cmEventBasedConnection::cmEventBasedConnection(
+  cmConnectionBufferStrategy* bufferStrategy)
+  : BufferStrategy(bufferStrategy)
+{
+}
+
+void cmEventBasedConnection::Connect(uv_stream_t* server)
+{
+  (void)server;
+  Server->OnConnected(nullptr);
+}
+
+void cmEventBasedConnection::OnDisconnect(int onerror)
+{
+  (void)onerror;
+  this->OnConnectionShuttingDown();
+  if (this->Server) {
+    this->Server->OnDisconnect(this);
+  }
+}
+
+cmConnection::~cmConnection()
+{
+}
+
+bool cmConnection::OnConnectionShuttingDown()
+{
+  this->Server = nullptr;
+  return true;
+}
+
+void cmConnection::SetServer(cmServerBase* s)
+{
+  Server = s;
+}
+
+void cmConnection::ProcessRequest(const std::string& request)
+{
+  Server->ProcessRequest(this, request);
+}
+
+bool cmConnection::OnServeStart(std::string* errString)
+{
+  (void)errString;
+  return true;
+}
+
+bool cmEventBasedConnection::OnConnectionShuttingDown()
+{
+  if (this->WriteStream.get()) {
+    this->WriteStream->data = nullptr;
+  }
+
+  WriteStream.reset();
+
+  return true;
+}
diff --git a/Source/cmConnection.h b/Source/cmConnection.h
new file mode 100644
index 0000000..ce2d2dc
--- /dev/null
+++ b/Source/cmConnection.h
@@ -0,0 +1,135 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#pragma once
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmUVHandlePtr.h"
+#include "cm_uv.h"
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+class cmServerBase;
+
+/***
+ * Given a sequence of bytes with any kind of buffering, instances of this
+ * class arrange logical chunks according to whatever the use case is for
+ * the connection.
+ */
+class cmConnectionBufferStrategy
+{
+public:
+  virtual ~cmConnectionBufferStrategy();
+
+  /***
+   * Called whenever with an active raw buffer. If a logical chunk
+   * becomes available, that chunk is returned and that portion is
+   * removed from the rawBuffer
+   *
+   * @param rawBuffer in/out parameter. Receive buffer; the buffer strategy is
+   * free to manipulate this buffer anyway it needs to.
+   *
+   * @return Next chunk from the stream. Returns the empty string if a chunk
+   * isn't ready yet. Users of this interface should repeatedly call this
+   * function until an empty string is returned since its entirely possible
+   * multiple chunks come in a single raw buffer.
+   */
+  virtual std::string BufferMessage(std::string& rawBuffer) = 0;
+
+  /***
+   * Called to properly buffer an outgoing message.
+   *
+   * @param rawBuffer Message to format in the correct way
+   *
+   * @return Formatted message
+   */
+  virtual std::string BufferOutMessage(const std::string& rawBuffer) const
+  {
+    return rawBuffer;
+  };
+  /***
+   * Resets the internal state of the buffering
+   */
+  virtual void clear();
+
+  // TODO: There should be a callback / flag set for errors
+};
+
+class cmConnection
+{
+  CM_DISABLE_COPY(cmConnection)
+
+public:
+  cmConnection() {}
+
+  virtual void WriteData(const std::string& data) = 0;
+
+  virtual ~cmConnection();
+
+  virtual bool OnConnectionShuttingDown();
+
+  virtual bool IsOpen() const = 0;
+
+  virtual void SetServer(cmServerBase* s);
+
+  virtual void ProcessRequest(const std::string& request);
+
+  virtual bool OnServeStart(std::string* pString);
+
+protected:
+  cmServerBase* Server = nullptr;
+};
+
+/***
+ * Abstraction of a connection; ties in event callbacks from libuv and notifies
+ * the server when appropriate
+ */
+class cmEventBasedConnection : public cmConnection
+{
+
+public:
+  /***
+   * @param bufferStrategy If no strategy is given, it will process the raw
+   * chunks as they come in. The connection
+   * owns the pointer given.
+   */
+  cmEventBasedConnection(cmConnectionBufferStrategy* bufferStrategy = nullptr);
+
+  virtual void Connect(uv_stream_t* server);
+
+  virtual void ReadData(const std::string& data);
+
+  bool IsOpen() const override;
+
+  void WriteData(const std::string& data) override;
+  bool OnConnectionShuttingDown() override;
+
+  virtual void OnDisconnect(int errorCode);
+
+  static void on_close(uv_handle_t* handle);
+
+  template <typename T>
+  static void on_close_delete(uv_handle_t* handle)
+  {
+    delete reinterpret_cast<T*>(handle);
+  }
+
+protected:
+  cm::uv_stream_ptr WriteStream;
+
+  std::string RawReadBuffer;
+
+  std::unique_ptr<cmConnectionBufferStrategy> BufferStrategy;
+
+  static void on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
+
+  static void on_write(uv_write_t* req, int status);
+
+  static void on_new_connection(uv_stream_t* stream, int status);
+
+  static void on_alloc_buffer(uv_handle_t* handle, size_t suggested_size,
+                              uv_buf_t* buf);
+};
diff --git a/Source/cmContinueCommand.cxx b/Source/cmContinueCommand.cxx
new file mode 100644
index 0000000..2298a05
--- /dev/null
+++ b/Source/cmContinueCommand.cxx
@@ -0,0 +1,33 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmContinueCommand.h"
+
+#include "cmExecutionStatus.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmake.h"
+
+// cmContinueCommand
+bool cmContinueCommand::InitialPass(std::vector<std::string> const& args,
+                                    cmExecutionStatus& status)
+{
+  if (!this->Makefile->IsLoopBlock()) {
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                 "A CONTINUE command was found outside of a "
+                                 "proper FOREACH or WHILE loop scope.");
+    cmSystemTools::SetFatalErrorOccured();
+    return true;
+  }
+
+  status.SetContinueInvoked();
+
+  if (!args.empty()) {
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                 "The CONTINUE command does not accept any "
+                                 "arguments.");
+    cmSystemTools::SetFatalErrorOccured();
+    return true;
+  }
+
+  return true;
+}
diff --git a/Source/cmContinueCommand.h b/Source/cmContinueCommand.h
new file mode 100644
index 0000000..d383d1d
--- /dev/null
+++ b/Source/cmContinueCommand.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmContinueCommand_h
+#define cmContinueCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmContinueCommand
+ * \brief Continue from an enclosing foreach or while loop
+ *
+ * cmContinueCommand returns from an enclosing foreach or while loop
+ */
+class cmContinueCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmContinueCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmConvertMSBuildXMLToJSON.py b/Source/cmConvertMSBuildXMLToJSON.py
new file mode 100644
index 0000000..92569e7
--- /dev/null
+++ b/Source/cmConvertMSBuildXMLToJSON.py
@@ -0,0 +1,453 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+import argparse
+import codecs
+import copy
+import logging
+import json
+import os
+
+from collections import OrderedDict
+from xml.dom.minidom import parse, parseString, Element
+
+
+class VSFlags:
+    """Flags corresponding to cmIDEFlagTable."""
+    UserValue = "UserValue"  # (1 << 0)
+    UserIgnored = "UserIgnored"  # (1 << 1)
+    UserRequired = "UserRequired"  # (1 << 2)
+    Continue = "Continue"  #(1 << 3)
+    SemicolonAppendable = "SemicolonAppendable"  # (1 << 4)
+    UserFollowing = "UserFollowing"  # (1 << 5)
+    CaseInsensitive = "CaseInsensitive"  # (1 << 6)
+    UserValueIgnored = [UserValue, UserIgnored]
+    UserValueRequired = [UserValue, UserRequired]
+
+
+def vsflags(*args):
+    """Combines the flags."""
+    values = []
+
+    for arg in args:
+        __append_list(values, arg)
+
+    return values
+
+
+def read_msbuild_xml(path, values={}):
+    """Reads the MS Build XML file at the path and returns its contents.
+
+    Keyword arguments:
+    values -- The map to append the contents to (default {})
+    """
+
+    # Attempt to read the file contents
+    try:
+        document = parse(path)
+    except Exception as e:
+        logging.exception('Could not read MS Build XML file at %s', path)
+        return values
+
+    # Convert the XML to JSON format
+    logging.info('Processing MS Build XML file at %s', path)
+
+    # Get the rule node
+    rule = document.getElementsByTagName('Rule')[0]
+
+    rule_name = rule.attributes['Name'].value
+
+    logging.info('Found rules for %s', rule_name)
+
+    # Proprocess Argument values
+    __preprocess_arguments(rule)
+
+    # Get all the values
+    converted_values = []
+    __convert(rule, 'EnumProperty', converted_values, __convert_enum)
+    __convert(rule, 'BoolProperty', converted_values, __convert_bool)
+    __convert(rule, 'StringListProperty', converted_values,
+              __convert_string_list)
+    __convert(rule, 'StringProperty', converted_values, __convert_string)
+    __convert(rule, 'IntProperty', converted_values, __convert_string)
+
+    values[rule_name] = converted_values
+
+    return values
+
+
+def read_msbuild_json(path, values=[]):
+    """Reads the MS Build JSON file at the path and returns its contents.
+
+    Keyword arguments:
+    values -- The list to append the contents to (default [])
+    """
+    if not os.path.exists(path):
+        logging.info('Could not find MS Build JSON file at %s', path)
+        return values
+
+    try:
+        values.extend(__read_json_file(path))
+    except Exception as e:
+        logging.exception('Could not read MS Build JSON file at %s', path)
+        return values
+
+    logging.info('Processing MS Build JSON file at %s', path)
+
+    return values
+
+
+def main():
+    """Script entrypoint."""
+    # Parse the arguments
+    parser = argparse.ArgumentParser(
+        description='Convert MSBuild XML to JSON format')
+
+    parser.add_argument(
+        '-t', '--toolchain', help='The name of the toolchain', required=True)
+    parser.add_argument(
+        '-o', '--output', help='The output directory', default='')
+    parser.add_argument(
+        '-r',
+        '--overwrite',
+        help='Whether previously output should be overwritten',
+        dest='overwrite',
+        action='store_true')
+    parser.set_defaults(overwrite=False)
+    parser.add_argument(
+        '-d',
+        '--debug',
+        help="Debug tool output",
+        action="store_const",
+        dest="loglevel",
+        const=logging.DEBUG,
+        default=logging.WARNING)
+    parser.add_argument(
+        '-v',
+        '--verbose',
+        help="Verbose output",
+        action="store_const",
+        dest="loglevel",
+        const=logging.INFO)
+    parser.add_argument('input', help='The input files', nargs='+')
+
+    args = parser.parse_args()
+
+    toolchain = args.toolchain
+
+    logging.basicConfig(level=args.loglevel)
+    logging.info('Creating %s toolchain files', toolchain)
+
+    values = {}
+
+    # Iterate through the inputs
+    for input in args.input:
+        input = __get_path(input)
+
+        read_msbuild_xml(input, values)
+
+    # Determine if the output directory needs to be created
+    output_dir = __get_path(args.output)
+
+    if not os.path.exists(output_dir):
+        os.mkdir(output_dir)
+        logging.info('Created output directory %s', output_dir)
+
+    for key, value in values.items():
+        output_path = __output_path(toolchain, key, output_dir)
+
+        if os.path.exists(output_path) and not args.overwrite:
+            logging.info('Comparing previous output to current')
+
+            __merge_json_values(value, read_msbuild_json(output_path))
+        else:
+            logging.info('Original output will be overwritten')
+
+        logging.info('Writing MS Build JSON file at %s', output_path)
+
+        __write_json_file(output_path, value)
+
+
+###########################################################################################
+# private joining functions
+def __merge_json_values(current, previous):
+    """Merges the values between the current and previous run of the script."""
+    for value in current:
+        name = value['name']
+
+        # Find the previous value
+        previous_value = __find_and_remove_value(previous, value)
+
+        if previous_value is not None:
+            flags = value['flags']
+            previous_flags = previous_value['flags']
+
+            if flags != previous_flags:
+                logging.warning(
+                    'Flags for %s are different. Using previous value.', name)
+
+                value['flags'] = previous_flags
+        else:
+            logging.warning('Value %s is a new value', name)
+
+    for value in previous:
+        name = value['name']
+        logging.warning(
+            'Value %s not present in current run. Appending value.', name)
+
+        current.append(value)
+
+
+def __find_and_remove_value(list, compare):
+    """Finds the value in the list that corresponds with the value of compare."""
+    # next throws if there are no matches
+    try:
+        found = next(value for value in list
+                     if value['name'] == compare['name'] and value['switch'] ==
+                     compare['switch'])
+    except:
+        return None
+
+    list.remove(found)
+
+    return found
+
+
+###########################################################################################
+# private xml functions
+def __convert(root, tag, values, func):
+    """Converts the tag type found in the root and converts them using the func
+    and appends them to the values.
+    """
+    elements = root.getElementsByTagName(tag)
+
+    for element in elements:
+        converted = func(element)
+
+        # Append to the list
+        __append_list(values, converted)
+
+
+def __convert_enum(node):
+    """Converts an EnumProperty node to JSON format."""
+    name = __get_attribute(node, 'Name')
+    logging.debug('Found EnumProperty named %s', name)
+
+    converted_values = []
+
+    for value in node.getElementsByTagName('EnumValue'):
+        converted = __convert_node(value)
+
+        converted['value'] = converted['name']
+        converted['name'] = name
+
+        # Modify flags when there is an argument child
+        __with_argument(value, converted)
+
+        converted_values.append(converted)
+
+    return converted_values
+
+
+def __convert_bool(node):
+    """Converts an BoolProperty node to JSON format."""
+    converted = __convert_node(node, default_value='true')
+
+    # Check for a switch for reversing the value
+    reverse_switch = __get_attribute(node, 'ReverseSwitch')
+
+    if reverse_switch:
+        converted_reverse = copy.deepcopy(converted)
+
+        converted_reverse['switch'] = reverse_switch
+        converted_reverse['value'] = 'false'
+
+        return [converted_reverse, converted]
+
+    # Modify flags when there is an argument child
+    __with_argument(node, converted)
+
+    return __check_for_flag(converted)
+
+
+def __convert_string_list(node):
+    """Converts a StringListProperty node to JSON format."""
+    converted = __convert_node(node)
+
+    # Determine flags for the string list
+    flags = vsflags(VSFlags.UserValue)
+
+    # Check for a separator to determine if it is semicolon appendable
+    # If not present assume the value should be ;
+    separator = __get_attribute(node, 'Separator', default_value=';')
+
+    if separator == ';':
+        flags = vsflags(flags, VSFlags.SemicolonAppendable)
+
+    converted['flags'] = flags
+
+    return __check_for_flag(converted)
+
+
+def __convert_string(node):
+    """Converts a StringProperty node to JSON format."""
+    converted = __convert_node(node, default_flags=vsflags(VSFlags.UserValue))
+
+    return __check_for_flag(converted)
+
+
+def __convert_node(node, default_value='', default_flags=vsflags()):
+    """Converts a XML node to a JSON equivalent."""
+    name = __get_attribute(node, 'Name')
+    logging.debug('Found %s named %s', node.tagName, name)
+
+    converted = {}
+    converted['name'] = name
+    converted['switch'] = __get_attribute(node, 'Switch')
+    converted['comment'] = __get_attribute(node, 'DisplayName')
+    converted['value'] = default_value
+
+    # Check for the Flags attribute in case it was created during preprocessing
+    flags = __get_attribute(node, 'Flags')
+
+    if flags:
+        flags = flags.split(',')
+    else:
+        flags = default_flags
+
+    converted['flags'] = flags
+
+    return converted
+
+
+def __check_for_flag(value):
+    """Checks whether the value has a switch value.
+
+    If not then returns None as it should not be added.
+    """
+    if value['switch']:
+        return value
+    else:
+        logging.warning('Skipping %s which has no command line switch',
+                        value['name'])
+        return None
+
+
+def __with_argument(node, value):
+    """Modifies the flags in value if the node contains an Argument."""
+    arguments = node.getElementsByTagName('Argument')
+
+    if arguments:
+        logging.debug('Found argument within %s', value['name'])
+        value['flags'] = vsflags(VSFlags.UserValueIgnored, VSFlags.Continue)
+
+
+def __preprocess_arguments(root):
+    """Preprocesses occurrences of Argument within the root.
+
+    Argument XML values reference other values within the document by name. The
+    referenced value does not contain a switch. This function will add the
+    switch associated with the argument.
+    """
+    # Set the flags to require a value
+    flags = ','.join(vsflags(VSFlags.UserValueRequired))
+
+    # Search through the arguments
+    arguments = root.getElementsByTagName('Argument')
+
+    for argument in arguments:
+        reference = __get_attribute(argument, 'Property')
+        found = None
+
+        # Look for the argument within the root's children
+        for child in root.childNodes:
+            # Ignore Text nodes
+            if isinstance(child, Element):
+                name = __get_attribute(child, 'Name')
+
+                if name == reference:
+                    found = child
+                    break
+
+        if found is not None:
+            logging.info('Found property named %s', reference)
+            # Get the associated switch
+            switch = __get_attribute(argument.parentNode, 'Switch')
+
+            # See if there is already a switch associated with the element.
+            if __get_attribute(found, 'Switch'):
+                logging.debug('Copying node %s', reference)
+                clone = found.cloneNode(True)
+                root.insertBefore(clone, found)
+                found = clone
+
+            found.setAttribute('Switch', switch)
+            found.setAttribute('Flags', flags)
+        else:
+            logging.warning('Could not find property named %s', reference)
+
+
+def __get_attribute(node, name, default_value=''):
+    """Retrieves the attribute of the given name from the node.
+
+    If not present then the default_value is used.
+    """
+    if node.hasAttribute(name):
+        return node.attributes[name].value.strip()
+    else:
+        return default_value
+
+
+###########################################################################################
+# private path functions
+def __get_path(path):
+    """Gets the path to the file."""
+    if not os.path.isabs(path):
+        path = os.path.join(os.getcwd(), path)
+
+    return os.path.normpath(path)
+
+
+def __output_path(toolchain, rule, output_dir):
+    """Gets the output path for a file given the toolchain, rule and output_dir"""
+    filename = '%s_%s.json' % (toolchain, rule)
+    return os.path.join(output_dir, filename)
+
+
+###########################################################################################
+# private JSON file functions
+def __read_json_file(path):
+    """Reads a JSON file at the path."""
+    with open(path, 'r') as f:
+        return json.load(f)
+
+
+def __write_json_file(path, values):
+    """Writes a JSON file at the path with the values provided."""
+    # Sort the keys to ensure ordering
+    sort_order = ['name', 'switch', 'comment', 'value', 'flags']
+    sorted_values = [
+        OrderedDict(
+            sorted(
+                value.items(), key=lambda value: sort_order.index(value[0])))
+        for value in values
+    ]
+
+    with open(path, 'w') as f:
+        json.dump(sorted_values, f, indent=2, separators=(',', ': '))
+
+
+###########################################################################################
+# private list helpers
+def __append_list(append_to, value):
+    """Appends the value to the list."""
+    if value is not None:
+        if isinstance(value, list):
+            append_to.extend(value)
+        else:
+            append_to.append(value)
+
+###########################################################################################
+# main entry point
+if __name__ == "__main__":
+    main()
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
new file mode 100644
index 0000000..fd258fe
--- /dev/null
+++ b/Source/cmCoreTryCompile.cxx
@@ -0,0 +1,973 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCoreTryCompile.h"
+
+#include "cmsys/Directory.hxx"
+#include <set>
+#include <sstream>
+#include <stdio.h>
+#include <string.h>
+#include <utility>
+
+#include "cmAlgorithms.h"
+#include "cmExportTryCompileFileGenerator.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmPolicies.h"
+#include "cmState.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmVersion.h"
+#include "cmake.h"
+
+static std::string const kCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN =
+  "CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN";
+static std::string const kCMAKE_C_COMPILER_TARGET = "CMAKE_C_COMPILER_TARGET";
+static std::string const kCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN =
+  "CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN";
+static std::string const kCMAKE_CXX_COMPILER_TARGET =
+  "CMAKE_CXX_COMPILER_TARGET";
+static std::string const kCMAKE_ENABLE_EXPORTS = "CMAKE_ENABLE_EXPORTS";
+static std::string const kCMAKE_LINK_SEARCH_END_STATIC =
+  "CMAKE_LINK_SEARCH_END_STATIC";
+static std::string const kCMAKE_LINK_SEARCH_START_STATIC =
+  "CMAKE_LINK_SEARCH_START_STATIC";
+static std::string const kCMAKE_OSX_ARCHITECTURES = "CMAKE_OSX_ARCHITECTURES";
+static std::string const kCMAKE_OSX_DEPLOYMENT_TARGET =
+  "CMAKE_OSX_DEPLOYMENT_TARGET";
+static std::string const kCMAKE_OSX_SYSROOT = "CMAKE_OSX_SYSROOT";
+static std::string const kCMAKE_POSITION_INDEPENDENT_CODE =
+  "CMAKE_POSITION_INDEPENDENT_CODE";
+static std::string const kCMAKE_SYSROOT = "CMAKE_SYSROOT";
+static std::string const kCMAKE_SYSROOT_COMPILE = "CMAKE_SYSROOT_COMPILE";
+static std::string const kCMAKE_SYSROOT_LINK = "CMAKE_SYSROOT_LINK";
+static std::string const kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES =
+  "CMAKE_TRY_COMPILE_OSX_ARCHITECTURES";
+static std::string const kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES =
+  "CMAKE_TRY_COMPILE_PLATFORM_VARIABLES";
+static std::string const kCMAKE_WARN_DEPRECATED = "CMAKE_WARN_DEPRECATED";
+
+static void writeProperty(FILE* fout, std::string const& targetName,
+                          std::string const& prop, std::string const& value)
+{
+  fprintf(fout, "set_property(TARGET %s PROPERTY %s %s)\n", targetName.c_str(),
+          cmOutputConverter::EscapeForCMake(prop).c_str(),
+          cmOutputConverter::EscapeForCMake(value).c_str());
+}
+
+std::string cmCoreTryCompile::LookupStdVar(std::string const& var,
+                                           bool warnCMP0067)
+{
+  std::string value = this->Makefile->GetSafeDefinition(var);
+  if (warnCMP0067 && !value.empty()) {
+    value.clear();
+    this->WarnCMP0067.push_back(var);
+  }
+  return value;
+}
+
+int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
+                                     bool isTryRun)
+{
+  this->BinaryDirectory = argv[1];
+  this->OutputFile.clear();
+  // which signature were we called with ?
+  this->SrcFileSignature = true;
+
+  cmStateEnums::TargetType targetType = cmStateEnums::EXECUTABLE;
+  const char* tt =
+    this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_TARGET_TYPE");
+  if (!isTryRun && tt && *tt) {
+    if (strcmp(tt, cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE)) ==
+        0) {
+      targetType = cmStateEnums::EXECUTABLE;
+    } else if (strcmp(tt, cmState::GetTargetTypeName(
+                            cmStateEnums::STATIC_LIBRARY)) == 0) {
+      targetType = cmStateEnums::STATIC_LIBRARY;
+    } else {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR, std::string("Invalid value '") + tt +
+          "' for "
+          "CMAKE_TRY_COMPILE_TARGET_TYPE.  Only "
+          "'" +
+          cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE) + "' and "
+                                                                 "'" +
+          cmState::GetTargetTypeName(cmStateEnums::STATIC_LIBRARY) +
+          "' "
+          "are allowed.");
+      return -1;
+    }
+  }
+
+  const char* sourceDirectory = argv[2].c_str();
+  const char* projectName = nullptr;
+  std::string targetName;
+  std::vector<std::string> cmakeFlags(1, "CMAKE_FLAGS"); // fake argv[0]
+  std::vector<std::string> compileDefs;
+  std::string outputVariable;
+  std::string copyFile;
+  std::string copyFileError;
+  std::string cStandard;
+  std::string cxxStandard;
+  std::string cudaStandard;
+  std::string cStandardRequired;
+  std::string cxxStandardRequired;
+  std::string cudaStandardRequired;
+  std::string cExtensions;
+  std::string cxxExtensions;
+  std::string cudaExtensions;
+  std::vector<std::string> targets;
+  std::string libsToLink = " ";
+  bool useOldLinkLibs = true;
+  char targetNameBuf[64];
+  bool didOutputVariable = false;
+  bool didCopyFile = false;
+  bool didCopyFileError = false;
+  bool didCStandard = false;
+  bool didCxxStandard = false;
+  bool didCudaStandard = false;
+  bool didCStandardRequired = false;
+  bool didCxxStandardRequired = false;
+  bool didCudaStandardRequired = false;
+  bool didCExtensions = false;
+  bool didCxxExtensions = false;
+  bool didCudaExtensions = false;
+  bool useSources = argv[2] == "SOURCES";
+  std::vector<std::string> sources;
+
+  enum Doing
+  {
+    DoingNone,
+    DoingCMakeFlags,
+    DoingCompileDefinitions,
+    DoingLinkLibraries,
+    DoingOutputVariable,
+    DoingCopyFile,
+    DoingCopyFileError,
+    DoingCStandard,
+    DoingCxxStandard,
+    DoingCudaStandard,
+    DoingCStandardRequired,
+    DoingCxxStandardRequired,
+    DoingCudaStandardRequired,
+    DoingCExtensions,
+    DoingCxxExtensions,
+    DoingCudaExtensions,
+    DoingSources
+  };
+  Doing doing = useSources ? DoingSources : DoingNone;
+  for (size_t i = 3; i < argv.size(); ++i) {
+    if (argv[i] == "CMAKE_FLAGS") {
+      doing = DoingCMakeFlags;
+    } else if (argv[i] == "COMPILE_DEFINITIONS") {
+      doing = DoingCompileDefinitions;
+    } else if (argv[i] == "LINK_LIBRARIES") {
+      doing = DoingLinkLibraries;
+      useOldLinkLibs = false;
+    } else if (argv[i] == "OUTPUT_VARIABLE") {
+      doing = DoingOutputVariable;
+      didOutputVariable = true;
+    } else if (argv[i] == "COPY_FILE") {
+      doing = DoingCopyFile;
+      didCopyFile = true;
+    } else if (argv[i] == "COPY_FILE_ERROR") {
+      doing = DoingCopyFileError;
+      didCopyFileError = true;
+    } else if (argv[i] == "C_STANDARD") {
+      doing = DoingCStandard;
+      didCStandard = true;
+    } else if (argv[i] == "CXX_STANDARD") {
+      doing = DoingCxxStandard;
+      didCxxStandard = true;
+    } else if (argv[i] == "CUDA_STANDARD") {
+      doing = DoingCudaStandard;
+      didCudaStandard = true;
+    } else if (argv[i] == "C_STANDARD_REQUIRED") {
+      doing = DoingCStandardRequired;
+      didCStandardRequired = true;
+    } else if (argv[i] == "CXX_STANDARD_REQUIRED") {
+      doing = DoingCxxStandardRequired;
+      didCxxStandardRequired = true;
+    } else if (argv[i] == "CUDA_STANDARD_REQUIRED") {
+      doing = DoingCudaStandardRequired;
+      didCudaStandardRequired = true;
+    } else if (argv[i] == "C_EXTENSIONS") {
+      doing = DoingCExtensions;
+      didCExtensions = true;
+    } else if (argv[i] == "CXX_EXTENSIONS") {
+      doing = DoingCxxExtensions;
+      didCxxExtensions = true;
+    } else if (argv[i] == "CUDA_EXTENSIONS") {
+      doing = DoingCudaExtensions;
+      didCudaExtensions = true;
+    } else if (doing == DoingCMakeFlags) {
+      cmakeFlags.push_back(argv[i]);
+    } else if (doing == DoingCompileDefinitions) {
+      compileDefs.push_back(argv[i]);
+    } else if (doing == DoingLinkLibraries) {
+      libsToLink += "\"" + cmSystemTools::TrimWhitespace(argv[i]) + "\" ";
+      if (cmTarget* tgt = this->Makefile->FindTargetToUse(argv[i])) {
+        switch (tgt->GetType()) {
+          case cmStateEnums::SHARED_LIBRARY:
+          case cmStateEnums::STATIC_LIBRARY:
+          case cmStateEnums::INTERFACE_LIBRARY:
+          case cmStateEnums::UNKNOWN_LIBRARY:
+            break;
+          case cmStateEnums::EXECUTABLE:
+            if (tgt->IsExecutableWithExports()) {
+              break;
+            }
+            CM_FALLTHROUGH;
+          default:
+            this->Makefile->IssueMessage(
+              cmake::FATAL_ERROR,
+              "Only libraries may be used as try_compile or try_run IMPORTED "
+              "LINK_LIBRARIES.  Got " +
+                std::string(tgt->GetName()) + " of "
+                                              "type " +
+                cmState::GetTargetTypeName(tgt->GetType()) + ".");
+            return -1;
+        }
+        if (tgt->IsImported()) {
+          targets.push_back(argv[i]);
+        }
+      }
+    } else if (doing == DoingOutputVariable) {
+      outputVariable = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCopyFile) {
+      copyFile = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCopyFileError) {
+      copyFileError = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCStandard) {
+      cStandard = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCxxStandard) {
+      cxxStandard = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCudaStandard) {
+      cudaStandard = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCStandardRequired) {
+      cStandardRequired = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCxxStandardRequired) {
+      cxxStandardRequired = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCudaStandardRequired) {
+      cudaStandardRequired = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCExtensions) {
+      cExtensions = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCxxExtensions) {
+      cxxExtensions = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingCudaExtensions) {
+      cudaExtensions = argv[i];
+      doing = DoingNone;
+    } else if (doing == DoingSources) {
+      sources.push_back(argv[i]);
+    } else if (i == 3) {
+      this->SrcFileSignature = false;
+      projectName = argv[i].c_str();
+    } else if (i == 4 && !this->SrcFileSignature) {
+      targetName = argv[i];
+    } else {
+      std::ostringstream m;
+      m << "try_compile given unknown argument \"" << argv[i] << "\".";
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, m.str());
+    }
+  }
+
+  if (didCopyFile && copyFile.empty()) {
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                 "COPY_FILE must be followed by a file path");
+    return -1;
+  }
+
+  if (didCopyFileError && copyFileError.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "COPY_FILE_ERROR must be followed by a variable name");
+    return -1;
+  }
+
+  if (didCopyFileError && !didCopyFile) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR, "COPY_FILE_ERROR may be used only with COPY_FILE");
+    return -1;
+  }
+
+  if (didOutputVariable && outputVariable.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "OUTPUT_VARIABLE must be followed by a variable name");
+    return -1;
+  }
+
+  if (useSources && sources.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "SOURCES must be followed by at least one source file");
+    return -1;
+  }
+
+  if (didCStandard && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR, "C_STANDARD allowed only in source file signature.");
+    return -1;
+  }
+  if (didCxxStandard && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CXX_STANDARD allowed only in source file signature.");
+    return -1;
+  }
+  if (didCudaStandard && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CUDA_STANDARD allowed only in source file signature.");
+    return -1;
+  }
+  if (didCStandardRequired && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "C_STANDARD_REQUIRED allowed only in source file signature.");
+    return -1;
+  }
+  if (didCxxStandardRequired && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CXX_STANDARD_REQUIRED allowed only in source file signature.");
+    return -1;
+  }
+  if (didCudaStandardRequired && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CUDA_STANDARD_REQUIRED allowed only in source file signature.");
+    return -1;
+  }
+  if (didCExtensions && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "C_EXTENSIONS allowed only in source file signature.");
+    return -1;
+  }
+  if (didCxxExtensions && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CXX_EXTENSIONS allowed only in source file signature.");
+    return -1;
+  }
+  if (didCudaExtensions && !this->SrcFileSignature) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "CUDA_EXTENSIONS allowed only in source file signature.");
+    return -1;
+  }
+
+  // compute the binary dir when TRY_COMPILE is called with a src file
+  // signature
+  if (this->SrcFileSignature) {
+    this->BinaryDirectory += cmake::GetCMakeFilesDirectory();
+    this->BinaryDirectory += "/CMakeTmp";
+  } else {
+    // only valid for srcfile signatures
+    if (!compileDefs.empty()) {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR,
+        "COMPILE_DEFINITIONS specified on a srcdir type TRY_COMPILE");
+      return -1;
+    }
+    if (!copyFile.empty()) {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR,
+        "COPY_FILE specified on a srcdir type TRY_COMPILE");
+      return -1;
+    }
+  }
+  // make sure the binary directory exists
+  cmSystemTools::MakeDirectory(this->BinaryDirectory.c_str());
+
+  // do not allow recursive try Compiles
+  if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory()) {
+    std::ostringstream e;
+    e << "Attempt at a recursive or nested TRY_COMPILE in directory\n"
+      << "  " << this->BinaryDirectory << "\n";
+    this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+    return -1;
+  }
+
+  std::string outFileName = this->BinaryDirectory + "/CMakeLists.txt";
+  // which signature are we using? If we are using var srcfile bindir
+  if (this->SrcFileSignature) {
+    // remove any CMakeCache.txt files so we will have a clean test
+    std::string ccFile = this->BinaryDirectory + "/CMakeCache.txt";
+    cmSystemTools::RemoveFile(ccFile);
+
+    // Choose sources.
+    if (!useSources) {
+      sources.push_back(argv[2]);
+    }
+
+    // Detect languages to enable.
+    cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+    std::set<std::string> testLangs;
+    for (std::string const& si : sources) {
+      std::string ext = cmSystemTools::GetFilenameLastExtension(si);
+      std::string lang = gg->GetLanguageFromExtension(ext.c_str());
+      if (!lang.empty()) {
+        testLangs.insert(lang);
+      } else {
+        std::ostringstream err;
+        err << "Unknown extension \"" << ext << "\" for file\n"
+            << "  " << si << "\n"
+            << "try_compile() works only for enabled languages.  "
+            << "Currently these are:\n  ";
+        std::vector<std::string> langs;
+        gg->GetEnabledLanguages(langs);
+        err << cmJoin(langs, " ");
+        err << "\nSee project() command to enable other languages.";
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR, err.str());
+        return -1;
+      }
+    }
+
+    std::string const tcConfig =
+      this->Makefile->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
+
+    // we need to create a directory and CMakeLists file etc...
+    // first create the directories
+    sourceDirectory = this->BinaryDirectory.c_str();
+
+    // now create a CMakeLists.txt file in that directory
+    FILE* fout = cmsys::SystemTools::Fopen(outFileName, "w");
+    if (!fout) {
+      std::ostringstream e;
+      /* clang-format off */
+      e << "Failed to open\n"
+        << "  " << outFileName << "\n"
+        << cmSystemTools::GetLastSystemError();
+      /* clang-format on */
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+      return -1;
+    }
+
+    const char* def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
+    fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n",
+            cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(),
+            cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion());
+    if (def) {
+      fprintf(fout, "set(CMAKE_MODULE_PATH \"%s\")\n", def);
+    }
+
+    std::string projectLangs;
+    for (std::string const& li : testLangs) {
+      projectLangs += " " + li;
+      std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE";
+      std::string rulesOverrideLang = rulesOverrideBase + "_" + li;
+      if (const char* rulesOverridePath =
+            this->Makefile->GetDefinition(rulesOverrideLang)) {
+        fprintf(fout, "set(%s \"%s\")\n", rulesOverrideLang.c_str(),
+                rulesOverridePath);
+      } else if (const char* rulesOverridePath2 =
+                   this->Makefile->GetDefinition(rulesOverrideBase)) {
+        fprintf(fout, "set(%s \"%s\")\n", rulesOverrideBase.c_str(),
+                rulesOverridePath2);
+      }
+    }
+    fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str());
+    fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n");
+    for (std::string const& li : testLangs) {
+      std::string langFlags = "CMAKE_" + li + "_FLAGS";
+      const char* flags = this->Makefile->GetDefinition(langFlags);
+      fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li.c_str(),
+              cmOutputConverter::EscapeForCMake(flags ? flags : "").c_str());
+      fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
+                    " ${COMPILE_DEFINITIONS}\")\n",
+              li.c_str(), li.c_str());
+    }
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0066)) {
+      case cmPolicies::WARN:
+        if (this->Makefile->PolicyOptionalWarningEnabled(
+              "CMAKE_POLICY_WARNING_CMP0066")) {
+          std::ostringstream w;
+          /* clang-format off */
+          w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0066) << "\n"
+            "For compatibility with older versions of CMake, try_compile "
+            "is not honoring caller config-specific compiler flags "
+            "(e.g. CMAKE_C_FLAGS_DEBUG) in the test project."
+            ;
+          /* clang-format on */
+          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+        }
+      case cmPolicies::OLD:
+        // OLD behavior is to do nothing.
+        break;
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::REQUIRED_ALWAYS:
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR,
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0066));
+        CM_FALLTHROUGH;
+      case cmPolicies::NEW: {
+        // NEW behavior is to pass config-specific compiler flags.
+        static std::string const cfgDefault = "DEBUG";
+        std::string const cfg =
+          !tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault;
+        for (std::string const& li : testLangs) {
+          std::string const langFlagsCfg = "CMAKE_" + li + "_FLAGS_" + cfg;
+          const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg);
+          fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(),
+                  cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "")
+                    .c_str());
+        }
+      } break;
+    }
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0056)) {
+      case cmPolicies::WARN:
+        if (this->Makefile->PolicyOptionalWarningEnabled(
+              "CMAKE_POLICY_WARNING_CMP0056")) {
+          std::ostringstream w;
+          /* clang-format off */
+          w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0056) << "\n"
+            "For compatibility with older versions of CMake, try_compile "
+            "is not honoring caller link flags (e.g. CMAKE_EXE_LINKER_FLAGS) "
+            "in the test project."
+            ;
+          /* clang-format on */
+          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+        }
+      case cmPolicies::OLD:
+        // OLD behavior is to do nothing.
+        break;
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::REQUIRED_ALWAYS:
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR,
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056));
+        CM_FALLTHROUGH;
+      case cmPolicies::NEW:
+        // NEW behavior is to pass linker flags.
+        {
+          const char* exeLinkFlags =
+            this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
+          fprintf(
+            fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
+            cmOutputConverter::EscapeForCMake(exeLinkFlags ? exeLinkFlags : "")
+              .c_str());
+        }
+        break;
+    }
+    fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS}"
+                  " ${EXE_LINKER_FLAGS}\")\n");
+    fprintf(fout, "include_directories(${INCLUDE_DIRECTORIES})\n");
+    fprintf(fout, "set(CMAKE_SUPPRESS_REGENERATION 1)\n");
+    fprintf(fout, "link_directories(${LINK_DIRECTORIES})\n");
+    // handle any compile flags we need to pass on
+    if (!compileDefs.empty()) {
+      fprintf(fout, "add_definitions(%s)\n", cmJoin(compileDefs, " ").c_str());
+    }
+
+    /* Use a random file name to avoid rapid creation and deletion
+       of the same executable name (some filesystems fail on that).  */
+    sprintf(targetNameBuf, "cmTC_%05x", cmSystemTools::RandomSeed() & 0xFFFFF);
+    targetName = targetNameBuf;
+
+    if (!targets.empty()) {
+      std::string fname = "/" + std::string(targetName) + "Targets.cmake";
+      cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile);
+      tcfg.SetExportFile((this->BinaryDirectory + fname).c_str());
+      tcfg.SetConfig(tcConfig);
+
+      if (!tcfg.GenerateImportFile()) {
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                     "could not write export file.");
+        fclose(fout);
+        return -1;
+      }
+      fprintf(fout, "\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/%s\")\n\n",
+              fname.c_str());
+    }
+
+    // Forward a set of variables to the inner project cache.
+    {
+      std::set<std::string> vars;
+      vars.insert(kCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN);
+      vars.insert(kCMAKE_C_COMPILER_TARGET);
+      vars.insert(kCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN);
+      vars.insert(kCMAKE_CXX_COMPILER_TARGET);
+      vars.insert(kCMAKE_ENABLE_EXPORTS);
+      vars.insert(kCMAKE_LINK_SEARCH_END_STATIC);
+      vars.insert(kCMAKE_LINK_SEARCH_START_STATIC);
+      vars.insert(kCMAKE_OSX_ARCHITECTURES);
+      vars.insert(kCMAKE_OSX_DEPLOYMENT_TARGET);
+      vars.insert(kCMAKE_OSX_SYSROOT);
+      vars.insert(kCMAKE_POSITION_INDEPENDENT_CODE);
+      vars.insert(kCMAKE_SYSROOT);
+      vars.insert(kCMAKE_SYSROOT_COMPILE);
+      vars.insert(kCMAKE_SYSROOT_LINK);
+      vars.insert(kCMAKE_WARN_DEPRECATED);
+
+      if (const char* varListStr = this->Makefile->GetDefinition(
+            kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES)) {
+        std::vector<std::string> varList;
+        cmSystemTools::ExpandListArgument(varListStr, varList);
+        vars.insert(varList.begin(), varList.end());
+      }
+
+      /* for the TRY_COMPILEs we want to be able to specify the architecture.
+         So the user can set CMAKE_OSX_ARCHITECTURES to i386;ppc and then set
+         CMAKE_TRY_COMPILE_OSX_ARCHITECTURES first to i386 and then to ppc to
+         have the tests run for each specific architecture. Since
+         cmLocalGenerator doesn't allow building for "the other"
+         architecture only via CMAKE_OSX_ARCHITECTURES.
+         */
+      if (const char* tcArchs = this->Makefile->GetDefinition(
+            kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES)) {
+        vars.erase(kCMAKE_OSX_ARCHITECTURES);
+        std::string flag = "-DCMAKE_OSX_ARCHITECTURES=" + std::string(tcArchs);
+        cmakeFlags.push_back(flag);
+      }
+
+      for (std::string const& var : vars) {
+        if (const char* val = this->Makefile->GetDefinition(var)) {
+          std::string flag = "-D" + var + "=" + val;
+          cmakeFlags.push_back(flag);
+        }
+      }
+    }
+
+    /* Set the appropriate policy information for ENABLE_EXPORTS */
+    fprintf(fout, "cmake_policy(SET CMP0065 %s)\n",
+            this->Makefile->GetPolicyStatus(cmPolicies::CMP0065) ==
+                cmPolicies::NEW
+              ? "NEW"
+              : "OLD");
+
+    if (targetType == cmStateEnums::EXECUTABLE) {
+      /* Put the executable at a known location (for COPY_FILE).  */
+      fprintf(fout, "set(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"%s\")\n",
+              this->BinaryDirectory.c_str());
+      /* Create the actual executable.  */
+      fprintf(fout, "add_executable(%s", targetName.c_str());
+    } else // if (targetType == cmStateEnums::STATIC_LIBRARY)
+    {
+      /* Put the static library at a known location (for COPY_FILE).  */
+      fprintf(fout, "set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY \"%s\")\n",
+              this->BinaryDirectory.c_str());
+      /* Create the actual static library.  */
+      fprintf(fout, "add_library(%s STATIC", targetName.c_str());
+    }
+    for (std::string const& si : sources) {
+      fprintf(fout, " \"%s\"", si.c_str());
+
+      // Add dependencies on any non-temporary sources.
+      if (si.find("CMakeTmp") == std::string::npos) {
+        this->Makefile->AddCMakeDependFile(si);
+      }
+    }
+    fprintf(fout, ")\n");
+
+    bool const testC = testLangs.find("C") != testLangs.end();
+    bool const testCxx = testLangs.find("CXX") != testLangs.end();
+    bool const testCuda = testLangs.find("CUDA") != testLangs.end();
+
+    bool warnCMP0067 = false;
+    bool honorStandard = true;
+
+    if (!didCStandard && !didCxxStandard && !didCudaStandard &&
+        !didCStandardRequired && !didCxxStandardRequired &&
+        !didCudaStandardRequired && !didCExtensions && !didCxxExtensions &&
+        !didCudaExtensions) {
+      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0067)) {
+        case cmPolicies::WARN:
+          warnCMP0067 = this->Makefile->PolicyOptionalWarningEnabled(
+            "CMAKE_POLICY_WARNING_CMP0067");
+          CM_FALLTHROUGH;
+        case cmPolicies::OLD:
+          // OLD behavior is to not honor the language standard variables.
+          honorStandard = false;
+          break;
+        case cmPolicies::REQUIRED_IF_USED:
+        case cmPolicies::REQUIRED_ALWAYS:
+          this->Makefile->IssueMessage(
+            cmake::FATAL_ERROR,
+            cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0067));
+        case cmPolicies::NEW:
+          // NEW behavior is to honor the language standard variables.
+          // We already initialized honorStandard to true.
+          break;
+      }
+    }
+
+    if (honorStandard || warnCMP0067) {
+      if (testC) {
+        if (!didCStandard) {
+          cStandard = this->LookupStdVar("CMAKE_C_STANDARD", warnCMP0067);
+        }
+        if (!didCStandardRequired) {
+          cStandardRequired =
+            this->LookupStdVar("CMAKE_C_STANDARD_REQUIRED", warnCMP0067);
+        }
+        if (!didCExtensions) {
+          cExtensions = this->LookupStdVar("CMAKE_C_EXTENSIONS", warnCMP0067);
+        }
+      }
+      if (testCxx) {
+        if (!didCxxStandard) {
+          cxxStandard = this->LookupStdVar("CMAKE_CXX_STANDARD", warnCMP0067);
+        }
+        if (!didCxxStandardRequired) {
+          cxxStandardRequired =
+            this->LookupStdVar("CMAKE_CXX_STANDARD_REQUIRED", warnCMP0067);
+        }
+        if (!didCxxExtensions) {
+          cxxExtensions =
+            this->LookupStdVar("CMAKE_CXX_EXTENSIONS", warnCMP0067);
+        }
+      }
+      if (testCuda) {
+        if (!didCudaStandard) {
+          cudaStandard =
+            this->LookupStdVar("CMAKE_CUDA_STANDARD", warnCMP0067);
+        }
+        if (!didCudaStandardRequired) {
+          cudaStandardRequired =
+            this->LookupStdVar("CMAKE_CUDA_STANDARD_REQUIRED", warnCMP0067);
+        }
+        if (!didCudaExtensions) {
+          cudaExtensions =
+            this->LookupStdVar("CMAKE_CUDA_EXTENSIONS", warnCMP0067);
+        }
+      }
+    }
+
+    if (!this->WarnCMP0067.empty()) {
+      std::ostringstream w;
+      /* clang-format off */
+      w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0067) << "\n"
+        "For compatibility with older versions of CMake, try_compile "
+        "is not honoring language standard variables in the test project:\n"
+        ;
+      /* clang-format on */
+      for (std::string const& vi : this->WarnCMP0067) {
+        w << "  " << vi << "\n";
+      }
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+    }
+
+    if (testC) {
+      if (!cStandard.empty()) {
+        writeProperty(fout, targetName, "C_STANDARD", cStandard);
+      }
+      if (!cStandardRequired.empty()) {
+        writeProperty(fout, targetName, "C_STANDARD_REQUIRED",
+                      cStandardRequired);
+      }
+      if (!cExtensions.empty()) {
+        writeProperty(fout, targetName, "C_EXTENSIONS", cExtensions);
+      }
+    }
+
+    if (testCxx) {
+      if (!cxxStandard.empty()) {
+        writeProperty(fout, targetName, "CXX_STANDARD", cxxStandard);
+      }
+      if (!cxxStandardRequired.empty()) {
+        writeProperty(fout, targetName, "CXX_STANDARD_REQUIRED",
+                      cxxStandardRequired);
+      }
+      if (!cxxExtensions.empty()) {
+        writeProperty(fout, targetName, "CXX_EXTENSIONS", cxxExtensions);
+      }
+    }
+
+    if (testCuda) {
+      if (!cudaStandard.empty()) {
+        writeProperty(fout, targetName, "CUDA_STANDARD", cudaStandard);
+      }
+      if (!cudaStandardRequired.empty()) {
+        writeProperty(fout, targetName, "CUDA_STANDARD_REQUIRED",
+                      cudaStandardRequired);
+      }
+      if (!cudaExtensions.empty()) {
+        writeProperty(fout, targetName, "CUDA_EXTENSIONS", cudaExtensions);
+      }
+    }
+
+    if (useOldLinkLibs) {
+      fprintf(fout, "target_link_libraries(%s ${LINK_LIBRARIES})\n",
+              targetName.c_str());
+    } else {
+      fprintf(fout, "target_link_libraries(%s %s)\n", targetName.c_str(),
+              libsToLink.c_str());
+    }
+    fclose(fout);
+    projectName = "CMAKE_TRY_COMPILE";
+  }
+
+  bool erroroc = cmSystemTools::GetErrorOccuredFlag();
+  cmSystemTools::ResetErrorOccuredFlag();
+  std::string output;
+  // actually do the try compile now that everything is setup
+  int res = this->Makefile->TryCompile(
+    sourceDirectory, this->BinaryDirectory, projectName, targetName,
+    this->SrcFileSignature, &cmakeFlags, output);
+  if (erroroc) {
+    cmSystemTools::SetErrorOccured();
+  }
+
+  // set the result var to the return value to indicate success or failure
+  this->Makefile->AddCacheDefinition(argv[0], (res == 0 ? "TRUE" : "FALSE"),
+                                     "Result of TRY_COMPILE",
+                                     cmStateEnums::INTERNAL);
+
+  if (!outputVariable.empty()) {
+    this->Makefile->AddDefinition(outputVariable, output.c_str());
+  }
+
+  if (this->SrcFileSignature) {
+    std::string copyFileErrorMessage;
+    this->FindOutputFile(targetName, targetType);
+
+    if ((res == 0) && !copyFile.empty()) {
+      if (this->OutputFile.empty() ||
+          !cmSystemTools::CopyFileAlways(this->OutputFile, copyFile)) {
+        std::ostringstream emsg;
+        /* clang-format off */
+        emsg << "Cannot copy output executable\n"
+             << "  '" << this->OutputFile << "'\n"
+             << "to destination specified by COPY_FILE:\n"
+             << "  '" << copyFile << "'\n";
+        /* clang-format on */
+        if (!this->FindErrorMessage.empty()) {
+          emsg << this->FindErrorMessage.c_str();
+        }
+        if (copyFileError.empty()) {
+          this->Makefile->IssueMessage(cmake::FATAL_ERROR, emsg.str());
+          return -1;
+        }
+        copyFileErrorMessage = emsg.str();
+      }
+    }
+
+    if (!copyFileError.empty()) {
+      this->Makefile->AddDefinition(copyFileError,
+                                    copyFileErrorMessage.c_str());
+    }
+  }
+  return res;
+}
+
+void cmCoreTryCompile::CleanupFiles(const char* binDir)
+{
+  if (!binDir) {
+    return;
+  }
+
+  std::string bdir = binDir;
+  if (bdir.find("CMakeTmp") == std::string::npos) {
+    cmSystemTools::Error(
+      "TRY_COMPILE attempt to remove -rf directory that does not contain "
+      "CMakeTmp:",
+      binDir);
+    return;
+  }
+
+  cmsys::Directory dir;
+  dir.Load(binDir);
+  std::set<std::string> deletedFiles;
+  for (unsigned long i = 0; i < dir.GetNumberOfFiles(); ++i) {
+    const char* fileName = dir.GetFile(i);
+    if (strcmp(fileName, ".") != 0 && strcmp(fileName, "..") != 0) {
+      if (deletedFiles.insert(fileName).second) {
+        std::string const fullPath =
+          std::string(binDir).append("/").append(fileName);
+        if (cmSystemTools::FileIsDirectory(fullPath)) {
+          this->CleanupFiles(fullPath.c_str());
+          cmSystemTools::RemoveADirectory(fullPath);
+        } else {
+#ifdef _WIN32
+          // Sometimes anti-virus software hangs on to new files so we
+          // cannot delete them immediately.  Try a few times.
+          cmSystemTools::WindowsFileRetry retry =
+            cmSystemTools::GetWindowsFileRetry();
+          while (!cmSystemTools::RemoveFile(fullPath.c_str()) &&
+                 --retry.Count &&
+                 cmSystemTools::FileExists(fullPath.c_str())) {
+            cmSystemTools::Delay(retry.Delay);
+          }
+          if (retry.Count == 0)
+#else
+          if (!cmSystemTools::RemoveFile(fullPath))
+#endif
+          {
+            std::string m = "Remove failed on file: " + fullPath;
+            cmSystemTools::ReportLastSystemError(m.c_str());
+          }
+        }
+      }
+    }
+  }
+}
+
+void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
+                                      cmStateEnums::TargetType targetType)
+{
+  this->FindErrorMessage.clear();
+  this->OutputFile.clear();
+  std::string tmpOutputFile = "/";
+  if (targetType == cmStateEnums::EXECUTABLE) {
+    tmpOutputFile += targetName;
+    tmpOutputFile +=
+      this->Makefile->GetSafeDefinition("CMAKE_EXECUTABLE_SUFFIX");
+  } else // if (targetType == cmStateEnums::STATIC_LIBRARY)
+  {
+    tmpOutputFile +=
+      this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_PREFIX");
+    tmpOutputFile += targetName;
+    tmpOutputFile +=
+      this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_SUFFIX");
+  }
+
+  // a list of directories where to search for the compilation result
+  // at first directly in the binary dir
+  std::vector<std::string> searchDirs;
+  searchDirs.push_back("");
+
+  const char* config =
+    this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
+  // if a config was specified try that first
+  if (config && config[0]) {
+    std::string tmp = "/";
+    tmp += config;
+    searchDirs.push_back(tmp);
+  }
+  searchDirs.push_back("/Debug");
+#if defined(__APPLE__)
+  std::string app = "/Debug/" + targetName + ".app";
+  searchDirs.push_back(app);
+#endif
+  searchDirs.push_back("/Development");
+
+  for (std::string const& sdir : searchDirs) {
+    std::string command = this->BinaryDirectory;
+    command += sdir;
+    command += tmpOutputFile;
+    if (cmSystemTools::FileExists(command.c_str())) {
+      this->OutputFile = cmSystemTools::CollapseFullPath(command);
+      return;
+    }
+  }
+
+  std::ostringstream emsg;
+  emsg << "Unable to find the executable at any of:\n";
+  emsg << cmWrap("  " + this->BinaryDirectory, searchDirs, tmpOutputFile, "\n")
+       << "\n";
+  this->FindErrorMessage = emsg.str();
+}
diff --git a/Source/cmCoreTryCompile.h b/Source/cmCoreTryCompile.h
new file mode 100644
index 0000000..365154d
--- /dev/null
+++ b/Source/cmCoreTryCompile.h
@@ -0,0 +1,56 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCoreTryCompile_h
+#define cmCoreTryCompile_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+#include "cmStateTypes.h"
+
+/** \class cmCoreTryCompile
+ * \brief Base class for cmTryCompileCommand and cmTryRunCommand
+ *
+ * cmCoreTryCompile implements the functionality to build a program.
+ * It is the base class for cmTryCompileCommand and cmTryRunCommand.
+ */
+class cmCoreTryCompile : public cmCommand
+{
+public:
+protected:
+  /**
+   * This is the core code for try compile. It is here so that other
+   * commands, such as TryRun can access the same logic without
+   * duplication.
+   */
+  int TryCompileCode(std::vector<std::string> const& argv, bool isTryRun);
+
+  /**
+   * This deletes all the files created by TryCompileCode.
+   * This way we do not have to rely on the timing and
+   * dependencies of makefiles.
+   */
+  void CleanupFiles(const char* binDir);
+
+  /**
+   * This tries to find the (executable) file created by
+  TryCompileCode. The result is stored in OutputFile. If nothing is found,
+  the error message is stored in FindErrorMessage.
+   */
+  void FindOutputFile(const std::string& targetName,
+                      cmStateEnums::TargetType targetType);
+
+  std::string BinaryDirectory;
+  std::string OutputFile;
+  std::string FindErrorMessage;
+  bool SrcFileSignature;
+
+private:
+  std::vector<std::string> WarnCMP0067;
+  std::string LookupStdVar(std::string const& var, bool warnCMP0067);
+};
+
+#endif
diff --git a/Source/cmCreateTestSourceList.cxx b/Source/cmCreateTestSourceList.cxx
new file mode 100644
index 0000000..69532e6
--- /dev/null
+++ b/Source/cmCreateTestSourceList.cxx
@@ -0,0 +1,160 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCreateTestSourceList.h"
+
+#include <algorithm>
+
+#include "cmMakefile.h"
+#include "cmSourceFile.h"
+#include "cmSystemTools.h"
+
+class cmExecutionStatus;
+
+// cmCreateTestSourceList
+bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
+{
+  if (args.size() < 3) {
+    this->SetError("called with wrong number of arguments.");
+    return false;
+  }
+
+  std::vector<std::string>::const_iterator i = args.begin();
+  std::string extraInclude;
+  std::string function;
+  std::vector<std::string> tests;
+  // extract extra include and function ot
+  for (; i != args.end(); i++) {
+    if (*i == "EXTRA_INCLUDE") {
+      ++i;
+      if (i == args.end()) {
+        this->SetError("incorrect arguments to EXTRA_INCLUDE");
+        return false;
+      }
+      extraInclude = "#include \"";
+      extraInclude += *i;
+      extraInclude += "\"\n";
+    } else if (*i == "FUNCTION") {
+      ++i;
+      if (i == args.end()) {
+        this->SetError("incorrect arguments to FUNCTION");
+        return false;
+      }
+      function = *i;
+      function += "(&ac, &av);\n";
+    } else {
+      tests.push_back(*i);
+    }
+  }
+  i = tests.begin();
+
+  // Name of the source list
+
+  const char* sourceList = i->c_str();
+  ++i;
+
+  // Name of the test driver
+  // make sure they specified an extension
+  if (cmSystemTools::GetFilenameExtension(*i).size() < 2) {
+    this->SetError(
+      "You must specify a file extension for the test driver file.");
+    return false;
+  }
+  std::string driver = this->Makefile->GetCurrentBinaryDirectory();
+  driver += "/";
+  driver += *i;
+  ++i;
+
+  std::string configFile = cmSystemTools::GetCMakeRoot();
+
+  configFile += "/Templates/TestDriver.cxx.in";
+  // Create the test driver file
+
+  std::vector<std::string>::const_iterator testsBegin = i;
+  std::vector<std::string> tests_func_name;
+
+  // The rest of the arguments consist of a list of test source files.
+  // Sadly, they can be in directories. Let's find a unique function
+  // name for the corresponding test, and push it to the tests_func_name
+  // list.
+  // For the moment:
+  //   - replace spaces ' ', ':' and '/' with underscores '_'
+  std::string forwardDeclareCode;
+  for (i = testsBegin; i != tests.end(); ++i) {
+    if (*i == "EXTRA_INCLUDE") {
+      break;
+    }
+    std::string func_name;
+    if (!cmSystemTools::GetFilenamePath(*i).empty()) {
+      func_name = cmSystemTools::GetFilenamePath(*i) + "/" +
+        cmSystemTools::GetFilenameWithoutLastExtension(*i);
+    } else {
+      func_name = cmSystemTools::GetFilenameWithoutLastExtension(*i);
+    }
+    cmSystemTools::ConvertToUnixSlashes(func_name);
+    std::replace(func_name.begin(), func_name.end(), ' ', '_');
+    std::replace(func_name.begin(), func_name.end(), '/', '_');
+    std::replace(func_name.begin(), func_name.end(), ':', '_');
+    tests_func_name.push_back(func_name);
+    forwardDeclareCode += "int ";
+    forwardDeclareCode += func_name;
+    forwardDeclareCode += "(int, char*[]);\n";
+  }
+
+  std::string functionMapCode;
+  int numTests = 0;
+  std::vector<std::string>::iterator j;
+  for (i = testsBegin, j = tests_func_name.begin(); i != tests.end();
+       ++i, ++j) {
+    std::string func_name;
+    if (!cmSystemTools::GetFilenamePath(*i).empty()) {
+      func_name = cmSystemTools::GetFilenamePath(*i) + "/" +
+        cmSystemTools::GetFilenameWithoutLastExtension(*i);
+    } else {
+      func_name = cmSystemTools::GetFilenameWithoutLastExtension(*i);
+    }
+    functionMapCode += "  {\n"
+                       "    \"";
+    functionMapCode += func_name;
+    functionMapCode += "\",\n"
+                       "    ";
+    functionMapCode += *j;
+    functionMapCode += "\n"
+                       "  },\n";
+    numTests++;
+  }
+  if (!extraInclude.empty()) {
+    this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
+                                  extraInclude.c_str());
+  }
+  if (!function.empty()) {
+    this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION",
+                                  function.c_str());
+  }
+  this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
+                                forwardDeclareCode.c_str());
+  this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
+                                functionMapCode.c_str());
+  bool res = true;
+  if (!this->Makefile->ConfigureFile(configFile.c_str(), driver.c_str(), false,
+                                     true, false)) {
+    res = false;
+  }
+
+  // Construct the source list.
+  std::string sourceListValue;
+  {
+    cmSourceFile* sf = this->Makefile->GetOrCreateSource(driver);
+    sf->SetProperty("ABSTRACT", "0");
+    sourceListValue = args[1];
+  }
+  for (i = testsBegin; i != tests.end(); ++i) {
+    cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i);
+    sf->SetProperty("ABSTRACT", "0");
+    sourceListValue += ";";
+    sourceListValue += *i;
+  }
+
+  this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
+  return res;
+}
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
new file mode 100644
index 0000000..005b32c
--- /dev/null
+++ b/Source/cmCreateTestSourceList.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCreateTestSourceList_h
+#define cmCreateTestSourceList_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmCreateTestSourceList
+ * \brief Test driver generation command
+ *
+ */
+
+class cmCreateTestSourceList : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmCreateTestSourceList; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmCryptoHash.cxx b/Source/cmCryptoHash.cxx
new file mode 100644
index 0000000..d914eb1
--- /dev/null
+++ b/Source/cmCryptoHash.cxx
@@ -0,0 +1,194 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCryptoHash.h"
+
+#include "cmAlgorithms.h"
+#include "cm_kwiml.h"
+#include "cm_rhash.h"
+#include "cmsys/FStream.hxx"
+#include <string.h>
+
+#include <memory> // IWYU pragma: keep
+
+static unsigned int const cmCryptoHashAlgoToId[] = {
+  /* clang-format needs this comment to break after the opening brace */
+  RHASH_MD5,      //
+  RHASH_SHA1,     //
+  RHASH_SHA224,   //
+  RHASH_SHA256,   //
+  RHASH_SHA384,   //
+  RHASH_SHA512,   //
+  RHASH_SHA3_224, //
+  RHASH_SHA3_256, //
+  RHASH_SHA3_384, //
+  RHASH_SHA3_512
+};
+
+static int cmCryptoHash_rhash_library_initialized;
+
+static rhash cmCryptoHash_rhash_init(unsigned int id)
+{
+  if (!cmCryptoHash_rhash_library_initialized) {
+    cmCryptoHash_rhash_library_initialized = 1;
+    rhash_library_init();
+  }
+  return rhash_init(id);
+}
+
+cmCryptoHash::cmCryptoHash(Algo algo)
+  : Id(cmCryptoHashAlgoToId[algo])
+  , CTX(cmCryptoHash_rhash_init(Id))
+{
+}
+
+cmCryptoHash::~cmCryptoHash()
+{
+  rhash_free(this->CTX);
+}
+
+std::unique_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo)
+{
+  if (strcmp(algo, "MD5") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoMD5);
+  }
+  if (strcmp(algo, "SHA1") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA1);
+  }
+  if (strcmp(algo, "SHA224") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA224);
+  }
+  if (strcmp(algo, "SHA256") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA256);
+  }
+  if (strcmp(algo, "SHA384") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA384);
+  }
+  if (strcmp(algo, "SHA512") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA512);
+  }
+  if (strcmp(algo, "SHA3_224") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA3_224);
+  }
+  if (strcmp(algo, "SHA3_256") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA3_256);
+  }
+  if (strcmp(algo, "SHA3_384") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA3_384);
+  }
+  if (strcmp(algo, "SHA3_512") == 0) {
+    return cm::make_unique<cmCryptoHash>(AlgoSHA3_512);
+  }
+  return std::unique_ptr<cmCryptoHash>(nullptr);
+}
+
+bool cmCryptoHash::IntFromHexDigit(char input, char& output)
+{
+  if (input >= '0' && input <= '9') {
+    output = char(input - '0');
+    return true;
+  }
+  if (input >= 'a' && input <= 'f') {
+    output = char(input - 'a' + 0xA);
+    return true;
+  }
+  if (input >= 'A' && input <= 'F') {
+    output = char(input - 'A' + 0xA);
+    return true;
+  }
+  return false;
+}
+
+std::string cmCryptoHash::ByteHashToString(
+  const std::vector<unsigned char>& hash)
+{
+  // Map from 4-bit index to hexadecimal representation.
+  static char const hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
+                                '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+  std::string res;
+  for (unsigned char v : hash) {
+    res.push_back(hex[v >> 4]);
+    res.push_back(hex[v & 0xF]);
+  }
+  return res;
+}
+
+std::vector<unsigned char> cmCryptoHash::ByteHashString(
+  const std::string& input)
+{
+  this->Initialize();
+  this->Append(reinterpret_cast<unsigned char const*>(input.c_str()),
+               static_cast<int>(input.size()));
+  return this->Finalize();
+}
+
+std::vector<unsigned char> cmCryptoHash::ByteHashFile(const std::string& file)
+{
+  cmsys::ifstream fin(file.c_str(), std::ios::in | std::ios::binary);
+  if (fin) {
+    this->Initialize();
+    {
+      // Should be efficient enough on most system:
+      KWIML_INT_uint64_t buffer[512];
+      char* buffer_c = reinterpret_cast<char*>(buffer);
+      unsigned char const* buffer_uc =
+        reinterpret_cast<unsigned char const*>(buffer);
+      // This copy loop is very sensitive on certain platforms with
+      // slightly broken stream libraries (like HPUX).  Normally, it is
+      // incorrect to not check the error condition on the fin.read()
+      // before using the data, but the fin.gcount() will be zero if an
+      // error occurred.  Therefore, the loop should be safe everywhere.
+      while (fin) {
+        fin.read(buffer_c, sizeof(buffer));
+        if (int gcount = static_cast<int>(fin.gcount())) {
+          this->Append(buffer_uc, gcount);
+        }
+      }
+    }
+    if (fin.eof()) {
+      // Success
+      return this->Finalize();
+    }
+    // Finalize anyway
+    this->Finalize();
+  }
+  // Return without success
+  return std::vector<unsigned char>();
+}
+
+std::string cmCryptoHash::HashString(const std::string& input)
+{
+  return ByteHashToString(this->ByteHashString(input));
+}
+
+std::string cmCryptoHash::HashFile(const std::string& file)
+{
+  return ByteHashToString(this->ByteHashFile(file));
+}
+
+void cmCryptoHash::Initialize()
+{
+  rhash_reset(this->CTX);
+}
+
+void cmCryptoHash::Append(void const* buf, size_t sz)
+{
+  rhash_update(this->CTX, buf, sz);
+}
+
+void cmCryptoHash::Append(std::string const& str)
+{
+  this->Append(str.c_str(), str.size());
+}
+
+std::vector<unsigned char> cmCryptoHash::Finalize()
+{
+  std::vector<unsigned char> hash(rhash_get_digest_size(this->Id), 0);
+  rhash_final(this->CTX, &hash[0]);
+  return hash;
+}
+
+std::string cmCryptoHash::FinalizeHex()
+{
+  return cmCryptoHash::ByteHashToString(this->Finalize());
+}
diff --git a/Source/cmCryptoHash.h b/Source/cmCryptoHash.h
new file mode 100644
index 0000000..1f2a1b5
--- /dev/null
+++ b/Source/cmCryptoHash.h
@@ -0,0 +1,86 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCryptoHash_h
+#define cmCryptoHash_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <memory> // IWYU pragma: keep
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+/**
+ * @brief Abstract base class for cryptographic hash generators
+ */
+class cmCryptoHash
+{
+  CM_DISABLE_COPY(cmCryptoHash)
+
+public:
+  enum Algo
+  {
+    AlgoMD5,
+    AlgoSHA1,
+    AlgoSHA224,
+    AlgoSHA256,
+    AlgoSHA384,
+    AlgoSHA512,
+    AlgoSHA3_224,
+    AlgoSHA3_256,
+    AlgoSHA3_384,
+    AlgoSHA3_512
+  };
+
+  cmCryptoHash(Algo algo);
+  ~cmCryptoHash();
+
+  /// @brief Returns a new hash generator of the requested type
+  /// @arg algo Hash type name. Supported hash types are
+  ///      MD5, SHA1, SHA224, SHA256, SHA384, SHA512,
+  ///      SHA3_224, SHA3_256, SHA3_384, SHA3_512
+  /// @return A valid auto pointer if algo is supported or
+  ///         an invalid/NULL pointer otherwise
+  static std::unique_ptr<cmCryptoHash> New(const char* algo);
+
+  /// @brief Converts a hex character to its binary value (4 bits)
+  /// @arg input Hex character [0-9a-fA-F].
+  /// @arg output Binary value of the input character (4 bits)
+  /// @return True if input was a valid hex character
+  static bool IntFromHexDigit(char input, char& output);
+
+  /// @brief Converts a byte hash to a sequence of hex character pairs
+  static std::string ByteHashToString(const std::vector<unsigned char>& hash);
+
+  /// @brief Calculates a binary hash from string input data
+  /// @return Binary hash vector
+  std::vector<unsigned char> ByteHashString(const std::string& input);
+
+  /// @brief Calculates a binary hash from file content
+  /// @see ByteHashString()
+  /// @return Non empty binary hash vector if the file was read successfully.
+  ///         An empty vector otherwise.
+  std::vector<unsigned char> ByteHashFile(const std::string& file);
+
+  /// @brief Calculates a hash string from string input data
+  /// @return Sequence of hex characters pairs for each byte of the binary hash
+  std::string HashString(const std::string& input);
+
+  /// @brief Calculates a hash string from file content
+  /// @see HashString()
+  /// @return Non empty hash string if the file was read successfully.
+  ///         An empty string otherwise.
+  std::string HashFile(const std::string& file);
+
+  void Initialize();
+  void Append(void const*, size_t);
+  void Append(std::string const& str);
+  std::vector<unsigned char> Finalize();
+  std::string FinalizeHex();
+
+private:
+  unsigned int Id;
+  struct rhash_context* CTX;
+};
+
+#endif
diff --git a/Source/cmCurl.cxx b/Source/cmCurl.cxx
new file mode 100644
index 0000000..8ef8bff
--- /dev/null
+++ b/Source/cmCurl.cxx
@@ -0,0 +1,96 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCurl.h"
+
+#include "cmThirdParty.h"
+
+#if !defined(CMAKE_USE_SYSTEM_CURL) && !defined(_WIN32) &&                    \
+  !defined(__APPLE__) && !defined(CURL_CA_BUNDLE) && !defined(CURL_CA_PATH)
+#define CMAKE_FIND_CAFILE
+#include "cmSystemTools.h"
+#endif
+
+// curl versions before 7.21.5 did not provide this error code
+#if defined(LIBCURL_VERSION_NUM) && LIBCURL_VERSION_NUM < 0x071505
+#define CURLE_NOT_BUILT_IN 4
+#endif
+
+#define check_curl_result(result, errstr)                                     \
+  if ((result) != CURLE_OK && (result) != CURLE_NOT_BUILT_IN) {               \
+    e += e.empty() ? "" : "\n";                                               \
+    e += (errstr);                                                            \
+    e += ::curl_easy_strerror(result);                                        \
+  }
+
+std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile)
+{
+  std::string e;
+  if (cafile && *cafile) {
+    ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_CAINFO, cafile);
+    check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
+  }
+#ifdef CMAKE_FIND_CAFILE
+#define CMAKE_CAFILE_FEDORA "/etc/pki/tls/certs/ca-bundle.crt"
+  else if (cmSystemTools::FileExists(CMAKE_CAFILE_FEDORA, true)) {
+    ::CURLcode res =
+      ::curl_easy_setopt(curl, CURLOPT_CAINFO, CMAKE_CAFILE_FEDORA);
+    check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
+  }
+#undef CMAKE_CAFILE_FEDORA
+  else {
+#define CMAKE_CAFILE_COMMON "/etc/ssl/certs/ca-certificates.crt"
+    if (cmSystemTools::FileExists(CMAKE_CAFILE_COMMON, true)) {
+      ::CURLcode res =
+        ::curl_easy_setopt(curl, CURLOPT_CAINFO, CMAKE_CAFILE_COMMON);
+      check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
+    }
+#undef CMAKE_CAFILE_COMMON
+#define CMAKE_CAPATH_COMMON "/etc/ssl/certs"
+    if (cmSystemTools::FileIsDirectory(CMAKE_CAPATH_COMMON)) {
+      ::CURLcode res =
+        ::curl_easy_setopt(curl, CURLOPT_CAPATH, CMAKE_CAPATH_COMMON);
+      check_curl_result(res, "Unable to set TLS/SSL Verify CAPATH: ");
+    }
+#undef CMAKE_CAPATH_COMMON
+  }
+#endif
+  return e;
+}
+
+std::string cmCurlSetNETRCOption(::CURL* curl, const std::string& netrc_level,
+                                 const std::string& netrc_file)
+{
+  std::string e;
+  CURL_NETRC_OPTION curl_netrc_level = CURL_NETRC_LAST;
+  ::CURLcode res;
+
+  if (!netrc_level.empty()) {
+    if (netrc_level == "OPTIONAL") {
+      curl_netrc_level = CURL_NETRC_OPTIONAL;
+    } else if (netrc_level == "REQUIRED") {
+      curl_netrc_level = CURL_NETRC_REQUIRED;
+    } else if (netrc_level == "IGNORED") {
+      curl_netrc_level = CURL_NETRC_IGNORED;
+    } else {
+      e = "NETRC accepts OPTIONAL, IGNORED or REQUIRED but got: ";
+      e += netrc_level;
+      return e;
+    }
+  }
+
+  if (curl_netrc_level != CURL_NETRC_LAST &&
+      curl_netrc_level != CURL_NETRC_IGNORED) {
+    res = ::curl_easy_setopt(curl, CURLOPT_NETRC, curl_netrc_level);
+    check_curl_result(res, "Unable to set netrc level: ");
+    if (!e.empty()) {
+      return e;
+    }
+
+    // check to see if a .netrc file has been specified
+    if (!netrc_file.empty()) {
+      res = ::curl_easy_setopt(curl, CURLOPT_NETRC_FILE, netrc_file.c_str());
+      check_curl_result(res, "Unable to set .netrc file path : ");
+    }
+  }
+  return e;
+}
diff --git a/Source/cmCurl.h b/Source/cmCurl.h
new file mode 100644
index 0000000..fe7eb80
--- /dev/null
+++ b/Source/cmCurl.h
@@ -0,0 +1,15 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCurl_h
+#define cmCurl_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cm_curl.h"
+#include <string>
+
+std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile = nullptr);
+std::string cmCurlSetNETRCOption(::CURL* curl, const std::string& netrc_level,
+                                 const std::string& netrc_file);
+
+#endif
diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx
new file mode 100644
index 0000000..cfd260c
--- /dev/null
+++ b/Source/cmCustomCommand.cxx
@@ -0,0 +1,148 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCustomCommand.h"
+
+#include "cmMakefile.h"
+
+cmCustomCommand::cmCustomCommand()
+  : Backtrace()
+{
+  this->HaveComment = false;
+  this->EscapeOldStyle = true;
+  this->EscapeAllowMakeVars = false;
+  this->UsesTerminal = false;
+  this->CommandExpandLists = false;
+}
+
+cmCustomCommand::cmCustomCommand(cmMakefile const* mf,
+                                 const std::vector<std::string>& outputs,
+                                 const std::vector<std::string>& byproducts,
+                                 const std::vector<std::string>& depends,
+                                 const cmCustomCommandLines& commandLines,
+                                 const char* comment,
+                                 const char* workingDirectory)
+  : Outputs(outputs)
+  , Byproducts(byproducts)
+  , Depends(depends)
+  , CommandLines(commandLines)
+  , Backtrace()
+  , Comment(comment ? comment : "")
+  , WorkingDirectory(workingDirectory ? workingDirectory : "")
+  , HaveComment(comment != nullptr)
+  , EscapeAllowMakeVars(false)
+  , EscapeOldStyle(true)
+  , CommandExpandLists(false)
+{
+  if (mf) {
+    this->Backtrace = mf->GetBacktrace();
+  }
+}
+
+const std::vector<std::string>& cmCustomCommand::GetOutputs() const
+{
+  return this->Outputs;
+}
+
+const std::vector<std::string>& cmCustomCommand::GetByproducts() const
+{
+  return this->Byproducts;
+}
+
+const std::vector<std::string>& cmCustomCommand::GetDepends() const
+{
+  return this->Depends;
+}
+
+const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const
+{
+  return this->CommandLines;
+}
+
+const char* cmCustomCommand::GetComment() const
+{
+  const char* no_comment = nullptr;
+  return this->HaveComment ? this->Comment.c_str() : no_comment;
+}
+
+void cmCustomCommand::AppendCommands(const cmCustomCommandLines& commandLines)
+{
+  this->CommandLines.insert(this->CommandLines.end(), commandLines.begin(),
+                            commandLines.end());
+}
+
+void cmCustomCommand::AppendDepends(const std::vector<std::string>& depends)
+{
+  this->Depends.insert(this->Depends.end(), depends.begin(), depends.end());
+}
+
+bool cmCustomCommand::GetEscapeOldStyle() const
+{
+  return this->EscapeOldStyle;
+}
+
+void cmCustomCommand::SetEscapeOldStyle(bool b)
+{
+  this->EscapeOldStyle = b;
+}
+
+bool cmCustomCommand::GetEscapeAllowMakeVars() const
+{
+  return this->EscapeAllowMakeVars;
+}
+
+void cmCustomCommand::SetEscapeAllowMakeVars(bool b)
+{
+  this->EscapeAllowMakeVars = b;
+}
+
+cmListFileBacktrace const& cmCustomCommand::GetBacktrace() const
+{
+  return this->Backtrace;
+}
+
+cmCustomCommand::ImplicitDependsList const&
+cmCustomCommand::GetImplicitDepends() const
+{
+  return this->ImplicitDepends;
+}
+
+void cmCustomCommand::SetImplicitDepends(ImplicitDependsList const& l)
+{
+  this->ImplicitDepends = l;
+}
+
+void cmCustomCommand::AppendImplicitDepends(ImplicitDependsList const& l)
+{
+  this->ImplicitDepends.insert(this->ImplicitDepends.end(), l.begin(),
+                               l.end());
+}
+
+bool cmCustomCommand::GetUsesTerminal() const
+{
+  return this->UsesTerminal;
+}
+
+void cmCustomCommand::SetUsesTerminal(bool b)
+{
+  this->UsesTerminal = b;
+}
+
+bool cmCustomCommand::GetCommandExpandLists() const
+{
+  return this->CommandExpandLists;
+}
+
+void cmCustomCommand::SetCommandExpandLists(bool b)
+{
+  this->CommandExpandLists = b;
+}
+
+const std::string& cmCustomCommand::GetDepfile() const
+{
+  return this->Depfile;
+}
+
+void cmCustomCommand::SetDepfile(const std::string& depfile)
+{
+  this->Depfile = depfile;
+}
diff --git a/Source/cmCustomCommand.h b/Source/cmCustomCommand.h
new file mode 100644
index 0000000..9e82f25
--- /dev/null
+++ b/Source/cmCustomCommand.h
@@ -0,0 +1,113 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCustomCommand_h
+#define cmCustomCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmCustomCommandLines.h"
+#include "cmListFileCache.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+class cmMakefile;
+
+/** \class cmCustomCommand
+ * \brief A class to encapsulate a custom command
+ *
+ * cmCustomCommand encapsulates the properties of a custom command
+ */
+class cmCustomCommand
+{
+public:
+  /** Default and copy constructors for STL containers.  */
+  cmCustomCommand();
+
+  /** Main constructor specifies all information for the command.  */
+  cmCustomCommand(cmMakefile const* mf,
+                  const std::vector<std::string>& outputs,
+                  const std::vector<std::string>& byproducts,
+                  const std::vector<std::string>& depends,
+                  const cmCustomCommandLines& commandLines,
+                  const char* comment, const char* workingDirectory);
+
+  /** Get the output file produced by the command.  */
+  const std::vector<std::string>& GetOutputs() const;
+
+  /** Get the extra files produced by the command.  */
+  const std::vector<std::string>& GetByproducts() const;
+
+  /** Get the vector that holds the list of dependencies.  */
+  const std::vector<std::string>& GetDepends() const;
+
+  /** Get the working directory.  */
+  std::string const& GetWorkingDirectory() const
+  {
+    return this->WorkingDirectory;
+  }
+
+  /** Get the list of command lines.  */
+  const cmCustomCommandLines& GetCommandLines() const;
+
+  /** Get the comment string for the command.  */
+  const char* GetComment() const;
+
+  /** Append to the list of command lines.  */
+  void AppendCommands(const cmCustomCommandLines& commandLines);
+
+  /** Append to the list of dependencies.  */
+  void AppendDepends(const std::vector<std::string>& depends);
+
+  /** Set/Get whether old-style escaping should be used.  */
+  bool GetEscapeOldStyle() const;
+  void SetEscapeOldStyle(bool b);
+
+  /** Set/Get whether the build tool can replace variables in
+      arguments to the command.  */
+  bool GetEscapeAllowMakeVars() const;
+  void SetEscapeAllowMakeVars(bool b);
+
+  /** Backtrace of the command that created this custom command.  */
+  cmListFileBacktrace const& GetBacktrace() const;
+
+  typedef std::pair<std::string, std::string> ImplicitDependsPair;
+  class ImplicitDependsList : public std::vector<ImplicitDependsPair>
+  {
+  };
+  void SetImplicitDepends(ImplicitDependsList const&);
+  void AppendImplicitDepends(ImplicitDependsList const&);
+  ImplicitDependsList const& GetImplicitDepends() const;
+
+  /** Set/Get whether this custom command should be given access to the
+      real console (if possible).  */
+  bool GetUsesTerminal() const;
+  void SetUsesTerminal(bool b);
+
+  /** Set/Get whether lists in command lines should be expanded. */
+  bool GetCommandExpandLists() const;
+  void SetCommandExpandLists(bool b);
+
+  /** Set/Get the depfile (used by the Ninja generator) */
+  const std::string& GetDepfile() const;
+  void SetDepfile(const std::string& depfile);
+
+private:
+  std::vector<std::string> Outputs;
+  std::vector<std::string> Byproducts;
+  std::vector<std::string> Depends;
+  cmCustomCommandLines CommandLines;
+  cmListFileBacktrace Backtrace;
+  ImplicitDependsList ImplicitDepends;
+  std::string Comment;
+  std::string WorkingDirectory;
+  std::string Depfile;
+  bool HaveComment;
+  bool EscapeAllowMakeVars;
+  bool EscapeOldStyle;
+  bool UsesTerminal;
+  bool CommandExpandLists;
+};
+
+#endif
diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx
new file mode 100644
index 0000000..3d816d5
--- /dev/null
+++ b/Source/cmCustomCommandGenerator.cxx
@@ -0,0 +1,198 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmCustomCommandGenerator.h"
+
+#include "cmCustomCommand.h"
+#include "cmCustomCommandLines.h"
+#include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+
+#include <memory> // IWYU pragma: keep
+#include <stddef.h>
+
+cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
+                                                   const std::string& config,
+                                                   cmLocalGenerator* lg)
+  : CC(cc)
+  , Config(config)
+  , LG(lg)
+  , OldStyle(cc.GetEscapeOldStyle())
+  , MakeVars(cc.GetEscapeAllowMakeVars())
+  , GE(new cmGeneratorExpression(cc.GetBacktrace()))
+{
+  const cmCustomCommandLines& cmdlines = this->CC.GetCommandLines();
+  for (cmCustomCommandLine const& cmdline : cmdlines) {
+    cmCustomCommandLine argv;
+    for (std::string const& clarg : cmdline) {
+      std::unique_ptr<cmCompiledGeneratorExpression> cge =
+        this->GE->Parse(clarg);
+      std::string parsed_arg = cge->Evaluate(this->LG, this->Config);
+      if (this->CC.GetCommandExpandLists()) {
+        std::vector<std::string> ExpandedArg;
+        cmSystemTools::ExpandListArgument(parsed_arg, ExpandedArg);
+        argv.insert(argv.end(), ExpandedArg.begin(), ExpandedArg.end());
+      } else {
+        argv.push_back(parsed_arg);
+      }
+    }
+    this->CommandLines.push_back(argv);
+  }
+
+  std::vector<std::string> depends = this->CC.GetDepends();
+  for (std::string const& d : depends) {
+    std::unique_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(d);
+    std::vector<std::string> result;
+    cmSystemTools::ExpandListArgument(cge->Evaluate(this->LG, this->Config),
+                                      result);
+    for (std::string& it : result) {
+      if (cmSystemTools::FileIsFullPath(it.c_str())) {
+        it = cmSystemTools::CollapseFullPath(it);
+      }
+    }
+    this->Depends.insert(this->Depends.end(), result.begin(), result.end());
+  }
+}
+
+cmCustomCommandGenerator::~cmCustomCommandGenerator()
+{
+  delete this->GE;
+}
+
+unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
+{
+  return static_cast<unsigned int>(this->CC.GetCommandLines().size());
+}
+
+const char* cmCustomCommandGenerator::GetCrossCompilingEmulator(
+  unsigned int c) const
+{
+  if (!this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")) {
+    return nullptr;
+  }
+  std::string const& argv0 = this->CommandLines[c][0];
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(argv0);
+  if (target && target->GetType() == cmStateEnums::EXECUTABLE &&
+      !target->IsImported()) {
+    return target->GetProperty("CROSSCOMPILING_EMULATOR");
+  }
+  return nullptr;
+}
+
+const char* cmCustomCommandGenerator::GetArgv0Location(unsigned int c) const
+{
+  std::string const& argv0 = this->CommandLines[c][0];
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(argv0);
+  if (target && target->GetType() == cmStateEnums::EXECUTABLE &&
+      (target->IsImported() ||
+       target->GetProperty("CROSSCOMPILING_EMULATOR") ||
+       !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING"))) {
+    return target->GetLocation(this->Config);
+  }
+  return nullptr;
+}
+
+bool cmCustomCommandGenerator::HasOnlyEmptyCommandLines() const
+{
+  for (size_t i = 0; i < this->CommandLines.size(); ++i) {
+    for (size_t j = 0; j < this->CommandLines[i].size(); ++j) {
+      if (!this->CommandLines[i][j].empty()) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
+{
+  if (const char* emulator = this->GetCrossCompilingEmulator(c)) {
+    return std::string(emulator);
+  }
+  if (const char* location = this->GetArgv0Location(c)) {
+    return std::string(location);
+  }
+
+  return this->CommandLines[c][0];
+}
+
+std::string escapeForShellOldStyle(const std::string& str)
+{
+  std::string result;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  // if there are spaces
+  std::string temp = str;
+  if (temp.find(" ") != std::string::npos &&
+      temp.find("\"") == std::string::npos) {
+    result = "\"";
+    result += str;
+    result += "\"";
+    return result;
+  }
+  return str;
+#else
+  for (const char* ch = str.c_str(); *ch != '\0'; ++ch) {
+    if (*ch == ' ') {
+      result += '\\';
+    }
+    result += *ch;
+  }
+  return result;
+#endif
+}
+
+void cmCustomCommandGenerator::AppendArguments(unsigned int c,
+                                               std::string& cmd) const
+{
+  unsigned int offset = 1;
+  if (this->GetCrossCompilingEmulator(c) != nullptr) {
+    offset = 0;
+  }
+  cmCustomCommandLine const& commandLine = this->CommandLines[c];
+  for (unsigned int j = offset; j < commandLine.size(); ++j) {
+    std::string arg;
+    if (const char* location = j == 0 ? this->GetArgv0Location(c) : nullptr) {
+      // GetCommand returned the emulator instead of the argv0 location,
+      // so transform the latter now.
+      arg = location;
+    } else {
+      arg = commandLine[j];
+    }
+    cmd += " ";
+    if (this->OldStyle) {
+      cmd += escapeForShellOldStyle(arg);
+    } else {
+      cmOutputConverter converter(this->LG->GetStateSnapshot());
+      cmd += converter.EscapeForShell(arg, this->MakeVars);
+    }
+  }
+}
+
+const char* cmCustomCommandGenerator::GetComment() const
+{
+  return this->CC.GetComment();
+}
+
+std::string cmCustomCommandGenerator::GetWorkingDirectory() const
+{
+  return this->CC.GetWorkingDirectory();
+}
+
+std::vector<std::string> const& cmCustomCommandGenerator::GetOutputs() const
+{
+  return this->CC.GetOutputs();
+}
+
+std::vector<std::string> const& cmCustomCommandGenerator::GetByproducts() const
+{
+  return this->CC.GetByproducts();
+}
+
+std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
+{
+  return this->Depends;
+}
diff --git a/Source/cmCustomCommandGenerator.h b/Source/cmCustomCommandGenerator.h
new file mode 100644
index 0000000..34fd653
--- /dev/null
+++ b/Source/cmCustomCommandGenerator.h
@@ -0,0 +1,46 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCustomCommandGenerator_h
+#define cmCustomCommandGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+#include "cmCustomCommandLines.h"
+
+#include <string>
+#include <vector>
+
+class cmCustomCommand;
+class cmGeneratorExpression;
+class cmLocalGenerator;
+
+class cmCustomCommandGenerator
+{
+  cmCustomCommand const& CC;
+  std::string Config;
+  cmLocalGenerator* LG;
+  bool OldStyle;
+  bool MakeVars;
+  cmGeneratorExpression* GE;
+  cmCustomCommandLines CommandLines;
+  std::vector<std::string> Depends;
+
+  const char* GetCrossCompilingEmulator(unsigned int c) const;
+  const char* GetArgv0Location(unsigned int c) const;
+
+public:
+  cmCustomCommandGenerator(cmCustomCommand const& cc,
+                           const std::string& config, cmLocalGenerator* lg);
+  ~cmCustomCommandGenerator();
+  cmCustomCommand const& GetCC() const { return this->CC; }
+  unsigned int GetNumberOfCommands() const;
+  std::string GetCommand(unsigned int c) const;
+  void AppendArguments(unsigned int c, std::string& cmd) const;
+  const char* GetComment() const;
+  std::string GetWorkingDirectory() const;
+  std::vector<std::string> const& GetOutputs() const;
+  std::vector<std::string> const& GetByproducts() const;
+  std::vector<std::string> const& GetDepends() const;
+  bool HasOnlyEmptyCommandLines() const;
+};
+
+#endif
diff --git a/Source/cmCustomCommandLines.h b/Source/cmCustomCommandLines.h
new file mode 100644
index 0000000..36838f2
--- /dev/null
+++ b/Source/cmCustomCommandLines.h
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmCustomCommandLines_h
+#define cmCustomCommandLines_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+/** Data structure to represent a single command line.  */
+class cmCustomCommandLine : public std::vector<std::string>
+{
+public:
+  typedef std::vector<std::string> Superclass;
+  typedef Superclass::iterator iterator;
+  typedef Superclass::const_iterator const_iterator;
+};
+
+/** Data structure to represent a list of command lines.  */
+class cmCustomCommandLines : public std::vector<cmCustomCommandLine>
+{
+public:
+  typedef std::vector<cmCustomCommandLine> Superclass;
+  typedef Superclass::iterator iterator;
+  typedef Superclass::const_iterator const_iterator;
+};
+
+#endif
diff --git a/Source/cmDefinePropertyCommand.cxx b/Source/cmDefinePropertyCommand.cxx
new file mode 100644
index 0000000..86a83da
--- /dev/null
+++ b/Source/cmDefinePropertyCommand.cxx
@@ -0,0 +1,106 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDefinePropertyCommand.h"
+
+#include <sstream>
+
+#include "cmMakefile.h"
+#include "cmProperty.h"
+#include "cmState.h"
+
+class cmExecutionStatus;
+
+bool cmDefinePropertyCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // Get the scope in which to define the property.
+  cmProperty::ScopeType scope;
+  std::string const& scope_arg = args[0];
+
+  if (scope_arg == "GLOBAL") {
+    scope = cmProperty::GLOBAL;
+  } else if (scope_arg == "DIRECTORY") {
+    scope = cmProperty::DIRECTORY;
+  } else if (scope_arg == "TARGET") {
+    scope = cmProperty::TARGET;
+  } else if (scope_arg == "SOURCE") {
+    scope = cmProperty::SOURCE_FILE;
+  } else if (scope_arg == "TEST") {
+    scope = cmProperty::TEST;
+  } else if (scope_arg == "VARIABLE") {
+    scope = cmProperty::VARIABLE;
+  } else if (scope_arg == "CACHED_VARIABLE") {
+    scope = cmProperty::CACHED_VARIABLE;
+  } else {
+    std::ostringstream e;
+    e << "given invalid scope " << scope_arg << ".  "
+      << "Valid scopes are "
+      << "GLOBAL, DIRECTORY, TARGET, SOURCE, "
+      << "TEST, VARIABLE, CACHED_VARIABLE.";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // Parse remaining arguments.
+  bool inherited = false;
+  enum Doing
+  {
+    DoingNone,
+    DoingProperty,
+    DoingBrief,
+    DoingFull
+  };
+  Doing doing = DoingNone;
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "PROPERTY") {
+      doing = DoingProperty;
+    } else if (args[i] == "BRIEF_DOCS") {
+      doing = DoingBrief;
+    } else if (args[i] == "FULL_DOCS") {
+      doing = DoingFull;
+    } else if (args[i] == "INHERITED") {
+      doing = DoingNone;
+      inherited = true;
+    } else if (doing == DoingProperty) {
+      doing = DoingNone;
+      this->PropertyName = args[i];
+    } else if (doing == DoingBrief) {
+      this->BriefDocs += args[i];
+    } else if (doing == DoingFull) {
+      this->FullDocs += args[i];
+    } else {
+      std::ostringstream e;
+      e << "given invalid argument \"" << args[i] << "\".";
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  // Make sure a property name was found.
+  if (this->PropertyName.empty()) {
+    this->SetError("not given a PROPERTY <name> argument.");
+    return false;
+  }
+
+  // Make sure documentation was given.
+  if (this->BriefDocs.empty()) {
+    this->SetError("not given a BRIEF_DOCS <brief-doc> argument.");
+    return false;
+  }
+  if (this->FullDocs.empty()) {
+    this->SetError("not given a FULL_DOCS <full-doc> argument.");
+    return false;
+  }
+
+  // Actually define the property.
+  this->Makefile->GetState()->DefineProperty(
+    this->PropertyName, scope, this->BriefDocs.c_str(), this->FullDocs.c_str(),
+    inherited);
+
+  return true;
+}
diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h
new file mode 100644
index 0000000..a9c1856
--- /dev/null
+++ b/Source/cmDefinePropertyCommand.h
@@ -0,0 +1,33 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDefinesPropertyCommand_h
+#define cmDefinesPropertyCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+class cmDefinePropertyCommand : public cmCommand
+{
+public:
+  cmCommand* Clone() override { return new cmDefinePropertyCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the input file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  std::string PropertyName;
+  std::string BriefDocs;
+  std::string FullDocs;
+};
+
+#endif
diff --git a/Source/cmDefinitions.cxx b/Source/cmDefinitions.cxx
new file mode 100644
index 0000000..e766854
--- /dev/null
+++ b/Source/cmDefinitions.cxx
@@ -0,0 +1,115 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDefinitions.h"
+
+#include <assert.h>
+#include <set>
+#include <utility>
+
+cmDefinitions::Def cmDefinitions::NoDef;
+
+cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key,
+                                                     StackIter begin,
+                                                     StackIter end, bool raise)
+{
+  assert(begin != end);
+  MapType::iterator i = begin->Map.find(key);
+  if (i != begin->Map.end()) {
+    i->second.Used = true;
+    return i->second;
+  }
+  StackIter it = begin;
+  ++it;
+  if (it == end) {
+    return cmDefinitions::NoDef;
+  }
+  Def const& def = cmDefinitions::GetInternal(key, it, end, raise);
+  if (!raise) {
+    return def;
+  }
+  return begin->Map.insert(MapType::value_type(key, def)).first->second;
+}
+
+const char* cmDefinitions::Get(const std::string& key, StackIter begin,
+                               StackIter end)
+{
+  Def const& def = cmDefinitions::GetInternal(key, begin, end, false);
+  return def.Exists ? def.c_str() : nullptr;
+}
+
+void cmDefinitions::Raise(const std::string& key, StackIter begin,
+                          StackIter end)
+{
+  cmDefinitions::GetInternal(key, begin, end, true);
+}
+
+bool cmDefinitions::HasKey(const std::string& key, StackIter begin,
+                           StackIter end)
+{
+  for (StackIter it = begin; it != end; ++it) {
+    MapType::const_iterator i = it->Map.find(key);
+    if (i != it->Map.end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void cmDefinitions::Set(const std::string& key, const char* value)
+{
+  Def def(value);
+  this->Map[key] = def;
+}
+
+std::vector<std::string> cmDefinitions::UnusedKeys() const
+{
+  std::vector<std::string> keys;
+  keys.reserve(this->Map.size());
+  // Consider local definitions.
+  for (auto const& mi : this->Map) {
+    if (!mi.second.Used) {
+      keys.push_back(mi.first);
+    }
+  }
+  return keys;
+}
+
+cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end)
+{
+  cmDefinitions closure;
+  std::set<std::string> undefined;
+  for (StackIter it = begin; it != end; ++it) {
+    // Consider local definitions.
+    for (auto const& mi : it->Map) {
+      // Use this key if it is not already set or unset.
+      if (closure.Map.find(mi.first) == closure.Map.end() &&
+          undefined.find(mi.first) == undefined.end()) {
+        if (mi.second.Exists) {
+          closure.Map.insert(mi);
+        } else {
+          undefined.insert(mi.first);
+        }
+      }
+    }
+  }
+  return closure;
+}
+
+std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin,
+                                                    StackIter end)
+{
+  std::set<std::string> bound;
+  std::vector<std::string> defined;
+
+  for (StackIter it = begin; it != end; ++it) {
+    defined.reserve(defined.size() + it->Map.size());
+    for (auto const& mi : it->Map) {
+      // Use this key if it is not already set or unset.
+      if (bound.insert(mi.first).second && mi.second.Exists) {
+        defined.push_back(mi.first);
+      }
+    }
+  }
+
+  return defined;
+}
diff --git a/Source/cmDefinitions.h b/Source/cmDefinitions.h
new file mode 100644
index 0000000..528b157
--- /dev/null
+++ b/Source/cmDefinitions.h
@@ -0,0 +1,80 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDefinitions_h
+#define cmDefinitions_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "cmLinkedTree.h"
+
+/** \class cmDefinitions
+ * \brief Store a scope of variable definitions for CMake language.
+ *
+ * This stores the state of variable definitions (set or unset) for
+ * one scope.  Sets are always local.  Gets search parent scopes
+ * transitively and save results locally.
+ */
+class cmDefinitions
+{
+  typedef cmLinkedTree<cmDefinitions>::iterator StackIter;
+
+public:
+  static const char* Get(const std::string& key, StackIter begin,
+                         StackIter end);
+
+  static void Raise(const std::string& key, StackIter begin, StackIter end);
+
+  static bool HasKey(const std::string& key, StackIter begin, StackIter end);
+
+  /** Set (or unset if null) a value associated with a key.  */
+  void Set(const std::string& key, const char* value);
+
+  std::vector<std::string> UnusedKeys() const;
+
+  static std::vector<std::string> ClosureKeys(StackIter begin, StackIter end);
+
+  static cmDefinitions MakeClosure(StackIter begin, StackIter end);
+
+private:
+  // String with existence boolean.
+  struct Def : public std::string
+  {
+  private:
+    typedef std::string std_string;
+
+  public:
+    Def()
+      : std_string()
+      , Exists(false)
+      , Used(false)
+    {
+    }
+    Def(const char* v)
+      : std_string(v ? v : "")
+      , Exists(v ? true : false)
+      , Used(false)
+    {
+    }
+    Def(const std_string& v)
+      : std_string(v)
+      , Exists(true)
+      , Used(false)
+    {
+    }
+    bool Exists;
+    bool Used;
+  };
+  static Def NoDef;
+
+  typedef std::unordered_map<std::string, Def> MapType;
+  MapType Map;
+
+  static Def const& GetInternal(const std::string& key, StackIter begin,
+                                StackIter end, bool raise);
+};
+
+#endif
diff --git a/Source/cmDepends.cxx b/Source/cmDepends.cxx
new file mode 100644
index 0000000..cdab671
--- /dev/null
+++ b/Source/cmDepends.cxx
@@ -0,0 +1,265 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDepends.h"
+
+#include "cmFileTimeComparison.h"
+#include "cmGeneratedFileStream.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+#include "cmWorkingDirectory.h"
+
+#include "cmsys/FStream.hxx"
+#include <sstream>
+#include <string.h>
+#include <utility>
+
+cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir)
+  : CompileDirectory()
+  , LocalGenerator(lg)
+  , Verbose(false)
+  , FileComparison(nullptr)
+  , TargetDirectory(targetDir)
+  , MaxPath(16384)
+  , Dependee(new char[MaxPath])
+  , Depender(new char[MaxPath])
+{
+}
+
+cmDepends::~cmDepends()
+{
+  delete[] this->Dependee;
+  delete[] this->Depender;
+}
+
+bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
+{
+  // Lookup the set of sources to scan.
+  std::string srcLang = "CMAKE_DEPENDS_CHECK_";
+  srcLang += this->Language;
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  const char* srcStr = mf->GetSafeDefinition(srcLang);
+  std::vector<std::string> pairs;
+  cmSystemTools::ExpandListArgument(srcStr, pairs);
+
+  std::map<std::string, std::set<std::string>> dependencies;
+  for (std::vector<std::string>::iterator si = pairs.begin();
+       si != pairs.end();) {
+    // Get the source and object file.
+    std::string const& src = *si++;
+    if (si == pairs.end()) {
+      break;
+    }
+    std::string const& obj = *si++;
+    dependencies[obj].insert(src);
+  }
+  for (auto const& d : dependencies) {
+
+    // Write the dependencies for this pair.
+    if (!this->WriteDependencies(d.second, d.first, makeDepends,
+                                 internalDepends)) {
+      return false;
+    }
+  }
+
+  return this->Finalize(makeDepends, internalDepends);
+}
+
+bool cmDepends::Finalize(std::ostream& /*unused*/, std::ostream& /*unused*/)
+{
+  return true;
+}
+
+bool cmDepends::Check(const char* makeFile, const char* internalFile,
+                      std::map<std::string, DependencyVector>& validDeps)
+{
+  // Dependency checks must be done in proper working directory.
+  cmWorkingDirectory workdir(this->CompileDirectory);
+
+  // Check whether dependencies must be regenerated.
+  bool okay = true;
+  cmsys::ifstream fin(internalFile);
+  if (!(fin && this->CheckDependencies(fin, internalFile, validDeps))) {
+    // Clear all dependencies so they will be regenerated.
+    this->Clear(makeFile);
+    cmSystemTools::RemoveFile(internalFile);
+    okay = false;
+  }
+
+  return okay;
+}
+
+void cmDepends::Clear(const char* file)
+{
+  // Print verbose output.
+  if (this->Verbose) {
+    std::ostringstream msg;
+    msg << "Clearing dependencies in \"" << file << "\"." << std::endl;
+    cmSystemTools::Stdout(msg.str().c_str());
+  }
+
+  // Write an empty dependency file.
+  cmGeneratedFileStream depFileStream(file);
+  depFileStream << "# Empty dependencies file\n"
+                << "# This may be replaced when dependencies are built."
+                << std::endl;
+}
+
+bool cmDepends::WriteDependencies(const std::set<std::string>& /*unused*/,
+                                  const std::string& /*unused*/,
+                                  std::ostream& /*unused*/,
+                                  std::ostream& /*unused*/)
+{
+  // This should be implemented by the subclass.
+  return false;
+}
+
+bool cmDepends::CheckDependencies(
+  std::istream& internalDepends, const char* internalDependsFileName,
+  std::map<std::string, DependencyVector>& validDeps)
+{
+  // Parse dependencies from the stream.  If any dependee is missing
+  // or newer than the depender then dependencies should be
+  // regenerated.
+  bool okay = true;
+  bool dependerExists = false;
+  DependencyVector* currentDependencies = nullptr;
+
+  while (internalDepends.getline(this->Dependee, this->MaxPath)) {
+    if (this->Dependee[0] == 0 || this->Dependee[0] == '#' ||
+        this->Dependee[0] == '\r') {
+      continue;
+    }
+    size_t len = internalDepends.gcount() - 1;
+    if (this->Dependee[len - 1] == '\r') {
+      len--;
+      this->Dependee[len] = 0;
+    }
+    if (this->Dependee[0] != ' ') {
+      memcpy(this->Depender, this->Dependee, len + 1);
+      // Calling FileExists() for the depender here saves in many cases 50%
+      // of the calls to FileExists() further down in the loop. E.g. for
+      // kdelibs/khtml this reduces the number of calls from 184k down to 92k,
+      // or the time for cmake -E cmake_depends from 0.3 s down to 0.21 s.
+      dependerExists = cmSystemTools::FileExists(this->Depender);
+      // If we erase validDeps[this->Depender] by overwriting it with an empty
+      // vector, we lose dependencies for dependers that have multiple
+      // entries. No need to initialize the entry, std::map will do so on first
+      // access.
+      currentDependencies = &validDeps[this->Depender];
+      continue;
+    }
+    /*
+    // Parse the dependency line.
+    if(!this->ParseDependency(line.c_str()))
+      {
+      continue;
+      }
+      */
+
+    // Dependencies must be regenerated
+    // * if the dependee does not exist
+    // * if the depender exists and is older than the dependee.
+    // * if the depender does not exist, but the dependee is newer than the
+    //   depends file
+    bool regenerate = false;
+    const char* dependee = this->Dependee + 1;
+    const char* depender = this->Depender;
+    if (currentDependencies != nullptr) {
+      currentDependencies->push_back(dependee);
+    }
+
+    if (!cmSystemTools::FileExists(dependee)) {
+      // The dependee does not exist.
+      regenerate = true;
+
+      // Print verbose output.
+      if (this->Verbose) {
+        std::ostringstream msg;
+        msg << "Dependee \"" << dependee << "\" does not exist for depender \""
+            << depender << "\"." << std::endl;
+        cmSystemTools::Stdout(msg.str().c_str());
+      }
+    } else {
+      if (dependerExists) {
+        // The dependee and depender both exist.  Compare file times.
+        int result = 0;
+        if ((!this->FileComparison->FileTimeCompare(depender, dependee,
+                                                    &result) ||
+             result < 0)) {
+          // The depender is older than the dependee.
+          regenerate = true;
+
+          // Print verbose output.
+          if (this->Verbose) {
+            std::ostringstream msg;
+            msg << "Dependee \"" << dependee << "\" is newer than depender \""
+                << depender << "\"." << std::endl;
+            cmSystemTools::Stdout(msg.str().c_str());
+          }
+        }
+      } else {
+        // The dependee exists, but the depender doesn't. Regenerate if the
+        // internalDepends file is older than the dependee.
+        int result = 0;
+        if ((!this->FileComparison->FileTimeCompare(internalDependsFileName,
+                                                    dependee, &result) ||
+             result < 0)) {
+          // The depends-file is older than the dependee.
+          regenerate = true;
+
+          // Print verbose output.
+          if (this->Verbose) {
+            std::ostringstream msg;
+            msg << "Dependee \"" << dependee
+                << "\" is newer than depends file \""
+                << internalDependsFileName << "\"." << std::endl;
+            cmSystemTools::Stdout(msg.str().c_str());
+          }
+        }
+      }
+    }
+    if (regenerate) {
+      // Dependencies must be regenerated.
+      okay = false;
+
+      // Remove the information of this depender from the map, it needs
+      // to be rescanned
+      if (currentDependencies != nullptr) {
+        validDeps.erase(this->Depender);
+        currentDependencies = nullptr;
+      }
+
+      // Remove the depender to be sure it is rebuilt.
+      if (dependerExists) {
+        cmSystemTools::RemoveFile(depender);
+        dependerExists = false;
+      }
+    }
+  }
+
+  return okay;
+}
+
+void cmDepends::SetIncludePathFromLanguage(const std::string& lang)
+{
+  // Look for the new per "TARGET_" variant first:
+  const char* includePath = nullptr;
+  std::string includePathVar = "CMAKE_";
+  includePathVar += lang;
+  includePathVar += "_TARGET_INCLUDE_PATH";
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  includePath = mf->GetDefinition(includePathVar);
+  if (includePath) {
+    cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
+  } else {
+    // Fallback to the old directory level variable if no per-target var:
+    includePathVar = "CMAKE_";
+    includePathVar += lang;
+    includePathVar += "_INCLUDE_PATH";
+    includePath = mf->GetDefinition(includePathVar);
+    if (includePath) {
+      cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
+    }
+  }
+}
diff --git a/Source/cmDepends.h b/Source/cmDepends.h
new file mode 100644
index 0000000..a4fee3c
--- /dev/null
+++ b/Source/cmDepends.h
@@ -0,0 +1,123 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDepends_h
+#define cmDepends_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <stddef.h>
+#include <string>
+#include <vector>
+
+class cmFileTimeComparison;
+class cmLocalGenerator;
+
+/** \class cmDepends
+ * \brief Dependency scanner superclass.
+ *
+ * This class is responsible for maintaining a .depends.make file in
+ * the build tree corresponding to an object file.  Subclasses help it
+ * maintain dependencies for particular languages.
+ */
+class cmDepends
+{
+  CM_DISABLE_COPY(cmDepends)
+
+public:
+  /** Instances need to know the build directory name and the relative
+      path from the build directory to the target file.  */
+  cmDepends(cmLocalGenerator* lg = nullptr, const char* targetDir = "");
+
+  /** at what level will the compile be done from */
+  void SetCompileDirectory(const char* dir) { this->CompileDirectory = dir; }
+
+  /** Set the local generator for the directory in which we are
+      scanning dependencies.  This is not a full local generator; it
+      has been setup to do relative path conversions for the current
+      directory.  */
+  void SetLocalGenerator(cmLocalGenerator* lg) { this->LocalGenerator = lg; }
+
+  /** Set the specific language to be scanned.  */
+  void SetLanguage(const std::string& lang) { this->Language = lang; }
+
+  /** Set the target build directory.  */
+  void SetTargetDirectory(const char* dir) { this->TargetDirectory = dir; }
+
+  /** should this be verbose in its output */
+  void SetVerbose(bool verb) { this->Verbose = verb; }
+
+  /** Virtual destructor to cleanup subclasses properly.  */
+  virtual ~cmDepends();
+
+  /** Write dependencies for the target file.  */
+  bool Write(std::ostream& makeDepends, std::ostream& internalDepends);
+
+  class DependencyVector : public std::vector<std::string>
+  {
+  };
+
+  /** Check dependencies for the target file.  Returns true if
+      dependencies are okay and false if they must be generated.  If
+      they must be generated Clear has already been called to wipe out
+      the old dependencies.
+      Dependencies which are still valid will be stored in validDeps. */
+  bool Check(const char* makeFile, const char* internalFile,
+             std::map<std::string, DependencyVector>& validDeps);
+
+  /** Clear dependencies for the target file so they will be regenerated.  */
+  void Clear(const char* file);
+
+  /** Set the file comparison object */
+  void SetFileComparison(cmFileTimeComparison* fc)
+  {
+    this->FileComparison = fc;
+  }
+
+protected:
+  // Write dependencies for the target file to the given stream.
+  // Return true for success and false for failure.
+  virtual bool WriteDependencies(const std::set<std::string>& sources,
+                                 const std::string& obj,
+                                 std::ostream& makeDepends,
+                                 std::ostream& internalDepends);
+
+  // Check dependencies for the target file in the given stream.
+  // Return false if dependencies must be regenerated and true
+  // otherwise.
+  virtual bool CheckDependencies(
+    std::istream& internalDepends, const char* internalDependsFileName,
+    std::map<std::string, DependencyVector>& validDeps);
+
+  // Finalize the dependency information for the target.
+  virtual bool Finalize(std::ostream& makeDepends,
+                        std::ostream& internalDepends);
+
+  // The directory in which the build rule for the target file is executed.
+  std::string CompileDirectory;
+
+  // The local generator.
+  cmLocalGenerator* LocalGenerator;
+
+  // Flag for verbose output.
+  bool Verbose;
+  cmFileTimeComparison* FileComparison;
+
+  std::string Language;
+
+  // The full path to the target's build directory.
+  std::string TargetDirectory;
+
+  size_t MaxPath;
+  char* Dependee;
+  char* Depender;
+
+  // The include file search path.
+  std::vector<std::string> IncludePath;
+
+  void SetIncludePathFromLanguage(const std::string& lang);
+};
+
+#endif
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
new file mode 100644
index 0000000..1ab3fa2
--- /dev/null
+++ b/Source/cmDependsC.cxx
@@ -0,0 +1,472 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDependsC.h"
+
+#include "cmsys/FStream.hxx"
+#include <utility>
+
+#include "cmAlgorithms.h"
+#include "cmFileTimeComparison.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmSystemTools.h"
+
+#define INCLUDE_REGEX_LINE                                                    \
+  "^[ \t]*[#%][ \t]*(include|import)[ \t]*[<\"]([^\">]+)([\">])"
+
+#define INCLUDE_REGEX_LINE_MARKER "#IncludeRegexLine: "
+#define INCLUDE_REGEX_SCAN_MARKER "#IncludeRegexScan: "
+#define INCLUDE_REGEX_COMPLAIN_MARKER "#IncludeRegexComplain: "
+#define INCLUDE_REGEX_TRANSFORM_MARKER "#IncludeRegexTransform: "
+
+cmDependsC::cmDependsC()
+  : ValidDeps(nullptr)
+{
+}
+
+cmDependsC::cmDependsC(
+  cmLocalGenerator* lg, const char* targetDir, const std::string& lang,
+  const std::map<std::string, DependencyVector>* validDeps)
+  : cmDepends(lg, targetDir)
+  , ValidDeps(validDeps)
+{
+  cmMakefile* mf = lg->GetMakefile();
+
+  // Configure the include file search path.
+  this->SetIncludePathFromLanguage(lang);
+
+  // Configure regular expressions.
+  std::string scanRegex = "^.*$";
+  std::string complainRegex = "^$";
+  {
+    std::string scanRegexVar = "CMAKE_";
+    scanRegexVar += lang;
+    scanRegexVar += "_INCLUDE_REGEX_SCAN";
+    if (const char* sr = mf->GetDefinition(scanRegexVar)) {
+      scanRegex = sr;
+    }
+    std::string complainRegexVar = "CMAKE_";
+    complainRegexVar += lang;
+    complainRegexVar += "_INCLUDE_REGEX_COMPLAIN";
+    if (const char* cr = mf->GetDefinition(complainRegexVar)) {
+      complainRegex = cr;
+    }
+  }
+
+  this->IncludeRegexLine.compile(INCLUDE_REGEX_LINE);
+  this->IncludeRegexScan.compile(scanRegex.c_str());
+  this->IncludeRegexComplain.compile(complainRegex.c_str());
+  this->IncludeRegexLineString = INCLUDE_REGEX_LINE_MARKER INCLUDE_REGEX_LINE;
+  this->IncludeRegexScanString = INCLUDE_REGEX_SCAN_MARKER;
+  this->IncludeRegexScanString += scanRegex;
+  this->IncludeRegexComplainString = INCLUDE_REGEX_COMPLAIN_MARKER;
+  this->IncludeRegexComplainString += complainRegex;
+
+  this->SetupTransforms();
+
+  this->CacheFileName = this->TargetDirectory;
+  this->CacheFileName += "/";
+  this->CacheFileName += lang;
+  this->CacheFileName += ".includecache";
+
+  this->ReadCacheFile();
+}
+
+cmDependsC::~cmDependsC()
+{
+  this->WriteCacheFile();
+  cmDeleteAll(this->FileCache);
+}
+
+bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
+                                   const std::string& obj,
+                                   std::ostream& makeDepends,
+                                   std::ostream& internalDepends)
+{
+  // Make sure this is a scanning instance.
+  if (sources.empty() || sources.begin()->empty()) {
+    cmSystemTools::Error("Cannot scan dependencies without a source file.");
+    return false;
+  }
+  if (obj.empty()) {
+    cmSystemTools::Error("Cannot scan dependencies without an object file.");
+    return false;
+  }
+
+  std::set<std::string> dependencies;
+  bool haveDeps = false;
+
+  if (this->ValidDeps != nullptr) {
+    std::map<std::string, DependencyVector>::const_iterator tmpIt =
+      this->ValidDeps->find(obj);
+    if (tmpIt != this->ValidDeps->end()) {
+      dependencies.insert(tmpIt->second.begin(), tmpIt->second.end());
+      haveDeps = true;
+    }
+  }
+
+  if (!haveDeps) {
+    // Walk the dependency graph starting with the source file.
+    int srcFiles = static_cast<int>(sources.size());
+    this->Encountered.clear();
+
+    for (std::string const& src : sources) {
+      UnscannedEntry root;
+      root.FileName = src;
+      this->Unscanned.push(root);
+      this->Encountered.insert(src);
+    }
+
+    std::set<std::string> scanned;
+
+    // Use reserve to allocate enough memory for tempPathStr
+    // so that during the loops no memory is allocated or freed
+    std::string tempPathStr;
+    tempPathStr.reserve(4 * 1024);
+
+    while (!this->Unscanned.empty()) {
+      // Get the next file to scan.
+      UnscannedEntry current = this->Unscanned.front();
+      this->Unscanned.pop();
+
+      // If not a full path, find the file in the include path.
+      std::string fullName;
+      if ((srcFiles > 0) ||
+          cmSystemTools::FileIsFullPath(current.FileName.c_str())) {
+        if (cmSystemTools::FileExists(current.FileName.c_str(), true)) {
+          fullName = current.FileName;
+        }
+      } else if (!current.QuotedLocation.empty() &&
+                 cmSystemTools::FileExists(current.QuotedLocation.c_str(),
+                                           true)) {
+        // The include statement producing this entry was a double-quote
+        // include and the included file is present in the directory of
+        // the source containing the include statement.
+        fullName = current.QuotedLocation;
+      } else {
+        std::map<std::string, std::string>::iterator headerLocationIt =
+          this->HeaderLocationCache.find(current.FileName);
+        if (headerLocationIt != this->HeaderLocationCache.end()) {
+          fullName = headerLocationIt->second;
+        } else {
+          for (std::string const& i : this->IncludePath) {
+            // Construct the name of the file as if it were in the current
+            // include directory.  Avoid using a leading "./".
+
+            tempPathStr =
+              cmSystemTools::CollapseCombinedPath(i, current.FileName);
+
+            // Look for the file in this location.
+            if (cmSystemTools::FileExists(tempPathStr.c_str(), true)) {
+              fullName = tempPathStr;
+              HeaderLocationCache[current.FileName] = fullName;
+              break;
+            }
+          }
+        }
+      }
+
+      // Complain if the file cannot be found and matches the complain
+      // regex.
+      if (fullName.empty() &&
+          this->IncludeRegexComplain.find(current.FileName.c_str())) {
+        cmSystemTools::Error("Cannot find file \"", current.FileName.c_str(),
+                             "\".");
+        return false;
+      }
+
+      // Scan the file if it was found and has not been scanned already.
+      if (!fullName.empty() && (scanned.find(fullName) == scanned.end())) {
+        // Record scanned files.
+        scanned.insert(fullName);
+
+        // Check whether this file is already in the cache
+        std::map<std::string, cmIncludeLines*>::iterator fileIt =
+          this->FileCache.find(fullName);
+        if (fileIt != this->FileCache.end()) {
+          fileIt->second->Used = true;
+          dependencies.insert(fullName);
+          for (UnscannedEntry const& inc : fileIt->second->UnscannedEntries) {
+            if (this->Encountered.find(inc.FileName) ==
+                this->Encountered.end()) {
+              this->Encountered.insert(inc.FileName);
+              this->Unscanned.push(inc);
+            }
+          }
+        } else {
+
+          // Try to scan the file.  Just leave it out if we cannot find
+          // it.
+          cmsys::ifstream fin(fullName.c_str());
+          if (fin) {
+            cmsys::FStream::BOM bom = cmsys::FStream::ReadBOM(fin);
+            if (bom == cmsys::FStream::BOM_None ||
+                bom == cmsys::FStream::BOM_UTF8) {
+              // Add this file as a dependency.
+              dependencies.insert(fullName);
+
+              // Scan this file for new dependencies.  Pass the directory
+              // containing the file to handle double-quote includes.
+              std::string dir = cmSystemTools::GetFilenamePath(fullName);
+              this->Scan(fin, dir.c_str(), fullName);
+            } else {
+              // Skip file with encoding we do not implement.
+            }
+          }
+        }
+      }
+
+      srcFiles--;
+    }
+  }
+
+  // Write the dependencies to the output stream.  Makefile rules
+  // written by the original local generator for this directory
+  // convert the dependencies to paths relative to the home output
+  // directory.  We must do the same here.
+  std::string binDir = this->LocalGenerator->GetBinaryDirectory();
+  std::string obj_i = this->LocalGenerator->ConvertToRelativePath(binDir, obj);
+  std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i.c_str());
+  internalDepends << obj_i << std::endl;
+
+  for (std::string const& dep : dependencies) {
+    makeDepends
+      << obj_m << ": "
+      << cmSystemTools::ConvertToOutputPath(
+           this->LocalGenerator->ConvertToRelativePath(binDir, dep).c_str())
+      << std::endl;
+    internalDepends << " " << dep << std::endl;
+  }
+  makeDepends << std::endl;
+
+  return true;
+}
+
+void cmDependsC::ReadCacheFile()
+{
+  if (this->CacheFileName.empty()) {
+    return;
+  }
+  cmsys::ifstream fin(this->CacheFileName.c_str());
+  if (!fin) {
+    return;
+  }
+
+  std::string line;
+  cmIncludeLines* cacheEntry = nullptr;
+  bool haveFileName = false;
+
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty()) {
+      cacheEntry = nullptr;
+      haveFileName = false;
+      continue;
+    }
+    // the first line after an empty line is the name of the parsed file
+    if (!haveFileName) {
+      haveFileName = true;
+      int newer = 0;
+      cmFileTimeComparison comp;
+      bool res = comp.FileTimeCompare(this->CacheFileName.c_str(),
+                                      line.c_str(), &newer);
+
+      if (res && newer == 1) // cache is newer than the parsed file
+      {
+        cacheEntry = new cmIncludeLines;
+        this->FileCache[line] = cacheEntry;
+      }
+      // file doesn't exist, check that the regular expressions
+      // haven't changed
+      else if (!res) {
+        if (line.find(INCLUDE_REGEX_LINE_MARKER) == 0) {
+          if (line != this->IncludeRegexLineString) {
+            return;
+          }
+        } else if (line.find(INCLUDE_REGEX_SCAN_MARKER) == 0) {
+          if (line != this->IncludeRegexScanString) {
+            return;
+          }
+        } else if (line.find(INCLUDE_REGEX_COMPLAIN_MARKER) == 0) {
+          if (line != this->IncludeRegexComplainString) {
+            return;
+          }
+        } else if (line.find(INCLUDE_REGEX_TRANSFORM_MARKER) == 0) {
+          if (line != this->IncludeRegexTransformString) {
+            return;
+          }
+        }
+      }
+    } else if (cacheEntry != nullptr) {
+      UnscannedEntry entry;
+      entry.FileName = line;
+      if (cmSystemTools::GetLineFromStream(fin, line)) {
+        if (line != "-") {
+          entry.QuotedLocation = line;
+        }
+        cacheEntry->UnscannedEntries.push_back(entry);
+      }
+    }
+  }
+}
+
+void cmDependsC::WriteCacheFile() const
+{
+  if (this->CacheFileName.empty()) {
+    return;
+  }
+  cmsys::ofstream cacheOut(this->CacheFileName.c_str());
+  if (!cacheOut) {
+    return;
+  }
+
+  cacheOut << this->IncludeRegexLineString << "\n\n";
+  cacheOut << this->IncludeRegexScanString << "\n\n";
+  cacheOut << this->IncludeRegexComplainString << "\n\n";
+  cacheOut << this->IncludeRegexTransformString << "\n\n";
+
+  for (auto const& fileIt : this->FileCache) {
+    if (fileIt.second->Used) {
+      cacheOut << fileIt.first << std::endl;
+
+      for (UnscannedEntry const& inc : fileIt.second->UnscannedEntries) {
+        cacheOut << inc.FileName << std::endl;
+        if (inc.QuotedLocation.empty()) {
+          cacheOut << "-" << std::endl;
+        } else {
+          cacheOut << inc.QuotedLocation << std::endl;
+        }
+      }
+      cacheOut << std::endl;
+    }
+  }
+}
+
+void cmDependsC::Scan(std::istream& is, const char* directory,
+                      const std::string& fullName)
+{
+  cmIncludeLines* newCacheEntry = new cmIncludeLines;
+  newCacheEntry->Used = true;
+  this->FileCache[fullName] = newCacheEntry;
+
+  // Read one line at a time.
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(is, line)) {
+    // Transform the line content first.
+    if (!this->TransformRules.empty()) {
+      this->TransformLine(line);
+    }
+
+    // Match include directives.
+    if (this->IncludeRegexLine.find(line.c_str())) {
+      // Get the file being included.
+      UnscannedEntry entry;
+      entry.FileName = this->IncludeRegexLine.match(2);
+      cmSystemTools::ConvertToUnixSlashes(entry.FileName);
+      if (this->IncludeRegexLine.match(3) == "\"" &&
+          !cmSystemTools::FileIsFullPath(entry.FileName.c_str())) {
+        // This was a double-quoted include with a relative path.  We
+        // must check for the file in the directory containing the
+        // file we are scanning.
+        entry.QuotedLocation =
+          cmSystemTools::CollapseCombinedPath(directory, entry.FileName);
+      }
+
+      // Queue the file if it has not yet been encountered and it
+      // matches the regular expression for recursive scanning.  Note
+      // that this check does not account for the possibility of two
+      // headers with the same name in different directories when one
+      // is included by double-quotes and the other by angle brackets.
+      // It also does not work properly if two header files with the same
+      // name exist in different directories, and both are included from a
+      // file their own directory by simply using "filename.h" (#12619)
+      // This kind of problem will be fixed when a more
+      // preprocessor-like implementation of this scanner is created.
+      if (this->IncludeRegexScan.find(entry.FileName.c_str())) {
+        newCacheEntry->UnscannedEntries.push_back(entry);
+        if (this->Encountered.find(entry.FileName) ==
+            this->Encountered.end()) {
+          this->Encountered.insert(entry.FileName);
+          this->Unscanned.push(entry);
+        }
+      }
+    }
+  }
+}
+
+void cmDependsC::SetupTransforms()
+{
+  // Get the transformation rules.
+  std::vector<std::string> transformRules;
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  if (const char* xform = mf->GetDefinition("CMAKE_INCLUDE_TRANSFORMS")) {
+    cmSystemTools::ExpandListArgument(xform, transformRules, true);
+  }
+  for (std::string const& tr : transformRules) {
+    this->ParseTransform(tr);
+  }
+
+  this->IncludeRegexTransformString = INCLUDE_REGEX_TRANSFORM_MARKER;
+  if (!this->TransformRules.empty()) {
+    // Construct the regular expression to match lines to be
+    // transformed.
+    std::string xform = "^([ \t]*[#%][ \t]*(include|import)[ \t]*)(";
+    const char* sep = "";
+    for (auto const& tr : this->TransformRules) {
+      xform += sep;
+      xform += tr.first;
+      sep = "|";
+    }
+    xform += ")[ \t]*\\(([^),]*)\\)";
+    this->IncludeRegexTransform.compile(xform.c_str());
+
+    // Build a string that encodes all transformation rules and will
+    // change when rules are changed.
+    this->IncludeRegexTransformString += xform;
+    for (auto const& tr : this->TransformRules) {
+      this->IncludeRegexTransformString += " ";
+      this->IncludeRegexTransformString += tr.first;
+      this->IncludeRegexTransformString += "(%)=";
+      this->IncludeRegexTransformString += tr.second;
+    }
+  }
+}
+
+void cmDependsC::ParseTransform(std::string const& xform)
+{
+  // A transform rule is of the form SOME_MACRO(%)=value-with-%
+  // We can simply separate with "(%)=".
+  std::string::size_type pos = xform.find("(%)=");
+  if (pos == std::string::npos || pos == 0) {
+    return;
+  }
+  std::string name = xform.substr(0, pos);
+  std::string value = xform.substr(pos + 4);
+  this->TransformRules[name] = value;
+}
+
+void cmDependsC::TransformLine(std::string& line)
+{
+  // Check for a transform rule match.  Return if none.
+  if (!this->IncludeRegexTransform.find(line.c_str())) {
+    return;
+  }
+  TransformRulesType::const_iterator tri =
+    this->TransformRules.find(this->IncludeRegexTransform.match(3));
+  if (tri == this->TransformRules.end()) {
+    return;
+  }
+
+  // Construct the transformed line.
+  std::string newline = this->IncludeRegexTransform.match(1);
+  std::string arg = this->IncludeRegexTransform.match(4);
+  for (const char* c = tri->second.c_str(); *c; ++c) {
+    if (*c == '%') {
+      newline += arg;
+    } else {
+      newline += *c;
+    }
+  }
+
+  // Return the transformed line.
+  line = newline;
+}
diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h
new file mode 100644
index 0000000..2f76f62
--- /dev/null
+++ b/Source/cmDependsC.h
@@ -0,0 +1,100 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDependsC_h
+#define cmDependsC_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmDepends.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <iosfwd>
+#include <map>
+#include <queue>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmLocalGenerator;
+
+/** \class cmDependsC
+ * \brief Dependency scanner for C and C++ object files.
+ */
+class cmDependsC : public cmDepends
+{
+  CM_DISABLE_COPY(cmDependsC)
+
+public:
+  /** Checking instances need to know the build directory name and the
+      relative path from the build directory to the target file.  */
+  cmDependsC();
+  cmDependsC(cmLocalGenerator* lg, const char* targetDir,
+             const std::string& lang,
+             const std::map<std::string, DependencyVector>* validDeps);
+
+  /** Virtual destructor to cleanup subclasses properly.  */
+  ~cmDependsC() override;
+
+protected:
+  // Implement writing/checking methods required by superclass.
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& obj, std::ostream& makeDepends,
+                         std::ostream& internalDepends) override;
+
+  // Method to scan a single file.
+  void Scan(std::istream& is, const char* directory,
+            const std::string& fullName);
+
+  // Regular expression to identify C preprocessor include directives.
+  cmsys::RegularExpression IncludeRegexLine;
+
+  // Regular expressions to choose which include files to scan
+  // recursively and which to complain about not finding.
+  cmsys::RegularExpression IncludeRegexScan;
+  cmsys::RegularExpression IncludeRegexComplain;
+  std::string IncludeRegexLineString;
+  std::string IncludeRegexScanString;
+  std::string IncludeRegexComplainString;
+
+  // Regex to transform #include lines.
+  std::string IncludeRegexTransformString;
+  cmsys::RegularExpression IncludeRegexTransform;
+  typedef std::map<std::string, std::string> TransformRulesType;
+  TransformRulesType TransformRules;
+  void SetupTransforms();
+  void ParseTransform(std::string const& xform);
+  void TransformLine(std::string& line);
+
+public:
+  // Data structures for dependency graph walk.
+  struct UnscannedEntry
+  {
+    std::string FileName;
+    std::string QuotedLocation;
+  };
+
+  struct cmIncludeLines
+  {
+    cmIncludeLines()
+      : Used(false)
+    {
+    }
+    std::vector<UnscannedEntry> UnscannedEntries;
+    bool Used;
+  };
+
+protected:
+  const std::map<std::string, DependencyVector>* ValidDeps;
+  std::set<std::string> Encountered;
+  std::queue<UnscannedEntry> Unscanned;
+
+  std::map<std::string, cmIncludeLines*> FileCache;
+  std::map<std::string, std::string> HeaderLocationCache;
+
+  std::string CacheFileName;
+
+  void WriteCacheFile() const;
+  void ReadCacheFile();
+};
+
+#endif
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
new file mode 100644
index 0000000..25d78c4
--- /dev/null
+++ b/Source/cmDependsFortran.cxx
@@ -0,0 +1,684 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDependsFortran.h"
+
+#include "cmsys/FStream.hxx"
+#include <assert.h>
+#include <iostream>
+#include <map>
+#include <stdlib.h>
+#include <string.h>
+#include <utility>
+
+#include "cmFortranParser.h" /* Interface to parser object.  */
+#include "cmGeneratedFileStream.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmStateDirectory.h"
+#include "cmStateSnapshot.h"
+#include "cmSystemTools.h"
+
+// TODO: Test compiler for the case of the mod file.  Some always
+// use lower case and some always use upper case.  I do not know if any
+// use the case from the source code.
+
+class cmDependsFortranInternals
+{
+public:
+  // The set of modules provided by this target.
+  std::set<std::string> TargetProvides;
+
+  // Map modules required by this target to locations.
+  typedef std::map<std::string, std::string> TargetRequiresMap;
+  TargetRequiresMap TargetRequires;
+
+  // Information about each object file.
+  typedef std::map<std::string, cmFortranSourceInfo> ObjectInfoMap;
+  ObjectInfoMap ObjectInfo;
+
+  cmFortranSourceInfo& CreateObjectInfo(const char* obj, const char* src)
+  {
+    std::map<std::string, cmFortranSourceInfo>::iterator i =
+      this->ObjectInfo.find(obj);
+    if (i == this->ObjectInfo.end()) {
+      std::map<std::string, cmFortranSourceInfo>::value_type entry(
+        obj, cmFortranSourceInfo());
+      i = this->ObjectInfo.insert(entry).first;
+      i->second.Source = src;
+    }
+    return i->second;
+  }
+};
+
+cmDependsFortran::cmDependsFortran()
+  : Internal(nullptr)
+{
+}
+
+cmDependsFortran::cmDependsFortran(cmLocalGenerator* lg)
+  : cmDepends(lg)
+  , Internal(new cmDependsFortranInternals)
+{
+  // Configure the include file search path.
+  this->SetIncludePathFromLanguage("Fortran");
+
+  // Get the list of definitions.
+  std::vector<std::string> definitions;
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  if (const char* c_defines =
+        mf->GetDefinition("CMAKE_TARGET_DEFINITIONS_Fortran")) {
+    cmSystemTools::ExpandListArgument(c_defines, definitions);
+  }
+
+  // translate i.e. FOO=BAR to FOO and add it to the list of defined
+  // preprocessor symbols
+  for (std::string def : definitions) {
+    std::string::size_type assignment = def.find('=');
+    if (assignment != std::string::npos) {
+      def = def.substr(0, assignment);
+    }
+    this->PPDefinitions.insert(def);
+  }
+}
+
+cmDependsFortran::~cmDependsFortran()
+{
+  delete this->Internal;
+}
+
+bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
+                                         const std::string& obj,
+                                         std::ostream& /*makeDepends*/,
+                                         std::ostream& /*internalDepends*/)
+{
+  // Make sure this is a scanning instance.
+  if (sources.empty() || sources.begin()->empty()) {
+    cmSystemTools::Error("Cannot scan dependencies without a source file.");
+    return false;
+  }
+  if (obj.empty()) {
+    cmSystemTools::Error("Cannot scan dependencies without an object file.");
+    return false;
+  }
+
+  bool okay = true;
+  for (std::string const& src : sources) {
+    // Get the information object for this source.
+    cmFortranSourceInfo& info =
+      this->Internal->CreateObjectInfo(obj.c_str(), src.c_str());
+
+    // Create the parser object. The constructor takes info by reference,
+    // so we may look into the resulting objects later.
+    cmFortranParser parser(this->IncludePath, this->PPDefinitions, info);
+
+    // Push on the starting file.
+    cmFortranParser_FilePush(&parser, src.c_str());
+
+    // Parse the translation unit.
+    if (cmFortran_yyparse(parser.Scanner) != 0) {
+      // Failed to parse the file.  Report failure to write dependencies.
+      okay = false;
+      /* clang-format off */
+      std::cerr <<
+        "warning: failed to parse dependencies from Fortran source "
+        "'" << src << "': " << parser.Error << std::endl
+        ;
+      /* clang-format on */
+    }
+  }
+  return okay;
+}
+
+bool cmDependsFortran::Finalize(std::ostream& makeDepends,
+                                std::ostream& internalDepends)
+{
+  // Prepare the module search process.
+  this->LocateModules();
+
+  // Get the directory in which stamp files will be stored.
+  const char* stamp_dir = this->TargetDirectory.c_str();
+
+  // Get the directory in which module files will be created.
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  std::string mod_dir =
+    mf->GetSafeDefinition("CMAKE_Fortran_TARGET_MODULE_DIR");
+  if (mod_dir.empty()) {
+    mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory();
+  }
+
+  // Actually write dependencies to the streams.
+  typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
+  ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
+  for (auto const& i : objInfo) {
+    if (!this->WriteDependenciesReal(i.first.c_str(), i.second, mod_dir,
+                                     stamp_dir, makeDepends,
+                                     internalDepends)) {
+      return false;
+    }
+  }
+
+  // Store the list of modules provided by this target.
+  std::string fiName = this->TargetDirectory;
+  fiName += "/fortran.internal";
+  cmGeneratedFileStream fiStream(fiName.c_str());
+  fiStream << "# The fortran modules provided by this target.\n";
+  fiStream << "provides\n";
+  std::set<std::string> const& provides = this->Internal->TargetProvides;
+  for (std::string const& i : provides) {
+    fiStream << " " << i << "\n";
+  }
+
+  // Create a script to clean the modules.
+  if (!provides.empty()) {
+    std::string fcName = this->TargetDirectory;
+    fcName += "/cmake_clean_Fortran.cmake";
+    cmGeneratedFileStream fcStream(fcName.c_str());
+    fcStream << "# Remove fortran modules provided by this target.\n";
+    fcStream << "FILE(REMOVE";
+    std::string currentBinDir =
+      this->LocalGenerator->GetCurrentBinaryDirectory();
+    for (std::string const& i : provides) {
+      std::string mod_upper = mod_dir;
+      mod_upper += "/";
+      mod_upper += cmSystemTools::UpperCase(i);
+      mod_upper += ".mod";
+      std::string mod_lower = mod_dir;
+      mod_lower += "/";
+      mod_lower += i;
+      mod_lower += ".mod";
+      std::string stamp = stamp_dir;
+      stamp += "/";
+      stamp += i;
+      stamp += ".mod.stamp";
+      fcStream << "\n";
+      fcStream << "  \""
+               << this->MaybeConvertToRelativePath(currentBinDir, mod_lower)
+               << "\"\n";
+      fcStream << "  \""
+               << this->MaybeConvertToRelativePath(currentBinDir, mod_upper)
+               << "\"\n";
+      fcStream << "  \""
+               << this->MaybeConvertToRelativePath(currentBinDir, stamp)
+               << "\"\n";
+    }
+    fcStream << "  )\n";
+  }
+  return true;
+}
+
+void cmDependsFortran::LocateModules()
+{
+  // Collect the set of modules provided and required by all sources.
+  typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
+  ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
+  for (auto const& infoI : objInfo) {
+    cmFortranSourceInfo const& info = infoI.second;
+    // Include this module in the set provided by this target.
+    this->Internal->TargetProvides.insert(info.Provides.begin(),
+                                          info.Provides.end());
+
+    for (std::string const& r : info.Requires) {
+      this->Internal->TargetRequires[r].clear();
+    }
+  }
+
+  // Short-circuit for simple targets.
+  if (this->Internal->TargetRequires.empty()) {
+    return;
+  }
+
+  // Match modules provided by this target to those it requires.
+  this->MatchLocalModules();
+
+  // Load information about other targets.
+  cmMakefile* mf = this->LocalGenerator->GetMakefile();
+  std::vector<std::string> infoFiles;
+  if (const char* infoFilesValue =
+        mf->GetDefinition("CMAKE_TARGET_LINKED_INFO_FILES")) {
+    cmSystemTools::ExpandListArgument(infoFilesValue, infoFiles);
+  }
+  for (std::string const& i : infoFiles) {
+    std::string targetDir = cmSystemTools::GetFilenamePath(i);
+    std::string fname = targetDir + "/fortran.internal";
+    cmsys::ifstream fin(fname.c_str());
+    if (fin) {
+      this->MatchRemoteModules(fin, targetDir.c_str());
+    }
+  }
+}
+
+void cmDependsFortran::MatchLocalModules()
+{
+  const char* stampDir = this->TargetDirectory.c_str();
+  std::set<std::string> const& provides = this->Internal->TargetProvides;
+  for (std::string const& i : provides) {
+    this->ConsiderModule(i.c_str(), stampDir);
+  }
+}
+
+void cmDependsFortran::MatchRemoteModules(std::istream& fin,
+                                          const char* stampDir)
+{
+  std::string line;
+  bool doing_provides = false;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    // Ignore comments and empty lines.
+    if (line.empty() || line[0] == '#' || line[0] == '\r') {
+      continue;
+    }
+
+    if (line[0] == ' ') {
+      if (doing_provides) {
+        this->ConsiderModule(line.c_str() + 1, stampDir);
+      }
+    } else if (line == "provides") {
+      doing_provides = true;
+    } else {
+      doing_provides = false;
+    }
+  }
+}
+
+void cmDependsFortran::ConsiderModule(const char* name, const char* stampDir)
+{
+  // Locate each required module.
+  typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap;
+  TargetRequiresMap::iterator required =
+    this->Internal->TargetRequires.find(name);
+  if (required != this->Internal->TargetRequires.end() &&
+      required->second.empty()) {
+    // The module is provided by a CMake target.  It will have a stamp file.
+    std::string stampFile = stampDir;
+    stampFile += "/";
+    stampFile += name;
+    stampFile += ".mod.stamp";
+    required->second = stampFile;
+  }
+}
+
+bool cmDependsFortran::WriteDependenciesReal(const char* obj,
+                                             cmFortranSourceInfo const& info,
+                                             std::string const& mod_dir,
+                                             const char* stamp_dir,
+                                             std::ostream& makeDepends,
+                                             std::ostream& internalDepends)
+{
+  typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap;
+
+  // Get the source file for this object.
+  const char* src = info.Source.c_str();
+
+  // Write the include dependencies to the output stream.
+  std::string binDir = this->LocalGenerator->GetBinaryDirectory();
+  std::string obj_i = this->MaybeConvertToRelativePath(binDir, obj);
+  std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i.c_str());
+  internalDepends << obj_i << std::endl;
+  internalDepends << " " << src << std::endl;
+  for (std::string const& i : info.Includes) {
+    makeDepends << obj_m << ": "
+                << cmSystemTools::ConvertToOutputPath(
+                     this->MaybeConvertToRelativePath(binDir, i).c_str())
+                << std::endl;
+    internalDepends << " " << i << std::endl;
+  }
+  makeDepends << std::endl;
+
+  // Write module requirements to the output stream.
+  for (std::string const& i : info.Requires) {
+    // Require only modules not provided in the same source.
+    if (info.Provides.find(i) != info.Provides.cend()) {
+      continue;
+    }
+
+    // The object file should depend on timestamped files for the
+    // modules it uses.
+    TargetRequiresMap::const_iterator required =
+      this->Internal->TargetRequires.find(i);
+    if (required == this->Internal->TargetRequires.end()) {
+      abort();
+    }
+    if (!required->second.empty()) {
+      // This module is known.  Depend on its timestamp file.
+      std::string stampFile = cmSystemTools::ConvertToOutputPath(
+        this->MaybeConvertToRelativePath(binDir, required->second).c_str());
+      makeDepends << obj_m << ": " << stampFile << "\n";
+    } else {
+      // This module is not known to CMake.  Try to locate it where
+      // the compiler will and depend on that.
+      std::string module;
+      if (this->FindModule(i, module)) {
+        module = cmSystemTools::ConvertToOutputPath(
+          this->MaybeConvertToRelativePath(binDir, module).c_str());
+        makeDepends << obj_m << ": " << module << "\n";
+      }
+    }
+  }
+
+  // If any modules are provided then they must be converted to stamp files.
+  if (!info.Provides.empty()) {
+    // Create a target to copy the module after the object file
+    // changes.
+    for (std::string const& i : info.Provides) {
+      // Include this module in the set provided by this target.
+      this->Internal->TargetProvides.insert(i);
+
+      // Always use lower case for the mod stamp file name.  The
+      // cmake_copy_f90_mod will call back to this class, which will
+      // try various cases for the real mod file name.
+      std::string m = cmSystemTools::LowerCase(i);
+      std::string modFile = mod_dir;
+      modFile += "/";
+      modFile += i;
+      modFile = this->LocalGenerator->ConvertToOutputFormat(
+        this->MaybeConvertToRelativePath(binDir, modFile),
+        cmOutputConverter::SHELL);
+      std::string stampFile = stamp_dir;
+      stampFile += "/";
+      stampFile += m;
+      stampFile += ".mod.stamp";
+      stampFile = this->MaybeConvertToRelativePath(binDir, stampFile);
+      std::string const stampFileForShell =
+        this->LocalGenerator->ConvertToOutputFormat(stampFile,
+                                                    cmOutputConverter::SHELL);
+      std::string const stampFileForMake =
+        cmSystemTools::ConvertToOutputPath(stampFile.c_str());
+
+      makeDepends << obj_m << ".provides.build"
+                  << ": " << stampFileForMake << "\n";
+      // Note that when cmake_copy_f90_mod finds that a module file
+      // and the corresponding stamp file have no differences, the stamp
+      // file is not updated. In such case the stamp file will be always
+      // older than its prerequisite and trigger cmake_copy_f90_mod
+      // on each new build. This is expected behavior for incremental
+      // builds and can not be changed without preforming recursive make
+      // calls that would considerably slow down the building process.
+      makeDepends << stampFileForMake << ": " << obj_m << "\n";
+      makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
+                  << " " << stampFileForShell;
+      cmMakefile* mf = this->LocalGenerator->GetMakefile();
+      const char* cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID");
+      if (cid && *cid) {
+        makeDepends << " " << cid;
+      }
+      makeDepends << "\n";
+    }
+    makeDepends << obj_m << ".provides.build:\n";
+    // After copying the modules update the timestamp file.
+    makeDepends << "\t$(CMAKE_COMMAND) -E touch " << obj_m
+                << ".provides.build\n";
+
+    // Make sure the module timestamp rule is evaluated by the time
+    // the target finishes building.
+    std::string driver = this->TargetDirectory;
+    driver += "/build";
+    driver = cmSystemTools::ConvertToOutputPath(
+      this->MaybeConvertToRelativePath(binDir, driver).c_str());
+    makeDepends << driver << ": " << obj_m << ".provides.build\n";
+  }
+
+  return true;
+}
+
+bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
+{
+  // Construct possible names for the module file.
+  std::string mod_upper = cmSystemTools::UpperCase(name);
+  std::string mod_lower = name;
+  mod_upper += ".mod";
+  mod_lower += ".mod";
+
+  // Search the include path for the module.
+  std::string fullName;
+  for (std::string const& ip : this->IncludePath) {
+    // Try the lower-case name.
+    fullName = ip;
+    fullName += "/";
+    fullName += mod_lower;
+    if (cmSystemTools::FileExists(fullName.c_str(), true)) {
+      module = fullName;
+      return true;
+    }
+
+    // Try the upper-case name.
+    fullName = ip;
+    fullName += "/";
+    fullName += mod_upper;
+    if (cmSystemTools::FileExists(fullName.c_str(), true)) {
+      module = fullName;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
+{
+  // Implements
+  //
+  //   $(CMAKE_COMMAND) -E cmake_copy_f90_mod input.mod output.mod.stamp
+  //                                          [compiler-id]
+  //
+  // Note that the case of the .mod file depends on the compiler.  In
+  // the future this copy could also account for the fact that some
+  // compilers include a timestamp in the .mod file so it changes even
+  // when the interface described in the module does not.
+
+  std::string mod = args[2];
+  std::string stamp = args[3];
+  std::string compilerId;
+  if (args.size() >= 5) {
+    compilerId = args[4];
+  }
+  std::string mod_dir = cmSystemTools::GetFilenamePath(mod);
+  if (!mod_dir.empty()) {
+    mod_dir += "/";
+  }
+  std::string mod_upper = mod_dir;
+  mod_upper += cmSystemTools::UpperCase(cmSystemTools::GetFilenameName(mod));
+  std::string mod_lower = mod_dir;
+  mod_lower += cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(mod));
+  mod += ".mod";
+  mod_upper += ".mod";
+  mod_lower += ".mod";
+  if (cmSystemTools::FileExists(mod_upper.c_str(), true)) {
+    if (cmDependsFortran::ModulesDiffer(mod_upper.c_str(), stamp.c_str(),
+                                        compilerId.c_str())) {
+      if (!cmSystemTools::CopyFileAlways(mod_upper, stamp)) {
+        std::cerr << "Error copying Fortran module from \"" << mod_upper
+                  << "\" to \"" << stamp << "\".\n";
+        return false;
+      }
+    }
+    return true;
+  }
+  if (cmSystemTools::FileExists(mod_lower.c_str(), true)) {
+    if (cmDependsFortran::ModulesDiffer(mod_lower.c_str(), stamp.c_str(),
+                                        compilerId.c_str())) {
+      if (!cmSystemTools::CopyFileAlways(mod_lower, stamp)) {
+        std::cerr << "Error copying Fortran module from \"" << mod_lower
+                  << "\" to \"" << stamp << "\".\n";
+        return false;
+      }
+    }
+    return true;
+  }
+
+  std::cerr << "Error copying Fortran module \"" << args[2] << "\".  Tried \""
+            << mod_upper << "\" and \"" << mod_lower << "\".\n";
+  return false;
+}
+
+// Helper function to look for a short sequence in a stream.  If this
+// is later used for longer sequences it should be re-written using an
+// efficient string search algorithm such as Boyer-Moore.
+static bool cmFortranStreamContainsSequence(std::istream& ifs, const char* seq,
+                                            int len)
+{
+  assert(len > 0);
+
+  int cur = 0;
+  while (cur < len) {
+    // Get the next character.
+    int token = ifs.get();
+    if (!ifs) {
+      return false;
+    }
+
+    // Check the character.
+    if (token == static_cast<int>(seq[cur])) {
+      ++cur;
+    } else {
+      // Assume the sequence has no repeating subsequence.
+      cur = 0;
+    }
+  }
+
+  // The entire sequence was matched.
+  return true;
+}
+
+// Helper function to compare the remaining content in two streams.
+static bool cmFortranStreamsDiffer(std::istream& ifs1, std::istream& ifs2)
+{
+  // Compare the remaining content.
+  for (;;) {
+    int ifs1_c = ifs1.get();
+    int ifs2_c = ifs2.get();
+    if (!ifs1 && !ifs2) {
+      // We have reached the end of both streams simultaneously.
+      // The streams are identical.
+      return false;
+    }
+
+    if (!ifs1 || !ifs2 || ifs1_c != ifs2_c) {
+      // We have reached the end of one stream before the other or
+      // found differing content.  The streams are different.
+      break;
+    }
+  }
+
+  return true;
+}
+
+bool cmDependsFortran::ModulesDiffer(const char* modFile,
+                                     const char* stampFile,
+                                     const char* compilerId)
+{
+  /*
+  gnu >= 4.9:
+    A mod file is an ascii file compressed with gzip.
+    Compiling twice produces identical modules.
+
+  gnu < 4.9:
+    A mod file is an ascii file.
+    <bar.mod>
+    FORTRAN module created from /path/to/foo.f90 on Sun Dec 30 22:47:58 2007
+    If you edit this, you'll get what you deserve.
+    ...
+    </bar.mod>
+    As you can see the first line contains the date.
+
+  intel:
+    A mod file is a binary file.
+    However, looking into both generated bar.mod files with a hex editor
+    shows that they differ only before a sequence linefeed-zero (0x0A 0x00)
+    which is located some bytes in front of the absolute path to the source
+    file.
+
+  sun:
+    A mod file is a binary file.  Compiling twice produces identical modules.
+
+  others:
+    TODO ...
+  */
+
+  /* Compilers which do _not_ produce different mod content when the same
+   * source is compiled twice
+   *   -SunPro
+   */
+  if (strcmp(compilerId, "SunPro") == 0) {
+    return cmSystemTools::FilesDiffer(modFile, stampFile);
+  }
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+  cmsys::ifstream finModFile(modFile, std::ios::in | std::ios::binary);
+  cmsys::ifstream finStampFile(stampFile, std::ios::in | std::ios::binary);
+#else
+  cmsys::ifstream finModFile(modFile);
+  cmsys::ifstream finStampFile(stampFile);
+#endif
+  if (!finModFile || !finStampFile) {
+    // At least one of the files does not exist.  The modules differ.
+    return true;
+  }
+
+  /* Compilers which _do_ produce different mod content when the same
+   * source is compiled twice
+   *   -GNU
+   *   -Intel
+   *
+   * Eat the stream content until all recompile only related changes
+   * are left behind.
+   */
+  if (strcmp(compilerId, "GNU") == 0) {
+    // GNU Fortran 4.9 and later compress .mod files with gzip
+    // but also do not include a date so we can fall through to
+    // compare them without skipping any prefix.
+    unsigned char hdr[2];
+    bool okay = !finModFile.read(reinterpret_cast<char*>(hdr), 2).fail();
+    finModFile.seekg(0);
+    if (!okay || hdr[0] != 0x1f || hdr[1] != 0x8b) {
+      const char seq[1] = { '\n' };
+      const int seqlen = 1;
+
+      if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
+        // The module is of unexpected format.  Assume it is different.
+        std::cerr << compilerId << " fortran module " << modFile
+                  << " has unexpected format." << std::endl;
+        return true;
+      }
+
+      if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
+        // The stamp must differ if the sequence is not contained.
+        return true;
+      }
+    }
+  } else if (strcmp(compilerId, "Intel") == 0) {
+    const char seq[2] = { '\n', '\0' };
+    const int seqlen = 2;
+
+    // Skip the leading byte which appears to be a version number.
+    // We do not need to check for an error because the sequence search
+    // below will fail in that case.
+    finModFile.get();
+    finStampFile.get();
+
+    if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
+      // The module is of unexpected format.  Assume it is different.
+      std::cerr << compilerId << " fortran module " << modFile
+                << " has unexpected format." << std::endl;
+      return true;
+    }
+
+    if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
+      // The stamp must differ if the sequence is not contained.
+      return true;
+    }
+  }
+
+  // Compare the remaining content.  If no compiler id matched above,
+  // including the case none was given, this will compare the whole
+  // content.
+  return cmFortranStreamsDiffer(finModFile, finStampFile);
+}
+
+std::string cmDependsFortran::MaybeConvertToRelativePath(
+  std::string const& base, std::string const& path)
+{
+  if (!cmOutputConverter::ContainedInDirectory(
+        base, path, this->LocalGenerator->GetStateSnapshot().GetDirectory())) {
+    return path;
+  }
+  return cmOutputConverter::ForceToRelativePath(base, path);
+}
diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h
new file mode 100644
index 0000000..bee9804
--- /dev/null
+++ b/Source/cmDependsFortran.h
@@ -0,0 +1,86 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmFortran_h
+#define cmFortran_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "cmDepends.h"
+
+class cmDependsFortranInternals;
+class cmFortranSourceInfo;
+class cmLocalGenerator;
+
+/** \class cmDependsFortran
+ * \brief Dependency scanner for Fortran object files.
+ */
+class cmDependsFortran : public cmDepends
+{
+  CM_DISABLE_COPY(cmDependsFortran)
+
+public:
+  /** Checking instances need to know the build directory name and the
+      relative path from the build directory to the target file.  */
+  cmDependsFortran();
+
+  /** Scanning need to know the build directory name, the relative
+      path from the build directory to the target file, the source
+      file from which to start scanning, the include file search
+      path, and the target directory.  */
+  cmDependsFortran(cmLocalGenerator* lg);
+
+  /** Virtual destructor to cleanup subclasses properly.  */
+  ~cmDependsFortran() override;
+
+  /** Callback from build system after a .mod file has been generated
+      by a Fortran90 compiler to copy the .mod file to the
+      corresponding stamp file.  */
+  static bool CopyModule(const std::vector<std::string>& args);
+
+  /** Determine if a mod file and the corresponding mod.stamp file
+      are representing  different module information. */
+  static bool ModulesDiffer(const char* modFile, const char* stampFile,
+                            const char* compilerId);
+
+protected:
+  // Finalize the dependency information for the target.
+  bool Finalize(std::ostream& makeDepends,
+                std::ostream& internalDepends) override;
+
+  // Find all the modules required by the target.
+  void LocateModules();
+  void MatchLocalModules();
+  void MatchRemoteModules(std::istream& fin, const char* stampDir);
+  void ConsiderModule(const char* name, const char* stampDir);
+  bool FindModule(std::string const& name, std::string& module);
+
+  // Implement writing/checking methods required by superclass.
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& file, std::ostream& makeDepends,
+                         std::ostream& internalDepends) override;
+
+  // Actually write the dependencies to the streams.
+  bool WriteDependenciesReal(const char* obj, cmFortranSourceInfo const& info,
+                             std::string const& mod_dir, const char* stamp_dir,
+                             std::ostream& makeDepends,
+                             std::ostream& internalDepends);
+
+  // The source file from which to start scanning.
+  std::string SourceFile;
+
+  std::set<std::string> PPDefinitions;
+
+  // Internal implementation details.
+  cmDependsFortranInternals* Internal;
+
+private:
+  std::string MaybeConvertToRelativePath(std::string const& base,
+                                         std::string const& path);
+};
+
+#endif
diff --git a/Source/cmDependsJava.cxx b/Source/cmDependsJava.cxx
new file mode 100644
index 0000000..29938ba
--- /dev/null
+++ b/Source/cmDependsJava.cxx
@@ -0,0 +1,34 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDependsJava.h"
+
+#include "cmSystemTools.h"
+
+cmDependsJava::cmDependsJava()
+{
+}
+
+cmDependsJava::~cmDependsJava()
+{
+}
+
+bool cmDependsJava::WriteDependencies(const std::set<std::string>& sources,
+                                      const std::string& /*obj*/,
+                                      std::ostream& /*makeDepends*/,
+                                      std::ostream& /*internalDepends*/)
+{
+  // Make sure this is a scanning instance.
+  if (sources.empty() || sources.begin()->empty()) {
+    cmSystemTools::Error("Cannot scan dependencies without an source file.");
+    return false;
+  }
+
+  return true;
+}
+
+bool cmDependsJava::CheckDependencies(
+  std::istream& /*internalDepends*/, const char* /*internalDependsFileName*/,
+  std::map<std::string, DependencyVector>& /*validDeps*/)
+{
+  return true;
+}
diff --git a/Source/cmDependsJava.h b/Source/cmDependsJava.h
new file mode 100644
index 0000000..d070840
--- /dev/null
+++ b/Source/cmDependsJava.h
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDependsJava_h
+#define cmDependsJava_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmDepends.h"
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <string>
+
+/** \class cmDependsJava
+ * \brief Dependency scanner for Java class files.
+ */
+class cmDependsJava : public cmDepends
+{
+  CM_DISABLE_COPY(cmDependsJava)
+
+public:
+  /** Checking instances need to know the build directory name and the
+      relative path from the build directory to the target file.  */
+  cmDependsJava();
+
+  /** Virtual destructor to cleanup subclasses properly.  */
+  ~cmDependsJava() override;
+
+protected:
+  // Implement writing/checking methods required by superclass.
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& file, std::ostream& makeDepends,
+                         std::ostream& internalDepends) override;
+  bool CheckDependencies(
+    std::istream& internalDepends, const char* internalDependsFileName,
+    std::map<std::string, DependencyVector>& validDeps) override;
+};
+
+#endif
diff --git a/Source/cmDependsJavaParserHelper.cxx b/Source/cmDependsJavaParserHelper.cxx
new file mode 100644
index 0000000..f227cf2
--- /dev/null
+++ b/Source/cmDependsJavaParserHelper.cxx
@@ -0,0 +1,336 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDependsJavaParserHelper.h"
+
+#include "cmDependsJavaLexer.h"
+#include "cmSystemTools.h"
+
+#include "cmsys/FStream.hxx"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int cmDependsJava_yyparse(yyscan_t yyscanner);
+
+cmDependsJavaParserHelper::cmDependsJavaParserHelper()
+{
+  this->CurrentDepth = 0;
+
+  this->UnionsAvailable = 0;
+  this->LastClassId = 0;
+
+  CurrentClass tl;
+  tl.Name = "*";
+  this->ClassStack.push_back(tl);
+}
+
+cmDependsJavaParserHelper::~cmDependsJavaParserHelper()
+{
+  this->CleanupParser();
+}
+
+void cmDependsJavaParserHelper::CurrentClass::AddFileNamesForPrinting(
+  std::vector<std::string>* files, const char* prefix, const char* sep) const
+{
+  std::string rname;
+  if (prefix) {
+    rname += prefix;
+    rname += sep;
+  }
+  rname += this->Name;
+  files->push_back(rname);
+  for (CurrentClass const& nc : this->NestedClasses) {
+    nc.AddFileNamesForPrinting(files, rname.c_str(), sep);
+  }
+}
+
+void cmDependsJavaParserHelper::DeallocateParserType(char** pt)
+{
+  if (!pt) {
+    return;
+  }
+  if (!*pt) {
+    return;
+  }
+  *pt = nullptr;
+  this->UnionsAvailable--;
+}
+
+void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
+{
+  if (!sclass) {
+    return;
+  }
+  for (std::string const& cf : this->ClassesFound) {
+    if (cf == sclass) {
+      return;
+    }
+  }
+  this->ClassesFound.push_back(sclass);
+}
+
+void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
+{
+  for (std::string const& pi : this->PackagesImport) {
+    if (pi == sclass) {
+      return;
+    }
+  }
+  this->PackagesImport.push_back(sclass);
+}
+
+void cmDependsJavaParserHelper::SafePrintMissing(const char* str, int line,
+                                                 int cnt)
+{
+  if (str) {
+    std::cout << line << " String " << cnt << " exists: ";
+    unsigned int cc;
+    for (cc = 0; cc < strlen(str); cc++) {
+      unsigned char ch = str[cc];
+      if (ch >= 32 && ch <= 126) {
+        std::cout << static_cast<char>(ch);
+      } else {
+        std::cout << "<" << static_cast<int>(ch) << ">";
+        break;
+      }
+    }
+    std::cout << "- " << strlen(str) << std::endl;
+  }
+}
+void cmDependsJavaParserHelper::Print(const char* place, const char* str)
+{
+  if (this->Verbose) {
+    std::cout << "[" << place << "=" << str << "]" << std::endl;
+  }
+}
+
+void cmDependsJavaParserHelper::CombineUnions(char** out, const char* in1,
+                                              char** in2, const char* sep)
+{
+  size_t len = 1;
+  if (in1) {
+    len += strlen(in1);
+  }
+  if (*in2) {
+    len += strlen(*in2);
+  }
+  if (sep) {
+    len += strlen(sep);
+  }
+  *out = new char[len];
+  *out[0] = 0;
+  if (in1) {
+    strcat(*out, in1);
+  }
+  if (sep) {
+    strcat(*out, sep);
+  }
+  if (*in2) {
+    strcat(*out, *in2);
+  }
+  if (*in2) {
+    this->DeallocateParserType(in2);
+  }
+  this->UnionsAvailable++;
+}
+
+void cmDependsJavaParserHelper::CheckEmpty(
+  int line, int cnt, cmDependsJavaParserHelper::ParserType* pt)
+{
+  int cc;
+  int kk = -cnt + 1;
+  for (cc = 1; cc <= cnt; cc++) {
+    cmDependsJavaParserHelper::ParserType* cpt = pt + kk;
+    this->SafePrintMissing(cpt->str, line, cc);
+    kk++;
+  }
+}
+
+void cmDependsJavaParserHelper::PrepareElement(
+  cmDependsJavaParserHelper::ParserType* me)
+{
+  // Inititalize self
+  me->str = nullptr;
+}
+
+void cmDependsJavaParserHelper::AllocateParserType(
+  cmDependsJavaParserHelper::ParserType* pt, const char* str, int len)
+{
+  pt->str = nullptr;
+  if (len == 0) {
+    len = static_cast<int>(strlen(str));
+  }
+  if (len == 0) {
+    return;
+  }
+  this->UnionsAvailable++;
+  pt->str = new char[len + 1];
+  strncpy(pt->str, str, len);
+  pt->str[len] = 0;
+  this->Allocates.push_back(pt->str);
+}
+
+void cmDependsJavaParserHelper::StartClass(const char* cls)
+{
+  CurrentClass cl;
+  cl.Name = cls;
+  this->ClassStack.push_back(cl);
+
+  this->CurrentDepth++;
+}
+
+void cmDependsJavaParserHelper::EndClass()
+{
+  if (this->ClassStack.empty()) {
+    std::cerr << "Error when parsing. Current class is null" << std::endl;
+    abort();
+  }
+  if (this->ClassStack.size() <= 1) {
+    std::cerr << "Error when parsing. Parent class is null" << std::endl;
+    abort();
+  }
+  CurrentClass& current = this->ClassStack.back();
+  CurrentClass& parent = this->ClassStack[this->ClassStack.size() - 2];
+  this->CurrentDepth--;
+  parent.NestedClasses.push_back(current);
+  this->ClassStack.pop_back();
+}
+
+void cmDependsJavaParserHelper::PrintClasses()
+{
+  if (this->ClassStack.empty()) {
+    std::cerr << "Error when parsing. No classes on class stack" << std::endl;
+    abort();
+  }
+  for (std::string const& f : this->GetFilesProduced()) {
+    std::cout << "  " << f << ".class" << std::endl;
+  }
+}
+
+std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
+{
+  std::vector<std::string> files;
+  CurrentClass const& toplevel = this->ClassStack.front();
+  for (CurrentClass const& nc : toplevel.NestedClasses) {
+    nc.AddFileNamesForPrinting(&files, nullptr, "$");
+  }
+  return files;
+}
+
+int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
+{
+  if (!str) {
+    return 0;
+  }
+  this->Verbose = verb;
+  this->InputBuffer = str;
+  this->InputBufferPos = 0;
+  this->CurrentLine = 0;
+
+  yyscan_t yyscanner;
+  cmDependsJava_yylex_init(&yyscanner);
+  cmDependsJava_yyset_extra(this, yyscanner);
+  int res = cmDependsJava_yyparse(yyscanner);
+  cmDependsJava_yylex_destroy(yyscanner);
+  if (res != 0) {
+    std::cout << "JP_Parse returned: " << res << std::endl;
+    return 0;
+  }
+
+  if (verb) {
+    if (!this->CurrentPackage.empty()) {
+      std::cout << "Current package is: " << this->CurrentPackage << std::endl;
+    }
+    std::cout << "Imports packages:";
+    if (!this->PackagesImport.empty()) {
+      std::vector<std::string>::iterator it;
+      for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
+           ++it) {
+        std::cout << " " << *it;
+      }
+    }
+    std::cout << std::endl;
+    std::cout << "Depends on:";
+    if (!this->ClassesFound.empty()) {
+      for (std::string const& cf : this->ClassesFound) {
+        std::cout << " " << cf;
+      }
+    }
+    std::cout << std::endl;
+    std::cout << "Generated files:" << std::endl;
+    this->PrintClasses();
+    if (this->UnionsAvailable != 0) {
+      std::cout << "There are still " << this->UnionsAvailable
+                << " unions available" << std::endl;
+    }
+  }
+  this->CleanupParser();
+  return 1;
+}
+
+void cmDependsJavaParserHelper::CleanupParser()
+{
+  for (char* allocate : this->Allocates) {
+    delete[] allocate;
+  }
+  this->Allocates.erase(this->Allocates.begin(), this->Allocates.end());
+}
+
+int cmDependsJavaParserHelper::LexInput(char* buf, int maxlen)
+{
+  if (maxlen < 1) {
+    return 0;
+  }
+  if (this->InputBufferPos < this->InputBuffer.size()) {
+    buf[0] = this->InputBuffer[this->InputBufferPos++];
+    if (buf[0] == '\n') {
+      this->CurrentLine++;
+    }
+    return 1;
+  }
+  buf[0] = '\n';
+  return 0;
+}
+void cmDependsJavaParserHelper::Error(const char* str)
+{
+  unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
+  fprintf(stderr, "JPError: %s (%lu / Line: %d)\n", str, pos,
+          this->CurrentLine);
+  int cc;
+  std::cerr << "String: [";
+  for (cc = 0;
+       cc < 30 && *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
+       cc++) {
+    std::cerr << *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
+  }
+  std::cerr << "]" << std::endl;
+}
+
+void cmDependsJavaParserHelper::UpdateCombine(const char* str1,
+                                              const char* str2)
+{
+  if (this->CurrentCombine.empty() && str1 != nullptr) {
+    this->CurrentCombine = str1;
+  }
+  this->CurrentCombine += ".";
+  this->CurrentCombine += str2;
+}
+
+int cmDependsJavaParserHelper::ParseFile(const char* file)
+{
+  if (!cmSystemTools::FileExists(file)) {
+    return 0;
+  }
+  cmsys::ifstream ifs(file);
+  if (!ifs) {
+    return 0;
+  }
+
+  std::string fullfile;
+  std::string line;
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
+    fullfile += line + "\n";
+  }
+  return this->ParseString(fullfile.c_str(), 0);
+}
diff --git a/Source/cmDependsJavaParserHelper.h b/Source/cmDependsJavaParserHelper.h
new file mode 100644
index 0000000..0b445d9
--- /dev/null
+++ b/Source/cmDependsJavaParserHelper.h
@@ -0,0 +1,96 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDependsJavaParserHelper_h
+#define cmDependsJavaParserHelper_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+/** \class cmDependsJavaParserHelper
+ * \brief Helper class for parsing java source files
+ *
+ * Finds dependencies for java file and list of outputs
+ */
+class cmDependsJavaParserHelper
+{
+public:
+  struct ParserType
+  {
+    char* str;
+  };
+
+  cmDependsJavaParserHelper();
+  ~cmDependsJavaParserHelper();
+
+  int ParseString(const char* str, int verb);
+  int ParseFile(const char* file);
+
+  // For the lexer:
+  void AllocateParserType(cmDependsJavaParserHelper::ParserType* pt,
+                          const char* str, int len = 0);
+
+  int LexInput(char* buf, int maxlen);
+  void Error(const char* str);
+
+  // For yacc
+  void AddClassFound(const char* sclass);
+  void PrepareElement(ParserType* me);
+  void DeallocateParserType(char** pt);
+  void CheckEmpty(int line, int cnt, ParserType* pt);
+  void StartClass(const char* cls);
+  void EndClass();
+  void AddPackagesImport(const char* sclass);
+  void SetCurrentPackage(const char* pkg) { this->CurrentPackage = pkg; }
+  const char* GetCurrentPackage() { return this->CurrentPackage.c_str(); }
+  void SetCurrentCombine(const char* cmb) { this->CurrentCombine = cmb; }
+  const char* GetCurrentCombine() { return this->CurrentCombine.c_str(); }
+  void UpdateCombine(const char* str1, const char* str2);
+
+  std::vector<std::string>& GetClassesFound() { return this->ClassesFound; }
+
+  std::vector<std::string> GetFilesProduced();
+
+private:
+  class CurrentClass
+  {
+  public:
+    std::string Name;
+    std::vector<CurrentClass> NestedClasses;
+    void AddFileNamesForPrinting(std::vector<std::string>* files,
+                                 const char* prefix, const char* sep) const;
+  };
+  std::string CurrentPackage;
+  std::string::size_type InputBufferPos;
+  std::string InputBuffer;
+  std::vector<char> OutputBuffer;
+  std::vector<std::string> ClassesFound;
+  std::vector<std::string> PackagesImport;
+  std::string CurrentCombine;
+
+  std::vector<CurrentClass> ClassStack;
+
+  int CurrentLine;
+  int UnionsAvailable;
+  int LastClassId;
+  int CurrentDepth;
+  int Verbose;
+
+  std::vector<char*> Allocates;
+
+  void PrintClasses();
+
+  void Print(const char* place, const char* str);
+  void CombineUnions(char** out, const char* in1, char** in2, const char* sep);
+  void SafePrintMissing(const char* str, int line, int cnt);
+
+  void CleanupParser();
+};
+
+#define YYSTYPE cmDependsJavaParserHelper::ParserType
+#define YYSTYPE_IS_DECLARED
+#define YY_EXTRA_TYPE cmDependsJavaParserHelper*
+#define YY_DECL int cmDependsJava_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
+
+#endif
diff --git a/Source/cmDisallowedCommand.cxx b/Source/cmDisallowedCommand.cxx
new file mode 100644
index 0000000..ce1965d
--- /dev/null
+++ b/Source/cmDisallowedCommand.cxx
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDisallowedCommand.h"
+
+#include "cmMakefile.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+bool cmDisallowedCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus& status)
+{
+  switch (this->Makefile->GetPolicyStatus(this->Policy)) {
+    case cmPolicies::WARN:
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
+                                   cmPolicies::GetPolicyWarning(this->Policy));
+      break;
+    case cmPolicies::OLD:
+      break;
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::REQUIRED_ALWAYS:
+    case cmPolicies::NEW:
+      this->Makefile->IssueMessage(cmake::FATAL_ERROR, this->Message);
+      return true;
+  }
+
+  this->Command->SetMakefile(this->GetMakefile());
+  bool const ret = this->Command->InitialPass(args, status);
+  this->SetError(this->Command->GetError());
+  return ret;
+}
diff --git a/Source/cmDisallowedCommand.h b/Source/cmDisallowedCommand.h
new file mode 100644
index 0000000..d85c00f
--- /dev/null
+++ b/Source/cmDisallowedCommand.h
@@ -0,0 +1,48 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDisallowedCommand_h
+#define cmDisallowedCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+#include "cmPolicies.h"
+
+class cmExecutionStatus;
+
+class cmDisallowedCommand : public cmCommand
+{
+public:
+  cmDisallowedCommand(cmCommand* command, cmPolicies::PolicyID policy,
+                      const char* message)
+    : Command(command)
+    , Policy(policy)
+    , Message(message)
+  {
+  }
+
+  ~cmDisallowedCommand() override { delete this->Command; }
+
+  cmCommand* Clone() override
+  {
+    return new cmDisallowedCommand(this->Command->Clone(), this->Policy,
+                                   this->Message);
+  }
+
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  void FinalPass() override { this->Command->FinalPass(); }
+
+  bool HasFinalPass() const override { return this->Command->HasFinalPass(); }
+
+private:
+  cmCommand* Command;
+  cmPolicies::PolicyID Policy;
+  const char* Message;
+};
+
+#endif
diff --git a/Source/cmDocumentation.cxx b/Source/cmDocumentation.cxx
new file mode 100644
index 0000000..0c96860
--- /dev/null
+++ b/Source/cmDocumentation.cxx
@@ -0,0 +1,745 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDocumentation.h"
+
+#include "cmAlgorithms.h"
+#include "cmDocumentationEntry.h"
+#include "cmDocumentationSection.h"
+#include "cmRST.h"
+#include "cmSystemTools.h"
+#include "cmVersion.h"
+
+#include "cmsys/FStream.hxx"
+#include "cmsys/Glob.hxx"
+#include <algorithm>
+#include <ctype.h>
+#include <string.h>
+#include <utility>
+
+static const char* cmDocumentationStandardOptions[][2] = {
+  { "--help,-help,-usage,-h,-H,/?", "Print usage information and exit." },
+  { "--version,-version,/V [<f>]", "Print version number and exit." },
+  { "--help-full [<f>]", "Print all help manuals and exit." },
+  { "--help-manual <man> [<f>]", "Print one help manual and exit." },
+  { "--help-manual-list [<f>]", "List help manuals available and exit." },
+  { "--help-command <cmd> [<f>]", "Print help for one command and exit." },
+  { "--help-command-list [<f>]",
+    "List commands with help available and exit." },
+  { "--help-commands [<f>]", "Print cmake-commands manual and exit." },
+  { "--help-module <mod> [<f>]", "Print help for one module and exit." },
+  { "--help-module-list [<f>]", "List modules with help available and exit." },
+  { "--help-modules [<f>]", "Print cmake-modules manual and exit." },
+  { "--help-policy <cmp> [<f>]", "Print help for one policy and exit." },
+  { "--help-policy-list [<f>]",
+    "List policies with help available and exit." },
+  { "--help-policies [<f>]", "Print cmake-policies manual and exit." },
+  { "--help-property <prop> [<f>]", "Print help for one property and exit." },
+  { "--help-property-list [<f>]",
+    "List properties with help available and exit." },
+  { "--help-properties [<f>]", "Print cmake-properties manual and exit." },
+  { "--help-variable var [<f>]", "Print help for one variable and exit." },
+  { "--help-variable-list [<f>]",
+    "List variables with help available and exit." },
+  { "--help-variables [<f>]", "Print cmake-variables manual and exit." },
+  { nullptr, nullptr }
+};
+
+static const char* cmDocumentationGeneratorsHeader[][2] = {
+  { nullptr, "The following generators are available on this platform:" },
+  { nullptr, nullptr }
+};
+
+cmDocumentation::cmDocumentation()
+{
+  this->addCommonStandardDocSections();
+  this->ShowGenerators = true;
+}
+
+cmDocumentation::~cmDocumentation()
+{
+  cmDeleteAll(this->AllSections);
+}
+
+bool cmDocumentation::PrintVersion(std::ostream& os)
+{
+  /* clang-format off */
+  os <<
+    this->GetNameString() <<
+    " version " << cmVersion::GetCMakeVersion() << "\n"
+    "\n"
+    "CMake suite maintained and supported by Kitware (kitware.com/cmake).\n"
+    ;
+  /* clang-format on */
+  return true;
+}
+
+bool cmDocumentation::PrintDocumentation(Type ht, std::ostream& os)
+{
+  switch (ht) {
+    case cmDocumentation::Usage:
+      return this->PrintUsage(os);
+    case cmDocumentation::Help:
+      return this->PrintHelp(os);
+    case cmDocumentation::Full:
+      return this->PrintHelpFull(os);
+    case cmDocumentation::OneManual:
+      return this->PrintHelpOneManual(os);
+    case cmDocumentation::OneCommand:
+      return this->PrintHelpOneCommand(os);
+    case cmDocumentation::OneModule:
+      return this->PrintHelpOneModule(os);
+    case cmDocumentation::OnePolicy:
+      return this->PrintHelpOnePolicy(os);
+    case cmDocumentation::OneProperty:
+      return this->PrintHelpOneProperty(os);
+    case cmDocumentation::OneVariable:
+      return this->PrintHelpOneVariable(os);
+    case cmDocumentation::ListManuals:
+      return this->PrintHelpListManuals(os);
+    case cmDocumentation::ListCommands:
+      return this->PrintHelpListCommands(os);
+    case cmDocumentation::ListModules:
+      return this->PrintHelpListModules(os);
+    case cmDocumentation::ListProperties:
+      return this->PrintHelpListProperties(os);
+    case cmDocumentation::ListVariables:
+      return this->PrintHelpListVariables(os);
+    case cmDocumentation::ListPolicies:
+      return this->PrintHelpListPolicies(os);
+    case cmDocumentation::ListGenerators:
+      return this->PrintHelpListGenerators(os);
+    case cmDocumentation::Version:
+      return this->PrintVersion(os);
+    case cmDocumentation::OldCustomModules:
+      return this->PrintOldCustomModules(os);
+    default:
+      return false;
+  }
+}
+
+bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os)
+{
+  int count = 0;
+  bool result = true;
+
+  // Loop over requested documentation types.
+  for (RequestedHelpItem const& rhi : this->RequestedHelpItems) {
+    this->CurrentArgument = rhi.Argument;
+    // If a file name was given, use it.  Otherwise, default to the
+    // given stream.
+    cmsys::ofstream fout;
+    std::ostream* s = &os;
+    if (!rhi.Filename.empty()) {
+      fout.open(rhi.Filename.c_str());
+      s = &fout;
+    } else if (++count > 1) {
+      os << "\n\n";
+    }
+
+    // Print this documentation type to the stream.
+    if (!this->PrintDocumentation(rhi.HelpType, *s) || s->fail()) {
+      result = false;
+    }
+  }
+  return result;
+}
+
+#define GET_OPT_ARGUMENT(target)                                              \
+  if ((i + 1 < argc) && !this->IsOption(argv[i + 1])) {                       \
+    (target) = argv[i + 1];                                                   \
+    i = i + 1;                                                                \
+  };
+
+void cmDocumentation::WarnFormFromFilename(
+  cmDocumentation::RequestedHelpItem& request, bool& result)
+{
+  std::string ext = cmSystemTools::GetFilenameLastExtension(request.Filename);
+  ext = cmSystemTools::UpperCase(ext);
+  if ((ext == ".HTM") || (ext == ".HTML")) {
+    request.HelpType = cmDocumentation::None;
+    result = true;
+    cmSystemTools::Message("Warning: HTML help format no longer supported");
+  } else if (ext == ".DOCBOOK") {
+    request.HelpType = cmDocumentation::None;
+    result = true;
+    cmSystemTools::Message("Warning: Docbook help format no longer supported");
+  }
+  // ".1" to ".9" should be manpages
+  else if ((ext.length() == 2) && (ext[1] >= '1') && (ext[1] <= '9')) {
+    request.HelpType = cmDocumentation::None;
+    result = true;
+    cmSystemTools::Message("Warning: Man help format no longer supported");
+  }
+}
+
+void cmDocumentation::addCommonStandardDocSections()
+{
+  cmDocumentationSection* sec;
+
+  sec = new cmDocumentationSection("Options", "OPTIONS");
+  sec->Append(cmDocumentationStandardOptions);
+  this->AllSections["Options"] = sec;
+}
+
+void cmDocumentation::addCMakeStandardDocSections()
+{
+  cmDocumentationSection* sec;
+
+  sec = new cmDocumentationSection("Generators", "GENERATORS");
+  sec->Append(cmDocumentationGeneratorsHeader);
+  this->AllSections["Generators"] = sec;
+}
+
+void cmDocumentation::addCTestStandardDocSections()
+{
+  // This is currently done for backward compatibility reason
+  // We may suppress some of these.
+  addCMakeStandardDocSections();
+}
+
+void cmDocumentation::addCPackStandardDocSections()
+{
+  cmDocumentationSection* sec;
+
+  sec = new cmDocumentationSection("Generators", "GENERATORS");
+  sec->Append(cmDocumentationGeneratorsHeader);
+  this->AllSections["Generators"] = sec;
+}
+
+bool cmDocumentation::CheckOptions(int argc, const char* const* argv,
+                                   const char* exitOpt)
+{
+  // Providing zero arguments gives usage information.
+  if (argc == 1) {
+    RequestedHelpItem help;
+    help.HelpType = cmDocumentation::Usage;
+    this->RequestedHelpItems.push_back(help);
+    return true;
+  }
+
+  // Search for supported help options.
+
+  bool result = false;
+  for (int i = 1; i < argc; ++i) {
+    if (exitOpt && strcmp(argv[i], exitOpt) == 0) {
+      return result;
+    }
+    RequestedHelpItem help;
+    // Check if this is a supported help option.
+    if ((strcmp(argv[i], "-help") == 0) || (strcmp(argv[i], "--help") == 0) ||
+        (strcmp(argv[i], "/?") == 0) || (strcmp(argv[i], "-usage") == 0) ||
+        (strcmp(argv[i], "-h") == 0) || (strcmp(argv[i], "-H") == 0)) {
+      help.HelpType = cmDocumentation::Help;
+      GET_OPT_ARGUMENT(help.Argument);
+      help.Argument = cmSystemTools::LowerCase(help.Argument);
+      // special case for single command
+      if (!help.Argument.empty()) {
+        help.HelpType = cmDocumentation::OneCommand;
+      }
+    } else if (strcmp(argv[i], "--help-properties") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      help.Argument = "cmake-properties.7";
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-policies") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      help.Argument = "cmake-policies.7";
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-variables") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      help.Argument = "cmake-variables.7";
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-modules") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      help.Argument = "cmake-modules.7";
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-custom-modules") == 0) {
+      GET_OPT_ARGUMENT(help.Filename);
+      cmSystemTools::Message(
+        "Warning: --help-custom-modules no longer supported");
+      if (help.Filename.empty()) {
+        return true;
+      }
+      // Avoid breaking old project builds completely by at least generating
+      // the output file.  Abuse help.Argument to give the file name to
+      // PrintOldCustomModules without disrupting our internal API.
+      help.HelpType = cmDocumentation::OldCustomModules;
+      help.Argument = cmSystemTools::GetFilenameName(help.Filename);
+    } else if (strcmp(argv[i], "--help-commands") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      help.Argument = "cmake-commands.7";
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-compatcommands") == 0) {
+      GET_OPT_ARGUMENT(help.Filename);
+      cmSystemTools::Message(
+        "Warning: --help-compatcommands no longer supported");
+      return true;
+    } else if (strcmp(argv[i], "--help-full") == 0) {
+      help.HelpType = cmDocumentation::Full;
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-html") == 0) {
+      GET_OPT_ARGUMENT(help.Filename);
+      cmSystemTools::Message("Warning: --help-html no longer supported");
+      return true;
+    } else if (strcmp(argv[i], "--help-man") == 0) {
+      GET_OPT_ARGUMENT(help.Filename);
+      cmSystemTools::Message("Warning: --help-man no longer supported");
+      return true;
+    } else if (strcmp(argv[i], "--help-command") == 0) {
+      help.HelpType = cmDocumentation::OneCommand;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      help.Argument = cmSystemTools::LowerCase(help.Argument);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-module") == 0) {
+      help.HelpType = cmDocumentation::OneModule;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-property") == 0) {
+      help.HelpType = cmDocumentation::OneProperty;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-policy") == 0) {
+      help.HelpType = cmDocumentation::OnePolicy;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-variable") == 0) {
+      help.HelpType = cmDocumentation::OneVariable;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-manual") == 0) {
+      help.HelpType = cmDocumentation::OneManual;
+      GET_OPT_ARGUMENT(help.Argument);
+      GET_OPT_ARGUMENT(help.Filename);
+      this->WarnFormFromFilename(help, result);
+    } else if (strcmp(argv[i], "--help-command-list") == 0) {
+      help.HelpType = cmDocumentation::ListCommands;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--help-module-list") == 0) {
+      help.HelpType = cmDocumentation::ListModules;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--help-property-list") == 0) {
+      help.HelpType = cmDocumentation::ListProperties;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--help-variable-list") == 0) {
+      help.HelpType = cmDocumentation::ListVariables;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--help-policy-list") == 0) {
+      help.HelpType = cmDocumentation::ListPolicies;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--help-manual-list") == 0) {
+      help.HelpType = cmDocumentation::ListManuals;
+      GET_OPT_ARGUMENT(help.Filename);
+    } else if (strcmp(argv[i], "--copyright") == 0) {
+      GET_OPT_ARGUMENT(help.Filename);
+      cmSystemTools::Message("Warning: --copyright no longer supported");
+      return true;
+    } else if ((strcmp(argv[i], "--version") == 0) ||
+               (strcmp(argv[i], "-version") == 0) ||
+               (strcmp(argv[i], "/V") == 0)) {
+      help.HelpType = cmDocumentation::Version;
+      GET_OPT_ARGUMENT(help.Filename);
+    }
+    if (help.HelpType != None) {
+      // This is a help option.  See if there is a file name given.
+      result = true;
+      this->RequestedHelpItems.push_back(help);
+    }
+  }
+  return result;
+}
+
+void cmDocumentation::SetName(const std::string& name)
+{
+  this->NameString = name;
+}
+
+void cmDocumentation::SetSection(const char* name,
+                                 cmDocumentationSection* section)
+{
+  if (this->AllSections.find(name) != this->AllSections.end()) {
+    delete this->AllSections[name];
+  }
+  this->AllSections[name] = section;
+}
+
+void cmDocumentation::SetSection(const char* name,
+                                 std::vector<cmDocumentationEntry>& docs)
+{
+  cmDocumentationSection* sec =
+    new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+  sec->Append(docs);
+  this->SetSection(name, sec);
+}
+
+void cmDocumentation::SetSection(const char* name, const char* docs[][2])
+{
+  cmDocumentationSection* sec =
+    new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+  sec->Append(docs);
+  this->SetSection(name, sec);
+}
+
+void cmDocumentation::SetSections(
+  std::map<std::string, cmDocumentationSection*>& sections)
+{
+  for (auto const& s : sections) {
+    this->SetSection(s.first.c_str(), s.second);
+  }
+}
+
+void cmDocumentation::PrependSection(const char* name, const char* docs[][2])
+{
+  cmDocumentationSection* sec = nullptr;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
+    sec = this->AllSections[name];
+  }
+  sec->Prepend(docs);
+}
+
+void cmDocumentation::PrependSection(const char* name,
+                                     std::vector<cmDocumentationEntry>& docs)
+{
+  cmDocumentationSection* sec = nullptr;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
+    sec = this->AllSections[name];
+  }
+  sec->Prepend(docs);
+}
+
+void cmDocumentation::AppendSection(const char* name, const char* docs[][2])
+{
+  cmDocumentationSection* sec = nullptr;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
+    sec = this->AllSections[name];
+  }
+  sec->Append(docs);
+}
+
+void cmDocumentation::AppendSection(const char* name,
+                                    std::vector<cmDocumentationEntry>& docs)
+{
+  cmDocumentationSection* sec = nullptr;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
+    sec = this->AllSections[name];
+  }
+  sec->Append(docs);
+}
+
+void cmDocumentation::AppendSection(const char* name,
+                                    cmDocumentationEntry& docs)
+{
+
+  std::vector<cmDocumentationEntry> docsVec;
+  docsVec.push_back(docs);
+  this->AppendSection(name, docsVec);
+}
+
+void cmDocumentation::PrependSection(const char* name,
+                                     cmDocumentationEntry& docs)
+{
+
+  std::vector<cmDocumentationEntry> docsVec;
+  docsVec.push_back(docs);
+  this->PrependSection(name, docsVec);
+}
+
+void cmDocumentation::GlobHelp(std::vector<std::string>& files,
+                               std::string const& pattern)
+{
+  cmsys::Glob gl;
+  std::string findExpr =
+    cmSystemTools::GetCMakeRoot() + "/Help/" + pattern + ".rst";
+  if (gl.FindFiles(findExpr)) {
+    files = gl.GetFiles();
+  }
+}
+
+void cmDocumentation::PrintNames(std::ostream& os, std::string const& pattern)
+{
+  std::vector<std::string> files;
+  this->GlobHelp(files, pattern);
+  std::vector<std::string> names;
+  for (std::string const& f : files) {
+    std::string line;
+    cmsys::ifstream fin(f.c_str());
+    while (fin && cmSystemTools::GetLineFromStream(fin, line)) {
+      if (!line.empty() && (isalnum(line[0]) || line[0] == '<')) {
+        names.push_back(line);
+        break;
+      }
+    }
+  }
+  std::sort(names.begin(), names.end());
+  for (std::string const& n : names) {
+    os << n << "\n";
+  }
+}
+
+bool cmDocumentation::PrintFiles(std::ostream& os, std::string const& pattern)
+{
+  bool found = false;
+  std::vector<std::string> files;
+  this->GlobHelp(files, pattern);
+  std::sort(files.begin(), files.end());
+  cmRST r(os, cmSystemTools::GetCMakeRoot() + "/Help");
+  for (std::string const& f : files) {
+    found = r.ProcessFile(f) || found;
+  }
+  return found;
+}
+
+bool cmDocumentation::PrintHelpFull(std::ostream& os)
+{
+  return this->PrintFiles(os, "index");
+}
+
+bool cmDocumentation::PrintHelpOneManual(std::ostream& os)
+{
+  std::string mname = this->CurrentArgument;
+  std::string::size_type mlen = mname.length();
+  if (mlen > 3 && mname[mlen - 3] == '(' && mname[mlen - 1] == ')') {
+    mname = mname.substr(0, mlen - 3) + "." + mname[mlen - 2];
+  }
+  if (this->PrintFiles(os, "manual/" + mname) ||
+      this->PrintFiles(os, "manual/" + mname + ".[0-9]")) {
+    return true;
+  }
+  // Argument was not a manual.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-manual is not an available manual.  "
+     << "Use --help-manual-list to see all available manuals.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListManuals(std::ostream& os)
+{
+  this->PrintNames(os, "manual/*");
+  return true;
+}
+
+bool cmDocumentation::PrintHelpOneCommand(std::ostream& os)
+{
+  std::string cname = cmSystemTools::LowerCase(this->CurrentArgument);
+  if (this->PrintFiles(os, "command/" + cname)) {
+    return true;
+  }
+  // Argument was not a command.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-command is not a CMake command.  "
+     << "Use --help-command-list to see all commands.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListCommands(std::ostream& os)
+{
+  this->PrintNames(os, "command/*");
+  return true;
+}
+
+bool cmDocumentation::PrintHelpOneModule(std::ostream& os)
+{
+  std::string mname = this->CurrentArgument;
+  if (this->PrintFiles(os, "module/" + mname)) {
+    return true;
+  }
+  // Argument was not a module.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-module is not a CMake module.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListModules(std::ostream& os)
+{
+  std::vector<std::string> files;
+  this->GlobHelp(files, "module/*");
+  std::vector<std::string> modules;
+  for (std::string const& f : files) {
+    std::string module = cmSystemTools::GetFilenameName(f);
+    modules.push_back(module.substr(0, module.size() - 4));
+  }
+  std::sort(modules.begin(), modules.end());
+  for (std::string const& m : modules) {
+    os << m << "\n";
+  }
+  return true;
+}
+
+bool cmDocumentation::PrintHelpOneProperty(std::ostream& os)
+{
+  std::string pname = cmSystemTools::HelpFileName(this->CurrentArgument);
+  if (this->PrintFiles(os, "prop_*/" + pname)) {
+    return true;
+  }
+  // Argument was not a property.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-property is not a CMake property.  "
+     << "Use --help-property-list to see all properties.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListProperties(std::ostream& os)
+{
+  this->PrintNames(os, "prop_*/*");
+  return true;
+}
+
+bool cmDocumentation::PrintHelpOnePolicy(std::ostream& os)
+{
+  std::string pname = this->CurrentArgument;
+  std::vector<std::string> files;
+  if (this->PrintFiles(os, "policy/" + pname)) {
+    return true;
+  }
+
+  // Argument was not a policy.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-policy is not a CMake policy.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListPolicies(std::ostream& os)
+{
+  this->PrintNames(os, "policy/*");
+  return true;
+}
+
+bool cmDocumentation::PrintHelpListGenerators(std::ostream& os)
+{
+  std::map<std::string, cmDocumentationSection*>::iterator si;
+  si = this->AllSections.find("Generators");
+  if (si != this->AllSections.end()) {
+    this->Formatter.SetIndent("  ");
+    this->Formatter.PrintSection(os, *si->second);
+  }
+  return true;
+}
+
+bool cmDocumentation::PrintHelpOneVariable(std::ostream& os)
+{
+  std::string vname = cmSystemTools::HelpFileName(this->CurrentArgument);
+  if (this->PrintFiles(os, "variable/" + vname)) {
+    return true;
+  }
+  // Argument was not a variable.  Complain.
+  os << "Argument \"" << this->CurrentArgument
+     << "\" to --help-variable is not a defined variable.  "
+     << "Use --help-variable-list to see all defined variables.\n";
+  return false;
+}
+
+bool cmDocumentation::PrintHelpListVariables(std::ostream& os)
+{
+  this->PrintNames(os, "variable/*");
+  return true;
+}
+
+bool cmDocumentation::PrintUsage(std::ostream& os)
+{
+  std::map<std::string, cmDocumentationSection*>::iterator si;
+  si = this->AllSections.find("Usage");
+  if (si != this->AllSections.end()) {
+    this->Formatter.PrintSection(os, *si->second);
+  }
+  return true;
+}
+
+bool cmDocumentation::PrintHelp(std::ostream& os)
+{
+  std::map<std::string, cmDocumentationSection*>::iterator si;
+  si = this->AllSections.find("Usage");
+  if (si != this->AllSections.end()) {
+    this->Formatter.PrintSection(os, *si->second);
+  }
+  si = this->AllSections.find("Options");
+  if (si != this->AllSections.end()) {
+    this->Formatter.PrintSection(os, *si->second);
+  }
+  if (this->ShowGenerators) {
+    si = this->AllSections.find("Generators");
+    if (si != this->AllSections.end()) {
+      this->Formatter.PrintSection(os, *si->second);
+    }
+  }
+  return true;
+}
+
+const char* cmDocumentation::GetNameString() const
+{
+  if (!this->NameString.empty()) {
+    return this->NameString.c_str();
+  }
+  return "CMake";
+}
+
+bool cmDocumentation::IsOption(const char* arg) const
+{
+  return ((arg[0] == '-') || (strcmp(arg, "/V") == 0) ||
+          (strcmp(arg, "/?") == 0));
+}
+
+bool cmDocumentation::PrintOldCustomModules(std::ostream& os)
+{
+  // CheckOptions abuses the Argument field to give us the file name.
+  std::string filename = this->CurrentArgument;
+  std::string ext = cmSystemTools::UpperCase(
+    cmSystemTools::GetFilenameLastExtension(filename));
+  std::string name = cmSystemTools::GetFilenameWithoutLastExtension(filename);
+
+  const char* summary = "cmake --help-custom-modules no longer supported\n";
+  const char* detail =
+    "CMake versions prior to 3.0 exposed their internal module help page\n"
+    "generation functionality through the --help-custom-modules option.\n"
+    "CMake versions 3.0 and above use other means to generate their module\n"
+    "help pages so this functionality is no longer available to be exposed.\n"
+    "\n"
+    "This file was generated as a placeholder to provide this information.\n";
+  if ((ext == ".HTM") || (ext == ".HTML")) {
+    os << "<html><title>" << name << "</title><body>\n"
+       << summary << "<p/>\n"
+       << detail << "</body></html>\n";
+  } else if ((ext.length() == 2) && (ext[1] >= '1') && (ext[1] <= '9')) {
+    /* clang-format off */
+    os <<
+      ".TH " << name << " " << ext[1] << " \"" <<
+      cmSystemTools::GetCurrentDateTime("%B %d, %Y") <<
+      "\" \"cmake " << cmVersion::GetCMakeVersion() << "\"\n"
+      ".SH NAME\n"
+      ".PP\n" <<
+      name << " \\- " << summary <<
+      "\n"
+      ".SH DESCRIPTION\n"
+      ".PP\n" <<
+      detail
+      ;
+    /* clang-format on */
+  } else {
+    os << name << "\n\n" << summary << "\n" << detail;
+  }
+  return true;
+}
diff --git a/Source/cmDocumentation.h b/Source/cmDocumentation.h
new file mode 100644
index 0000000..c80bed1
--- /dev/null
+++ b/Source/cmDocumentation.h
@@ -0,0 +1,134 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef _cmDocumentation_h
+#define _cmDocumentation_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmDocumentationFormatter.h"
+
+#include <iosfwd>
+#include <map>
+#include <string>
+#include <vector>
+
+class cmDocumentationSection;
+struct cmDocumentationEntry;
+
+/** Class to generate documentation.  */
+class cmDocumentation : public cmDocumentationEnums
+{
+public:
+  cmDocumentation();
+
+  ~cmDocumentation();
+
+  /**
+   * Check command line arguments for documentation options.  Returns
+   * true if documentation options are found, and false otherwise.
+   * When true is returned, PrintRequestedDocumentation should be
+   * called.  exitOpt can be used for things like cmake -E, so that
+   * all arguments after the -E are ignored and not searched for
+   * help arguments.
+   */
+  bool CheckOptions(int argc, const char* const* argv,
+                    const char* exitOpt = nullptr);
+
+  /**
+   * Print help requested on the command line.  Call after
+   * CheckOptions returns true.  Returns true on success, and false
+   * otherwise.  Failure can occur when output files specified on the
+   * command line cannot be written.
+   */
+  bool PrintRequestedDocumentation(std::ostream& os);
+
+  /** Print help of the given type.  */
+  bool PrintDocumentation(Type ht, std::ostream& os);
+
+  void SetShowGenerators(bool showGen) { this->ShowGenerators = showGen; }
+
+  /** Set the program name for standard document generation.  */
+  void SetName(const std::string& name);
+
+  /** Set a section of the documentation. Typical sections include Name,
+      Usage, Description, Options */
+  void SetSection(const char* sectionName, cmDocumentationSection* section);
+  void SetSection(const char* sectionName,
+                  std::vector<cmDocumentationEntry>& docs);
+  void SetSection(const char* sectionName, const char* docs[][2]);
+  void SetSections(std::map<std::string, cmDocumentationSection*>& sections);
+
+  /** Add the documentation to the beginning/end of the section */
+  void PrependSection(const char* sectionName, const char* docs[][2]);
+  void PrependSection(const char* sectionName,
+                      std::vector<cmDocumentationEntry>& docs);
+  void PrependSection(const char* sectionName, cmDocumentationEntry& docs);
+  void AppendSection(const char* sectionName, const char* docs[][2]);
+  void AppendSection(const char* sectionName,
+                     std::vector<cmDocumentationEntry>& docs);
+  void AppendSection(const char* sectionName, cmDocumentationEntry& docs);
+
+  /** Add common (to all tools) documentation section(s) */
+  void addCommonStandardDocSections();
+
+  /** Add the CMake standard documentation section(s) */
+  void addCMakeStandardDocSections();
+
+  /** Add the CTest standard documentation section(s) */
+  void addCTestStandardDocSections();
+
+  /** Add the CPack standard documentation section(s) */
+  void addCPackStandardDocSections();
+
+private:
+  void GlobHelp(std::vector<std::string>& files, std::string const& pattern);
+  void PrintNames(std::ostream& os, std::string const& pattern);
+  bool PrintFiles(std::ostream& os, std::string const& pattern);
+
+  bool PrintVersion(std::ostream& os);
+  bool PrintUsage(std::ostream& os);
+  bool PrintHelp(std::ostream& os);
+  bool PrintHelpFull(std::ostream& os);
+  bool PrintHelpOneManual(std::ostream& os);
+  bool PrintHelpOneCommand(std::ostream& os);
+  bool PrintHelpOneModule(std::ostream& os);
+  bool PrintHelpOnePolicy(std::ostream& os);
+  bool PrintHelpOneProperty(std::ostream& os);
+  bool PrintHelpOneVariable(std::ostream& os);
+  bool PrintHelpListManuals(std::ostream& os);
+  bool PrintHelpListCommands(std::ostream& os);
+  bool PrintHelpListModules(std::ostream& os);
+  bool PrintHelpListProperties(std::ostream& os);
+  bool PrintHelpListVariables(std::ostream& os);
+  bool PrintHelpListPolicies(std::ostream& os);
+  bool PrintHelpListGenerators(std::ostream& os);
+  bool PrintOldCustomModules(std::ostream& os);
+
+  const char* GetNameString() const;
+  bool IsOption(const char* arg) const;
+
+  bool ShowGenerators;
+
+  std::string NameString;
+  std::map<std::string, cmDocumentationSection*> AllSections;
+
+  std::string CurrentArgument;
+
+  struct RequestedHelpItem
+  {
+    RequestedHelpItem()
+      : HelpType(None)
+    {
+    }
+    cmDocumentationEnums::Type HelpType;
+    std::string Filename;
+    std::string Argument;
+  };
+
+  std::vector<RequestedHelpItem> RequestedHelpItems;
+  cmDocumentationFormatter Formatter;
+
+  static void WarnFormFromFilename(RequestedHelpItem& request, bool& result);
+};
+
+#endif
diff --git a/Source/cmDocumentationEntry.h b/Source/cmDocumentationEntry.h
new file mode 100644
index 0000000..ea43b88
--- /dev/null
+++ b/Source/cmDocumentationEntry.h
@@ -0,0 +1,36 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmDocumentationEntry_h
+#define cmDocumentationEntry_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+/** Standard documentation entry for cmDocumentation's formatting.  */
+struct cmDocumentationEntry
+{
+  std::string Name;
+  std::string Brief;
+  cmDocumentationEntry() {}
+  cmDocumentationEntry(const char* doc[2])
+  {
+    if (doc[0]) {
+      this->Name = doc[0];
+    }
+    if (doc[1]) {
+      this->Brief = doc[1];
+    }
+  }
+  cmDocumentationEntry(const char* n, const char* b)
+  {
+    if (n) {
+      this->Name = n;
+    }
+    if (b) {
+      this->Brief = b;
+    }
+  }
+};
+
+#endif
diff --git a/Source/cmDocumentationFormatter.cxx b/Source/cmDocumentationFormatter.cxx
new file mode 100644
index 0000000..6b996e4
--- /dev/null
+++ b/Source/cmDocumentationFormatter.cxx
@@ -0,0 +1,193 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDocumentationFormatter.h"
+
+#include "cmDocumentationEntry.h"
+#include "cmDocumentationSection.h"
+
+#include <ostream>
+#include <string.h>
+#include <string>
+#include <vector>
+
+cmDocumentationFormatter::cmDocumentationFormatter()
+  : TextWidth(77)
+  , TextIndent("")
+{
+}
+
+cmDocumentationFormatter::~cmDocumentationFormatter()
+{
+}
+
+void cmDocumentationFormatter::PrintFormatted(std::ostream& os,
+                                              const char* text)
+{
+  if (!text) {
+    return;
+  }
+  const char* ptr = text;
+  while (*ptr) {
+    // Any ptrs starting in a space are treated as preformatted text.
+    std::string preformatted;
+    while (*ptr == ' ') {
+      for (char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr) {
+        preformatted.append(1, ch);
+      }
+      if (*ptr) {
+        ++ptr;
+        preformatted.append(1, '\n');
+      }
+    }
+    if (!preformatted.empty()) {
+      this->PrintPreformatted(os, preformatted.c_str());
+    }
+
+    // Other ptrs are treated as paragraphs.
+    std::string paragraph;
+    for (char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr) {
+      paragraph.append(1, ch);
+    }
+    if (*ptr) {
+      ++ptr;
+      paragraph.append(1, '\n');
+    }
+    if (!paragraph.empty()) {
+      this->PrintParagraph(os, paragraph.c_str());
+    }
+  }
+}
+
+void cmDocumentationFormatter::PrintPreformatted(std::ostream& os,
+                                                 const char* text)
+{
+  bool newline = true;
+  for (const char* ptr = text; *ptr; ++ptr) {
+    if (newline && *ptr != '\n') {
+      os << this->TextIndent;
+      newline = false;
+    }
+    os << *ptr;
+    if (*ptr == '\n') {
+      newline = true;
+    }
+  }
+  os << "\n";
+}
+
+void cmDocumentationFormatter::PrintParagraph(std::ostream& os,
+                                              const char* text)
+{
+  os << this->TextIndent;
+  this->PrintColumn(os, text);
+  os << "\n";
+}
+
+void cmDocumentationFormatter::SetIndent(const char* indent)
+{
+  this->TextIndent = indent;
+}
+
+void cmDocumentationFormatter::PrintColumn(std::ostream& os, const char* text)
+{
+  // Print text arranged in an indented column of fixed witdh.
+  const char* l = text;
+  long column = 0;
+  bool newSentence = false;
+  bool firstLine = true;
+  int width = this->TextWidth - static_cast<int>(strlen(this->TextIndent));
+
+  // Loop until the end of the text.
+  while (*l) {
+    // Parse the next word.
+    const char* r = l;
+    while (*r && (*r != '\n') && (*r != ' ')) {
+      ++r;
+    }
+
+    // Does it fit on this line?
+    if (r - l < (width - column - (newSentence ? 1 : 0))) {
+      // Word fits on this line.
+      if (r > l) {
+        if (column) {
+          // Not first word on line.  Separate from the previous word
+          // by a space, or two if this is a new sentence.
+          if (newSentence) {
+            os << "  ";
+            column += 2;
+          } else {
+            os << " ";
+            column += 1;
+          }
+        } else {
+          // First word on line.  Print indentation unless this is the
+          // first line.
+          os << (firstLine ? "" : this->TextIndent);
+        }
+
+        // Print the word.
+        os.write(l, static_cast<long>(r - l));
+        newSentence = (*(r - 1) == '.');
+      }
+
+      if (*r == '\n') {
+        // Text provided a newline.  Start a new line.
+        os << "\n";
+        ++r;
+        column = 0;
+        firstLine = false;
+      } else {
+        // No provided newline.  Continue this line.
+        column += static_cast<long>(r - l);
+      }
+    } else {
+      // Word does not fit on this line.  Start a new line.
+      os << "\n";
+      firstLine = false;
+      if (r > l) {
+        os << this->TextIndent;
+        os.write(l, static_cast<long>(r - l));
+        column = static_cast<long>(r - l);
+        newSentence = (*(r - 1) == '.');
+      } else {
+        column = 0;
+      }
+    }
+
+    // Move to beginning of next word.  Skip over whitespace.
+    l = r;
+    while (*l == ' ') {
+      ++l;
+    }
+  }
+}
+
+void cmDocumentationFormatter::PrintSection(
+  std::ostream& os, cmDocumentationSection const& section)
+{
+  os << section.GetName() << "\n";
+
+  const std::vector<cmDocumentationEntry>& entries = section.GetEntries();
+  for (cmDocumentationEntry const& entry : entries) {
+    if (!entry.Name.empty()) {
+      os << "  " << entry.Name;
+      this->TextIndent = "                                 ";
+      int align = static_cast<int>(strlen(this->TextIndent)) - 4;
+      for (int i = static_cast<int>(entry.Name.size()); i < align; ++i) {
+        os << " ";
+      }
+      if (entry.Name.size() > strlen(this->TextIndent) - 4) {
+        os << "\n";
+        os.write(this->TextIndent, strlen(this->TextIndent) - 2);
+      }
+      os << "= ";
+      this->PrintColumn(os, entry.Brief.c_str());
+      os << "\n";
+    } else {
+      os << "\n";
+      this->TextIndent = "";
+      this->PrintFormatted(os, entry.Brief.c_str());
+    }
+  }
+  os << "\n";
+}
diff --git a/Source/cmDocumentationFormatter.h b/Source/cmDocumentationFormatter.h
new file mode 100644
index 0000000..1f04250
--- /dev/null
+++ b/Source/cmDocumentationFormatter.h
@@ -0,0 +1,66 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef _cmDocumentationFormatter_h
+#define _cmDocumentationFormatter_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+
+/** This is just a helper class to make it build with MSVC 6.0.
+Actually the enums and internal classes could directly go into
+cmDocumentation, but then MSVC6 complains in RequestedHelpItem that
+cmDocumentation is an undefined type and so it doesn't know the enums.
+Moving the enums to a class which is then already completely parsed helps
+against this. */
+class cmDocumentationEnums
+{
+public:
+  /** Types of help provided.  */
+  enum Type
+  {
+    None,
+    Version,
+    Usage,
+    Help,
+    Full,
+    ListManuals,
+    ListCommands,
+    ListModules,
+    ListProperties,
+    ListVariables,
+    ListPolicies,
+    ListGenerators,
+    OneManual,
+    OneCommand,
+    OneModule,
+    OneProperty,
+    OneVariable,
+    OnePolicy,
+    OldCustomModules
+  };
+};
+
+class cmDocumentationSection;
+
+/** Print documentation in a simple text format. */
+class cmDocumentationFormatter
+{
+public:
+  cmDocumentationFormatter();
+  virtual ~cmDocumentationFormatter();
+  void PrintFormatted(std::ostream& os, const char* text);
+
+  virtual void PrintSection(std::ostream& os,
+                            cmDocumentationSection const& section);
+  virtual void PrintPreformatted(std::ostream& os, const char* text);
+  virtual void PrintParagraph(std::ostream& os, const char* text);
+  void PrintColumn(std::ostream& os, const char* text);
+  void SetIndent(const char* indent);
+
+private:
+  int TextWidth;
+  const char* TextIndent;
+};
+
+#endif
diff --git a/Source/cmDocumentationSection.cxx b/Source/cmDocumentationSection.cxx
new file mode 100644
index 0000000..c47f33e
--- /dev/null
+++ b/Source/cmDocumentationSection.cxx
@@ -0,0 +1,28 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDocumentationSection.h"
+
+void cmDocumentationSection::Append(const char* data[][2])
+{
+  int i = 0;
+  while (data[i][1]) {
+    this->Entries.push_back(cmDocumentationEntry(data[i][0], data[i][1]));
+    data += 1;
+  }
+}
+
+void cmDocumentationSection::Prepend(const char* data[][2])
+{
+  std::vector<cmDocumentationEntry> tmp;
+  int i = 0;
+  while (data[i][1]) {
+    tmp.push_back(cmDocumentationEntry(data[i][0], data[i][1]));
+    data += 1;
+  }
+  this->Entries.insert(this->Entries.begin(), tmp.begin(), tmp.end());
+}
+
+void cmDocumentationSection::Append(const char* n, const char* b)
+{
+  this->Entries.push_back(cmDocumentationEntry(n, b));
+}
diff --git a/Source/cmDocumentationSection.h b/Source/cmDocumentationSection.h
new file mode 100644
index 0000000..d9e8187
--- /dev/null
+++ b/Source/cmDocumentationSection.h
@@ -0,0 +1,69 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef _cmDocumentationSection_h
+#define _cmDocumentationSection_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmDocumentationEntry.h"
+
+#include <string>
+#include <vector>
+
+// Low-level interface for custom documents:
+/** Internal class representing a section of the documentation.
+ * Cares e.g. for the different section titles in the different
+ * output formats.
+ */
+class cmDocumentationSection
+{
+public:
+  /** Create a cmSection, with a special name for man-output mode. */
+  cmDocumentationSection(const char* name, const char*)
+    : Name(name)
+  {
+  }
+
+  /** Has any content been added to this section or is it empty ? */
+  bool IsEmpty() const { return this->Entries.empty(); }
+
+  /** Clear contents. */
+  void Clear() { this->Entries.clear(); }
+
+  /** Return the name of this section. */
+  std::string GetName() const { return this->Name; }
+
+  /** Return a pointer to the first entry of this section. */
+  const std::vector<cmDocumentationEntry>& GetEntries() const
+  {
+    return this->Entries;
+  }
+
+  /** Append an entry to this section. */
+  void Append(const cmDocumentationEntry& entry)
+  {
+    this->Entries.push_back(entry);
+  }
+  void Append(const std::vector<cmDocumentationEntry>& entries)
+  {
+    this->Entries.insert(this->Entries.end(), entries.begin(), entries.end());
+  }
+
+  /** Append an entry to this section using NULL terminated chars */
+  void Append(const char* [][2]);
+  void Append(const char* n, const char* b);
+
+  /** prepend some documentation to this section */
+  void Prepend(const char* [][2]);
+  void Prepend(const std::vector<cmDocumentationEntry>& entries)
+  {
+    this->Entries.insert(this->Entries.begin(), entries.begin(),
+                         entries.end());
+  }
+
+private:
+  std::string Name;
+  std::vector<cmDocumentationEntry> Entries;
+};
+
+#endif
diff --git a/Source/cmDynamicLoader.cxx b/Source/cmDynamicLoader.cxx
new file mode 100644
index 0000000..7da6ff5
--- /dev/null
+++ b/Source/cmDynamicLoader.cxx
@@ -0,0 +1,98 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmDynamicLoader.h"
+
+#include <map>
+#include <string>
+#include <utility>
+
+class cmDynamicLoaderCache
+{
+public:
+  ~cmDynamicLoaderCache();
+  void CacheFile(const char* path, cmsys::DynamicLoader::LibraryHandle /*p*/);
+  bool GetCacheFile(const char* path,
+                    cmsys::DynamicLoader::LibraryHandle& /*p*/);
+  bool FlushCache(const char* path);
+  void FlushCache();
+  static cmDynamicLoaderCache* GetInstance();
+
+private:
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle> CacheMap;
+  static cmDynamicLoaderCache* Instance;
+};
+
+cmDynamicLoaderCache* cmDynamicLoaderCache::Instance = nullptr;
+
+cmDynamicLoaderCache::~cmDynamicLoaderCache()
+{
+}
+
+void cmDynamicLoaderCache::CacheFile(const char* path,
+                                     cmsys::DynamicLoader::LibraryHandle p)
+{
+  cmsys::DynamicLoader::LibraryHandle h;
+  if (this->GetCacheFile(path, h)) {
+    this->FlushCache(path);
+  }
+  this->CacheMap[path] = p;
+}
+
+bool cmDynamicLoaderCache::GetCacheFile(const char* path,
+                                        cmsys::DynamicLoader::LibraryHandle& p)
+{
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it =
+    this->CacheMap.find(path);
+  if (it != this->CacheMap.end()) {
+    p = it->second;
+    return true;
+  }
+  return false;
+}
+
+bool cmDynamicLoaderCache::FlushCache(const char* path)
+{
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it =
+    this->CacheMap.find(path);
+  bool ret = false;
+  if (it != this->CacheMap.end()) {
+    cmsys::DynamicLoader::CloseLibrary(it->second);
+    this->CacheMap.erase(it);
+    ret = true;
+  }
+  return ret;
+}
+
+void cmDynamicLoaderCache::FlushCache()
+{
+  for (auto const& it : this->CacheMap) {
+    cmsys::DynamicLoader::CloseLibrary(it.second);
+  }
+  delete cmDynamicLoaderCache::Instance;
+  cmDynamicLoaderCache::Instance = nullptr;
+}
+
+cmDynamicLoaderCache* cmDynamicLoaderCache::GetInstance()
+{
+  if (!cmDynamicLoaderCache::Instance) {
+    cmDynamicLoaderCache::Instance = new cmDynamicLoaderCache;
+  }
+  return cmDynamicLoaderCache::Instance;
+}
+
+cmsys::DynamicLoader::LibraryHandle cmDynamicLoader::OpenLibrary(
+  const char* libname)
+{
+  cmsys::DynamicLoader::LibraryHandle lh;
+  if (cmDynamicLoaderCache::GetInstance()->GetCacheFile(libname, lh)) {
+    return lh;
+  }
+  lh = cmsys::DynamicLoader::OpenLibrary(libname);
+  cmDynamicLoaderCache::GetInstance()->CacheFile(libname, lh);
+  return lh;
+}
+
+void cmDynamicLoader::FlushCache()
+{
+  cmDynamicLoaderCache::GetInstance()->FlushCache();
+}
diff --git a/Source/cmDynamicLoader.h b/Source/cmDynamicLoader.h
new file mode 100644
index 0000000..61d3b46
--- /dev/null
+++ b/Source/cmDynamicLoader.h
@@ -0,0 +1,35 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+// .NAME cmDynamicLoader - class interface to system dynamic libraries
+// .SECTION Description
+// cmDynamicLoader provides a portable interface to loading dynamic
+// libraries into a process.
+
+#ifndef cmDynamicLoader_h
+#define cmDynamicLoader_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmsys/DynamicLoader.hxx" // IWYU pragma: export
+
+class cmDynamicLoader
+{
+  CM_DISABLE_COPY(cmDynamicLoader)
+
+public:
+  // Description:
+  // Load a dynamic library into the current process.
+  // The returned cmsys::DynamicLoader::LibraryHandle can be used to access
+  // the symbols in the library.
+  static cmsys::DynamicLoader::LibraryHandle OpenLibrary(const char*);
+
+  // Description:
+  // Flush the cache of dynamic loader.
+  static void FlushCache();
+
+protected:
+  cmDynamicLoader() {}
+  ~cmDynamicLoader() {}
+};
+
+#endif
diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx
new file mode 100644
index 0000000..76374b2
--- /dev/null
+++ b/Source/cmELF.cxx
@@ -0,0 +1,839 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmELF.h"
+
+#include "cm_kwiml.h"
+#include "cmsys/FStream.hxx"
+#include <map>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+#include <stddef.h>
+#include <utility>
+#include <vector>
+
+// Include the ELF format information system header.
+#if defined(__OpenBSD__)
+#include <elf_abi.h>
+#include <stdint.h>
+#elif defined(__HAIKU__)
+#include <elf32.h>
+#include <elf64.h>
+typedef struct Elf32_Ehdr Elf32_Ehdr;
+typedef struct Elf32_Shdr Elf32_Shdr;
+typedef struct Elf32_Sym Elf32_Sym;
+typedef struct Elf32_Rel Elf32_Rel;
+typedef struct Elf32_Rela Elf32_Rela;
+#define ELFMAG0 0x7F
+#define ELFMAG1 'E'
+#define ELFMAG2 'L'
+#define ELFMAG3 'F'
+#define ET_NONE 0
+#define ET_REL 1
+#define ET_EXEC 2
+#define ET_DYN 3
+#define ET_CORE 4
+#define EM_386 3
+#define EM_SPARC 2
+#define EM_PPC 20
+#else
+#include <elf.h>
+#endif
+#if defined(__sun)
+#include <sys/link.h> // For dynamic section information
+#endif
+#ifdef _SCO_DS
+#include <link.h> // For DT_SONAME etc.
+#endif
+#ifndef DT_RUNPATH
+#define DT_RUNPATH 29
+#endif
+
+// Low-level byte swapping implementation.
+template <size_t s>
+struct cmELFByteSwapSize
+{
+};
+void cmELFByteSwap(char* /*unused*/, cmELFByteSwapSize<1> /*unused*/)
+{
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<2> /*unused*/)
+{
+  char one_byte;
+  one_byte = data[0];
+  data[0] = data[1];
+  data[1] = one_byte;
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<4> /*unused*/)
+{
+  char one_byte;
+  one_byte = data[0];
+  data[0] = data[3];
+  data[3] = one_byte;
+  one_byte = data[1];
+  data[1] = data[2];
+  data[2] = one_byte;
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<8> /*unused*/)
+{
+  char one_byte;
+  one_byte = data[0];
+  data[0] = data[7];
+  data[7] = one_byte;
+  one_byte = data[1];
+  data[1] = data[6];
+  data[6] = one_byte;
+  one_byte = data[2];
+  data[2] = data[5];
+  data[5] = one_byte;
+  one_byte = data[3];
+  data[3] = data[4];
+  data[4] = one_byte;
+}
+
+// Low-level byte swapping interface.
+template <typename T>
+void cmELFByteSwap(T& x)
+{
+  cmELFByteSwap(reinterpret_cast<char*>(&x), cmELFByteSwapSize<sizeof(T)>());
+}
+
+class cmELFInternal
+{
+public:
+  typedef cmELF::StringEntry StringEntry;
+  enum ByteOrderType
+  {
+    ByteOrderMSB,
+    ByteOrderLSB
+  };
+
+  // Construct and take ownership of the file stream object.
+  cmELFInternal(cmELF* external, std::unique_ptr<cmsys::ifstream>& fin,
+                ByteOrderType order)
+    : External(external)
+    , Stream(*fin.release())
+    , ByteOrder(order)
+    , ELFType(cmELF::FileTypeInvalid)
+  {
+// In most cases the processor-specific byte order will match that
+// of the target execution environment.  If we choose wrong here
+// it is fixed when the header is read.
+#if KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_LITTLE
+    this->NeedSwap = (this->ByteOrder == ByteOrderMSB);
+#elif KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_BIG
+    this->NeedSwap = (this->ByteOrder == ByteOrderLSB);
+#else
+    this->NeedSwap = false; // Final decision is at runtime anyway.
+#endif
+
+    // We have not yet loaded the section info.
+    this->DynamicSectionIndex = -1;
+  }
+
+  // Destruct and delete the file stream object.
+  virtual ~cmELFInternal() { delete &this->Stream; }
+
+  // Forward to the per-class implementation.
+  virtual unsigned int GetNumberOfSections() const = 0;
+  virtual unsigned long GetDynamicEntryPosition(int j) = 0;
+  virtual cmELF::DynamicEntryList GetDynamicEntries() = 0;
+  virtual std::vector<char> EncodeDynamicEntries(
+    const cmELF::DynamicEntryList&) = 0;
+  virtual StringEntry const* GetDynamicSectionString(unsigned int tag) = 0;
+  virtual void PrintInfo(std::ostream& os) const = 0;
+
+  // Lookup the SONAME in the DYNAMIC section.
+  StringEntry const* GetSOName()
+  {
+    return this->GetDynamicSectionString(DT_SONAME);
+  }
+
+  // Lookup the RPATH in the DYNAMIC section.
+  StringEntry const* GetRPath()
+  {
+    return this->GetDynamicSectionString(DT_RPATH);
+  }
+
+  // Lookup the RUNPATH in the DYNAMIC section.
+  StringEntry const* GetRunPath()
+  {
+    return this->GetDynamicSectionString(DT_RUNPATH);
+  }
+
+  // Return the recorded ELF type.
+  cmELF::FileType GetFileType() const { return this->ELFType; }
+protected:
+  // Data common to all ELF class implementations.
+
+  // The external cmELF object.
+  cmELF* External;
+
+  // The stream from which to read.
+  std::istream& Stream;
+
+  // The byte order of the ELF file.
+  ByteOrderType ByteOrder;
+
+  // The ELF file type.
+  cmELF::FileType ELFType;
+
+  // Whether we need to byte-swap structures read from the stream.
+  bool NeedSwap;
+
+  // The section header index of the DYNAMIC section (-1 if none).
+  int DynamicSectionIndex;
+
+  // Helper methods for subclasses.
+  void SetErrorMessage(const char* msg)
+  {
+    this->External->ErrorMessage = msg;
+    this->ELFType = cmELF::FileTypeInvalid;
+  }
+
+  // Store string table entry states.
+  std::map<unsigned int, StringEntry> DynamicSectionStrings;
+};
+
+// Configure the implementation template for 32-bit ELF files.
+struct cmELFTypes32
+{
+  typedef Elf32_Ehdr ELF_Ehdr;
+  typedef Elf32_Shdr ELF_Shdr;
+  typedef Elf32_Dyn ELF_Dyn;
+  typedef Elf32_Half ELF_Half;
+  typedef KWIML_INT_uint32_t tagtype;
+  static const char* GetName() { return "32-bit"; }
+};
+
+// Configure the implementation template for 64-bit ELF files.
+#ifndef _SCO_DS
+struct cmELFTypes64
+{
+  typedef Elf64_Ehdr ELF_Ehdr;
+  typedef Elf64_Shdr ELF_Shdr;
+  typedef Elf64_Dyn ELF_Dyn;
+  typedef Elf64_Half ELF_Half;
+  typedef KWIML_INT_uint64_t tagtype;
+  static const char* GetName() { return "64-bit"; }
+};
+#endif
+
+// Parser implementation template.
+template <class Types>
+class cmELFInternalImpl : public cmELFInternal
+{
+public:
+  // Copy the ELF file format types from our configuration parameter.
+  typedef typename Types::ELF_Ehdr ELF_Ehdr;
+  typedef typename Types::ELF_Shdr ELF_Shdr;
+  typedef typename Types::ELF_Dyn ELF_Dyn;
+  typedef typename Types::ELF_Half ELF_Half;
+  typedef typename Types::tagtype tagtype;
+
+  // Construct with a stream and byte swap indicator.
+  cmELFInternalImpl(cmELF* external, std::unique_ptr<cmsys::ifstream>& fin,
+                    ByteOrderType order);
+
+  // Return the number of sections as specified by the ELF header.
+  unsigned int GetNumberOfSections() const override
+  {
+    return static_cast<unsigned int>(this->ELFHeader.e_shnum);
+  }
+
+  // Get the file position of a dynamic section entry.
+  unsigned long GetDynamicEntryPosition(int j) override;
+
+  cmELF::DynamicEntryList GetDynamicEntries() override;
+  std::vector<char> EncodeDynamicEntries(
+    const cmELF::DynamicEntryList&) override;
+
+  // Lookup a string from the dynamic section with the given tag.
+  StringEntry const* GetDynamicSectionString(unsigned int tag) override;
+
+  // Print information about the ELF file.
+  void PrintInfo(std::ostream& os) const override
+  {
+    os << "ELF " << Types::GetName();
+    if (this->ByteOrder == ByteOrderMSB) {
+      os << " MSB";
+    } else if (this->ByteOrder == ByteOrderLSB) {
+      os << " LSB";
+    }
+    switch (this->ELFType) {
+      case cmELF::FileTypeInvalid:
+        os << " invalid file";
+        break;
+      case cmELF::FileTypeRelocatableObject:
+        os << " relocatable object";
+        break;
+      case cmELF::FileTypeExecutable:
+        os << " executable";
+        break;
+      case cmELF::FileTypeSharedLibrary:
+        os << " shared library";
+        break;
+      case cmELF::FileTypeCore:
+        os << " core file";
+        break;
+      case cmELF::FileTypeSpecificOS:
+        os << " os-specific type";
+        break;
+      case cmELF::FileTypeSpecificProc:
+        os << " processor-specific type";
+        break;
+    }
+    os << "\n";
+  }
+
+private:
+  // ByteSwap(ELF_Dyn) assumes d_val and d_ptr are the same size
+  typedef char dyn_size_assert
+    [sizeof(ELF_Dyn().d_un.d_val) == sizeof(ELF_Dyn().d_un.d_ptr) ? 1 : -1];
+
+  void ByteSwap(ELF_Ehdr& elf_header)
+  {
+    cmELFByteSwap(elf_header.e_type);
+    cmELFByteSwap(elf_header.e_machine);
+    cmELFByteSwap(elf_header.e_version);
+    cmELFByteSwap(elf_header.e_entry);
+    cmELFByteSwap(elf_header.e_phoff);
+    cmELFByteSwap(elf_header.e_shoff);
+    cmELFByteSwap(elf_header.e_flags);
+    cmELFByteSwap(elf_header.e_ehsize);
+    cmELFByteSwap(elf_header.e_phentsize);
+    cmELFByteSwap(elf_header.e_phnum);
+    cmELFByteSwap(elf_header.e_shentsize);
+    cmELFByteSwap(elf_header.e_shnum);
+    cmELFByteSwap(elf_header.e_shstrndx);
+  }
+
+  void ByteSwap(ELF_Shdr& sec_header)
+  {
+    cmELFByteSwap(sec_header.sh_name);
+    cmELFByteSwap(sec_header.sh_type);
+    cmELFByteSwap(sec_header.sh_flags);
+    cmELFByteSwap(sec_header.sh_addr);
+    cmELFByteSwap(sec_header.sh_offset);
+    cmELFByteSwap(sec_header.sh_size);
+    cmELFByteSwap(sec_header.sh_link);
+    cmELFByteSwap(sec_header.sh_info);
+    cmELFByteSwap(sec_header.sh_addralign);
+    cmELFByteSwap(sec_header.sh_entsize);
+  }
+
+  void ByteSwap(ELF_Dyn& dyn)
+  {
+    cmELFByteSwap(dyn.d_tag);
+    cmELFByteSwap(dyn.d_un.d_val);
+  }
+
+  bool FileTypeValid(ELF_Half et)
+  {
+    unsigned int eti = static_cast<unsigned int>(et);
+    if (eti == ET_NONE || eti == ET_REL || eti == ET_EXEC || eti == ET_DYN ||
+        eti == ET_CORE) {
+      return true;
+    }
+#if defined(ET_LOOS) && defined(ET_HIOS)
+    if (eti >= ET_LOOS && eti <= ET_HIOS) {
+      return true;
+    }
+#endif
+#if defined(ET_LOPROC) && defined(ET_HIPROC)
+    if (eti >= ET_LOPROC && eti <= ET_HIPROC) {
+      return true;
+    }
+#endif
+    return false;
+  }
+
+  bool Read(ELF_Ehdr& x)
+  {
+    // Read the header from the file.
+    if (!this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x))) {
+      return false;
+    }
+
+    // The byte order of ELF header fields may not match that of the
+    // processor-specific data.  The header fields are ordered to
+    // match the target execution environment, so we may need to
+    // memorize the order of all platforms based on the e_machine
+    // value.  As a heuristic, if the type is invalid but its
+    // swapped value is okay then flip our swap mode.
+    ELF_Half et = x.e_type;
+    if (this->NeedSwap) {
+      cmELFByteSwap(et);
+    }
+    if (!this->FileTypeValid(et)) {
+      cmELFByteSwap(et);
+      if (this->FileTypeValid(et)) {
+        // The previous byte order guess was wrong.  Flip it.
+        this->NeedSwap = !this->NeedSwap;
+      }
+    }
+
+    // Fix the byte order of the header.
+    if (this->NeedSwap) {
+      ByteSwap(x);
+    }
+    return true;
+  }
+  bool Read(ELF_Shdr& x)
+  {
+    if (this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+        this->NeedSwap) {
+      ByteSwap(x);
+    }
+    return !this->Stream.fail();
+  }
+  bool Read(ELF_Dyn& x)
+  {
+    if (this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+        this->NeedSwap) {
+      ByteSwap(x);
+    }
+    return !this->Stream.fail();
+  }
+
+  bool LoadSectionHeader(ELF_Half i)
+  {
+    // Read the section header from the file.
+    this->Stream.seekg(this->ELFHeader.e_shoff +
+                       this->ELFHeader.e_shentsize * i);
+    if (!this->Read(this->SectionHeaders[i])) {
+      return false;
+    }
+
+    // Identify some important sections.
+    if (this->SectionHeaders[i].sh_type == SHT_DYNAMIC) {
+      this->DynamicSectionIndex = i;
+    }
+    return true;
+  }
+
+  bool LoadDynamicSection();
+
+  // Store the main ELF header.
+  ELF_Ehdr ELFHeader;
+
+  // Store all the section headers.
+  std::vector<ELF_Shdr> SectionHeaders;
+
+  // Store all entries of the DYNAMIC section.
+  std::vector<ELF_Dyn> DynamicSectionEntries;
+};
+
+template <class Types>
+cmELFInternalImpl<Types>::cmELFInternalImpl(
+  cmELF* external, std::unique_ptr<cmsys::ifstream>& fin, ByteOrderType order)
+  : cmELFInternal(external, fin, order)
+{
+  // Read the main header.
+  if (!this->Read(this->ELFHeader)) {
+    this->SetErrorMessage("Failed to read main ELF header.");
+    return;
+  }
+
+  // Determine the ELF file type.
+  switch (this->ELFHeader.e_type) {
+    case ET_NONE:
+      this->SetErrorMessage("ELF file type is NONE.");
+      return;
+    case ET_REL:
+      this->ELFType = cmELF::FileTypeRelocatableObject;
+      break;
+    case ET_EXEC:
+      this->ELFType = cmELF::FileTypeExecutable;
+      break;
+    case ET_DYN:
+      this->ELFType = cmELF::FileTypeSharedLibrary;
+      break;
+    case ET_CORE:
+      this->ELFType = cmELF::FileTypeCore;
+      break;
+    default: {
+      unsigned int eti = static_cast<unsigned int>(this->ELFHeader.e_type);
+#if defined(ET_LOOS) && defined(ET_HIOS)
+      if (eti >= ET_LOOS && eti <= ET_HIOS) {
+        this->ELFType = cmELF::FileTypeSpecificOS;
+        break;
+      }
+#endif
+#if defined(ET_LOPROC) && defined(ET_HIPROC)
+      if (eti >= ET_LOPROC && eti <= ET_HIPROC) {
+        this->ELFType = cmELF::FileTypeSpecificProc;
+        break;
+      }
+#endif
+      std::ostringstream e;
+      e << "Unknown ELF file type " << eti;
+      this->SetErrorMessage(e.str().c_str());
+      return;
+    }
+  }
+
+  // Load the section headers.
+  this->SectionHeaders.resize(this->ELFHeader.e_shnum);
+  for (ELF_Half i = 0; i < this->ELFHeader.e_shnum; ++i) {
+    if (!this->LoadSectionHeader(i)) {
+      this->SetErrorMessage("Failed to load section headers.");
+      return;
+    }
+  }
+}
+
+template <class Types>
+bool cmELFInternalImpl<Types>::LoadDynamicSection()
+{
+  // If there is no dynamic section we are done.
+  if (this->DynamicSectionIndex < 0) {
+    return false;
+  }
+
+  // If the section was already loaded we are done.
+  if (!this->DynamicSectionEntries.empty()) {
+    return true;
+  }
+
+  // If there are no entries we are done.
+  ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+  if (sec.sh_entsize == 0) {
+    return false;
+  }
+
+  // Allocate the dynamic section entries.
+  int n = static_cast<int>(sec.sh_size / sec.sh_entsize);
+  this->DynamicSectionEntries.resize(n);
+
+  // Read each entry.
+  for (int j = 0; j < n; ++j) {
+    // Seek to the beginning of the section entry.
+    this->Stream.seekg(sec.sh_offset + sec.sh_entsize * j);
+    ELF_Dyn& dyn = this->DynamicSectionEntries[j];
+
+    // Try reading the entry.
+    if (!this->Read(dyn)) {
+      this->SetErrorMessage("Error reading entry from DYNAMIC section.");
+      this->DynamicSectionIndex = -1;
+      return false;
+    }
+  }
+  return true;
+}
+
+template <class Types>
+unsigned long cmELFInternalImpl<Types>::GetDynamicEntryPosition(int j)
+{
+  if (!this->LoadDynamicSection()) {
+    return 0;
+  }
+  if (j < 0 || j >= static_cast<int>(this->DynamicSectionEntries.size())) {
+    return 0;
+  }
+  ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+  return static_cast<unsigned long>(sec.sh_offset + sec.sh_entsize * j);
+}
+
+template <class Types>
+cmELF::DynamicEntryList cmELFInternalImpl<Types>::GetDynamicEntries()
+{
+  cmELF::DynamicEntryList result;
+
+  // Ensure entries have been read from file
+  if (!this->LoadDynamicSection()) {
+    return result;
+  }
+
+  // Copy into public array
+  result.reserve(this->DynamicSectionEntries.size());
+  for (ELF_Dyn& dyn : this->DynamicSectionEntries) {
+    result.push_back(
+      std::pair<unsigned long, unsigned long>(dyn.d_tag, dyn.d_un.d_val));
+  }
+
+  return result;
+}
+
+template <class Types>
+std::vector<char> cmELFInternalImpl<Types>::EncodeDynamicEntries(
+  const cmELF::DynamicEntryList& entries)
+{
+  std::vector<char> result;
+  result.reserve(sizeof(ELF_Dyn) * entries.size());
+
+  for (auto const& entry : entries) {
+    // Store the entry in an ELF_Dyn, byteswap it, then serialize to chars
+    ELF_Dyn dyn;
+    dyn.d_tag = static_cast<tagtype>(entry.first);
+    dyn.d_un.d_val = static_cast<tagtype>(entry.second);
+
+    if (this->NeedSwap) {
+      ByteSwap(dyn);
+    }
+
+    char* pdyn = reinterpret_cast<char*>(&dyn);
+    result.insert(result.end(), pdyn, pdyn + sizeof(ELF_Dyn));
+  }
+
+  return result;
+}
+
+template <class Types>
+cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString(
+  unsigned int tag)
+{
+  // Short-circuit if already checked.
+  std::map<unsigned int, StringEntry>::iterator dssi =
+    this->DynamicSectionStrings.find(tag);
+  if (dssi != this->DynamicSectionStrings.end()) {
+    if (dssi->second.Position > 0) {
+      return &dssi->second;
+    }
+    return nullptr;
+  }
+
+  // Create an entry for this tag.  Assume it is missing until found.
+  StringEntry& se = this->DynamicSectionStrings[tag];
+  se.Position = 0;
+  se.Size = 0;
+  se.IndexInSection = -1;
+
+  // Try reading the dynamic section.
+  if (!this->LoadDynamicSection()) {
+    return nullptr;
+  }
+
+  // Get the string table referenced by the DYNAMIC section.
+  ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+  if (sec.sh_link >= this->SectionHeaders.size()) {
+    this->SetErrorMessage("Section DYNAMIC has invalid string table index.");
+    return nullptr;
+  }
+  ELF_Shdr const& strtab = this->SectionHeaders[sec.sh_link];
+
+  // Look for the requested entry.
+  for (typename std::vector<ELF_Dyn>::iterator di =
+         this->DynamicSectionEntries.begin();
+       di != this->DynamicSectionEntries.end(); ++di) {
+    ELF_Dyn& dyn = *di;
+    if (static_cast<tagtype>(dyn.d_tag) == static_cast<tagtype>(tag)) {
+      // We found the tag requested.
+      // Make sure the position given is within the string section.
+      if (dyn.d_un.d_val >= strtab.sh_size) {
+        this->SetErrorMessage("Section DYNAMIC references string beyond "
+                              "the end of its string section.");
+        return nullptr;
+      }
+
+      // Seek to the position reported by the entry.
+      unsigned long first = static_cast<unsigned long>(dyn.d_un.d_val);
+      unsigned long last = first;
+      unsigned long end = static_cast<unsigned long>(strtab.sh_size);
+      this->Stream.seekg(strtab.sh_offset + first);
+
+      // Read the string.  It may be followed by more than one NULL
+      // terminator.  Count the total size of the region allocated to
+      // the string.  This assumes that the next string in the table
+      // is non-empty, but the "chrpath" tool makes the same
+      // assumption.
+      bool terminated = false;
+      char c;
+      while (last != end && this->Stream.get(c) && !(terminated && c)) {
+        ++last;
+        if (c) {
+          se.Value += c;
+        } else {
+          terminated = true;
+        }
+      }
+
+      // Make sure the whole value was read.
+      if (!this->Stream) {
+        this->SetErrorMessage("Dynamic section specifies unreadable RPATH.");
+        se.Value = "";
+        return nullptr;
+      }
+
+      // The value has been read successfully.  Report it.
+      se.Position = static_cast<unsigned long>(strtab.sh_offset + first);
+      se.Size = last - first;
+      se.IndexInSection =
+        static_cast<int>(di - this->DynamicSectionEntries.begin());
+      return &se;
+    }
+  }
+  return nullptr;
+}
+
+//============================================================================
+// External class implementation.
+
+const long cmELF::TagRPath = DT_RPATH;
+const long cmELF::TagRunPath = DT_RUNPATH;
+
+#ifdef DT_MIPS_RLD_MAP_REL
+const long cmELF::TagMipsRldMapRel = DT_MIPS_RLD_MAP_REL;
+#else
+const long cmELF::TagMipsRldMapRel = 0;
+#endif
+
+cmELF::cmELF(const char* fname)
+  : Internal(nullptr)
+{
+  // Try to open the file.
+  std::unique_ptr<cmsys::ifstream> fin(new cmsys::ifstream(fname));
+
+  // Quit now if the file could not be opened.
+  if (!fin.get() || !*fin) {
+    this->ErrorMessage = "Error opening input file.";
+    return;
+  }
+
+  // Read the ELF identification block.
+  char ident[EI_NIDENT];
+  if (!fin->read(ident, EI_NIDENT)) {
+    this->ErrorMessage = "Error reading ELF identification.";
+    return;
+  }
+  if (!fin->seekg(0)) {
+    this->ErrorMessage = "Error seeking to beginning of file.";
+    return;
+  }
+
+  // Verify the ELF identification.
+  if (!(ident[EI_MAG0] == ELFMAG0 && ident[EI_MAG1] == ELFMAG1 &&
+        ident[EI_MAG2] == ELFMAG2 && ident[EI_MAG3] == ELFMAG3)) {
+    this->ErrorMessage = "File does not have a valid ELF identification.";
+    return;
+  }
+
+  // Check the byte order in which the rest of the file is encoded.
+  cmELFInternal::ByteOrderType order;
+  if (ident[EI_DATA] == ELFDATA2LSB) {
+    // File is LSB.
+    order = cmELFInternal::ByteOrderLSB;
+  } else if (ident[EI_DATA] == ELFDATA2MSB) {
+    // File is MSB.
+    order = cmELFInternal::ByteOrderMSB;
+  } else {
+    this->ErrorMessage = "ELF file is not LSB or MSB encoded.";
+    return;
+  }
+
+  // Check the class of the file and construct the corresponding
+  // parser implementation.
+  if (ident[EI_CLASS] == ELFCLASS32) {
+    // 32-bit ELF
+    this->Internal = new cmELFInternalImpl<cmELFTypes32>(this, fin, order);
+  }
+#ifndef _SCO_DS
+  else if (ident[EI_CLASS] == ELFCLASS64) {
+    // 64-bit ELF
+    this->Internal = new cmELFInternalImpl<cmELFTypes64>(this, fin, order);
+  }
+#endif
+  else {
+    this->ErrorMessage = "ELF file class is not 32-bit or 64-bit.";
+    return;
+  }
+}
+
+cmELF::~cmELF()
+{
+  delete this->Internal;
+}
+
+bool cmELF::Valid() const
+{
+  return this->Internal && this->Internal->GetFileType() != FileTypeInvalid;
+}
+
+cmELF::FileType cmELF::GetFileType() const
+{
+  if (this->Valid()) {
+    return this->Internal->GetFileType();
+  }
+  return FileTypeInvalid;
+}
+
+unsigned int cmELF::GetNumberOfSections() const
+{
+  if (this->Valid()) {
+    return this->Internal->GetNumberOfSections();
+  }
+  return 0;
+}
+
+unsigned long cmELF::GetDynamicEntryPosition(int index) const
+{
+  if (this->Valid()) {
+    return this->Internal->GetDynamicEntryPosition(index);
+  }
+  return 0;
+}
+
+cmELF::DynamicEntryList cmELF::GetDynamicEntries() const
+{
+  if (this->Valid()) {
+    return this->Internal->GetDynamicEntries();
+  }
+
+  return cmELF::DynamicEntryList();
+}
+
+std::vector<char> cmELF::EncodeDynamicEntries(
+  const cmELF::DynamicEntryList& dentries) const
+{
+  if (this->Valid()) {
+    return this->Internal->EncodeDynamicEntries(dentries);
+  }
+
+  return std::vector<char>();
+}
+
+bool cmELF::GetSOName(std::string& soname)
+{
+  if (StringEntry const* se = this->GetSOName()) {
+    soname = se->Value;
+    return true;
+  }
+  return false;
+}
+
+cmELF::StringEntry const* cmELF::GetSOName()
+{
+  if (this->Valid() &&
+      this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary) {
+    return this->Internal->GetSOName();
+  }
+  return nullptr;
+}
+
+cmELF::StringEntry const* cmELF::GetRPath()
+{
+  if (this->Valid() &&
+      (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+       this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) {
+    return this->Internal->GetRPath();
+  }
+  return nullptr;
+}
+
+cmELF::StringEntry const* cmELF::GetRunPath()
+{
+  if (this->Valid() &&
+      (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+       this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) {
+    return this->Internal->GetRunPath();
+  }
+  return nullptr;
+}
+
+void cmELF::PrintInfo(std::ostream& os) const
+{
+  if (this->Valid()) {
+    this->Internal->PrintInfo(os);
+  } else {
+    os << "Not a valid ELF file.\n";
+  }
+}
diff --git a/Source/cmELF.h b/Source/cmELF.h
new file mode 100644
index 0000000..8c17348
--- /dev/null
+++ b/Source/cmELF.h
@@ -0,0 +1,112 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmELF_h
+#define cmELF_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if !defined(CMAKE_USE_ELF_PARSER)
+#error "This file may be included only if CMAKE_USE_ELF_PARSER is enabled."
+#endif
+
+class cmELFInternal;
+
+/** \class cmELF
+ * \brief Executable and Link Format (ELF) parser.
+ */
+class cmELF
+{
+public:
+  /** Construct with the name of the ELF input file to parse.  */
+  cmELF(const char* fname);
+
+  /** Destruct.   */
+  ~cmELF();
+
+  /** Get the error message if any.  */
+  std::string const& GetErrorMessage() const { return this->ErrorMessage; }
+
+  /** Boolean conversion.  True if the ELF file is valid.  */
+  operator bool() const { return this->Valid(); }
+
+  /** Enumeration of ELF file types.  */
+  enum FileType
+  {
+    FileTypeInvalid,
+    FileTypeRelocatableObject,
+    FileTypeExecutable,
+    FileTypeSharedLibrary,
+    FileTypeCore,
+    FileTypeSpecificOS,
+    FileTypeSpecificProc
+  };
+
+  /** Represent string table entries.  */
+  struct StringEntry
+  {
+    // The string value itself.
+    std::string Value;
+
+    // The position in the file at which the string appears.
+    unsigned long Position;
+
+    // The size of the string table entry.  This includes the space
+    // allocated for one or more null terminators.
+    unsigned long Size;
+
+    // The index of the section entry referencing the string.
+    int IndexInSection;
+  };
+
+  /** Represent entire dynamic section header */
+  typedef std::vector<std::pair<long, unsigned long>> DynamicEntryList;
+
+  /** Get the type of the file opened.  */
+  FileType GetFileType() const;
+
+  /** Get the number of ELF sections present.  */
+  unsigned int GetNumberOfSections() const;
+
+  /** Get the position of a DYNAMIC section header entry.  Returns
+      zero on error.  */
+  unsigned long GetDynamicEntryPosition(int index) const;
+
+  /** Get a copy of all the DYNAMIC section header entries.
+      Returns an empty vector on error */
+  DynamicEntryList GetDynamicEntries() const;
+
+  /** Encodes a DYNAMIC section header entry list into a char vector according
+      to the type of ELF file this is */
+  std::vector<char> EncodeDynamicEntries(
+    const DynamicEntryList& entries) const;
+
+  /** Get the SONAME field if any.  */
+  bool GetSOName(std::string& soname);
+  StringEntry const* GetSOName();
+
+  /** Get the RPATH field if any.  */
+  StringEntry const* GetRPath();
+
+  /** Get the RUNPATH field if any.  */
+  StringEntry const* GetRunPath();
+
+  /** Print human-readable information about the ELF file.  */
+  void PrintInfo(std::ostream& os) const;
+
+  /** Interesting dynamic tags.
+      If the tag is 0, it does not exist in the host ELF implementation */
+  static const long TagRPath, TagRunPath, TagMipsRldMapRel;
+
+private:
+  friend class cmELFInternal;
+  bool Valid() const;
+  cmELFInternal* Internal;
+  std::string ErrorMessage;
+};
+
+#endif
diff --git a/Source/cmEnableLanguageCommand.cxx b/Source/cmEnableLanguageCommand.cxx
new file mode 100644
index 0000000..ddd26de
--- /dev/null
+++ b/Source/cmEnableLanguageCommand.cxx
@@ -0,0 +1,29 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmEnableLanguageCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+
+// cmEnableLanguageCommand
+bool cmEnableLanguageCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
+{
+  bool optional = false;
+  std::vector<std::string> languages;
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  for (std::string const& it : args) {
+    if (it == "OPTIONAL") {
+      optional = true;
+    } else {
+      languages.push_back(it);
+    }
+  }
+
+  this->Makefile->EnableLanguage(languages, optional);
+  return true;
+}
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
new file mode 100644
index 0000000..97645a9
--- /dev/null
+++ b/Source/cmEnableLanguageCommand.h
@@ -0,0 +1,39 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmEnableLanguageCommand_h
+#define cmEnableLanguageCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmEnableLanguageCommand
+ * \brief Specify the name for this build project.
+ *
+ * cmEnableLanguageCommand is used to specify a name for this build project.
+ * It is defined once per set of CMakeList.txt files (including
+ * all subdirectories). Currently it just sets the name of the workspace
+ * file for Microsoft Visual C++
+ */
+class cmEnableLanguageCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmEnableLanguageCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx
new file mode 100644
index 0000000..6a64450
--- /dev/null
+++ b/Source/cmEnableTestingCommand.cxx
@@ -0,0 +1,16 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmEnableTestingCommand.h"
+
+#include "cmMakefile.h"
+
+class cmExecutionStatus;
+
+// we do this in the final pass so that we now the subdirs have all
+// been defined
+bool cmEnableTestingCommand::InitialPass(std::vector<std::string> const&,
+                                         cmExecutionStatus&)
+{
+  this->Makefile->AddDefinition("CMAKE_TESTING_ENABLED", "1");
+  return true;
+}
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
new file mode 100644
index 0000000..88a17b9
--- /dev/null
+++ b/Source/cmEnableTestingCommand.h
@@ -0,0 +1,44 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmEnableTestingCommand_h
+#define cmEnableTestingCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmEnableTestingCommand
+ * \brief Enable testing for this directory and below.
+ *
+ * Produce the output testfile. This produces a file in the build directory
+ * called CMakeTestfile with a syntax similar to CMakeLists.txt.  It contains
+ * the SUBDIRS() and ADD_TEST() commands from the source CMakeLists.txt
+ * file with CMake variables expanded.  Only the subdirs and tests
+ * within the valid control structures are replicated in Testfile
+ * (i.e. SUBDIRS() and ADD_TEST() commands within IF() commands that are
+ * not entered by CMake are not replicated in Testfile).
+ * Note that CTest expects to find this file in the build directory root;
+ * therefore, this command should be in the source directory root too.
+ */
+class cmEnableTestingCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmEnableTestingCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) override;
+};
+
+#endif
diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx
new file mode 100644
index 0000000..88e085d
--- /dev/null
+++ b/Source/cmExecProgramCommand.cxx
@@ -0,0 +1,286 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExecProgramCommand.h"
+
+#include "cmsys/Process.h"
+#include <stdio.h>
+
+#include "cmMakefile.h"
+#include "cmProcessOutput.h"
+#include "cmSystemTools.h"
+
+class cmExecutionStatus;
+
+// cmExecProgramCommand
+bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  std::string arguments;
+  bool doingargs = false;
+  int count = 0;
+  std::string output_variable;
+  bool haveoutput_variable = false;
+  std::string return_variable;
+  bool havereturn_variable = false;
+  for (std::string const& arg : args) {
+    if (arg == "OUTPUT_VARIABLE") {
+      count++;
+      doingargs = false;
+      havereturn_variable = false;
+      haveoutput_variable = true;
+    } else if (haveoutput_variable) {
+      if (!output_variable.empty()) {
+        this->SetError("called with incorrect number of arguments");
+        return false;
+      }
+      output_variable = arg;
+      haveoutput_variable = false;
+      count++;
+    } else if (arg == "RETURN_VALUE") {
+      count++;
+      doingargs = false;
+      haveoutput_variable = false;
+      havereturn_variable = true;
+    } else if (havereturn_variable) {
+      if (!return_variable.empty()) {
+        this->SetError("called with incorrect number of arguments");
+        return false;
+      }
+      return_variable = arg;
+      havereturn_variable = false;
+      count++;
+    } else if (arg == "ARGS") {
+      count++;
+      havereturn_variable = false;
+      haveoutput_variable = false;
+      doingargs = true;
+    } else if (doingargs) {
+      arguments += arg;
+      arguments += " ";
+      count++;
+    }
+  }
+
+  std::string command;
+  if (!arguments.empty()) {
+    command = cmSystemTools::ConvertToRunCommandPath(args[0].c_str());
+    command += " ";
+    command += arguments;
+  } else {
+    command = args[0];
+  }
+  bool verbose = true;
+  if (!output_variable.empty()) {
+    verbose = false;
+  }
+  int retVal = 0;
+  std::string output;
+  bool result = true;
+  if (args.size() - count == 2) {
+    cmSystemTools::MakeDirectory(args[1].c_str());
+    result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal,
+                                              args[1].c_str(), verbose);
+  } else {
+    result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal,
+                                              nullptr, verbose);
+  }
+  if (!result) {
+    retVal = -1;
+  }
+
+  if (!output_variable.empty()) {
+    std::string::size_type first = output.find_first_not_of(" \n\t\r");
+    std::string::size_type last = output.find_last_not_of(" \n\t\r");
+    if (first == std::string::npos) {
+      first = 0;
+    }
+    if (last == std::string::npos) {
+      last = output.size() - 1;
+    }
+
+    std::string coutput = std::string(output, first, last - first + 1);
+    this->Makefile->AddDefinition(output_variable, coutput.c_str());
+  }
+
+  if (!return_variable.empty()) {
+    char buffer[100];
+    sprintf(buffer, "%d", retVal);
+    this->Makefile->AddDefinition(return_variable, buffer);
+  }
+
+  return true;
+}
+
+bool cmExecProgramCommand::RunCommand(const char* command, std::string& output,
+                                      int& retVal, const char* dir,
+                                      bool verbose, Encoding encoding)
+{
+  if (cmSystemTools::GetRunCommandOutput()) {
+    verbose = false;
+  }
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  // if the command does not start with a quote, then
+  // try to find the program, and if the program can not be
+  // found use system to run the command as it must be a built in
+  // shell command like echo or dir
+  int count = 0;
+  std::string shortCmd;
+  if (command[0] == '\"') {
+    // count the number of quotes
+    for (const char* s = command; *s != 0; ++s) {
+      if (*s == '\"') {
+        count++;
+        if (count > 2) {
+          break;
+        }
+      }
+    }
+    // if there are more than two double quotes use
+    // GetShortPathName, the cmd.exe program in windows which
+    // is used by system fails to execute if there are more than
+    // one set of quotes in the arguments
+    if (count > 2) {
+      cmsys::RegularExpression quoted("^\"([^\"]*)\"[ \t](.*)");
+      if (quoted.find(command)) {
+        std::string cmd = quoted.match(1);
+        std::string args = quoted.match(2);
+        if (!cmSystemTools::FileExists(cmd.c_str())) {
+          shortCmd = cmd;
+        } else if (!cmSystemTools::GetShortPath(cmd.c_str(), shortCmd)) {
+          cmSystemTools::Error("GetShortPath failed for ", cmd.c_str());
+          return false;
+        }
+        shortCmd += " ";
+        shortCmd += args;
+
+        command = shortCmd.c_str();
+      } else {
+        cmSystemTools::Error("Could not parse command line with quotes ",
+                             command);
+      }
+    }
+  }
+#endif
+
+  // Allocate a process instance.
+  cmsysProcess* cp = cmsysProcess_New();
+  if (!cp) {
+    cmSystemTools::Error("Error allocating process instance.");
+    return false;
+  }
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  if (dir) {
+    cmsysProcess_SetWorkingDirectory(cp, dir);
+  }
+  if (cmSystemTools::GetRunCommandHideConsole()) {
+    cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+  }
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_Verbatim, 1);
+  const char* cmd[] = { command, 0 };
+  cmsysProcess_SetCommand(cp, cmd);
+#else
+  std::string commandInDir;
+  if (dir) {
+    commandInDir = "cd \"";
+    commandInDir += dir;
+    commandInDir += "\" && ";
+    commandInDir += command;
+  } else {
+    commandInDir = command;
+  }
+#ifndef __VMS
+  commandInDir += " 2>&1";
+#endif
+  command = commandInDir.c_str();
+  if (verbose) {
+    cmSystemTools::Stdout("running ");
+    cmSystemTools::Stdout(command);
+    cmSystemTools::Stdout("\n");
+  }
+  fflush(stdout);
+  fflush(stderr);
+  const char* cmd[] = { "/bin/sh", "-c", command, nullptr };
+  cmsysProcess_SetCommand(cp, cmd);
+#endif
+
+  cmsysProcess_Execute(cp);
+
+  // Read the process output.
+  int length;
+  char* data;
+  int p;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  while ((p = cmsysProcess_WaitForData(cp, &data, &length, nullptr), p)) {
+    if (p == cmsysProcess_Pipe_STDOUT || p == cmsysProcess_Pipe_STDERR) {
+      if (verbose) {
+        processOutput.DecodeText(data, length, strdata);
+        cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+      }
+      output.append(data, length);
+    }
+  }
+
+  if (verbose) {
+    processOutput.DecodeText(std::string(), strdata);
+    if (!strdata.empty()) {
+      cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+    }
+  }
+
+  // All output has been read.  Wait for the process to exit.
+  cmsysProcess_WaitForExit(cp, nullptr);
+  processOutput.DecodeText(output, output);
+
+  // Check the result of running the process.
+  std::string msg;
+  switch (cmsysProcess_GetState(cp)) {
+    case cmsysProcess_State_Exited:
+      retVal = cmsysProcess_GetExitValue(cp);
+      break;
+    case cmsysProcess_State_Exception:
+      retVal = -1;
+      msg += "\nProcess terminated due to: ";
+      msg += cmsysProcess_GetExceptionString(cp);
+      break;
+    case cmsysProcess_State_Error:
+      retVal = -1;
+      msg += "\nProcess failed because: ";
+      msg += cmsysProcess_GetErrorString(cp);
+      break;
+    case cmsysProcess_State_Expired:
+      retVal = -1;
+      msg += "\nProcess terminated due to timeout.";
+      break;
+  }
+  if (!msg.empty()) {
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    // Old Windows process execution printed this info.
+    msg += "\n\nfor command: ";
+    msg += command;
+    if (dir) {
+      msg += "\nin dir: ";
+      msg += dir;
+    }
+    msg += "\n";
+    if (verbose) {
+      cmSystemTools::Stdout(msg.c_str());
+    }
+    output += msg;
+#else
+    // Old UNIX process execution only put message in output.
+    output += msg;
+#endif
+  }
+
+  // Delete the process instance.
+  cmsysProcess_Delete(cp);
+
+  return true;
+}
diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h
new file mode 100644
index 0000000..dc5da74
--- /dev/null
+++ b/Source/cmExecProgramCommand.h
@@ -0,0 +1,45 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExecProgramCommand_h
+#define cmExecProgramCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+#include "cmProcessOutput.h"
+
+class cmExecutionStatus;
+
+/** \class cmExecProgramCommand
+ * \brief Command that adds a target to the build system.
+ *
+ * cmExecProgramCommand adds an extra target to the build system.
+ * This is useful when you would like to add special
+ * targets like "install,", "clean," and so on.
+ */
+class cmExecProgramCommand : public cmCommand
+{
+public:
+  typedef cmProcessOutput::Encoding Encoding;
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmExecProgramCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  static bool RunCommand(const char* command, std::string& output, int& retVal,
+                         const char* directory = nullptr, bool verbose = true,
+                         Encoding encoding = cmProcessOutput::Auto);
+};
+
+#endif
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
new file mode 100644
index 0000000..39e774e
--- /dev/null
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -0,0 +1,410 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExecuteProcessCommand.h"
+
+#include "cmsys/Process.h"
+#include <ctype.h> /* isspace */
+#include <sstream>
+#include <stdio.h>
+
+#include "cmAlgorithms.h"
+#include "cmMakefile.h"
+#include "cmProcessOutput.h"
+#include "cmSystemTools.h"
+
+class cmExecutionStatus;
+
+static bool cmExecuteProcessCommandIsWhitespace(char c)
+{
+  return (isspace(static_cast<int>(c)) || c == '\n' || c == '\r');
+}
+
+void cmExecuteProcessCommandFixText(std::vector<char>& output,
+                                    bool strip_trailing_whitespace);
+void cmExecuteProcessCommandAppend(std::vector<char>& output, const char* data,
+                                   int length);
+
+// cmExecuteProcessCommand
+bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  std::vector<std::vector<const char*>> cmds;
+  std::string arguments;
+  bool doing_command = false;
+  size_t command_index = 0;
+  bool output_quiet = false;
+  bool error_quiet = false;
+  bool output_strip_trailing_whitespace = false;
+  bool error_strip_trailing_whitespace = false;
+  std::string timeout_string;
+  std::string input_file;
+  std::string output_file;
+  std::string error_file;
+  std::string output_variable;
+  std::string error_variable;
+  std::string result_variable;
+  std::string results_variable;
+  std::string working_directory;
+  cmProcessOutput::Encoding encoding = cmProcessOutput::None;
+  for (size_t i = 0; i < args.size(); ++i) {
+    if (args[i] == "COMMAND") {
+      doing_command = true;
+      command_index = cmds.size();
+      cmds.push_back(std::vector<const char*>());
+    } else if (args[i] == "OUTPUT_VARIABLE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        output_variable = args[i];
+      } else {
+        this->SetError(" called with no value for OUTPUT_VARIABLE.");
+        return false;
+      }
+    } else if (args[i] == "ERROR_VARIABLE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        error_variable = args[i];
+      } else {
+        this->SetError(" called with no value for ERROR_VARIABLE.");
+        return false;
+      }
+    } else if (args[i] == "RESULT_VARIABLE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        result_variable = args[i];
+      } else {
+        this->SetError(" called with no value for RESULT_VARIABLE.");
+        return false;
+      }
+    } else if (args[i] == "RESULTS_VARIABLE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        results_variable = args[i];
+      } else {
+        this->SetError(" called with no value for RESULTS_VARIABLE.");
+        return false;
+      }
+    } else if (args[i] == "WORKING_DIRECTORY") {
+      doing_command = false;
+      if (++i < args.size()) {
+        working_directory = args[i];
+      } else {
+        this->SetError(" called with no value for WORKING_DIRECTORY.");
+        return false;
+      }
+    } else if (args[i] == "INPUT_FILE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        input_file = args[i];
+      } else {
+        this->SetError(" called with no value for INPUT_FILE.");
+        return false;
+      }
+    } else if (args[i] == "OUTPUT_FILE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        output_file = args[i];
+      } else {
+        this->SetError(" called with no value for OUTPUT_FILE.");
+        return false;
+      }
+    } else if (args[i] == "ERROR_FILE") {
+      doing_command = false;
+      if (++i < args.size()) {
+        error_file = args[i];
+      } else {
+        this->SetError(" called with no value for ERROR_FILE.");
+        return false;
+      }
+    } else if (args[i] == "TIMEOUT") {
+      doing_command = false;
+      if (++i < args.size()) {
+        timeout_string = args[i];
+      } else {
+        this->SetError(" called with no value for TIMEOUT.");
+        return false;
+      }
+    } else if (args[i] == "OUTPUT_QUIET") {
+      doing_command = false;
+      output_quiet = true;
+    } else if (args[i] == "ERROR_QUIET") {
+      doing_command = false;
+      error_quiet = true;
+    } else if (args[i] == "OUTPUT_STRIP_TRAILING_WHITESPACE") {
+      doing_command = false;
+      output_strip_trailing_whitespace = true;
+    } else if (args[i] == "ERROR_STRIP_TRAILING_WHITESPACE") {
+      doing_command = false;
+      error_strip_trailing_whitespace = true;
+    } else if (args[i] == "ENCODING") {
+      doing_command = false;
+      if (++i < args.size()) {
+        encoding = cmProcessOutput::FindEncoding(args[i]);
+      } else {
+        this->SetError(" called with no value for ENCODING.");
+        return false;
+      }
+    } else if (doing_command) {
+      cmds[command_index].push_back(args[i].c_str());
+    } else {
+      std::ostringstream e;
+      e << " given unknown argument \"" << args[i] << "\".";
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  if (!this->Makefile->CanIWriteThisFile(output_file.c_str())) {
+    std::string e = "attempted to output into a file: " + output_file +
+      " into a source directory.";
+    this->SetError(e);
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+  }
+
+  // Check for commands given.
+  if (cmds.empty()) {
+    this->SetError(" called with no COMMAND argument.");
+    return false;
+  }
+  for (auto& cmd : cmds) {
+    if (cmd.empty()) {
+      this->SetError(" given COMMAND argument with no value.");
+      return false;
+    }
+    // Add the null terminating pointer to the command argument list.
+    cmd.push_back(nullptr);
+  }
+
+  // Parse the timeout string.
+  double timeout = -1;
+  if (!timeout_string.empty()) {
+    if (sscanf(timeout_string.c_str(), "%lg", &timeout) != 1) {
+      this->SetError(" called with TIMEOUT value that could not be parsed.");
+      return false;
+    }
+  }
+
+  // Create a process instance.
+  cmsysProcess* cp = cmsysProcess_New();
+
+  // Set the command sequence.
+  for (auto const& cmd : cmds) {
+    cmsysProcess_AddCommand(cp, &*cmd.begin());
+  }
+
+  // Set the process working directory.
+  if (!working_directory.empty()) {
+    cmsysProcess_SetWorkingDirectory(cp, working_directory.c_str());
+  }
+
+  // Always hide the process window.
+  cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+
+  // Check the output variables.
+  bool merge_output = false;
+  if (!input_file.empty()) {
+    cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDIN, input_file.c_str());
+  }
+  if (!output_file.empty()) {
+    cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDOUT,
+                             output_file.c_str());
+  }
+  if (!error_file.empty()) {
+    if (error_file == output_file) {
+      merge_output = true;
+    } else {
+      cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDERR,
+                               error_file.c_str());
+    }
+  }
+  if (!output_variable.empty() && output_variable == error_variable) {
+    merge_output = true;
+  }
+  if (merge_output) {
+    cmsysProcess_SetOption(cp, cmsysProcess_Option_MergeOutput, 1);
+  }
+
+  // Set the timeout if any.
+  if (timeout >= 0) {
+    cmsysProcess_SetTimeout(cp, timeout);
+  }
+
+  // Start the process.
+  cmsysProcess_Execute(cp);
+
+  // Read the process output.
+  std::vector<char> tempOutput;
+  std::vector<char> tempError;
+  int length;
+  char* data;
+  int p;
+  cmProcessOutput processOutput(encoding);
+  std::string strdata;
+  while ((p = cmsysProcess_WaitForData(cp, &data, &length, nullptr), p)) {
+    // Put the output in the right place.
+    if (p == cmsysProcess_Pipe_STDOUT && !output_quiet) {
+      if (output_variable.empty()) {
+        processOutput.DecodeText(data, length, strdata, 1);
+        cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+      } else {
+        cmExecuteProcessCommandAppend(tempOutput, data, length);
+      }
+    } else if (p == cmsysProcess_Pipe_STDERR && !error_quiet) {
+      if (error_variable.empty()) {
+        processOutput.DecodeText(data, length, strdata, 2);
+        cmSystemTools::Stderr(strdata.c_str(), strdata.size());
+      } else {
+        cmExecuteProcessCommandAppend(tempError, data, length);
+      }
+    }
+  }
+  if (!output_quiet && output_variable.empty()) {
+    processOutput.DecodeText(std::string(), strdata, 1);
+    if (!strdata.empty()) {
+      cmSystemTools::Stdout(strdata.c_str(), strdata.size());
+    }
+  }
+  if (!error_quiet && error_variable.empty()) {
+    processOutput.DecodeText(std::string(), strdata, 2);
+    if (!strdata.empty()) {
+      cmSystemTools::Stderr(strdata.c_str(), strdata.size());
+    }
+  }
+
+  // All output has been read.  Wait for the process to exit.
+  cmsysProcess_WaitForExit(cp, nullptr);
+  processOutput.DecodeText(tempOutput, tempOutput);
+  processOutput.DecodeText(tempError, tempError);
+
+  // Fix the text in the output strings.
+  cmExecuteProcessCommandFixText(tempOutput, output_strip_trailing_whitespace);
+  cmExecuteProcessCommandFixText(tempError, error_strip_trailing_whitespace);
+
+  // Store the output obtained.
+  if (!output_variable.empty() && !tempOutput.empty()) {
+    this->Makefile->AddDefinition(output_variable, &*tempOutput.begin());
+  }
+  if (!merge_output && !error_variable.empty() && !tempError.empty()) {
+    this->Makefile->AddDefinition(error_variable, &*tempError.begin());
+  }
+
+  // Store the result of running the process.
+  if (!result_variable.empty()) {
+    switch (cmsysProcess_GetState(cp)) {
+      case cmsysProcess_State_Exited: {
+        int v = cmsysProcess_GetExitValue(cp);
+        char buf[16];
+        sprintf(buf, "%d", v);
+        this->Makefile->AddDefinition(result_variable, buf);
+      } break;
+      case cmsysProcess_State_Exception:
+        this->Makefile->AddDefinition(result_variable,
+                                      cmsysProcess_GetExceptionString(cp));
+        break;
+      case cmsysProcess_State_Error:
+        this->Makefile->AddDefinition(result_variable,
+                                      cmsysProcess_GetErrorString(cp));
+        break;
+      case cmsysProcess_State_Expired:
+        this->Makefile->AddDefinition(result_variable,
+                                      "Process terminated due to timeout");
+        break;
+    }
+  }
+  // Store the result of running the processes.
+  if (!results_variable.empty()) {
+    switch (cmsysProcess_GetState(cp)) {
+      case cmsysProcess_State_Exited: {
+        std::vector<std::string> res;
+        for (size_t i = 0; i < cmds.size(); ++i) {
+          switch (cmsysProcess_GetStateByIndex(cp, static_cast<int>(i))) {
+            case kwsysProcess_StateByIndex_Exited: {
+              int exitCode =
+                cmsysProcess_GetExitValueByIndex(cp, static_cast<int>(i));
+              char buf[16];
+              sprintf(buf, "%d", exitCode);
+              res.push_back(buf);
+            } break;
+            case kwsysProcess_StateByIndex_Exception:
+              res.push_back(cmsysProcess_GetExceptionStringByIndex(
+                cp, static_cast<int>(i)));
+              break;
+            case kwsysProcess_StateByIndex_Error:
+            default:
+              res.push_back("Error getting the child return code");
+              break;
+          }
+        }
+        this->Makefile->AddDefinition(results_variable,
+                                      cmJoin(res, ";").c_str());
+      } break;
+      case cmsysProcess_State_Exception:
+        this->Makefile->AddDefinition(results_variable,
+                                      cmsysProcess_GetExceptionString(cp));
+        break;
+      case cmsysProcess_State_Error:
+        this->Makefile->AddDefinition(results_variable,
+                                      cmsysProcess_GetErrorString(cp));
+        break;
+      case cmsysProcess_State_Expired:
+        this->Makefile->AddDefinition(results_variable,
+                                      "Process terminated due to timeout");
+        break;
+    }
+  }
+
+  // Delete the process instance.
+  cmsysProcess_Delete(cp);
+
+  return true;
+}
+
+void cmExecuteProcessCommandFixText(std::vector<char>& output,
+                                    bool strip_trailing_whitespace)
+{
+  // Remove \0 characters and the \r part of \r\n pairs.
+  unsigned int in_index = 0;
+  unsigned int out_index = 0;
+  while (in_index < output.size()) {
+    char c = output[in_index++];
+    if ((c != '\r' ||
+         !(in_index < output.size() && output[in_index] == '\n')) &&
+        c != '\0') {
+      output[out_index++] = c;
+    }
+  }
+
+  // Remove trailing whitespace if requested.
+  if (strip_trailing_whitespace) {
+    while (out_index > 0 &&
+           cmExecuteProcessCommandIsWhitespace(output[out_index - 1])) {
+      --out_index;
+    }
+  }
+
+  // Shrink the vector to the size needed.
+  output.resize(out_index);
+
+  // Put a terminator on the text string.
+  output.push_back('\0');
+}
+
+void cmExecuteProcessCommandAppend(std::vector<char>& output, const char* data,
+                                   int length)
+{
+#if defined(__APPLE__)
+  // HACK on Apple to work around bug with inserting at the
+  // end of an empty vector.  This resulted in random failures
+  // that were hard to reproduce.
+  if (output.empty() && length > 0) {
+    output.push_back(data[0]);
+    ++data;
+    --length;
+  }
+#endif
+  output.insert(output.end(), data, data + length);
+}
diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h
new file mode 100644
index 0000000..b415deb
--- /dev/null
+++ b/Source/cmExecuteProcessCommand.h
@@ -0,0 +1,37 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExecuteProcessCommand_h
+#define cmExecuteProcessCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+/** \class cmExecuteProcessCommand
+ * \brief Command that adds a target to the build system.
+ *
+ * cmExecuteProcessCommand is a CMake language interface to the KWSys
+ * Process Execution implementation.
+ */
+class cmExecuteProcessCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmExecuteProcessCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+};
+
+#endif
diff --git a/Source/cmExecutionStatus.h b/Source/cmExecutionStatus.h
new file mode 100644
index 0000000..ac5fe1d
--- /dev/null
+++ b/Source/cmExecutionStatus.h
@@ -0,0 +1,49 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExecutionStatus_h
+#define cmExecutionStatus_h
+
+/** \class cmExecutionStatus
+ * \brief Superclass for all command status classes
+ *
+ * when a command is involked it may set values on a command status instance
+ */
+class cmExecutionStatus
+{
+public:
+  cmExecutionStatus()
+    : ReturnInvoked(false)
+    , BreakInvoked(false)
+    , ContinueInvoked(false)
+    , NestedError(false)
+  {
+  }
+
+  void Clear()
+  {
+    this->ReturnInvoked = false;
+    this->BreakInvoked = false;
+    this->ContinueInvoked = false;
+    this->NestedError = false;
+  }
+
+  void SetReturnInvoked() { this->ReturnInvoked = true; }
+  bool GetReturnInvoked() const { return this->ReturnInvoked; }
+
+  void SetBreakInvoked() { this->BreakInvoked = true; }
+  bool GetBreakInvoked() const { return this->BreakInvoked; }
+
+  void SetContinueInvoked() { this->ContinueInvoked = true; }
+  bool GetContinueInvoked() const { return this->ContinueInvoked; }
+
+  void SetNestedError() { this->NestedError = true; }
+  bool GetNestedError() const { return this->NestedError; }
+
+private:
+  bool ReturnInvoked;
+  bool BreakInvoked;
+  bool ContinueInvoked;
+  bool NestedError;
+};
+
+#endif
diff --git a/Source/cmExpandedCommandArgument.cxx b/Source/cmExpandedCommandArgument.cxx
new file mode 100644
index 0000000..0bea65f
--- /dev/null
+++ b/Source/cmExpandedCommandArgument.cxx
@@ -0,0 +1,40 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExpandedCommandArgument.h"
+
+cmExpandedCommandArgument::cmExpandedCommandArgument()
+  : Quoted(false)
+{
+}
+
+cmExpandedCommandArgument::cmExpandedCommandArgument(std::string const& value,
+                                                     bool quoted)
+  : Value(value)
+  , Quoted(quoted)
+{
+}
+
+std::string const& cmExpandedCommandArgument::GetValue() const
+{
+  return this->Value;
+}
+
+bool cmExpandedCommandArgument::WasQuoted() const
+{
+  return this->Quoted;
+}
+
+bool cmExpandedCommandArgument::operator==(std::string const& value) const
+{
+  return this->Value == value;
+}
+
+bool cmExpandedCommandArgument::empty() const
+{
+  return this->Value.empty();
+}
+
+const char* cmExpandedCommandArgument::c_str() const
+{
+  return this->Value.c_str();
+}
diff --git a/Source/cmExpandedCommandArgument.h b/Source/cmExpandedCommandArgument.h
new file mode 100644
index 0000000..fe86528
--- /dev/null
+++ b/Source/cmExpandedCommandArgument.h
@@ -0,0 +1,38 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExpandedCommandArgument_h
+#define cmExpandedCommandArgument_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+
+/** \class cmExpandedCommandArgument
+ * \brief Represents an expanded command argument
+ *
+ * cmCommandArgument stores a string representing an expanded
+ * command argument and context information.
+ */
+
+class cmExpandedCommandArgument
+{
+public:
+  cmExpandedCommandArgument();
+  cmExpandedCommandArgument(std::string const& value, bool quoted);
+
+  std::string const& GetValue() const;
+
+  bool WasQuoted() const;
+
+  bool operator==(std::string const& value) const;
+
+  bool empty() const;
+
+  const char* c_str() const;
+
+private:
+  std::string Value;
+  bool Quoted;
+};
+
+#endif
diff --git a/Source/cmExportBuildAndroidMKGenerator.cxx b/Source/cmExportBuildAndroidMKGenerator.cxx
new file mode 100644
index 0000000..5e2cd53
--- /dev/null
+++ b/Source/cmExportBuildAndroidMKGenerator.cxx
@@ -0,0 +1,200 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportBuildAndroidMKGenerator.h"
+
+#include <algorithm>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+#include <utility>
+
+#include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
+#include "cmLinkItem.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+cmExportBuildAndroidMKGenerator::cmExportBuildAndroidMKGenerator()
+{
+  this->LG = nullptr;
+  this->ExportSet = nullptr;
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateImportHeaderCode(
+  std::ostream& os, const std::string&)
+{
+  os << "LOCAL_PATH := $(call my-dir)\n\n";
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateImportFooterCode(std::ostream&)
+{
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateExpectedTargetsCode(
+  std::ostream&, const std::string&)
+{
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateImportTargetCode(
+  std::ostream& os, const cmGeneratorTarget* target)
+{
+  std::string targetName = this->Namespace;
+  targetName += target->GetExportName();
+  os << "include $(CLEAR_VARS)\n";
+  os << "LOCAL_MODULE := ";
+  os << targetName << "\n";
+  os << "LOCAL_SRC_FILES := ";
+  std::string path =
+    cmSystemTools::ConvertToOutputPath(target->GetFullPath().c_str());
+  os << path << "\n";
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateImportPropertyCode(
+  std::ostream&, const std::string&, cmGeneratorTarget const*,
+  ImportPropertyMap const&)
+{
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateMissingTargetsCheckCode(
+  std::ostream&, const std::vector<std::string>&)
+{
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
+  const cmGeneratorTarget* target, std::ostream& os,
+  const ImportPropertyMap& properties)
+{
+  std::string config;
+  if (!this->Configurations.empty()) {
+    config = this->Configurations[0];
+  }
+  cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
+    target, os, properties, cmExportBuildAndroidMKGenerator::BUILD, config);
+}
+
+void cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
+  const cmGeneratorTarget* target, std::ostream& os,
+  const ImportPropertyMap& properties, GenerateType type,
+  std::string const& config)
+{
+  const bool newCMP0022Behavior =
+    target->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+    target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+  if (!newCMP0022Behavior) {
+    std::ostringstream w;
+    if (type == cmExportBuildAndroidMKGenerator::BUILD) {
+      w << "export(TARGETS ... ANDROID_MK) called with policy CMP0022";
+    } else {
+      w << "install( EXPORT_ANDROID_MK ...) called with policy CMP0022";
+    }
+    w << " set to OLD for target " << target->Target->GetName() << ". "
+      << "The export will only work with CMP0022 set to NEW.";
+    target->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+  }
+  if (!properties.empty()) {
+    os << "LOCAL_CPP_FEATURES := rtti exceptions\n";
+    for (auto const& property : properties) {
+      if (property.first == "INTERFACE_COMPILE_OPTIONS") {
+        os << "LOCAL_CPP_FEATURES += ";
+        os << (property.second) << "\n";
+      } else if (property.first == "INTERFACE_LINK_LIBRARIES") {
+        // need to look at list in pi->second and see if static or shared
+        // FindTargetToLink
+        // target->GetLocalGenerator()->FindGeneratorTargetToUse()
+        // then add to LOCAL_CPPFLAGS
+        std::vector<std::string> libraries;
+        cmSystemTools::ExpandListArgument(property.second, libraries);
+        std::string staticLibs;
+        std::string sharedLibs;
+        std::string ldlibs;
+        for (std::string const& lib : libraries) {
+          cmGeneratorTarget* gt =
+            target->GetLocalGenerator()->FindGeneratorTargetToUse(lib);
+          if (gt) {
+
+            if (gt->GetType() == cmStateEnums::SHARED_LIBRARY ||
+                gt->GetType() == cmStateEnums::MODULE_LIBRARY) {
+              sharedLibs += " " + lib;
+            } else {
+              staticLibs += " " + lib;
+            }
+          } else {
+            // evaluate any generator expressions with the current
+            // build type of the makefile
+            cmGeneratorExpression ge;
+            std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(lib);
+            std::string evaluated =
+              cge->Evaluate(target->GetLocalGenerator(), config);
+            bool relpath = false;
+            if (type == cmExportBuildAndroidMKGenerator::INSTALL) {
+              relpath = lib.substr(0, 3) == "../";
+            }
+            // check for full path or if it already has a -l, or
+            // in the case of an install check for relative paths
+            // if it is full or a link library then use string directly
+            if (cmSystemTools::FileIsFullPath(evaluated) ||
+                evaluated.substr(0, 2) == "-l" || relpath) {
+              ldlibs += " " + evaluated;
+              // if it is not a path and does not have a -l then add -l
+            } else if (!evaluated.empty()) {
+              ldlibs += " -l" + evaluated;
+            }
+          }
+        }
+        if (!sharedLibs.empty()) {
+          os << "LOCAL_SHARED_LIBRARIES :=" << sharedLibs << "\n";
+        }
+        if (!staticLibs.empty()) {
+          os << "LOCAL_STATIC_LIBRARIES :=" << staticLibs << "\n";
+        }
+        if (!ldlibs.empty()) {
+          os << "LOCAL_EXPORT_LDLIBS :=" << ldlibs << "\n";
+        }
+      } else if (property.first == "INTERFACE_INCLUDE_DIRECTORIES") {
+        std::string includes = property.second;
+        std::vector<std::string> includeList;
+        cmSystemTools::ExpandListArgument(includes, includeList);
+        os << "LOCAL_EXPORT_C_INCLUDES := ";
+        std::string end;
+        for (std::string const& i : includeList) {
+          os << end << i;
+          end = "\\\n";
+        }
+        os << "\n";
+      } else {
+        os << "# " << property.first << " " << (property.second) << "\n";
+      }
+    }
+  }
+
+  // Tell the NDK build system if prebuilt static libraries use C++.
+  if (target->GetType() == cmStateEnums::STATIC_LIBRARY) {
+    cmLinkImplementation const* li = target->GetLinkImplementation(config);
+    if (std::find(li->Languages.begin(), li->Languages.end(), "CXX") !=
+        li->Languages.end()) {
+      os << "LOCAL_HAS_CPP := true\n";
+    }
+  }
+
+  switch (target->GetType()) {
+    case cmStateEnums::SHARED_LIBRARY:
+    case cmStateEnums::MODULE_LIBRARY:
+      os << "include $(PREBUILT_SHARED_LIBRARY)\n";
+      break;
+    case cmStateEnums::STATIC_LIBRARY:
+      os << "include $(PREBUILT_STATIC_LIBRARY)\n";
+      break;
+    case cmStateEnums::EXECUTABLE:
+    case cmStateEnums::UTILITY:
+    case cmStateEnums::OBJECT_LIBRARY:
+    case cmStateEnums::GLOBAL_TARGET:
+    case cmStateEnums::INTERFACE_LIBRARY:
+    case cmStateEnums::UNKNOWN_LIBRARY:
+      break;
+  }
+  os << "\n";
+}
diff --git a/Source/cmExportBuildAndroidMKGenerator.h b/Source/cmExportBuildAndroidMKGenerator.h
new file mode 100644
index 0000000..c80839b
--- /dev/null
+++ b/Source/cmExportBuildAndroidMKGenerator.h
@@ -0,0 +1,65 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportBuildAndroidMKGenerator_h
+#define cmExportBuildAndroidMKGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "cmExportBuildFileGenerator.h"
+#include "cmExportFileGenerator.h"
+
+class cmGeneratorTarget;
+
+/** \class cmExportBuildAndroidMKGenerator
+ * \brief Generate a file exporting targets from a build tree.
+ *
+ * cmExportBuildAndroidMKGenerator generates a file exporting targets from
+ * a build tree.  This exports the targets to the Android ndk build tool
+ * makefile format for prebuilt libraries.
+ *
+ * This is used to implement the EXPORT() command.
+ */
+class cmExportBuildAndroidMKGenerator : public cmExportBuildFileGenerator
+{
+public:
+  cmExportBuildAndroidMKGenerator();
+  // this is so cmExportInstallAndroidMKGenerator can share this
+  // function as they are almost the same
+  enum GenerateType
+  {
+    BUILD,
+    INSTALL
+  };
+  static void GenerateInterfaceProperties(cmGeneratorTarget const* target,
+                                          std::ostream& os,
+                                          const ImportPropertyMap& properties,
+                                          GenerateType type,
+                                          std::string const& config);
+
+protected:
+  // Implement virtual methods from the superclass.
+  void GeneratePolicyHeaderCode(std::ostream&) override {}
+  void GeneratePolicyFooterCode(std::ostream&) override {}
+  void GenerateImportHeaderCode(std::ostream& os,
+                                const std::string& config = "") override;
+  void GenerateImportFooterCode(std::ostream& os) override;
+  void GenerateImportTargetCode(std::ostream& os,
+                                const cmGeneratorTarget* target) override;
+  void GenerateExpectedTargetsCode(
+    std::ostream& os, const std::string& expectedTargets) override;
+  void GenerateImportPropertyCode(
+    std::ostream& os, const std::string& config,
+    cmGeneratorTarget const* target,
+    ImportPropertyMap const& properties) override;
+  void GenerateMissingTargetsCheckCode(
+    std::ostream& os, const std::vector<std::string>& missingTargets) override;
+  void GenerateInterfaceProperties(
+    cmGeneratorTarget const* target, std::ostream& os,
+    const ImportPropertyMap& properties) override;
+};
+
+#endif
diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
new file mode 100644
index 0000000..bb1dda3
--- /dev/null
+++ b/Source/cmExportBuildFileGenerator.cxx
@@ -0,0 +1,310 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportBuildFileGenerator.h"
+
+#include "cmAlgorithms.h"
+#include "cmExportSet.h"
+#include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetExport.h"
+#include "cmake.h"
+
+#include <algorithm>
+#include <map>
+#include <set>
+#include <sstream>
+#include <utility>
+
+class cmSourceFile;
+
+cmExportBuildFileGenerator::cmExportBuildFileGenerator()
+{
+  this->LG = nullptr;
+  this->ExportSet = nullptr;
+}
+
+void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
+{
+  this->LG = lg;
+  if (this->ExportSet) {
+    this->ExportSet->Compute(lg);
+  }
+}
+
+bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
+{
+  {
+    std::string expectedTargets;
+    std::string sep;
+    std::vector<std::string> targets;
+    this->GetTargets(targets);
+    for (std::string const& tei : targets) {
+      cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(tei);
+      expectedTargets += sep + this->Namespace + te->GetExportName();
+      sep = " ";
+      if (this->ExportedTargets.insert(te).second) {
+        this->Exports.push_back(te);
+      } else {
+        std::ostringstream e;
+        e << "given target \"" << te->GetName() << "\" more than once.";
+        this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+          cmake::FATAL_ERROR, e.str(),
+          this->LG->GetMakefile()->GetBacktrace());
+        return false;
+      }
+      if (te->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+        this->GenerateRequiredCMakeVersion(os, "3.0.0");
+      }
+    }
+
+    this->GenerateExpectedTargetsCode(os, expectedTargets);
+  }
+
+  std::vector<std::string> missingTargets;
+
+  // Create all the imported targets.
+  for (cmGeneratorTarget* gte : this->Exports) {
+    this->GenerateImportTargetCode(os, gte);
+
+    gte->Target->AppendBuildInterfaceIncludes();
+
+    ImportPropertyMap properties;
+
+    this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
+                                    cmGeneratorExpression::BuildInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
+                                    properties);
+    const bool newCMP0022Behavior =
+      gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+      gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    if (newCMP0022Behavior) {
+      this->PopulateInterfaceLinkLibrariesProperty(
+        gte, cmGeneratorExpression::BuildInterface, properties,
+        missingTargets);
+    }
+    this->PopulateCompatibleInterfaceProperties(gte, properties);
+
+    this->GenerateInterfaceProperties(gte, os, properties);
+  }
+
+  // Generate import file content for each configuration.
+  for (std::string const& c : this->Configurations) {
+    this->GenerateImportConfig(os, c, missingTargets);
+  }
+
+  this->GenerateMissingTargetsCheckCode(os, missingTargets);
+
+  return true;
+}
+
+void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
+  std::ostream& os, const std::string& config, std::string const& suffix,
+  std::vector<std::string>& missingTargets)
+{
+  for (cmGeneratorTarget* target : this->Exports) {
+    // Collect import properties for this target.
+    ImportPropertyMap properties;
+
+    if (target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
+      this->SetImportLocationProperty(config, suffix, target, properties);
+    }
+    if (!properties.empty()) {
+      // Get the rest of the target details.
+      if (target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
+        this->SetImportDetailProperties(config, suffix, target, properties,
+                                        missingTargets);
+        this->SetImportLinkInterface(config, suffix,
+                                     cmGeneratorExpression::BuildInterface,
+                                     target, properties, missingTargets);
+      }
+
+      // TOOD: PUBLIC_HEADER_LOCATION
+      // This should wait until the build feature propagation stuff
+      // is done.  Then this can be a propagated include directory.
+      // this->GenerateImportProperty(config, te->HeaderGenerator,
+      //                              properties);
+
+      // Generate code in the export file.
+      this->GenerateImportPropertyCode(os, config, target, properties);
+    }
+  }
+}
+
+void cmExportBuildFileGenerator::SetExportSet(cmExportSet* exportSet)
+{
+  this->ExportSet = exportSet;
+}
+
+void cmExportBuildFileGenerator::SetImportLocationProperty(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorTarget* target, ImportPropertyMap& properties)
+{
+  // Get the makefile in which to lookup target information.
+  cmMakefile* mf = target->Makefile;
+
+  if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+    std::string prop = "IMPORTED_OBJECTS";
+    prop += suffix;
+
+    // Compute all the object files inside this target and setup
+    // IMPORTED_OBJECTS as a list of object files
+    std::vector<cmSourceFile const*> objectSources;
+    target->GetObjectSources(objectSources, config);
+    std::string const obj_dir = target->GetObjectDirectory(config);
+    std::vector<std::string> objects;
+    for (cmSourceFile const* sf : objectSources) {
+      const std::string& obj = target->GetObjectName(sf);
+      objects.push_back(obj_dir + obj);
+    }
+
+    // Store the property.
+    properties[prop] = cmJoin(objects, ";");
+  } else {
+    // Add the main target file.
+    {
+      std::string prop = "IMPORTED_LOCATION";
+      prop += suffix;
+      std::string value;
+      if (target->IsAppBundleOnApple()) {
+        value =
+          target->GetFullPath(config, cmStateEnums::RuntimeBinaryArtifact);
+      } else {
+        value = target->GetFullPath(config,
+                                    cmStateEnums::RuntimeBinaryArtifact, true);
+      }
+      properties[prop] = value;
+    }
+
+    // Add the import library for windows DLLs.
+    if (target->HasImportLibrary() &&
+        mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+      std::string prop = "IMPORTED_IMPLIB";
+      prop += suffix;
+      std::string value =
+        target->GetFullPath(config, cmStateEnums::ImportLibraryArtifact);
+      target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+      properties[prop] = value;
+    }
+  }
+}
+
+void cmExportBuildFileGenerator::HandleMissingTarget(
+  std::string& link_libs, std::vector<std::string>& missingTargets,
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
+{
+  // The target is not in the export.
+  if (!this->AppendMode) {
+    const std::string name = dependee->GetName();
+    cmGlobalGenerator* gg =
+      dependee->GetLocalGenerator()->GetGlobalGenerator();
+    std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
+
+    int targetOccurrences = static_cast<int>(namespaces.size());
+    if (targetOccurrences == 1) {
+      std::string missingTarget = namespaces[0];
+
+      missingTarget += dependee->GetExportName();
+      link_libs += missingTarget;
+      missingTargets.push_back(missingTarget);
+      return;
+    }
+    // We are not appending, so all exported targets should be
+    // known here.  This is probably user-error.
+    this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
+  }
+  // Assume the target will be exported by another command.
+  // Append it with the export namespace.
+  link_libs += this->Namespace;
+  link_libs += dependee->GetExportName();
+}
+
+void cmExportBuildFileGenerator::GetTargets(
+  std::vector<std::string>& targets) const
+{
+  if (this->ExportSet) {
+    for (cmTargetExport* te : *this->ExportSet->GetTargetExports()) {
+      targets.push_back(te->TargetName);
+    }
+    return;
+  }
+  targets = this->Targets;
+}
+
+std::vector<std::string> cmExportBuildFileGenerator::FindNamespaces(
+  cmGlobalGenerator* gg, const std::string& name)
+{
+  std::vector<std::string> namespaces;
+
+  std::map<std::string, cmExportBuildFileGenerator*>& exportSets =
+    gg->GetBuildExportSets();
+
+  for (auto const& exp : exportSets) {
+    const cmExportBuildFileGenerator* exportSet = exp.second;
+    std::vector<std::string> targets;
+    exportSet->GetTargets(targets);
+    if (std::find(targets.begin(), targets.end(), name) != targets.end()) {
+      namespaces.push_back(exportSet->GetNamespace());
+    }
+  }
+
+  return namespaces;
+}
+
+void cmExportBuildFileGenerator::ComplainAboutMissingTarget(
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee, int occurrences)
+{
+  if (cmSystemTools::GetErrorOccuredFlag()) {
+    return;
+  }
+
+  std::ostringstream e;
+  e << "export called with target \"" << depender->GetName()
+    << "\" which requires target \"" << dependee->GetName() << "\" ";
+  if (occurrences == 0) {
+    e << "that is not in the export set.\n";
+  } else {
+    e << "that is not in this export set, but " << occurrences
+      << " times in others.\n";
+  }
+  e << "If the required target is not easy to reference in this call, "
+    << "consider using the APPEND option with multiple separate calls.";
+
+  this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+    cmake::FATAL_ERROR, e.str(), this->LG->GetMakefile()->GetBacktrace());
+}
+
+std::string cmExportBuildFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string& config)
+{
+  std::string install_name_dir;
+
+  cmMakefile* mf = target->Target->GetMakefile();
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForBuildTree(config);
+  }
+
+  return install_name_dir;
+}
diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h
new file mode 100644
index 0000000..6457a77
--- /dev/null
+++ b/Source/cmExportBuildFileGenerator.h
@@ -0,0 +1,83 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportBuildFileGenerator_h
+#define cmExportBuildFileGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmExportFileGenerator.h"
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+class cmExportSet;
+class cmGeneratorTarget;
+class cmGlobalGenerator;
+class cmLocalGenerator;
+
+/** \class cmExportBuildFileGenerator
+ * \brief Generate a file exporting targets from a build tree.
+ *
+ * cmExportBuildFileGenerator generates a file exporting targets from
+ * a build tree.  A single file exports information for all
+ * configurations built.
+ *
+ * This is used to implement the EXPORT() command.
+ */
+class cmExportBuildFileGenerator : public cmExportFileGenerator
+{
+public:
+  cmExportBuildFileGenerator();
+
+  /** Set the list of targets to export.  */
+  void SetTargets(std::vector<std::string> const& targets)
+  {
+    this->Targets = targets;
+  }
+  void GetTargets(std::vector<std::string>& targets) const;
+  void AppendTargets(std::vector<std::string> const& targets)
+  {
+    this->Targets.insert(this->Targets.end(), targets.begin(), targets.end());
+  }
+  void SetExportSet(cmExportSet*);
+
+  /** Set whether to append generated code to the output file.  */
+  void SetAppendMode(bool append) { this->AppendMode = append; }
+
+  void Compute(cmLocalGenerator* lg);
+
+protected:
+  // Implement virtual methods from the superclass.
+  bool GenerateMainFile(std::ostream& os) override;
+  void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets) override;
+  void HandleMissingTarget(std::string& link_libs,
+                           std::vector<std::string>& missingTargets,
+                           cmGeneratorTarget* depender,
+                           cmGeneratorTarget* dependee) override;
+
+  void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
+                                  cmGeneratorTarget* dependee,
+                                  int occurrences);
+
+  /** Fill in properties indicating built file locations.  */
+  void SetImportLocationProperty(const std::string& config,
+                                 std::string const& suffix,
+                                 cmGeneratorTarget* target,
+                                 ImportPropertyMap& properties);
+
+  std::string InstallNameDir(cmGeneratorTarget* target,
+                             const std::string& config) override;
+
+  std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
+                                          const std::string& name);
+
+  std::vector<std::string> Targets;
+  cmExportSet* ExportSet;
+  std::vector<cmGeneratorTarget*> Exports;
+  cmLocalGenerator* LG;
+};
+
+#endif
diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
new file mode 100644
index 0000000..9913129
--- /dev/null
+++ b/Source/cmExportCommand.cxx
@@ -0,0 +1,367 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportCommand.h"
+
+#include "cmsys/RegularExpression.hxx"
+#include <map>
+#include <sstream>
+
+#include "cmExportBuildAndroidMKGenerator.h"
+#include "cmExportBuildFileGenerator.h"
+#include "cmExportSetMap.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+#if defined(__HAIKU__)
+#include <FindDirectory.h>
+#include <StorageDefs.h>
+#endif
+
+cmExportCommand::cmExportCommand()
+  : cmCommand()
+  , ArgumentGroup()
+  , Targets(&Helper, "TARGETS")
+  , Append(&Helper, "APPEND", &ArgumentGroup)
+  , ExportSetName(&Helper, "EXPORT", &ArgumentGroup)
+  , Namespace(&Helper, "NAMESPACE", &ArgumentGroup)
+  , Filename(&Helper, "FILE", &ArgumentGroup)
+  , ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
+  , AndroidMKFile(&Helper, "ANDROID_MK")
+{
+  this->ExportSet = nullptr;
+}
+
+// cmExportCommand
+bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
+{
+  if (args.size() < 2) {
+    this->SetError("called with too few arguments");
+    return false;
+  }
+
+  if (args[0] == "PACKAGE") {
+    return this->HandlePackage(args);
+  }
+  if (args[0] == "EXPORT") {
+    this->ExportSetName.Follows(nullptr);
+    this->ArgumentGroup.Follows(&this->ExportSetName);
+  } else {
+    this->Targets.Follows(nullptr);
+    this->ArgumentGroup.Follows(&this->Targets);
+  }
+
+  std::vector<std::string> unknownArgs;
+  this->Helper.Parse(&args, &unknownArgs);
+
+  if (!unknownArgs.empty()) {
+    this->SetError("Unknown arguments.");
+    return false;
+  }
+
+  std::string fname;
+  bool android = false;
+  if (this->AndroidMKFile.WasFound()) {
+    fname = this->AndroidMKFile.GetString();
+    android = true;
+  }
+  if (!this->Filename.WasFound() && fname.empty()) {
+    if (args[0] != "EXPORT") {
+      this->SetError("FILE <filename> option missing.");
+      return false;
+    }
+    fname = this->ExportSetName.GetString() + ".cmake";
+  } else if (fname.empty()) {
+    // Make sure the file has a .cmake extension.
+    if (cmSystemTools::GetFilenameLastExtension(this->Filename.GetCString()) !=
+        ".cmake") {
+      std::ostringstream e;
+      e << "FILE option given filename \"" << this->Filename.GetString()
+        << "\" which does not have an extension of \".cmake\".\n";
+      this->SetError(e.str());
+      return false;
+    }
+    fname = this->Filename.GetString();
+  }
+
+  // Get the file to write.
+  if (cmSystemTools::FileIsFullPath(fname.c_str())) {
+    if (!this->Makefile->CanIWriteThisFile(fname.c_str())) {
+      std::ostringstream e;
+      e << "FILE option given filename \"" << fname
+        << "\" which is in the source tree.\n";
+      this->SetError(e.str());
+      return false;
+    }
+  } else {
+    // Interpret relative paths with respect to the current build dir.
+    std::string dir = this->Makefile->GetCurrentBinaryDirectory();
+    fname = dir + "/" + fname;
+  }
+
+  std::vector<std::string> targets;
+
+  cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+
+  if (args[0] == "EXPORT") {
+    if (this->Append.IsEnabled()) {
+      std::ostringstream e;
+      e << "EXPORT signature does not recognise the APPEND option.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    if (this->ExportOld.IsEnabled()) {
+      std::ostringstream e;
+      e << "EXPORT signature does not recognise the "
+           "EXPORT_LINK_INTERFACE_LIBRARIES option.";
+      this->SetError(e.str());
+      return false;
+    }
+
+    cmExportSetMap& setMap = gg->GetExportSets();
+    std::string setName = this->ExportSetName.GetString();
+    if (setMap.find(setName) == setMap.end()) {
+      std::ostringstream e;
+      e << "Export set \"" << setName << "\" not found.";
+      this->SetError(e.str());
+      return false;
+    }
+    this->ExportSet = setMap[setName];
+  } else if (this->Targets.WasFound()) {
+    for (std::string const& currentTarget : this->Targets.GetVector()) {
+      if (this->Makefile->IsAlias(currentTarget)) {
+        std::ostringstream e;
+        e << "given ALIAS target \"" << currentTarget
+          << "\" which may not be exported.";
+        this->SetError(e.str());
+        return false;
+      }
+
+      if (cmTarget* target = gg->FindTarget(currentTarget)) {
+        if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+          std::string reason;
+          if (!this->Makefile->GetGlobalGenerator()
+                 ->HasKnownObjectFileLocation(&reason)) {
+            std::ostringstream e;
+            e << "given OBJECT library \"" << currentTarget
+              << "\" which may not be exported" << reason << ".";
+            this->SetError(e.str());
+            return false;
+          }
+        }
+        if (target->GetType() == cmStateEnums::UTILITY) {
+          this->SetError("given custom target \"" + currentTarget +
+                         "\" which may not be exported.");
+          return false;
+        }
+      } else {
+        std::ostringstream e;
+        e << "given target \"" << currentTarget
+          << "\" which is not built by this project.";
+        this->SetError(e.str());
+        return false;
+      }
+      targets.push_back(currentTarget);
+    }
+    if (this->Append.IsEnabled()) {
+      if (cmExportBuildFileGenerator* ebfg =
+            gg->GetExportedTargetsFile(fname)) {
+        ebfg->AppendTargets(targets);
+        return true;
+      }
+    }
+  } else {
+    this->SetError("EXPORT or TARGETS specifier missing.");
+    return false;
+  }
+
+  // Setup export file generation.
+  cmExportBuildFileGenerator* ebfg = nullptr;
+  if (android) {
+    ebfg = new cmExportBuildAndroidMKGenerator;
+  } else {
+    ebfg = new cmExportBuildFileGenerator;
+  }
+  ebfg->SetExportFile(fname.c_str());
+  ebfg->SetNamespace(this->Namespace.GetCString());
+  ebfg->SetAppendMode(this->Append.IsEnabled());
+  if (this->ExportSet) {
+    ebfg->SetExportSet(this->ExportSet);
+  } else {
+    ebfg->SetTargets(targets);
+  }
+  this->Makefile->AddExportBuildFileGenerator(ebfg);
+  ebfg->SetExportOld(this->ExportOld.IsEnabled());
+
+  // Compute the set of configurations exported.
+  std::vector<std::string> configurationTypes;
+  this->Makefile->GetConfigurations(configurationTypes);
+  if (configurationTypes.empty()) {
+    configurationTypes.push_back("");
+  }
+  for (std::string const& ct : configurationTypes) {
+    ebfg->AddConfiguration(ct);
+  }
+  if (this->ExportSet) {
+    gg->AddBuildExportExportSet(ebfg);
+  } else {
+    gg->AddBuildExportSet(ebfg);
+  }
+
+  return true;
+}
+
+bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
+{
+  // Parse PACKAGE mode arguments.
+  enum Doing
+  {
+    DoingNone,
+    DoingPackage
+  };
+  Doing doing = DoingPackage;
+  std::string package;
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (doing == DoingPackage) {
+      package = args[i];
+      doing = DoingNone;
+    } else {
+      std::ostringstream e;
+      e << "PACKAGE given unknown argument: " << args[i];
+      this->SetError(e.str());
+      return false;
+    }
+  }
+
+  // Verify the package name.
+  if (package.empty()) {
+    this->SetError("PACKAGE must be given a package name.");
+    return false;
+  }
+  const char* packageExpr = "^[A-Za-z0-9_.-]+$";
+  cmsys::RegularExpression packageRegex(packageExpr);
+  if (!packageRegex.find(package.c_str())) {
+    std::ostringstream e;
+    e << "PACKAGE given invalid package name \"" << package << "\".  "
+      << "Package names must match \"" << packageExpr << "\".";
+    this->SetError(e.str());
+    return false;
+  }
+
+  // If the CMAKE_EXPORT_NO_PACKAGE_REGISTRY variable is set the command
+  // export(PACKAGE) does nothing.
+  if (this->Makefile->IsOn("CMAKE_EXPORT_NO_PACKAGE_REGISTRY")) {
+    return true;
+  }
+
+  // We store the current build directory in the registry as a value
+  // named by a hash of its own content.  This is deterministic and is
+  // unique with high probability.
+  const char* outDir = this->Makefile->GetCurrentBinaryDirectory();
+  std::string hash = cmSystemTools::ComputeStringMD5(outDir);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  this->StorePackageRegistryWin(package, outDir, hash.c_str());
+#else
+  this->StorePackageRegistryDir(package, outDir, hash.c_str());
+#endif
+
+  return true;
+}
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <windows.h>
+
+void cmExportCommand::ReportRegistryError(std::string const& msg,
+                                          std::string const& key, long err)
+{
+  std::ostringstream e;
+  e << msg << "\n"
+    << "  HKEY_CURRENT_USER\\" << key << "\n";
+  wchar_t winmsg[1024];
+  if (FormatMessageW(
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), winmsg, 1024, 0) > 0) {
+    e << "Windows reported:\n"
+      << "  " << cmsys::Encoding::ToNarrow(winmsg);
+  }
+  this->Makefile->IssueMessage(cmake::WARNING, e.str());
+}
+
+void cmExportCommand::StorePackageRegistryWin(std::string const& package,
+                                              const char* content,
+                                              const char* hash)
+{
+  std::string key = "Software\\Kitware\\CMake\\Packages\\";
+  key += package;
+  HKEY hKey;
+  LONG err =
+    RegCreateKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(key).c_str(), 0,
+                    0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, 0, &hKey, 0);
+  if (err != ERROR_SUCCESS) {
+    this->ReportRegistryError("Cannot create/open registry key", key, err);
+    return;
+  }
+
+  std::wstring wcontent = cmsys::Encoding::ToWide(content);
+  err =
+    RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(), 0, REG_SZ,
+                   (BYTE const*)wcontent.c_str(),
+                   static_cast<DWORD>(wcontent.size() + 1) * sizeof(wchar_t));
+  RegCloseKey(hKey);
+  if (err != ERROR_SUCCESS) {
+    std::ostringstream msg;
+    msg << "Cannot set registry value \"" << hash << "\" under key";
+    this->ReportRegistryError(msg.str(), key, err);
+    return;
+  }
+}
+#else
+void cmExportCommand::StorePackageRegistryDir(std::string const& package,
+                                              const char* content,
+                                              const char* hash)
+{
+#if defined(__HAIKU__)
+  char dir[B_PATH_NAME_LENGTH];
+  if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
+      B_OK) {
+    return;
+  }
+  std::string fname = dir;
+  fname += "/cmake/packages/";
+  fname += package;
+#else
+  std::string fname;
+  if (!cmSystemTools::GetEnv("HOME", fname)) {
+    return;
+  }
+  cmSystemTools::ConvertToUnixSlashes(fname);
+  fname += "/.cmake/packages/";
+  fname += package;
+#endif
+  cmSystemTools::MakeDirectory(fname.c_str());
+  fname += "/";
+  fname += hash;
+  if (!cmSystemTools::FileExists(fname.c_str())) {
+    cmGeneratedFileStream entry(fname.c_str(), true);
+    if (entry) {
+      entry << content << "\n";
+    } else {
+      std::ostringstream e;
+      /* clang-format off */
+      e << "Cannot create package registry file:\n"
+        << "  " << fname << "\n"
+        << cmSystemTools::GetLastSystemError() << "\n";
+      /* clang-format on */
+      this->Makefile->IssueMessage(cmake::WARNING, e.str());
+    }
+  }
+}
+#endif
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
new file mode 100644
index 0000000..a5c6751
--- /dev/null
+++ b/Source/cmExportCommand.h
@@ -0,0 +1,64 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportCommand_h
+#define cmExportCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+#include "cmCommandArgumentsHelper.h"
+
+class cmExecutionStatus;
+class cmExportSet;
+
+/** \class cmExportLibraryDependenciesCommand
+ * \brief Add a test to the lists of tests to run.
+ *
+ * cmExportLibraryDependenciesCommand adds a test to the list of tests to run
+ *
+ */
+class cmExportCommand : public cmCommand
+{
+public:
+  cmExportCommand();
+  /**
+   * This is a virtual constructor for the command.
+   */
+  cmCommand* Clone() override { return new cmExportCommand; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+private:
+  cmCommandArgumentsHelper Helper;
+  cmCommandArgumentGroup ArgumentGroup;
+  cmCAStringVector Targets;
+  cmCAEnabler Append;
+  cmCAString ExportSetName;
+  cmCAString Namespace;
+  cmCAString Filename;
+  cmCAEnabler ExportOld;
+  cmCAString AndroidMKFile;
+
+  cmExportSet* ExportSet;
+
+  friend class cmExportBuildFileGenerator;
+  std::string ErrorMessage;
+
+  bool HandlePackage(std::vector<std::string> const& args);
+  void StorePackageRegistryWin(std::string const& package, const char* content,
+                               const char* hash);
+  void StorePackageRegistryDir(std::string const& package, const char* content,
+                               const char* hash);
+  void ReportRegistryError(std::string const& msg, std::string const& key,
+                           long err);
+};
+
+#endif
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
new file mode 100644
index 0000000..7985d0f
--- /dev/null
+++ b/Source/cmExportFileGenerator.cxx
@@ -0,0 +1,1095 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportFileGenerator.h"
+
+#include "cmAlgorithms.h"
+#include "cmComputeLinkInformation.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGeneratorTarget.h"
+#include "cmLinkItem.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmPolicies.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetExport.h"
+#include "cmake.h"
+
+#include "cmsys/FStream.hxx"
+#include <assert.h>
+#include <memory> // IWYU pragma: keep
+#include <sstream>
+#include <string.h>
+#include <utility>
+
+static std::string cmExportFileGeneratorEscape(std::string const& str)
+{
+  // Escape a property value for writing into a .cmake file.
+  std::string result = cmOutputConverter::EscapeForCMake(str);
+  // Un-escape variable references generated by our own export code.
+  cmSystemTools::ReplaceString(result, "\\${_IMPORT_PREFIX}",
+                               "${_IMPORT_PREFIX}");
+  cmSystemTools::ReplaceString(result, "\\${CMAKE_IMPORT_LIBRARY_SUFFIX}",
+                               "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+  return result;
+}
+
+cmExportFileGenerator::cmExportFileGenerator()
+{
+  this->AppendMode = false;
+  this->ExportOld = false;
+}
+
+void cmExportFileGenerator::AddConfiguration(const std::string& config)
+{
+  this->Configurations.push_back(config);
+}
+
+void cmExportFileGenerator::SetExportFile(const char* mainFile)
+{
+  this->MainImportFile = mainFile;
+  this->FileDir = cmSystemTools::GetFilenamePath(this->MainImportFile);
+  this->FileBase =
+    cmSystemTools::GetFilenameWithoutLastExtension(this->MainImportFile);
+  this->FileExt =
+    cmSystemTools::GetFilenameLastExtension(this->MainImportFile);
+}
+
+const char* cmExportFileGenerator::GetMainExportFileName() const
+{
+  return this->MainImportFile.c_str();
+}
+
+bool cmExportFileGenerator::GenerateImportFile()
+{
+  // Open the output file to generate it.
+  std::unique_ptr<cmsys::ofstream> foutPtr;
+  if (this->AppendMode) {
+    // Open for append.
+    foutPtr = cm::make_unique<cmsys::ofstream>(this->MainImportFile.c_str(),
+                                               std::ios::app);
+  } else {
+    // Generate atomically and with copy-if-different.
+    std::unique_ptr<cmGeneratedFileStream> ap(
+      new cmGeneratedFileStream(this->MainImportFile.c_str(), true));
+    ap->SetCopyIfDifferent(true);
+    foutPtr = std::move(ap);
+  }
+  if (!foutPtr.get() || !*foutPtr) {
+    std::string se = cmSystemTools::GetLastSystemError();
+    std::ostringstream e;
+    e << "cannot write to file \"" << this->MainImportFile << "\": " << se;
+    cmSystemTools::Error(e.str().c_str());
+    return false;
+  }
+  std::ostream& os = *foutPtr;
+
+  // Start with the import file header.
+  this->GeneratePolicyHeaderCode(os);
+  this->GenerateImportHeaderCode(os);
+
+  // Create all the imported targets.
+  bool result = this->GenerateMainFile(os);
+
+  // End with the import file footer.
+  this->GenerateImportFooterCode(os);
+  this->GeneratePolicyFooterCode(os);
+
+  return result;
+}
+
+void cmExportFileGenerator::GenerateImportConfig(
+  std::ostream& os, const std::string& config,
+  std::vector<std::string>& missingTargets)
+{
+  // Construct the property configuration suffix.
+  std::string suffix = "_";
+  if (!config.empty()) {
+    suffix += cmSystemTools::UpperCase(config);
+  } else {
+    suffix += "NOCONFIG";
+  }
+
+  // Generate the per-config target information.
+  this->GenerateImportTargetsConfig(os, config, suffix, missingTargets);
+}
+
+void cmExportFileGenerator::PopulateInterfaceProperty(
+  const std::string& propName, cmGeneratorTarget* target,
+  ImportPropertyMap& properties)
+{
+  const char* input = target->GetProperty(propName);
+  if (input) {
+    properties[propName] = input;
+  }
+}
+
+void cmExportFileGenerator::PopulateInterfaceProperty(
+  const std::string& propName, const std::string& outputName,
+  cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  const char* input = target->GetProperty(propName);
+  if (input) {
+    if (!*input) {
+      // Set to empty
+      properties[outputName].clear();
+      return;
+    }
+
+    std::string prepro =
+      cmGeneratorExpression::Preprocess(input, preprocessRule);
+    if (!prepro.empty()) {
+      this->ResolveTargetsInGeneratorExpressions(prepro, target,
+                                                 missingTargets);
+      properties[outputName] = prepro;
+    }
+  }
+}
+
+void cmExportFileGenerator::GenerateRequiredCMakeVersion(
+  std::ostream& os, const char* versionString)
+{
+  /* clang-format off */
+  os << "if(CMAKE_VERSION VERSION_LESS " << versionString << ")\n"
+        "  message(FATAL_ERROR \"This file relies on consumers using "
+        "CMake " << versionString << " or greater.\")\n"
+        "endif()\n\n";
+  /* clang-format on */
+}
+
+bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
+  cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  if (!target->IsLinkable()) {
+    return false;
+  }
+  const char* input = target->GetProperty("INTERFACE_LINK_LIBRARIES");
+  if (input) {
+    std::string prepro =
+      cmGeneratorExpression::Preprocess(input, preprocessRule);
+    if (!prepro.empty()) {
+      this->ResolveTargetsInGeneratorExpressions(
+        prepro, target, missingTargets, ReplaceFreeTargets);
+      properties["INTERFACE_LINK_LIBRARIES"] = prepro;
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool isSubDirectory(const char* a, const char* b)
+{
+  return (cmSystemTools::ComparePath(a, b) ||
+          cmSystemTools::IsSubDirectory(a, b));
+}
+
+static bool checkInterfaceDirs(const std::string& prepro,
+                               cmGeneratorTarget* target,
+                               const std::string& prop)
+{
+  const char* installDir =
+    target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+  const char* topSourceDir = target->GetLocalGenerator()->GetSourceDirectory();
+  const char* topBinaryDir = target->GetLocalGenerator()->GetBinaryDirectory();
+
+  std::vector<std::string> parts;
+  cmGeneratorExpression::Split(prepro, parts);
+
+  const bool inSourceBuild = strcmp(topSourceDir, topBinaryDir) == 0;
+
+  bool hadFatalError = false;
+
+  for (std::string const& li : parts) {
+    size_t genexPos = cmGeneratorExpression::Find(li);
+    if (genexPos == 0) {
+      continue;
+    }
+    cmake::MessageType messageType = cmake::FATAL_ERROR;
+    std::ostringstream e;
+    if (genexPos != std::string::npos) {
+      if (prop == "INTERFACE_INCLUDE_DIRECTORIES") {
+        switch (target->GetPolicyStatusCMP0041()) {
+          case cmPolicies::WARN:
+            messageType = cmake::WARNING;
+            e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0041) << "\n";
+            break;
+          case cmPolicies::OLD:
+            continue;
+          case cmPolicies::REQUIRED_IF_USED:
+          case cmPolicies::REQUIRED_ALWAYS:
+          case cmPolicies::NEW:
+            hadFatalError = true;
+            break; // Issue fatal message.
+        }
+      } else {
+        hadFatalError = true;
+      }
+    }
+    if (cmHasLiteralPrefix(li.c_str(), "${_IMPORT_PREFIX}")) {
+      continue;
+    }
+    if (!cmSystemTools::FileIsFullPath(li.c_str())) {
+      /* clang-format off */
+      e << "Target \"" << target->GetName() << "\" " << prop <<
+           " property contains relative path:\n"
+           "  \"" << li << "\"";
+      /* clang-format on */
+      target->GetLocalGenerator()->IssueMessage(messageType, e.str());
+    }
+    bool inBinary = isSubDirectory(li.c_str(), topBinaryDir);
+    bool inSource = isSubDirectory(li.c_str(), topSourceDir);
+    if (isSubDirectory(li.c_str(), installDir)) {
+      // The include directory is inside the install tree.  If the
+      // install tree is not inside the source tree or build tree then
+      // fall through to the checks below that the include directory is not
+      // also inside the source tree or build tree.
+      bool shouldContinue =
+        (!inBinary || isSubDirectory(installDir, topBinaryDir)) &&
+        (!inSource || isSubDirectory(installDir, topSourceDir));
+
+      if (prop == "INTERFACE_INCLUDE_DIRECTORIES") {
+        if (!shouldContinue) {
+          switch (target->GetPolicyStatusCMP0052()) {
+            case cmPolicies::WARN: {
+              std::ostringstream s;
+              s << cmPolicies::GetPolicyWarning(cmPolicies::CMP0052) << "\n";
+              s << "Directory:\n    \"" << li
+                << "\"\nin "
+                   "INTERFACE_INCLUDE_DIRECTORIES of target \""
+                << target->GetName() << "\" is a subdirectory of the install "
+                                        "directory:\n    \""
+                << installDir << "\"\nhowever it is also "
+                                 "a subdirectory of the "
+                << (inBinary ? "build" : "source") << " tree:\n    \""
+                << (inBinary ? topBinaryDir : topSourceDir) << "\""
+                << std::endl;
+              target->GetLocalGenerator()->IssueMessage(cmake::AUTHOR_WARNING,
+                                                        s.str());
+              CM_FALLTHROUGH;
+            }
+            case cmPolicies::OLD:
+              shouldContinue = true;
+              break;
+            case cmPolicies::REQUIRED_ALWAYS:
+            case cmPolicies::REQUIRED_IF_USED:
+            case cmPolicies::NEW:
+              break;
+          }
+        }
+      }
+      if (shouldContinue) {
+        continue;
+      }
+    }
+    if (inBinary) {
+      /* clang-format off */
+      e << "Target \"" << target->GetName() << "\" " << prop <<
+           " property contains path:\n"
+           "  \"" << li << "\"\nwhich is prefixed in the build directory.";
+      /* clang-format on */
+      target->GetLocalGenerator()->IssueMessage(messageType, e.str());
+    }
+    if (!inSourceBuild) {
+      if (inSource) {
+        e << "Target \"" << target->GetName() << "\" " << prop
+          << " property contains path:\n"
+             "  \""
+          << li << "\"\nwhich is prefixed in the source directory.";
+        target->GetLocalGenerator()->IssueMessage(messageType, e.str());
+      }
+    }
+  }
+  return !hadFatalError;
+}
+
+static void prefixItems(std::string& exportDirs)
+{
+  std::vector<std::string> entries;
+  cmGeneratorExpression::Split(exportDirs, entries);
+  exportDirs.clear();
+  const char* sep = "";
+  for (std::string const& e : entries) {
+    exportDirs += sep;
+    sep = ";";
+    if (!cmSystemTools::FileIsFullPath(e.c_str()) &&
+        e.find("${_IMPORT_PREFIX}") == std::string::npos) {
+      exportDirs += "${_IMPORT_PREFIX}/";
+    }
+    exportDirs += e;
+  }
+}
+
+void cmExportFileGenerator::PopulateSourcesInterface(
+  cmTargetExport* tei, cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  cmGeneratorTarget* gt = tei->Target;
+  assert(preprocessRule == cmGeneratorExpression::InstallInterface);
+
+  const char* propName = "INTERFACE_SOURCES";
+  const char* input = gt->GetProperty(propName);
+
+  if (!input) {
+    return;
+  }
+
+  if (!*input) {
+    properties[propName].clear();
+    return;
+  }
+
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(input, preprocessRule, true);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, gt, missingTargets);
+
+    if (!checkInterfaceDirs(prepro, gt, propName)) {
+      return;
+    }
+    properties[propName] = prepro;
+  }
+}
+
+void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
+  cmTargetExport* tei, cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  cmGeneratorTarget* target = tei->Target;
+  assert(preprocessRule == cmGeneratorExpression::InstallInterface);
+
+  const char* propName = "INTERFACE_INCLUDE_DIRECTORIES";
+  const char* input = target->GetProperty(propName);
+
+  cmGeneratorExpression ge;
+
+  std::string dirs = cmGeneratorExpression::Preprocess(
+    tei->InterfaceIncludeDirectories, preprocessRule, true);
+  this->ReplaceInstallPrefix(dirs);
+  std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
+  std::string exportDirs =
+    cge->Evaluate(target->GetLocalGenerator(), "", false, target);
+
+  if (cge->GetHadContextSensitiveCondition()) {
+    cmLocalGenerator* lg = target->GetLocalGenerator();
+    std::ostringstream e;
+    e << "Target \"" << target->GetName()
+      << "\" is installed with "
+         "INCLUDES DESTINATION set to a context sensitive path.  Paths which "
+         "depend on the configuration, policy values or the link interface "
+         "are "
+         "not supported.  Consider using target_include_directories instead.";
+    lg->IssueMessage(cmake::FATAL_ERROR, e.str());
+    return;
+  }
+
+  if (!input && exportDirs.empty()) {
+    return;
+  }
+  if ((input && !*input) && exportDirs.empty()) {
+    // Set to empty
+    properties[propName].clear();
+    return;
+  }
+
+  prefixItems(exportDirs);
+
+  std::string includes = (input ? input : "");
+  const char* sep = input ? ";" : "";
+  includes += sep + exportDirs;
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(includes, preprocessRule, true);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets);
+
+    if (!checkInterfaceDirs(prepro, target, propName)) {
+      return;
+    }
+    properties[propName] = prepro;
+  }
+}
+
+void cmExportFileGenerator::PopulateInterfaceProperty(
+  const std::string& propName, cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  this->PopulateInterfaceProperty(propName, propName, target, preprocessRule,
+                                  properties, missingTargets);
+}
+
+void getPropertyContents(cmGeneratorTarget const* tgt, const std::string& prop,
+                         std::set<std::string>& ifaceProperties)
+{
+  const char* p = tgt->GetProperty(prop);
+  if (!p) {
+    return;
+  }
+  std::vector<std::string> content;
+  cmSystemTools::ExpandListArgument(p, content);
+  ifaceProperties.insert(content.begin(), content.end());
+}
+
+void getCompatibleInterfaceProperties(cmGeneratorTarget* target,
+                                      std::set<std::string>& ifaceProperties,
+                                      const std::string& config)
+{
+  if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+    // object libraries have no link information, so nothing to compute
+    return;
+  }
+
+  cmComputeLinkInformation* info = target->GetLinkInformation(config);
+
+  if (!info) {
+    cmLocalGenerator* lg = target->GetLocalGenerator();
+    std::ostringstream e;
+    e << "Exporting the target \"" << target->GetName()
+      << "\" is not "
+         "allowed since its linker language cannot be determined";
+    lg->IssueMessage(cmake::FATAL_ERROR, e.str());
+    return;
+  }
+
+  const cmComputeLinkInformation::ItemVector& deps = info->GetItems();
+
+  for (auto const& dep : deps) {
+    if (!dep.Target) {
+      continue;
+    }
+    getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_BOOL",
+                        ifaceProperties);
+    getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_STRING",
+                        ifaceProperties);
+    getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_NUMBER_MIN",
+                        ifaceProperties);
+    getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_NUMBER_MAX",
+                        ifaceProperties);
+  }
+}
+
+void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
+  cmGeneratorTarget* gtarget, ImportPropertyMap& properties)
+{
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX", gtarget,
+                                  properties);
+
+  std::set<std::string> ifaceProperties;
+
+  getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_BOOL", ifaceProperties);
+  getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_STRING", ifaceProperties);
+  getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MIN",
+                      ifaceProperties);
+  getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MAX",
+                      ifaceProperties);
+
+  if (gtarget->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
+    getCompatibleInterfaceProperties(gtarget, ifaceProperties, "");
+
+    std::vector<std::string> configNames;
+    gtarget->Target->GetMakefile()->GetConfigurations(configNames);
+
+    for (std::string const& cn : configNames) {
+      getCompatibleInterfaceProperties(gtarget, ifaceProperties, cn);
+    }
+  }
+
+  for (std::string const& ip : ifaceProperties) {
+    this->PopulateInterfaceProperty("INTERFACE_" + ip, gtarget, properties);
+  }
+}
+
+void cmExportFileGenerator::GenerateInterfaceProperties(
+  const cmGeneratorTarget* target, std::ostream& os,
+  const ImportPropertyMap& properties)
+{
+  if (!properties.empty()) {
+    std::string targetName = this->Namespace;
+    targetName += target->GetExportName();
+    os << "set_target_properties(" << targetName << " PROPERTIES\n";
+    for (auto const& property : properties) {
+      os << "  " << property.first << " "
+         << cmExportFileGeneratorEscape(property.second) << "\n";
+    }
+    os << ")\n\n";
+  }
+}
+
+bool cmExportFileGenerator::AddTargetNamespace(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets)
+{
+  cmLocalGenerator* lg = target->GetLocalGenerator();
+
+  cmGeneratorTarget* tgt = lg->FindGeneratorTargetToUse(input);
+  if (!tgt) {
+    return false;
+  }
+
+  if (tgt->IsImported()) {
+    return true;
+  }
+  if (this->ExportedTargets.find(tgt) != this->ExportedTargets.end()) {
+    input = this->Namespace + tgt->GetExportName();
+  } else {
+    std::string namespacedTarget;
+    this->HandleMissingTarget(namespacedTarget, missingTargets, target, tgt);
+    if (!namespacedTarget.empty()) {
+      input = namespacedTarget;
+    }
+  }
+  return true;
+}
+
+void cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets, FreeTargetsReplace replace)
+{
+  if (replace == NoReplaceFreeTargets) {
+    this->ResolveTargetsInGeneratorExpression(input, target, missingTargets);
+    return;
+  }
+  std::vector<std::string> parts;
+  cmGeneratorExpression::Split(input, parts);
+
+  std::string sep;
+  input.clear();
+  for (std::string& li : parts) {
+    if (cmGeneratorExpression::Find(li) == std::string::npos) {
+      this->AddTargetNamespace(li, target, missingTargets);
+    } else {
+      this->ResolveTargetsInGeneratorExpression(li, target, missingTargets);
+    }
+    input += sep + li;
+    sep = ";";
+  }
+}
+
+void cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets)
+{
+  std::string::size_type pos = 0;
+  std::string::size_type lastPos = pos;
+
+  while ((pos = input.find("$<TARGET_PROPERTY:", lastPos)) !=
+         std::string::npos) {
+    std::string::size_type nameStartPos =
+      pos + sizeof("$<TARGET_PROPERTY:") - 1;
+    std::string::size_type closePos = input.find('>', nameStartPos);
+    std::string::size_type commaPos = input.find(',', nameStartPos);
+    std::string::size_type nextOpenPos = input.find("$<", nameStartPos);
+    if (commaPos == std::string::npos    // Implied 'this' target
+        || closePos == std::string::npos // Incomplete expression.
+        || closePos < commaPos           // Implied 'this' target
+        || nextOpenPos < commaPos)       // Non-literal
+    {
+      lastPos = nameStartPos;
+      continue;
+    }
+
+    std::string targetName =
+      input.substr(nameStartPos, commaPos - nameStartPos);
+
+    if (this->AddTargetNamespace(targetName, target, missingTargets)) {
+      input.replace(nameStartPos, commaPos - nameStartPos, targetName);
+    }
+    lastPos = nameStartPos + targetName.size() + 1;
+  }
+
+  std::string errorString;
+  pos = 0;
+  lastPos = pos;
+  while ((pos = input.find("$<TARGET_NAME:", lastPos)) != std::string::npos) {
+    std::string::size_type nameStartPos = pos + sizeof("$<TARGET_NAME:") - 1;
+    std::string::size_type endPos = input.find('>', nameStartPos);
+    if (endPos == std::string::npos) {
+      errorString = "$<TARGET_NAME:...> expression incomplete";
+      break;
+    }
+    std::string targetName = input.substr(nameStartPos, endPos - nameStartPos);
+    if (targetName.find("$<") != std::string::npos) {
+      errorString = "$<TARGET_NAME:...> requires its parameter to be a "
+                    "literal.";
+      break;
+    }
+    if (!this->AddTargetNamespace(targetName, target, missingTargets)) {
+      errorString = "$<TARGET_NAME:...> requires its parameter to be a "
+                    "reachable target.";
+      break;
+    }
+    input.replace(pos, endPos - pos + 1, targetName);
+    lastPos = endPos;
+  }
+
+  pos = 0;
+  lastPos = pos;
+  while (errorString.empty() &&
+         (pos = input.find("$<LINK_ONLY:", lastPos)) != std::string::npos) {
+    std::string::size_type nameStartPos = pos + sizeof("$<LINK_ONLY:") - 1;
+    std::string::size_type endPos = input.find('>', nameStartPos);
+    if (endPos == std::string::npos) {
+      errorString = "$<LINK_ONLY:...> expression incomplete";
+      break;
+    }
+    std::string libName = input.substr(nameStartPos, endPos - nameStartPos);
+    if (cmGeneratorExpression::IsValidTargetName(libName) &&
+        this->AddTargetNamespace(libName, target, missingTargets)) {
+      input.replace(nameStartPos, endPos - nameStartPos, libName);
+    }
+    lastPos = nameStartPos + libName.size() + 1;
+  }
+
+  this->ReplaceInstallPrefix(input);
+
+  if (!errorString.empty()) {
+    target->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, errorString);
+  }
+}
+
+void cmExportFileGenerator::ReplaceInstallPrefix(std::string& /*unused*/)
+{
+  // Do nothing
+}
+
+void cmExportFileGenerator::SetImportLinkInterface(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  cmGeneratorTarget* target, ImportPropertyMap& properties,
+  std::vector<std::string>& missingTargets)
+{
+  // Add the transitive link dependencies for this configuration.
+  cmLinkInterface const* iface = target->GetLinkInterface(config, target);
+  if (!iface) {
+    return;
+  }
+
+  if (iface->ImplementationIsInterface) {
+    // Policy CMP0022 must not be NEW.
+    this->SetImportLinkProperty(suffix, target,
+                                "IMPORTED_LINK_INTERFACE_LIBRARIES",
+                                iface->Libraries, properties, missingTargets);
+    return;
+  }
+
+  const char* propContent;
+
+  if (const char* prop_suffixed =
+        target->GetProperty("LINK_INTERFACE_LIBRARIES" + suffix)) {
+    propContent = prop_suffixed;
+  } else if (const char* prop =
+               target->GetProperty("LINK_INTERFACE_LIBRARIES")) {
+    propContent = prop;
+  } else {
+    return;
+  }
+
+  const bool newCMP0022Behavior =
+    target->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+    target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+
+  if (newCMP0022Behavior && !this->ExportOld) {
+    cmLocalGenerator* lg = target->GetLocalGenerator();
+    std::ostringstream e;
+    e << "Target \"" << target->GetName()
+      << "\" has policy CMP0022 enabled, "
+         "but also has old-style LINK_INTERFACE_LIBRARIES properties "
+         "populated, but it was exported without the "
+         "EXPORT_LINK_INTERFACE_LIBRARIES to export the old-style properties";
+    lg->IssueMessage(cmake::FATAL_ERROR, e.str());
+    return;
+  }
+
+  if (!*propContent) {
+    properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix].clear();
+    return;
+  }
+
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(propContent, preprocessRule);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets,
+                                               ReplaceFreeTargets);
+    properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = prepro;
+  }
+}
+
+void cmExportFileGenerator::SetImportDetailProperties(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorTarget* target, ImportPropertyMap& properties,
+  std::vector<std::string>& missingTargets)
+{
+  // Get the makefile in which to lookup target information.
+  cmMakefile* mf = target->Makefile;
+
+  // Add the soname for unix shared libraries.
+  if (target->GetType() == cmStateEnums::SHARED_LIBRARY ||
+      target->GetType() == cmStateEnums::MODULE_LIBRARY) {
+    if (!target->IsDLLPlatform()) {
+      std::string prop;
+      std::string value;
+      if (target->HasSOName(config)) {
+        if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+          value = this->InstallNameDir(target, config);
+        }
+        prop = "IMPORTED_SONAME";
+        value += target->GetSOName(config);
+      } else {
+        prop = "IMPORTED_NO_SONAME";
+        value = "TRUE";
+      }
+      prop += suffix;
+      properties[prop] = value;
+    }
+  }
+
+  // Add the transitive link dependencies for this configuration.
+  if (cmLinkInterface const* iface =
+        target->GetLinkInterface(config, target)) {
+    this->SetImportLinkProperty(suffix, target,
+                                "IMPORTED_LINK_INTERFACE_LANGUAGES",
+                                iface->Languages, properties, missingTargets);
+
+    std::vector<std::string> dummy;
+    this->SetImportLinkProperty(suffix, target,
+                                "IMPORTED_LINK_DEPENDENT_LIBRARIES",
+                                iface->SharedDeps, properties, dummy);
+    if (iface->Multiplicity > 0) {
+      std::string prop = "IMPORTED_LINK_INTERFACE_MULTIPLICITY";
+      prop += suffix;
+      std::ostringstream m;
+      m << iface->Multiplicity;
+      properties[prop] = m.str();
+    }
+  }
+}
+
+template <typename T>
+void cmExportFileGenerator::SetImportLinkProperty(
+  std::string const& suffix, cmGeneratorTarget* target,
+  const std::string& propName, std::vector<T> const& entries,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
+{
+  // Skip the property if there are no entries.
+  if (entries.empty()) {
+    return;
+  }
+
+  // Construct the property value.
+  std::string link_entries;
+  const char* sep = "";
+  for (T const& l : entries) {
+    // Separate this from the previous entry.
+    link_entries += sep;
+    sep = ";";
+
+    std::string temp = l;
+    this->AddTargetNamespace(temp, target, missingTargets);
+    link_entries += temp;
+  }
+
+  // Store the property.
+  std::string prop = propName;
+  prop += suffix;
+  properties[prop] = link_entries;
+}
+
+void cmExportFileGenerator::GeneratePolicyHeaderCode(std::ostream& os)
+{
+  // Protect that file against use with older CMake versions.
+  /* clang-format off */
+  os << "# Generated by CMake\n\n";
+  os << "if(\"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}\" LESS 2.5)\n"
+     << "   message(FATAL_ERROR \"CMake >= 2.6.0 required\")\n"
+     << "endif()\n";
+  /* clang-format on */
+
+  // Isolate the file policy level.
+  // We use 2.6 here instead of the current version because newer
+  // versions of CMake should be able to export files imported by 2.6
+  // until the import format changes.
+  /* clang-format off */
+  os << "cmake_policy(PUSH)\n"
+     << "cmake_policy(VERSION 2.6)\n";
+  /* clang-format on */
+}
+
+void cmExportFileGenerator::GeneratePolicyFooterCode(std::ostream& os)
+{
+  os << "cmake_policy(POP)\n";
+}
+
+void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
+                                                     const std::string& config)
+{
+  os << "#----------------------------------------------------------------\n"
+     << "# Generated CMake target import file";
+  if (!config.empty()) {
+    os << " for configuration \"" << config << "\".\n";
+  } else {
+    os << ".\n";
+  }
+  os << "#----------------------------------------------------------------\n"
+     << "\n";
+  this->GenerateImportVersionCode(os);
+}
+
+void cmExportFileGenerator::GenerateImportFooterCode(std::ostream& os)
+{
+  os << "# Commands beyond this point should not need to know the version.\n"
+     << "set(CMAKE_IMPORT_FILE_VERSION)\n";
+}
+
+void cmExportFileGenerator::GenerateImportVersionCode(std::ostream& os)
+{
+  // Store an import file format version.  This will let us change the
+  // format later while still allowing old import files to work.
+  /* clang-format off */
+  os << "# Commands may need to know the format version.\n"
+     << "set(CMAKE_IMPORT_FILE_VERSION 1)\n"
+     << "\n";
+  /* clang-format on */
+}
+
+void cmExportFileGenerator::GenerateExpectedTargetsCode(
+  std::ostream& os, const std::string& expectedTargets)
+{
+  /* clang-format off */
+  os << "# Protect against multiple inclusion, which would fail when already "
+        "imported targets are added once more.\n"
+        "set(_targetsDefined)\n"
+        "set(_targetsNotDefined)\n"
+        "set(_expectedTargets)\n"
+        "foreach(_expectedTarget " << expectedTargets << ")\n"
+        "  list(APPEND _expectedTargets ${_expectedTarget})\n"
+        "  if(NOT TARGET ${_expectedTarget})\n"
+        "    list(APPEND _targetsNotDefined ${_expectedTarget})\n"
+        "  endif()\n"
+        "  if(TARGET ${_expectedTarget})\n"
+        "    list(APPEND _targetsDefined ${_expectedTarget})\n"
+        "  endif()\n"
+        "endforeach()\n"
+        "if(\"${_targetsDefined}\" STREQUAL \"${_expectedTargets}\")\n"
+        "  unset(_targetsDefined)\n"
+        "  unset(_targetsNotDefined)\n"
+        "  unset(_expectedTargets)\n"
+        "  set(CMAKE_IMPORT_FILE_VERSION)\n"
+        "  cmake_policy(POP)\n"
+        "  return()\n"
+        "endif()\n"
+        "if(NOT \"${_targetsDefined}\" STREQUAL \"\")\n"
+        "  message(FATAL_ERROR \"Some (but not all) targets in this export "
+        "set were already defined.\\nTargets Defined: ${_targetsDefined}\\n"
+        "Targets not yet defined: ${_targetsNotDefined}\\n\")\n"
+        "endif()\n"
+        "unset(_targetsDefined)\n"
+        "unset(_targetsNotDefined)\n"
+        "unset(_expectedTargets)\n"
+        "\n\n";
+  /* clang-format on */
+}
+void cmExportFileGenerator::GenerateImportTargetCode(
+  std::ostream& os, const cmGeneratorTarget* target)
+{
+  // Construct the imported target name.
+  std::string targetName = this->Namespace;
+
+  targetName += target->GetExportName();
+
+  // Create the imported target.
+  os << "# Create imported target " << targetName << "\n";
+  switch (target->GetType()) {
+    case cmStateEnums::EXECUTABLE:
+      os << "add_executable(" << targetName << " IMPORTED)\n";
+      break;
+    case cmStateEnums::STATIC_LIBRARY:
+      os << "add_library(" << targetName << " STATIC IMPORTED)\n";
+      break;
+    case cmStateEnums::SHARED_LIBRARY:
+      os << "add_library(" << targetName << " SHARED IMPORTED)\n";
+      break;
+    case cmStateEnums::MODULE_LIBRARY:
+      os << "add_library(" << targetName << " MODULE IMPORTED)\n";
+      break;
+    case cmStateEnums::UNKNOWN_LIBRARY:
+      os << "add_library(" << targetName << " UNKNOWN IMPORTED)\n";
+      break;
+    case cmStateEnums::OBJECT_LIBRARY:
+      os << "add_library(" << targetName << " OBJECT IMPORTED)\n";
+      break;
+    case cmStateEnums::INTERFACE_LIBRARY:
+      os << "add_library(" << targetName << " INTERFACE IMPORTED)\n";
+      break;
+    default: // should never happen
+      break;
+  }
+
+  // Mark the imported executable if it has exports.
+  if (target->IsExecutableWithExports()) {
+    os << "set_property(TARGET " << targetName
+       << " PROPERTY ENABLE_EXPORTS 1)\n";
+  }
+
+  // Mark the imported library if it is a framework.
+  if (target->IsFrameworkOnApple()) {
+    os << "set_property(TARGET " << targetName << " PROPERTY FRAMEWORK 1)\n";
+  }
+
+  // Mark the imported executable if it is an application bundle.
+  if (target->IsAppBundleOnApple()) {
+    os << "set_property(TARGET " << targetName
+       << " PROPERTY MACOSX_BUNDLE 1)\n";
+  }
+
+  if (target->IsCFBundleOnApple()) {
+    os << "set_property(TARGET " << targetName << " PROPERTY BUNDLE 1)\n";
+  }
+  os << "\n";
+}
+
+void cmExportFileGenerator::GenerateImportPropertyCode(
+  std::ostream& os, const std::string& config, cmGeneratorTarget const* target,
+  ImportPropertyMap const& properties)
+{
+  // Construct the imported target name.
+  std::string targetName = this->Namespace;
+
+  targetName += target->GetExportName();
+
+  // Set the import properties.
+  os << "# Import target \"" << targetName << "\" for configuration \""
+     << config << "\"\n";
+  os << "set_property(TARGET " << targetName
+     << " APPEND PROPERTY IMPORTED_CONFIGURATIONS ";
+  if (!config.empty()) {
+    os << cmSystemTools::UpperCase(config);
+  } else {
+    os << "NOCONFIG";
+  }
+  os << ")\n";
+  os << "set_target_properties(" << targetName << " PROPERTIES\n";
+  for (auto const& property : properties) {
+    os << "  " << property.first << " "
+       << cmExportFileGeneratorEscape(property.second) << "\n";
+  }
+  os << "  )\n"
+     << "\n";
+}
+
+void cmExportFileGenerator::GenerateMissingTargetsCheckCode(
+  std::ostream& os, const std::vector<std::string>& missingTargets)
+{
+  if (missingTargets.empty()) {
+    /* clang-format off */
+    os << "# This file does not depend on other imported targets which have\n"
+          "# been exported from the same project but in a separate "
+            "export set.\n\n";
+    /* clang-format on */
+    return;
+  }
+  /* clang-format off */
+  os << "# Make sure the targets which have been exported in some other \n"
+        "# export set exist.\n"
+        "unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)\n"
+        "foreach(_target ";
+  /* clang-format on */
+  std::set<std::string> emitted;
+  for (std::string const& missingTarget : missingTargets) {
+    if (emitted.insert(missingTarget).second) {
+      os << "\"" << missingTarget << "\" ";
+    }
+  }
+  /* clang-format off */
+  os << ")\n"
+        "  if(NOT TARGET \"${_target}\" )\n"
+        "    set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets \""
+        "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}\")"
+        "\n"
+        "  endif()\n"
+        "endforeach()\n"
+        "\n"
+        "if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)\n"
+        "  if(CMAKE_FIND_PACKAGE_NAME)\n"
+        "    set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)\n"
+        "    set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "
+        "\"The following imported targets are "
+        "referenced, but are missing: "
+                 "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}\")\n"
+        "  else()\n"
+        "    message(FATAL_ERROR \"The following imported targets are "
+        "referenced, but are missing: "
+                "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}\")\n"
+        "  endif()\n"
+        "endif()\n"
+        "unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets)\n"
+        "\n";
+  /* clang-format on */
+}
+
+void cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
+{
+  // Add code which verifies at cmake time that the file which is being
+  // imported actually exists on disk. This should in theory always be theory
+  // case, but still when packages are split into normal and development
+  // packages this might get broken (e.g. the Config.cmake could be part of
+  // the non-development package, something similar happened to me without
+  // on SUSE with a mysql pkg-config file, which claimed everything is fine,
+  // but the development package was not installed.).
+  /* clang-format off */
+  os << "# Loop over all imported files and verify that they actually exist\n"
+        "foreach(target ${_IMPORT_CHECK_TARGETS} )\n"
+        "  foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )\n"
+        "    if(NOT EXISTS \"${file}\" )\n"
+        "      message(FATAL_ERROR \"The imported target \\\"${target}\\\""
+        " references the file\n"
+        "   \\\"${file}\\\"\n"
+        "but this file does not exist.  Possible reasons include:\n"
+        "* The file was deleted, renamed, or moved to another location.\n"
+        "* An install or uninstall procedure did not complete successfully.\n"
+        "* The installation package was faulty and contained\n"
+        "   \\\"${CMAKE_CURRENT_LIST_FILE}\\\"\n"
+        "but not all the files it references.\n"
+        "\")\n"
+        "    endif()\n"
+        "  endforeach()\n"
+        "  unset(_IMPORT_CHECK_FILES_FOR_${target})\n"
+        "endforeach()\n"
+        "unset(_IMPORT_CHECK_TARGETS)\n"
+        "\n";
+  /* clang-format on */
+}
+
+void cmExportFileGenerator::GenerateImportedFileChecksCode(
+  std::ostream& os, cmGeneratorTarget* target,
+  ImportPropertyMap const& properties,
+  const std::set<std::string>& importedLocations)
+{
+  // Construct the imported target name.
+  std::string targetName = this->Namespace;
+  targetName += target->GetExportName();
+
+  os << "list(APPEND _IMPORT_CHECK_TARGETS " << targetName
+     << " )\n"
+        "list(APPEND _IMPORT_CHECK_FILES_FOR_"
+     << targetName << " ";
+
+  for (std::string const& li : importedLocations) {
+    ImportPropertyMap::const_iterator pi = properties.find(li);
+    if (pi != properties.end()) {
+      os << cmExportFileGeneratorEscape(pi->second) << " ";
+    }
+  }
+
+  os << ")\n\n";
+}
diff --git a/Source/cmExportFileGenerator.h b/Source/cmExportFileGenerator.h
new file mode 100644
index 0000000..985c8f6
--- /dev/null
+++ b/Source/cmExportFileGenerator.h
@@ -0,0 +1,207 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportFileGenerator_h
+#define cmExportFileGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmGeneratorExpression.h"
+#include "cmVersion.h"
+#include "cmVersionConfig.h"
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmGeneratorTarget;
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+#define DEVEL_CMAKE_VERSION(major, minor)                                     \
+  (CMake_VERSION_ENCODE(major, minor, 0) >                                    \
+       CMake_VERSION_ENCODE(CMake_VERSION_MAJOR, CMake_VERSION_MINOR, 0)      \
+     ? STRINGIFY(CMake_VERSION_MAJOR) "." STRINGIFY(                          \
+         CMake_VERSION_MINOR) "." STRINGIFY(CMake_VERSION_PATCH)              \
+     : #major "." #minor ".0")
+
+class cmTargetExport;
+
+/** \class cmExportFileGenerator
+ * \brief Generate a file exporting targets from a build or install tree.
+ *
+ * cmExportFileGenerator is the superclass for
+ * cmExportBuildFileGenerator and cmExportInstallFileGenerator.  It
+ * contains common code generation routines for the two kinds of
+ * export implementations.
+ */
+class cmExportFileGenerator
+{
+public:
+  cmExportFileGenerator();
+  virtual ~cmExportFileGenerator() {}
+
+  /** Set the full path to the export file to generate.  */
+  void SetExportFile(const char* mainFile);
+  const char* GetMainExportFileName() const;
+
+  /** Set the namespace in which to place exported target names.  */
+  void SetNamespace(const std::string& ns) { this->Namespace = ns; }
+  std::string GetNamespace() const { return this->Namespace; }
+
+  void SetExportOld(bool exportOld) { this->ExportOld = exportOld; }
+
+  /** Add a configuration to be exported.  */
+  void AddConfiguration(const std::string& config);
+
+  /** Actually generate the export file.  Returns whether there was an
+      error.  */
+  bool GenerateImportFile();
+
+protected:
+  typedef std::map<std::string, std::string> ImportPropertyMap;
+
+  // Generate per-configuration target information to the given output
+  // stream.
+  void GenerateImportConfig(std::ostream& os, const std::string& config,
+                            std::vector<std::string>& missingTargets);
+
+  // Methods to implement export file code generation.
+  virtual void GeneratePolicyHeaderCode(std::ostream& os);
+  virtual void GeneratePolicyFooterCode(std::ostream& os);
+  virtual void GenerateImportHeaderCode(std::ostream& os,
+                                        const std::string& config = "");
+  virtual void GenerateImportFooterCode(std::ostream& os);
+  void GenerateImportVersionCode(std::ostream& os);
+  virtual void GenerateImportTargetCode(std::ostream& os,
+                                        cmGeneratorTarget const* target);
+  virtual void GenerateImportPropertyCode(std::ostream& os,
+                                          const std::string& config,
+                                          cmGeneratorTarget const* target,
+                                          ImportPropertyMap const& properties);
+  virtual void GenerateImportedFileChecksCode(
+    std::ostream& os, cmGeneratorTarget* target,
+    ImportPropertyMap const& properties,
+    const std::set<std::string>& importedLocations);
+  virtual void GenerateImportedFileCheckLoop(std::ostream& os);
+  virtual void GenerateMissingTargetsCheckCode(
+    std::ostream& os, const std::vector<std::string>& missingTargets);
+
+  virtual void GenerateExpectedTargetsCode(std::ostream& os,
+                                           const std::string& expectedTargets);
+
+  // Collect properties with detailed information about targets beyond
+  // their location on disk.
+  void SetImportDetailProperties(const std::string& config,
+                                 std::string const& suffix,
+                                 cmGeneratorTarget* target,
+                                 ImportPropertyMap& properties,
+                                 std::vector<std::string>& missingTargets);
+
+  template <typename T>
+  void SetImportLinkProperty(std::string const& suffix,
+                             cmGeneratorTarget* target,
+                             const std::string& propName,
+                             std::vector<T> const& entries,
+                             ImportPropertyMap& properties,
+                             std::vector<std::string>& missingTargets);
+
+  /** Each subclass knows how to generate its kind of export file.  */
+  virtual bool GenerateMainFile(std::ostream& os) = 0;
+
+  /** Each subclass knows where the target files are located.  */
+  virtual void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets) = 0;
+
+  /** Each subclass knows how to deal with a target that is  missing from an
+   *  export set.  */
+  virtual void HandleMissingTarget(std::string& link_libs,
+                                   std::vector<std::string>& missingTargets,
+                                   cmGeneratorTarget* depender,
+                                   cmGeneratorTarget* dependee) = 0;
+  void PopulateInterfaceProperty(const std::string&, cmGeneratorTarget* target,
+                                 cmGeneratorExpression::PreprocessContext,
+                                 ImportPropertyMap& properties,
+                                 std::vector<std::string>& missingTargets);
+  bool PopulateInterfaceLinkLibrariesProperty(
+    cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
+  void PopulateInterfaceProperty(const std::string& propName,
+                                 cmGeneratorTarget* target,
+                                 ImportPropertyMap& properties);
+  void PopulateCompatibleInterfaceProperties(cmGeneratorTarget* target,
+                                             ImportPropertyMap& properties);
+  virtual void GenerateInterfaceProperties(
+    cmGeneratorTarget const* target, std::ostream& os,
+    const ImportPropertyMap& properties);
+  void PopulateIncludeDirectoriesInterface(
+    cmTargetExport* target,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
+  void PopulateSourcesInterface(
+    cmTargetExport* target,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
+
+  void SetImportLinkInterface(
+    const std::string& config, std::string const& suffix,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    cmGeneratorTarget* target, ImportPropertyMap& properties,
+    std::vector<std::string>& missingTargets);
+
+  enum FreeTargetsReplace
+  {
+    ReplaceFreeTargets,
+    NoReplaceFreeTargets
+  };
+
+  void ResolveTargetsInGeneratorExpressions(
+    std::string& input, cmGeneratorTarget* target,
+    std::vector<std::string>& missingTargets,
+    FreeTargetsReplace replace = NoReplaceFreeTargets);
+
+  virtual void GenerateRequiredCMakeVersion(std::ostream& os,
+                                            const char* versionString);
+
+  // The namespace in which the exports are placed in the generated file.
+  std::string Namespace;
+
+  bool ExportOld;
+
+  // The set of configurations to export.
+  std::vector<std::string> Configurations;
+
+  // The file to generate.
+  std::string MainImportFile;
+  std::string FileDir;
+  std::string FileBase;
+  std::string FileExt;
+  bool AppendMode;
+
+  // The set of targets included in the export.
+  std::set<cmGeneratorTarget*> ExportedTargets;
+
+private:
+  void PopulateInterfaceProperty(const std::string&, const std::string&,
+                                 cmGeneratorTarget* target,
+                                 cmGeneratorExpression::PreprocessContext,
+                                 ImportPropertyMap& properties,
+                                 std::vector<std::string>& missingTargets);
+
+  bool AddTargetNamespace(std::string& input, cmGeneratorTarget* target,
+                          std::vector<std::string>& missingTargets);
+
+  void ResolveTargetsInGeneratorExpression(
+    std::string& input, cmGeneratorTarget* target,
+    std::vector<std::string>& missingTargets);
+
+  virtual void ReplaceInstallPrefix(std::string& input);
+
+  virtual std::string InstallNameDir(cmGeneratorTarget* target,
+                                     const std::string& config) = 0;
+};
+
+#endif
diff --git a/Source/cmExportInstallAndroidMKGenerator.cxx b/Source/cmExportInstallAndroidMKGenerator.cxx
new file mode 100644
index 0000000..fe565e6
--- /dev/null
+++ b/Source/cmExportInstallAndroidMKGenerator.cxx
@@ -0,0 +1,135 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportInstallAndroidMKGenerator.h"
+
+#include <ostream>
+#include <stddef.h>
+
+#include "cmExportBuildAndroidMKGenerator.h"
+#include "cmExportSet.h"
+#include "cmGeneratorTarget.h"
+#include "cmInstallExportGenerator.h"
+#include "cmInstallTargetGenerator.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetExport.h"
+
+cmExportInstallAndroidMKGenerator::cmExportInstallAndroidMKGenerator(
+  cmInstallExportGenerator* iegen)
+  : cmExportInstallFileGenerator(iegen)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportHeaderCode(
+  std::ostream& os, const std::string&)
+{
+  std::string installDir = this->IEGen->GetDestination();
+  os << "LOCAL_PATH := $(call my-dir)\n";
+  size_t numDotDot = cmSystemTools::CountChar(installDir.c_str(), '/');
+  numDotDot += installDir.empty() ? 0 : 1;
+  std::string path;
+  for (size_t n = 0; n < numDotDot; n++) {
+    path += "/..";
+  }
+  os << "_IMPORT_PREFIX := "
+     << "$(LOCAL_PATH)" << path << "\n\n";
+  for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
+    // Collect import properties for this target.
+    if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+      continue;
+    }
+    std::string dest;
+    if (te->LibraryGenerator) {
+      dest = te->LibraryGenerator->GetDestination("");
+    }
+    if (te->ArchiveGenerator) {
+      dest = te->ArchiveGenerator->GetDestination("");
+    }
+    te->Target->Target->SetProperty("__dest", dest.c_str());
+  }
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportFooterCode(std::ostream&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportTargetCode(
+  std::ostream& os, const cmGeneratorTarget* target)
+{
+  std::string targetName = this->Namespace;
+  targetName += target->GetExportName();
+  os << "include $(CLEAR_VARS)\n";
+  os << "LOCAL_MODULE := ";
+  os << targetName << "\n";
+  os << "LOCAL_SRC_FILES := $(_IMPORT_PREFIX)/";
+  os << target->Target->GetProperty("__dest") << "/";
+  std::string config;
+  if (!this->Configurations.empty()) {
+    config = this->Configurations[0];
+  }
+  os << target->GetFullName(config) << "\n";
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateExpectedTargetsCode(
+  std::ostream&, const std::string&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportPropertyCode(
+  std::ostream&, const std::string&, cmGeneratorTarget const*,
+  ImportPropertyMap const&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateMissingTargetsCheckCode(
+  std::ostream&, const std::vector<std::string>&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateInterfaceProperties(
+  cmGeneratorTarget const* target, std::ostream& os,
+  const ImportPropertyMap& properties)
+{
+  std::string config;
+  if (!this->Configurations.empty()) {
+    config = this->Configurations[0];
+  }
+  cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
+    target, os, properties, cmExportBuildAndroidMKGenerator::INSTALL, config);
+}
+
+void cmExportInstallAndroidMKGenerator::LoadConfigFiles(std::ostream&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportPrefix(std::ostream&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateRequiredCMakeVersion(
+  std::ostream&, const char*)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::CleanupTemporaryVariables(
+  std::ostream&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportedFileCheckLoop(
+  std::ostream&)
+{
+}
+
+void cmExportInstallAndroidMKGenerator::GenerateImportedFileChecksCode(
+  std::ostream&, cmGeneratorTarget*, ImportPropertyMap const&,
+  const std::set<std::string>&)
+{
+}
+
+bool cmExportInstallAndroidMKGenerator::GenerateImportFileConfig(
+  const std::string&, std::vector<std::string>&)
+{
+  return true;
+}
diff --git a/Source/cmExportInstallAndroidMKGenerator.h b/Source/cmExportInstallAndroidMKGenerator.h
new file mode 100644
index 0000000..91554ee
--- /dev/null
+++ b/Source/cmExportInstallAndroidMKGenerator.h
@@ -0,0 +1,71 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportInstallAndroidMKGenerator_h
+#define cmExportInstallAndroidMKGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <iosfwd>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "cmExportFileGenerator.h"
+#include "cmExportInstallFileGenerator.h"
+
+class cmGeneratorTarget;
+class cmInstallExportGenerator;
+
+/** \class cmExportInstallAndroidMKGenerator
+ * \brief Generate a file exporting targets from an install tree.
+ *
+ * cmExportInstallAndroidMKGenerator generates files exporting targets from
+ * install an installation tree.  The files are placed in a temporary
+ * location for installation by cmInstallExportGenerator.  The file format
+ * is for the ndk build system and is a makefile fragment specifying prebuilt
+ * libraries to the ndk build system.
+ *
+ * This is used to implement the INSTALL(EXPORT_ANDROID_MK) command.
+ */
+class cmExportInstallAndroidMKGenerator : public cmExportInstallFileGenerator
+{
+public:
+  /** Construct with the export installer that will install the
+      files.  */
+  cmExportInstallAndroidMKGenerator(cmInstallExportGenerator* iegen);
+
+protected:
+  // Implement virtual methods from the superclass.
+  void GeneratePolicyHeaderCode(std::ostream&) override {}
+  void GeneratePolicyFooterCode(std::ostream&) override {}
+  void GenerateImportHeaderCode(std::ostream& os,
+                                const std::string& config = "") override;
+  void GenerateImportFooterCode(std::ostream& os) override;
+  void GenerateImportTargetCode(std::ostream& os,
+                                const cmGeneratorTarget* target) override;
+  void GenerateExpectedTargetsCode(
+    std::ostream& os, const std::string& expectedTargets) override;
+  void GenerateImportPropertyCode(
+    std::ostream& os, const std::string& config,
+    cmGeneratorTarget const* target,
+    ImportPropertyMap const& properties) override;
+  void GenerateMissingTargetsCheckCode(
+    std::ostream& os, const std::vector<std::string>& missingTargets) override;
+  void GenerateInterfaceProperties(
+    cmGeneratorTarget const* target, std::ostream& os,
+    const ImportPropertyMap& properties) override;
+  void GenerateImportPrefix(std::ostream& os) override;
+  void LoadConfigFiles(std::ostream&) override;
+  void GenerateRequiredCMakeVersion(std::ostream& os,
+                                    const char* versionString) override;
+  void CleanupTemporaryVariables(std::ostream&) override;
+  void GenerateImportedFileCheckLoop(std::ostream& os) override;
+  void GenerateImportedFileChecksCode(
+    std::ostream& os, cmGeneratorTarget* target,
+    ImportPropertyMap const& properties,
+    const std::set<std::string>& importedLocations) override;
+  bool GenerateImportFileConfig(const std::string& config,
+                                std::vector<std::string>&) override;
+};
+
+#endif
diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx
new file mode 100644
index 0000000..9b65e9e
--- /dev/null
+++ b/Source/cmExportInstallFileGenerator.cxx
@@ -0,0 +1,509 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportInstallFileGenerator.h"
+
+#include "cmAlgorithms.h"
+#include "cmExportSet.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
+#include "cmGlobalGenerator.h"
+#include "cmInstallExportGenerator.h"
+#include "cmInstallTargetGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmMakefile.h"
+#include "cmPolicies.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetExport.h"
+
+#include <sstream>
+#include <utility>
+
+class cmExportSetMap;
+
+cmExportInstallFileGenerator::cmExportInstallFileGenerator(
+  cmInstallExportGenerator* iegen)
+  : IEGen(iegen)
+{
+}
+
+std::string cmExportInstallFileGenerator::GetConfigImportFileGlob()
+{
+  std::string glob = this->FileBase;
+  glob += "-*";
+  glob += this->FileExt;
+  return glob;
+}
+
+bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
+{
+  std::vector<cmTargetExport*> allTargets;
+  {
+    std::string expectedTargets;
+    std::string sep;
+    for (cmTargetExport* te :
+         *this->IEGen->GetExportSet()->GetTargetExports()) {
+      expectedTargets += sep + this->Namespace + te->Target->GetExportName();
+      sep = " ";
+      if (this->ExportedTargets.insert(te->Target).second) {
+        allTargets.push_back(te);
+      } else {
+        std::ostringstream e;
+        e << "install(EXPORT \"" << this->IEGen->GetExportSet()->GetName()
+          << "\" ...) "
+          << "includes target \"" << te->Target->GetName()
+          << "\" more than once in the export set.";
+        cmSystemTools::Error(e.str().c_str());
+        return false;
+      }
+    }
+
+    this->GenerateExpectedTargetsCode(os, expectedTargets);
+  }
+
+  // Compute the relative import prefix for the file
+  this->GenerateImportPrefix(os);
+
+  std::vector<std::string> missingTargets;
+
+  bool require2_8_12 = false;
+  bool require3_0_0 = false;
+  bool require3_1_0 = false;
+  bool requiresConfigFiles = false;
+  // Create all the imported targets.
+  for (cmTargetExport* te : allTargets) {
+    cmGeneratorTarget* gt = te->Target;
+
+    requiresConfigFiles =
+      requiresConfigFiles || gt->GetType() != cmStateEnums::INTERFACE_LIBRARY;
+
+    this->GenerateImportTargetCode(os, gt);
+
+    ImportPropertyMap properties;
+
+    this->PopulateIncludeDirectoriesInterface(
+      te, cmGeneratorExpression::InstallInterface, properties, missingTargets);
+    this->PopulateSourcesInterface(te, cmGeneratorExpression::InstallInterface,
+                                   properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+
+    const bool newCMP0022Behavior =
+      gt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+      gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    if (newCMP0022Behavior) {
+      if (this->PopulateInterfaceLinkLibrariesProperty(
+            gt, cmGeneratorExpression::InstallInterface, properties,
+            missingTargets) &&
+          !this->ExportOld) {
+        require2_8_12 = true;
+      }
+    }
+    if (gt->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+      require3_0_0 = true;
+    }
+    if (gt->GetProperty("INTERFACE_SOURCES")) {
+      // We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1
+      // can consume them.
+      require3_1_0 = true;
+    }
+
+    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gt,
+                                    properties);
+
+    this->PopulateCompatibleInterfaceProperties(gt, properties);
+
+    this->GenerateInterfaceProperties(gt, os, properties);
+  }
+
+  if (require3_1_0) {
+    this->GenerateRequiredCMakeVersion(os, "3.1.0");
+  } else if (require3_0_0) {
+    this->GenerateRequiredCMakeVersion(os, "3.0.0");
+  } else if (require2_8_12) {
+    this->GenerateRequiredCMakeVersion(os, "2.8.12");
+  }
+
+  this->LoadConfigFiles(os);
+
+  this->CleanupTemporaryVariables(os);
+  this->GenerateImportedFileCheckLoop(os);
+
+  bool result = true;
+  // Generate an import file for each configuration.
+  // Don't do this if we only export INTERFACE_LIBRARY targets.
+  if (requiresConfigFiles) {
+    for (std::string const& c : this->Configurations) {
+      if (!this->GenerateImportFileConfig(c, missingTargets)) {
+        result = false;
+      }
+    }
+  }
+
+  this->GenerateMissingTargetsCheckCode(os, missingTargets);
+
+  return result;
+}
+
+void cmExportInstallFileGenerator::GenerateImportPrefix(std::ostream& os)
+{
+  // Set an _IMPORT_PREFIX variable for import location properties
+  // to reference if they are relative to the install prefix.
+  std::string installPrefix =
+    this->IEGen->GetLocalGenerator()->GetMakefile()->GetSafeDefinition(
+      "CMAKE_INSTALL_PREFIX");
+  std::string const& expDest = this->IEGen->GetDestination();
+  if (cmSystemTools::FileIsFullPath(expDest)) {
+    // The export file is being installed to an absolute path so the
+    // package is not relocatable.  Use the configured install prefix.
+    /* clang-format off */
+    os <<
+      "# The installation prefix configured by this project.\n"
+      "set(_IMPORT_PREFIX \"" << installPrefix << "\")\n"
+      "\n";
+    /* clang-format on */
+  } else {
+    // Add code to compute the installation prefix relative to the
+    // import file location.
+    std::string absDest = installPrefix + "/" + expDest;
+    std::string absDestS = absDest + "/";
+    os << "# Compute the installation prefix relative to this file.\n"
+       << "get_filename_component(_IMPORT_PREFIX"
+       << " \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n";
+    if (cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/libx32/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/usr/libx32/")) {
+      // Handle "/usr move" symlinks created by some Linux distros.
+      /* clang-format off */
+      os <<
+        "# Use original install prefix when loaded through a\n"
+        "# cross-prefix symbolic link such as /lib -> /usr/lib.\n"
+        "get_filename_component(_realCurr \"${_IMPORT_PREFIX}\" REALPATH)\n"
+        "get_filename_component(_realOrig \"" << absDest << "\" REALPATH)\n"
+        "if(_realCurr STREQUAL _realOrig)\n"
+        "  set(_IMPORT_PREFIX \"" << absDest << "\")\n"
+        "endif()\n"
+        "unset(_realOrig)\n"
+        "unset(_realCurr)\n";
+      /* clang-format on */
+    }
+    std::string dest = expDest;
+    while (!dest.empty()) {
+      os << "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" "
+            "PATH)\n";
+      dest = cmSystemTools::GetFilenamePath(dest);
+    }
+    os << "if(_IMPORT_PREFIX STREQUAL \"/\")\n"
+       << "  set(_IMPORT_PREFIX \"\")\n"
+       << "endif()\n"
+       << "\n";
+  }
+}
+
+void cmExportInstallFileGenerator::CleanupTemporaryVariables(std::ostream& os)
+{
+  /* clang-format off */
+  os << "# Cleanup temporary variables.\n"
+     << "set(_IMPORT_PREFIX)\n"
+     << "\n";
+  /* clang-format on */
+}
+
+void cmExportInstallFileGenerator::LoadConfigFiles(std::ostream& os)
+{
+  // Now load per-configuration properties for them.
+  /* clang-format off */
+  os << "# Load information for each installed configuration.\n"
+     << "get_filename_component(_DIR \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n"
+     << "file(GLOB CONFIG_FILES \"${_DIR}/"
+     << this->GetConfigImportFileGlob() << "\")\n"
+     << "foreach(f ${CONFIG_FILES})\n"
+     << "  include(${f})\n"
+     << "endforeach()\n"
+     << "\n";
+  /* clang-format on */
+}
+
+void cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string& input)
+{
+  std::string::size_type pos = 0;
+  std::string::size_type lastPos = pos;
+
+  while ((pos = input.find("$<INSTALL_PREFIX>", lastPos)) !=
+         std::string::npos) {
+    std::string::size_type endPos = pos + sizeof("$<INSTALL_PREFIX>") - 1;
+    input.replace(pos, endPos - pos, "${_IMPORT_PREFIX}");
+    lastPos = endPos;
+  }
+}
+
+bool cmExportInstallFileGenerator::GenerateImportFileConfig(
+  const std::string& config, std::vector<std::string>& missingTargets)
+{
+  // Skip configurations not enabled for this export.
+  if (!this->IEGen->InstallsForConfig(config)) {
+    return true;
+  }
+
+  // Construct the name of the file to generate.
+  std::string fileName = this->FileDir;
+  fileName += "/";
+  fileName += this->FileBase;
+  fileName += "-";
+  if (!config.empty()) {
+    fileName += cmSystemTools::LowerCase(config);
+  } else {
+    fileName += "noconfig";
+  }
+  fileName += this->FileExt;
+
+  // Open the output file to generate it.
+  cmGeneratedFileStream exportFileStream(fileName.c_str(), true);
+  if (!exportFileStream) {
+    std::string se = cmSystemTools::GetLastSystemError();
+    std::ostringstream e;
+    e << "cannot write to file \"" << fileName << "\": " << se;
+    cmSystemTools::Error(e.str().c_str());
+    return false;
+  }
+  std::ostream& os = exportFileStream;
+
+  // Start with the import file header.
+  this->GenerateImportHeaderCode(os, config);
+
+  // Generate the per-config target information.
+  this->GenerateImportConfig(os, config, missingTargets);
+
+  // End with the import file footer.
+  this->GenerateImportFooterCode(os);
+
+  // Record this per-config import file.
+  this->ConfigImportFiles[config] = fileName;
+
+  return true;
+}
+
+void cmExportInstallFileGenerator::GenerateImportTargetsConfig(
+  std::ostream& os, const std::string& config, std::string const& suffix,
+  std::vector<std::string>& missingTargets)
+{
+  // Add each target in the set to the export.
+  for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
+    // Collect import properties for this target.
+    if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
+      continue;
+    }
+
+    ImportPropertyMap properties;
+    std::set<std::string> importedLocations;
+
+    this->SetImportLocationProperty(config, suffix, te->ArchiveGenerator,
+                                    properties, importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
+                                    properties, importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->RuntimeGenerator,
+                                    properties, importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->ObjectsGenerator,
+                                    properties, importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
+                                    properties, importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
+                                    properties, importedLocations);
+
+    // If any file location was set for the target add it to the
+    // import file.
+    if (!properties.empty()) {
+      // Get the rest of the target details.
+      cmGeneratorTarget* gtgt = te->Target;
+      this->SetImportDetailProperties(config, suffix, gtgt, properties,
+                                      missingTargets);
+
+      this->SetImportLinkInterface(config, suffix,
+                                   cmGeneratorExpression::InstallInterface,
+                                   gtgt, properties, missingTargets);
+
+      // TOOD: PUBLIC_HEADER_LOCATION
+      // This should wait until the build feature propagation stuff
+      // is done.  Then this can be a propagated include directory.
+      // this->GenerateImportProperty(config, te->HeaderGenerator,
+      //                              properties);
+
+      // Generate code in the export file.
+      this->GenerateImportPropertyCode(os, config, gtgt, properties);
+      this->GenerateImportedFileChecksCode(os, gtgt, properties,
+                                           importedLocations);
+    }
+  }
+}
+
+void cmExportInstallFileGenerator::SetImportLocationProperty(
+  const std::string& config, std::string const& suffix,
+  cmInstallTargetGenerator* itgen, ImportPropertyMap& properties,
+  std::set<std::string>& importedLocations)
+{
+  // Skip rules that do not match this configuration.
+  if (!(itgen && itgen->InstallsForConfig(config))) {
+    return;
+  }
+
+  // Get the target to be installed.
+  cmGeneratorTarget* target = itgen->GetTarget();
+
+  // Construct the installed location of the target.
+  std::string dest = itgen->GetDestination(config);
+  std::string value;
+  if (!cmSystemTools::FileIsFullPath(dest.c_str())) {
+    // The target is installed relative to the installation prefix.
+    value = "${_IMPORT_PREFIX}/";
+  }
+  value += dest;
+  value += "/";
+
+  if (itgen->IsImportLibrary()) {
+    // Construct the property name.
+    std::string prop = "IMPORTED_IMPLIB";
+    prop += suffix;
+
+    // Append the installed file name.
+    value += itgen->GetInstallFilename(target, config,
+                                       cmInstallTargetGenerator::NameImplib);
+
+    // Store the property.
+    properties[prop] = value;
+    importedLocations.insert(prop);
+  } else if (itgen->GetTarget()->GetType() == cmStateEnums::OBJECT_LIBRARY) {
+    // Construct the property name.
+    std::string prop = "IMPORTED_OBJECTS";
+    prop += suffix;
+
+    // Compute all the object files inside this target and setup
+    // IMPORTED_OBJECTS as a list of object files
+    std::vector<std::string> objects;
+    itgen->GetInstallObjectNames(config, objects);
+    for (std::string& obj : objects) {
+      obj = value + obj;
+    }
+
+    // Store the property.
+    properties[prop] = cmJoin(objects, ";");
+    importedLocations.insert(prop);
+  } else {
+    // Construct the property name.
+    std::string prop = "IMPORTED_LOCATION";
+    prop += suffix;
+
+    // Append the installed file name.
+    if (target->IsAppBundleOnApple()) {
+      value += itgen->GetInstallFilename(target, config);
+      value += ".app/Contents/MacOS/";
+      value += itgen->GetInstallFilename(target, config);
+    } else {
+      value += itgen->GetInstallFilename(target, config,
+                                         cmInstallTargetGenerator::NameReal);
+    }
+
+    // Store the property.
+    properties[prop] = value;
+    importedLocations.insert(prop);
+  }
+}
+
+void cmExportInstallFileGenerator::HandleMissingTarget(
+  std::string& link_libs, std::vector<std::string>& missingTargets,
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
+{
+  const std::string name = dependee->GetName();
+  cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator();
+  std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
+  int targetOccurrences = static_cast<int>(namespaces.size());
+  if (targetOccurrences == 1) {
+    std::string missingTarget = namespaces[0];
+
+    missingTarget += dependee->GetExportName();
+    link_libs += missingTarget;
+    missingTargets.push_back(missingTarget);
+  } else {
+    // All exported targets should be known here and should be unique.
+    // This is probably user-error.
+    this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
+  }
+}
+
+std::vector<std::string> cmExportInstallFileGenerator::FindNamespaces(
+  cmGlobalGenerator* gg, const std::string& name)
+{
+  std::vector<std::string> namespaces;
+  const cmExportSetMap& exportSets = gg->GetExportSets();
+
+  for (auto const& expIt : exportSets) {
+    const cmExportSet* exportSet = expIt.second;
+    std::vector<cmTargetExport*> const* targets =
+      exportSet->GetTargetExports();
+
+    bool containsTarget = false;
+    for (cmTargetExport* target : *targets) {
+      if (name == target->TargetName) {
+        containsTarget = true;
+        break;
+      }
+    }
+
+    if (containsTarget) {
+      std::vector<cmInstallExportGenerator const*> const* installs =
+        exportSet->GetInstallations();
+      for (cmInstallExportGenerator const* install : *installs) {
+        namespaces.push_back(install->GetNamespace());
+      }
+    }
+  }
+
+  return namespaces;
+}
+
+void cmExportInstallFileGenerator::ComplainAboutMissingTarget(
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee, int occurrences)
+{
+  std::ostringstream e;
+  e << "install(EXPORT \"" << this->IEGen->GetExportSet()->GetName()
+    << "\" ...) "
+    << "includes target \"" << depender->GetName()
+    << "\" which requires target \"" << dependee->GetName() << "\" ";
+  if (occurrences == 0) {
+    e << "that is not in the export set.";
+  } else {
+    e << "that is not in this export set, but " << occurrences
+      << " times in others.";
+  }
+  cmSystemTools::Error(e.str().c_str());
+}
+
+std::string cmExportInstallFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string& /*config*/)
+{
+  std::string install_name_dir;
+
+  cmMakefile* mf = target->Target->GetMakefile();
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForInstallTree();
+  }
+
+  return install_name_dir;
+}
diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h
new file mode 100644
index 0000000..cda8433
--- /dev/null
+++ b/Source/cmExportInstallFileGenerator.h
@@ -0,0 +1,102 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportInstallFileGenerator_h
+#define cmExportInstallFileGenerator_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cmExportFileGenerator.h"
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+class cmGeneratorTarget;
+class cmGlobalGenerator;
+class cmInstallExportGenerator;
+class cmInstallTargetGenerator;
+
+/** \class cmExportInstallFileGenerator
+ * \brief Generate a file exporting targets from an install tree.
+ *
+ * cmExportInstallFileGenerator generates files exporting targets from
+ * install an installation tree.  The files are placed in a temporary
+ * location for installation by cmInstallExportGenerator.  One main
+ * file is generated that creates the imported targets and loads
+ * per-configuration files.  Target locations and settings for each
+ * configuration are written to these per-configuration files.  After
+ * installation the main file loads the configurations that have been
+ * installed.
+ *
+ * This is used to implement the INSTALL(EXPORT) command.
+ */
+class cmExportInstallFileGenerator : public cmExportFileGenerator
+{
+public:
+  /** Construct with the export installer that will install the
+      files.  */
+  cmExportInstallFileGenerator(cmInstallExportGenerator* iegen);
+
+  /** Get the per-config file generated for each configuraiton.  This
+      maps from the configuration name to the file temporary location
+      for installation.  */
+  std::map<std::string, std::string> const& GetConfigImportFiles()
+  {
+    return this->ConfigImportFiles;
+  }
+
+  /** Compute the globbing expression used to load per-config import
+      files from the main file.  */
+  std::string GetConfigImportFileGlob();
+
+protected:
+  // Implement virtual methods from the superclass.
+  bool GenerateMainFile(std::ostream& os) override;
+  void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets) override;
+  void HandleMissingTarget(std::string& link_libs,
+                           std::vector<std::string>& missingTargets,
+                           cmGeneratorTarget* depender,
+                           cmGeneratorTarget* dependee) override;
+
+  void ReplaceInstallPrefix(std::string& input) override;
+
+  void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
+                                  cmGeneratorTarget* dependee,
+                                  int occurrences);
+
+  std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
+                                          const std::string& name);
+
+  /** Generate the relative import prefix.  */
+  virtual void GenerateImportPrefix(std::ostream&);
+
+  /** Generate the relative import prefix.  */
+  virtual void LoadConfigFiles(std::ostream&);
+
+  virtual void CleanupTemporaryVariables(std::ostream&);
+
+  /** Generate a per-configuration file for the targets.  */
+  virtual bool GenerateImportFileConfig(
+    const std::string& config, std::vector<std::string>& missingTargets);
+
+  /** Fill in properties indicating installed file locations.  */
+  void SetImportLocationProperty(const std::string& config,
+                                 std::string const& suffix,
+                                 cmInstallTargetGenerator* itgen,
+                                 ImportPropertyMap& properties,
+                                 std::set<std::string>& importedLocations);
+
+  std::string InstallNameDir(cmGeneratorTarget* target,
+                             const std::string& config) override;
+
+  cmInstallExportGenerator* IEGen;
+
+  // The import file generated for each configuration.
+  std::map<std::string, std::string> ConfigImportFiles;
+};
+
+#endif
diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx
new file mode 100644
index 0000000..50f8cb0
--- /dev/null
+++ b/Source/cmExportLibraryDependenciesCommand.cxx
@@ -0,0 +1,168 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#include "cmExportLibraryDependenciesCommand.h"
+
+#include "cmsys/FStream.hxx"
+#include <map>
+#include <memory> // IWYU pragma: keep
+#include <utility>
+
+#include "cmAlgorithms.h"
+#include "cmGeneratedFileStream.h"
+#include "cmGlobalGenerator.h"
+#include "cmMakefile.h"
+#include "cmStateTypes.h"
+#include "cmSystemTools.h"
+#include "cmTarget.h"
+#include "cmTargetLinkLibraryType.h"
+#include "cmake.h"
+
+class cmExecutionStatus;
+
+bool cmExportLibraryDependenciesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
+{
+  if (args.empty()) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // store the arguments for the final pass
+  this->Filename = args[0];
+  this->Append = false;
+  if (args.size() > 1) {
+    if (args[1] == "APPEND") {
+      this->Append = true;
+    }
+  }
+  return true;
+}
+
+void cmExportLibraryDependenciesCommand::FinalPass()
+{
+  // export_library_dependencies() shouldn't modify anything
+  // ensure this by calling a const method
+  this->ConstFinalPass();
+}
+
+void cmExportLibraryDependenciesCommand::ConstFinalPass() const
+{
+  // Use copy-if-different if not appending.
+  std::unique_ptr<cmsys::ofstream> foutPtr;
+  if (this->Append) {
+    foutPtr =
+      cm::make_unique<cmsys::ofstream>(this->Filename.c_str(), std::ios::app);
+  } else {
+    std::unique_ptr<cmGeneratedFileStream> ap(
+      new cmGeneratedFileStream(this->Filename.c_str(), true));
+    ap->SetCopyIfDifferent(true);
+    foutPtr = std::move(ap);
+  }
+  std::ostream& fout = *foutPtr;
+
+  if (!fout) {
+    cmSystemTools::Error("Error Writing ", this->Filename.c_str());
+    cmSystemTools::ReportLastSystemError("");
+    return;
+  }
+
+  // Collect dependency information about all library targets built in
+  // the project.
+  cmake* cm = this->Makefile->GetCMakeInstance();
+  cmGlobalGenerator* global = cm->GetGlobalGenerator();
+  const std::vector<cmMakefile*>& locals = global->GetMakefiles();
+  std::map<std::string, std::string> libDepsOld;
+  std::map<std::string, std::string> libDepsNew;
+  std::map<std::string, std::string> libTypes;
+  for (cmMakefile* local : locals) {
+    const cmTargets& tgts = local->GetTargets();
+    for (auto const& tgt : tgts) {
+      // Get the current target.
+      cmTarget const& target = tgt.second;
+
+      // Skip non-library targets.
+      if (target.GetType() < cmStateEnums::STATIC_LIBRARY ||
+          target.GetType() > cmStateEnums::MODULE_LIBRARY) {
+        continue;
+      }
+
+      // Construct the dependency variable name.
+      std::string targetEntry = target.GetName();
+      targetEntry += "_LIB_DEPENDS";
+
+      // Construct the dependency variable value with the direct link
+      // dependencies.
+      std::string valueOld;
+      std::string valueNew;
+      cmTarget::LinkLibraryVectorType const& libs =
+        target.GetOriginalLinkLibraries();
+      for (cmTarget::LibraryID const& li : libs) {
+        std::string ltVar = li.first;
+        ltVar += "_LINK_TYPE";
+        std::string ltValue;
+        switch (li.second) {
+          case GENERAL_LibraryType:
+            valueNew += "general;";
+            ltValue = "general";
+            break;
+          case DEBUG_LibraryType:
+            valueNew += "debug;";
+            ltValue = "debug";
+            break;
+          case OPTIMIZED_LibraryType:
+            valueNew += "optimized;";
+            ltValue = "optimized";
+            break;
+        }
+        std::string lib = li.first;
+        if (cmTarget* libtgt = global->FindTarget(lib)) {
+          // Handle simple output name changes.  This command is
+          // deprecated so we do not support full target name
+          // translation (which requires per-configuration info).
+          if (const char* outname = libtgt->GetProperty("OUTPUT_NAME")) {
+            lib = outname;
+          }
+        }
+        valueOld += lib;
+        valueOld += ";";
+        valueNew += lib;
+        valueNew += ";";
+
+        std::string& ltEntry = libTypes[ltVar];
+        if (ltEntry.empty()) {
+          ltEntry = ltValue;
+        } else if (ltEntry != ltValue) {
+          ltEntry = "general";
+        }
+      }
+      libDepsNew[targetEntry] = valueNew;
+      libDepsOld[targetEntry] = valueOld;
+    }
+  }
+
+  // Generate dependency information for both old and new style CMake
+  // versions.
+  const char* vertest =
+    "\"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}\" GREATER 2.4";
+  fout << "# Generated by CMake\n\n";
+  fout << "if(" << vertest << ")\n";
+  fout << "  # Information for CMake 2.6 and above.\n";
+  for (auto const& i : libDepsNew) {
+    if (!i.second.empty()) {
+      fout << "  set(\"" << i.first << "\" \"" << i.second << "\")\n";
+    }
+  }
+  fout << "else()\n";
+  fout << "  # Information for CMake 2.4 and lower.\n";
+  for (auto const& i : libDepsOld) {
+    if (!i.second.empty()) {
+      fout << "  set(\"" << i.first << "\" \"" << i.second << "\")\n";
+    }
+  }
+  for (auto const& i : libTypes) {
+    if (i.second != "general") {
+      fout << "  set(\"" << i.first << "\" \"" << i.second << "\")\n";
+    }
+  }
+  fout << "endif()\n";
+}
diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h
new file mode 100644
index 0000000..bf5e9bc
--- /dev/null
+++ b/Source/cmExportLibraryDependenciesCommand.h
@@ -0,0 +1,34 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmExportLibraryDependenciesCommand_h
+#define cmExportLibraryDependenciesCommand_h
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <string>
+#include <vector>
+
+#include "cmCommand.h"
+
+class cmExecutionStatus;
+
+class cmExportLibraryDependenciesCommand : public cmCommand
+{
+public:
+  cmCommand* Clone() override
+  {
+    return new cmExportLibraryDependenciesCommand;
+  }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) override;
+
+  void FinalPass() override;
+  bool HasFinalPass() const override { return true; }
+
+private:
+  std::string Filename;
+  bool Append;
+  void ConstFinalPass() const;
+};
+
+#endif
diff --git a/Source/cmExportSet.cxx b/Source/cmExportSet.cxx
new file mode 100644

path: root/Lib/difflib.py

"""
Module difflib -- helpers for computing deltas between objects.

Function get_close_matches(word, possibilities, n=3, cutoff=0.6):
    Use SequenceMatcher to return list of the best "good enough" matches.

Function context_diff(a, b):
    For two lists of strings, return a delta in context diff format.

Function ndiff(a, b):
    Return a delta: the difference between `a` and `b` (lists of strings).

Function restore(delta, which):
    Return one of the two sequences that generated an ndiff delta.

Function unified_diff(a, b):
    For two lists of strings, return a delta in unified diff format.

Class SequenceMatcher:
    A flexible class for comparing pairs of sequences of any type.

Class Differ:
    For producing human-readable deltas from sequences of lines of text.

Class HtmlDiff:
    For producing HTML side by side comparison with change highlights.
"""

__all__ = ['get_close_matches', 'ndiff', 'restore', 'SequenceMatcher',
           'Differ','IS_CHARACTER_JUNK', 'IS_LINE_JUNK', 'context_diff',
           'unified_diff', 'HtmlDiff', 'Match']

import warnings
import heapq
from collections import namedtuple as _namedtuple

Match = _namedtuple('Match', 'a b size')

def _calculate_ratio(matches, length):
    if length:
        return 2.0 * matches / length
    return 1.0

class SequenceMatcher:

    """
    SequenceMatcher is a flexible class for comparing pairs of sequences of
    any type, so long as the sequence elements are hashable.  The basic
    algorithm predates, and is a little fancier than, an algorithm
    published in the late 1980's by Ratcliff and Obershelp under the
    hyperbolic name "gestalt pattern matching".  The basic idea is to find
    the longest contiguous matching subsequence that contains no "junk"
    elements (R-O doesn't address junk).  The same idea is then applied
    recursively to the pieces of the sequences to the left and to the right
    of the matching subsequence.  This does not yield minimal edit
    sequences, but does tend to yield matches that "look right" to people.

    SequenceMatcher tries to compute a "human-friendly diff" between two
    sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
    longest *contiguous* & junk-free matching subsequence.  That's what
    catches peoples' eyes.  The Windows(tm) windiff has another interesting
    notion, pairing up elements that appear uniquely in each sequence.
    That, and the method here, appear to yield more intuitive difference
    reports than does diff.  This method appears to be the least vulnerable
    to synching up on blocks of "junk lines", though (like blank lines in
    ordinary text files, or maybe "<P>" lines in HTML files).  That may be
    because this is the only method of the 3 that has a *concept* of
    "junk" <wink>.

    Example, comparing two strings, and considering blanks to be "junk":

    >>> s = SequenceMatcher(lambda x: x == " ",
    ...                     "private Thread currentThread;",
    ...                     "private volatile Thread currentThread;")
    >>>

    .ratio() returns a float in [0, 1], measuring the "similarity" of the
    sequences.  As a rule of thumb, a .ratio() value over 0.6 means the
    sequences are close matches:

    >>> print(round(s.ratio(), 3))
    0.866
    >>>

    If you're only interested in where the sequences match,
    .get_matching_blocks() is handy:

    >>> for block in s.get_matching_blocks():
    ...     print("a[%d] and b[%d] match for %d elements" % block)
    a[0] and b[0] match for 8 elements
    a[8] and b[17] match for 21 elements
    a[29] and b[38] match for 0 elements

    Note that the last tuple returned by .get_matching_blocks() is always a
    dummy, (len(a), len(b), 0), and this is the only case in which the last
    tuple element (number of elements matched) is 0.

    If you want to know how to change the first sequence into the second,
    use .get_opcodes():

    >>> for opcode in s.get_opcodes():
    ...     print("%6s a[%d:%d] b[%d:%d]" % opcode)
     equal a[0:8] b[0:8]
    insert a[8:8] b[8:17]
     equal a[8:29] b[17:38]

    See the Differ class for a fancy human-friendly file differencer, which
    uses SequenceMatcher both to compare sequences of lines, and to compare
    sequences of characters within similar (near-matching) lines.

    See also function get_close_matches() in this module, which shows how
    simple code building on SequenceMatcher can be used to do useful work.

    Timing:  Basic R-O is cubic time worst case and quadratic time expected
    case.  SequenceMatcher is quadratic time for the worst case and has
    expected-case behavior dependent in a complicated way on how many
    elements the sequences have in common; best case time is linear.

    Methods:

    __init__(isjunk=None, a='', b='')
        Construct a SequenceMatcher.

    set_seqs(a, b)
        Set the two sequences to be compared.

    set_seq1(a)
        Set the first sequence to be compared.

    set_seq2(b)
        Set the second sequence to be compared.

    find_longest_match(alo, ahi, blo, bhi)
        Find longest matching block in a[alo:ahi] and b[blo:bhi].

    get_matching_blocks()
        Return list of triples describing matching subsequences.

    get_opcodes()
        Return list of 5-tuples describing how to turn a into b.

    ratio()
        Return a measure of the sequences' similarity (float in [0,1]).

    quick_ratio()
        Return an upper bound on .ratio() relatively quickly.

    real_quick_ratio()
        Return an upper bound on ratio() very quickly.
    """

    def __init__(self, isjunk=None, a='', b='', autojunk=True):
        """Construct a SequenceMatcher.

        Optional arg isjunk is None (the default), or a one-argument
        function that takes a sequence element and returns true iff the
        element is junk.  None is equivalent to passing "lambda x: 0", i.e.
        no elements are considered to be junk.  For example, pass
            lambda x: x in " \\t"
        if you're comparing lines as sequences of characters, and don't
        want to synch up on blanks or hard tabs.

        Optional arg a is the first of two sequences to be compared.  By
        default, an empty string.  The elements of a must be hashable.  See
        also .set_seqs() and .set_seq1().

        Optional arg b is the second of two sequences to be compared.  By
        default, an empty string.  The elements of b must be hashable. See
        also .set_seqs() and .set_seq2().

        Optional arg autojunk should be set to False to disable the
        "automatic junk heuristic" that treats popular elements as junk
        (see module documentation for more information).
        """

        # Members:
        # a
        #      first sequence
        # b
        #      second sequence; differences are computed as "what do
        #      we need to do to 'a' to change it into 'b'?"
        # b2j
        #      for x in b, b2j[x] is a list of the indices (into b)
        #      at which x appears; junk and popular elements do not appear
        # fullbcount
        #      for x in b, fullbcount[x] == the number of times x
        #      appears in b; only materialized if really needed (used
        #      only for computing quick_ratio())
        # matching_blocks
        #      a list of (i, j, k) triples, where a[i:i+k] == b[j:j+k];
        #      ascending & non-overlapping in i and in j; terminated by
        #      a dummy (len(a), len(b), 0) sentinel
        # opcodes
        #      a list of (tag, i1, i2, j1, j2) tuples, where tag is
        #      one of
        #          'replace'   a[i1:i2] should be replaced by b[j1:j2]
        #          'delete'    a[i1:i2] should be deleted
        #          'insert'    b[j1:j2] should be inserted
        #          'equal'     a[i1:i2] == b[j1:j2]
        # isjunk
        #      a user-supplied function taking a sequence element and
        #      returning true iff the element is "junk" -- this has
        #      subtle but helpful effects on the algorithm, which I'll
        #      get around to writing up someday <0.9 wink>.
        #      DON'T USE!  Only __chain_b uses this.  Use "in self.bjunk".
        # bjunk
        #      the items in b for which isjunk is True.
        # bpopular
        #      nonjunk items in b treated as junk by the heuristic (if used).

        self.isjunk = isjunk
        self.a = self.b = None
        self.autojunk = autojunk
        self.set_seqs(a, b)

    def set_seqs(self, a, b):
        """Set the two sequences to be compared.

        >>> s = SequenceMatcher()
        >>> s.set_seqs("abcd", "bcde")
        >>> s.ratio()
        0.75
        """

        self.set_seq1(a)
        self.set_seq2(b)

    def set_seq1(self, a):
        """Set the first sequence to be compared.

        The second sequence to be compared is not changed.

        >>> s = SequenceMatcher(None, "abcd", "bcde")
        >>> s.ratio()
        0.75
        >>> s.set_seq1("bcde")
        >>> s.ratio()
        1.0
        >>>

        SequenceMatcher computes and caches detailed information about the
        second sequence, so if you want to compare one sequence S against
        many sequences, use .set_seq2(S) once and call .set_seq1(x)
        repeatedly for each of the other sequences.

        See also set_seqs() and set_seq2().
        """

        if a is self.a:
            return
        self.a = a
        self.matching_blocks = self.opcodes = None

    def set_seq2(self, b):
        """Set the second sequence to be compared.

        The first sequence to be compared is not changed.

        >>> s = SequenceMatcher(None, "abcd", "bcde")
        >>> s.ratio()
        0.75
        >>> s.set_seq2("abcd")
        >>> s.ratio()
        1.0
        >>>

        SequenceMatcher computes and caches detailed information about the
        second sequence, so if you want to compare one sequence S against
        many sequences, use .set_seq2(S) once and call .set_seq1(x)
        repeatedly for each of the other sequences.

        See also set_seqs() and set_seq1().
        """

        if b is self.b:
            return
        self.b = b
        self.matching_blocks = self.opcodes = None
        self.fullbcount = None
        self.__chain_b()

    # For each element x in b, set b2j[x] to a list of the indices in
    # b where x appears; the indices are in increasing order; note that
    # the number of times x appears in b is len(b2j[x]) ...
    # when self.isjunk is defined, junk elements don't show up in this
    # map at all, which stops the central find_longest_match method
    # from starting any matching block at a junk element ...
    # b2j also does not contain entries for "popular" elements, meaning
    # elements that account for more than 1 + 1% of the total elements, and
    # when the sequence is reasonably large (>= 200 elements); this can
    # be viewed as an adaptive notion of semi-junk, and yields an enormous
    # speedup when, e.g., comparing program files with hundreds of
    # instances of "return NULL;" ...
    # note that this is only called when b changes; so for cross-product
    # kinds of matches, it's best to call set_seq2 once, then set_seq1
    # repeatedly

    def __chain_b(self):
        # Because isjunk is a user-defined (not C) function, and we test
        # for junk a LOT, it's important to minimize the number of calls.
        # Before the tricks described here, __chain_b was by far the most
        # time-consuming routine in the whole module!  If anyone sees
        # Jim Roskind, thank him again for profile.py -- I never would
        # have guessed that.
        # The first trick is to build b2j ignoring the possibility
        # of junk.  I.e., we don't call isjunk at all yet.  Throwing
        # out the junk later is much cheaper than building b2j "right"
        # from the start.
        b = self.b
        self.b2j = b2j = {}

        for i, elt in enumerate(b):
            indices = b2j.setdefault(elt, [])
            indices.append(i)

        # Purge junk elements
        self.bjunk = junk = set()
        isjunk = self.isjunk
        if isjunk:
            for elt in b2j.keys():
                if isjunk(elt):
                    junk.add(elt)
            for elt in junk: # separate loop avoids separate list of keys
                del b2j[elt]

        # Purge popular elements that are not junk
        self.bpopular = popular = set()
        n = len(b)
        if self.autojunk and n >= 200:
            ntest = n // 100 + 1
            for elt, idxs in b2j.items():
                if len(idxs) > ntest:
                    popular.add(elt)
            for elt in popular: # ditto; as fast for 1% deletion
                del b2j[elt]

    def isbjunk(self, item):
        "Deprecated; use 'item in SequenceMatcher().bjunk'."
        warnings.warn("'SequenceMatcher().isbjunk(item)' is deprecated;\n"
                      "use 'item in SMinstance.bjunk' instead.",
                      DeprecationWarning, 2)
        return item in self.bjunk

    def isbpopular(self, item):
        "Deprecated; use 'item in SequenceMatcher().bpopular'."
        warnings.warn("'SequenceMatcher().isbpopular(item)' is deprecated;\n"
                      "use 'item in SMinstance.bpopular' instead.",
                      DeprecationWarning, 2)
        return item in self.bpopular

    def find_longest_match(self, alo, ahi, blo, bhi):
        """Find longest matching block in a[alo:ahi] and b[blo:bhi].

        If isjunk is not defined:

        Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
            alo <= i <= i+k <= ahi
            blo <= j <= j+k <= bhi
        and for all (i',j',k') meeting those conditions,
            k >= k'
            i <= i'
            and if i == i', j <= j'

        In other words, of all maximal matching blocks, return one that
        starts earliest in a, and of all those maximal matching blocks that
        start earliest in a, return the one that starts earliest in b.

        >>> s = SequenceMatcher(None, " abcd", "abcd abcd")
        >>> s.find_longest_match(0, 5, 0, 9)
        Match(a=0, b=4, size=5)

        If isjunk is defined, first the longest matching block is
        determined as above, but with the additional restriction that no
        junk element appears in the block.  Then that block is extended as
        far as possible by matching (only) junk elements on both sides.  So
        the resulting block never matches on junk except as identical junk
        happens to be adjacent to an "interesting" match.

        Here's the same example as before, but considering blanks to be
        junk.  That prevents " abcd" from matching the " abcd" at the tail
        end of the second sequence directly.  Instead only the "abcd" can
        match, and matches the leftmost "abcd" in the second sequence:

        >>> s = SequenceMatcher(lambda x: x==" ", " abcd", "abcd abcd")
        >>> s.find_longest_match(0, 5, 0, 9)
        Match(a=1, b=0, size=4)

        If no blocks match, return (alo, blo, 0).

        >>> s = SequenceMatcher(None, "ab", "c")
        >>> s.find_longest_match(0, 2, 0, 1)
        Match(a=0, b=0, size=0)
        """

        # CAUTION:  stripping common prefix or suffix would be incorrect.
        # E.g.,
        #    ab
        #    acab
        # Longest matching block is "ab", but if common prefix is
        # stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
        # strip, so ends up claiming that ab is changed to acab by
        # inserting "ca" in the middle.  That's minimal but unintuitive:
        # "it's obvious" that someone inserted "ac" at the front.
        # Windiff ends up at the same place as diff, but by pairing up
        # the unique 'b's and then matching the first two 'a's.

        a, b, b2j, isbjunk = self.a, self.b, self.b2j, self.bjunk.__contains__
        besti, bestj, bestsize = alo, blo, 0
        # find longest junk-free match
        # during an iteration of the loop, j2len[j] = length of longest
        # junk-free match ending with a[i-1] and b[j]
        j2len = {}
        nothing = []
        for i in range(alo, ahi):
            # look at all instances of a[i] in b; note that because
            # b2j has no junk keys, the loop is skipped if a[i] is junk
            j2lenget = j2len.get
            newj2len = {}
            for j in b2j.get(a[i], nothing):
                # a[i] matches b[j]
                if j < blo:
                    continue
                if j >= bhi:
                    break
                k = newj2len[j] = j2lenget(j-1, 0) + 1
                if k > bestsize:
                    besti, bestj, bestsize = i-k+1, j-k+1, k
            j2len = newj2len

        # Extend the best by non-junk elements on each end.  In particular,
        # "popular" non-junk elements aren't in b2j, which greatly speeds
        # the inner loop above, but also means "the best" match so far
        # doesn't contain any junk *or* popular non-junk elements.
        while besti > alo and bestj > blo and \
              not isbjunk(b[bestj-1]) and \
              a[besti-1] == b[bestj-1]:
            besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        while besti+bestsize < ahi and bestj+bestsize < bhi and \
              not isbjunk(b[bestj+bestsize]) and \
              a[besti+bestsize] == b[bestj+bestsize]:
            bestsize += 1

        # Now that we have a wholly interesting match (albeit possibly
        # empty!), we may as well suck up the matching junk on each
        # side of it too.  Can't think of a good reason not to, and it
        # saves post-processing the (possibly considerable) expense of
        # figuring out what to do with it.  In the case of an empty
        # interesting match, this is clearly the right thing to do,
        # because no other kind of match is possible in the regions.
        while besti > alo and bestj > blo and \
              isbjunk(b[bestj-1]) and \
              a[besti-1] == b[bestj-1]:
            besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        while besti+bestsize < ahi and bestj+bestsize < bhi and \
              isbjunk(b[bestj+bestsize]) and \
              a[besti+bestsize] == b[bestj+bestsize]:
            bestsize = bestsize + 1

        return Match(besti, bestj, bestsize)

    def get_matching_blocks(self):
        """Return list of triples describing matching subsequences.

        Each triple is of the form (i, j, n), and means that
        a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
        i and in j.  New in Python 2.5, it's also guaranteed that if
        (i, j, n) and (i', j', n') are adjacent triples in the list, and
        the second is not the last triple in the list, then i+n != i' or
        j+n != j'.  IOW, adjacent triples never describe adjacent equal
        blocks.

        The last triple is a dummy, (len(a), len(b), 0), and is the only
        triple with n==0.

        >>> s = SequenceMatcher(None, "abxcd", "abcd")
        >>> list(s.get_matching_blocks())
        [Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]
        """

        if self.matching_blocks is not None:
            return self.matching_blocks
        la, lb = len(self.a), len(self.b)

        # This is most naturally expressed as a recursive algorithm, but
        # at least one user bumped into extreme use cases that exceeded
        # the recursion limit on their box.  So, now we maintain a list
        # ('queue`) of blocks we still need to look at, and append partial
        # results to `matching_blocks` in a loop; the matches are sorted
        # at the end.
        queue = [(0, la, 0, lb)]
        matching_blocks = []
        while queue:
            alo, ahi, blo, bhi = queue.pop()
            i, j, k = x = self.find_longest_match(alo, ahi, blo, bhi)
            # a[alo:i] vs b[blo:j] unknown
            # a[i:i+k] same as b[j:j+k]
            # a[i+k:ahi] vs b[j+k:bhi] unknown
            if k:   # if k is 0, there was no matching block
                matching_blocks.append(x)
                if alo < i and blo < j:
                    queue.append((alo, i, blo, j))
                if i+k < ahi and j+k < bhi:
                    queue.append((i+k, ahi, j+k, bhi))
        matching_blocks.sort()

        # It's possible that we have adjacent equal blocks in the
        # matching_blocks list now.  Starting with 2.5, this code was added
        # to collapse them.
        i1 = j1 = k1 = 0
        non_adjacent = []
        for i2, j2, k2 in matching_blocks:
            # Is this block adjacent to i1, j1, k1?
            if i1 + k1 == i2 and j1 + k1 == j2:
                # Yes, so collapse them -- this just increases the length of
                # the first block by the length of the second, and the first
                # block so lengthened remains the block to compare against.
                k1 += k2
            else:
                # Not adjacent.  Remember the first block (k1==0 means it's
                # the dummy we started with), and make the second block the
                # new block to compare against.
                if k1:
                    non_adjacent.append((i1, j1, k1))
                i1, j1, k1 = i2, j2, k2
        if k1:
            non_adjacent.append((i1, j1, k1))

        non_adjacent.append( (la, lb, 0) )
        self.matching_blocks = non_adjacent
        return map(Match._make, self.matching_blocks)

    def get_opcodes(self):
        """Return list of 5-tuples describing how to turn a into b.

        Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
        has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
        tuple preceding it, and likewise for j1 == the previous j2.

        The tags are strings, with these meanings:

        'replace':  a[i1:i2] should be replaced by b[j1:j2]
        'delete':   a[i1:i2] should be deleted.
                    Note that j1==j2 in this case.
        'insert':   b[j1:j2] should be inserted at a[i1:i1].
                    Note that i1==i2 in this case.
        'equal':    a[i1:i2] == b[j1:j2]

        >>> a = "qabxcd"
        >>> b = "abycdf"
        >>> s = SequenceMatcher(None, a, b)
        >>> for tag, i1, i2, j1, j2 in s.get_opcodes():
        ...    print(("%7s a[%d:%d] (%s) b[%d:%d] (%s)" %
        ...           (tag, i1, i2, a[i1:i2], j1, j2, b[j1:j2])))
         delete a[0:1] (q) b[0:0] ()
          equal a[1:3] (ab) b[0:2] (ab)
        replace a[3:4] (x) b[2:3] (y)
          equal a[4:6] (cd) b[3:5] (cd)
         insert a[6:6] () b[5:6] (f)
        """

        if self.opcodes is not None:
            return self.opcodes
        i = j = 0
        self.opcodes = answer = []
        for ai, bj, size in self.get_matching_blocks():
            # invariant:  we've pumped out correct diffs to change
            # a[:i] into b[:j], and the next matching block is
            # a[ai:ai+size] == b[bj:bj+size].  So we need to pump
            # out a diff to change a[i:ai] into b[j:bj], pump out
            # the matching block, and move (i,j) beyond the match
            tag = ''
            if i < ai and j < bj:
                tag = 'replace'
            elif i < ai:
                tag = 'delete'
            elif j < bj:
                tag = 'insert'
            if tag:
                answer.append( (tag, i, ai, j, bj) )
            i, j = ai+size, bj+size
            # the list of matching blocks is terminated by a
            # sentinel with size 0
            if size:
                answer.append( ('equal', ai, i, bj, j) )
        return answer

    def get_grouped_opcodes(self, n=3):
        """ Isolate change clusters by eliminating ranges with no changes.

        Return a generator of groups with up to n lines of context.
        Each group is in the same format as returned by get_opcodes().

        >>> from pprint import pprint
        >>> a = list(map(str, range(1,40)))
        >>> b = a[:]
        >>> b[8:8] = ['i']     # Make an insertion
        >>> b[20] += 'x'       # Make a replacement
        >>> b[23:28] = []      # Make a deletion
        >>> b[30] += 'y'       # Make another replacement
        >>> pprint(list(SequenceMatcher(None,a,b).get_grouped_opcodes()))
        [[('equal', 5, 8, 5, 8), ('insert', 8, 8, 8, 9), ('equal', 8, 11, 9, 12)],
         [('equal', 16, 19, 17, 20),
          ('replace', 19, 20, 20, 21),
          ('equal', 20, 22, 21, 23),
          ('delete', 22, 27, 23, 23),
          ('equal', 27, 30, 23, 26)],
         [('equal', 31, 34, 27, 30),
          ('replace', 34, 35, 30, 31),
          ('equal', 35, 38, 31, 34)]]
        """

        codes = self.get_opcodes()
        if not codes:
            codes = [("equal", 0, 1, 0, 1)]
        # Fixup leading and trailing groups if they show no changes.
        if codes[0][0] == 'equal':
            tag, i1, i2, j1, j2 = codes[0]
            codes[0] = tag, max(i1, i2-n), i2, max(j1, j2-n), j2
        if codes[-1][0] == 'equal':
            tag, i1, i2, j1, j2 = codes[-1]
            codes[-1] = tag, i1, min(i2, i1+n), j1, min(j2, j1+n)

        nn = n + n
        group = []
        for tag, i1, i2, j1, j2 in codes:
            # End the current group and start a new one whenever
            # there is a large range with no changes.
            if tag == 'equal' and i2-i1 > nn:
                group.append((tag, i1, min(i2, i1+n), j1, min(j2, j1+n)))
                yield group
                group = []
                i1, j1 = max(i1, i2-n), max(j1, j2-n)
            group.append((tag, i1, i2, j1 ,j2))
        if group and not (len(group)==1 and group[0][0] == 'equal'):
            yield group

    def ratio(self):
        """Return a measure of the sequences' similarity (float in [0,1]).

        Where T is the total number of elements in both sequences, and
        M is the number of matches, this is 2.0*M / T.
        Note that this is 1 if the sequences are identical, and 0 if
        they have nothing in common.

        .ratio() is expensive to compute if you haven't already computed
        .get_matching_blocks() or .get_opcodes(), in which case you may
        want to try .quick_ratio() or .real_quick_ratio() first to get an
        upper bound.

        >>> s = SequenceMatcher(None, "abcd", "bcde")
        >>> s.ratio()
        0.75
        >>> s.quick_ratio()
        0.75
        >>> s.real_quick_ratio()
        1.0
        """

        matches = sum(triple[-1] for triple in self.get_matching_blocks())
        return _calculate_ratio(matches, len(self.a) + len(self.b))

    def quick_ratio(self):
        """Return an upper bound on ratio() relatively quickly.

        This isn't defined beyond that it is an upper bound on .ratio(), and
        is faster to compute.
        """

        # viewing a and b as multisets, set matches to the cardinality
        # of their intersection; this counts the number of matches
        # without regard to order, so is clearly an upper bound
        if self.fullbcount is None:
            self.fullbcount = fullbcount = {}
            for elt in self.b:
                fullbcount[elt] = fullbcount.get(elt, 0) + 1
        fullbcount = self.fullbcount
        # avail[x] is the number of times x appears in 'b' less the
        # number of times we've seen it in 'a' so far ... kinda
        avail = {}
        availhas, matches = avail.__contains__, 0
        for elt in self.a:
            if availhas(elt):
                numb = avail[elt]
            else:
                numb = fullbcount.get(elt, 0)
            avail[elt] = numb - 1
            if numb > 0:
                matches = matches + 1
        return _calculate_ratio(matches, len(self.a) + len(self.b))

    def real_quick_ratio(self):
        """Return an upper bound on ratio() very quickly.

        This isn't defined beyond that it is an upper bound on .ratio(), and
        is faster to compute than either .ratio() or .quick_ratio().
        """

        la, lb = len(self.a), len(self.b)
        # can't have more matches than the number of elements in the
        # shorter sequence
        return _calculate_ratio(min(la, lb), la + lb)

def get_close_matches(word, possibilities, n=3, cutoff=0.6):
    """Use SequenceMatcher to return list of the best "good enough" matches.

    word is a sequence for which close matches are desired (typically a
    string).

    possibilities is a list of sequences against which to match word
    (typically a list of strings).

    Optional arg n (default 3) is the maximum number of close matches to
    return.  n must be > 0.

    Optional arg cutoff (default 0.6) is a float in [0, 1].  Possibilities
    that don't score at least that similar to word are ignored.

    The best (no more than n) matches among the possibilities are returned
    in a list, sorted by similarity score, most similar first.

    >>> get_close_matches("appel", ["ape", "apple", "peach", "puppy"])
    ['apple', 'ape']
    >>> import keyword as _keyword
    >>> get_close_matches("wheel", _keyword.kwlist)
    ['while']
    >>> get_close_matches("Apple", _keyword.kwlist)
    []
    >>> get_close_matches("accept", _keyword.kwlist)
    ['except']
    """

    if not n >  0:
        raise ValueError("n must be > 0: %r" % (n,))
    if not 0.0 <= cutoff <= 1.0:
        raise ValueError("cutoff must be in [0.0, 1.0]: %r" % (cutoff,))
    result = []
    s = SequenceMatcher()
    s.set_seq2(word)
    for x in possibilities:
        s.set_seq1(x)
        if s.real_quick_ratio() >= cutoff and \
           s.quick_ratio() >= cutoff and \
           s.ratio() >= cutoff:
            result.append((s.ratio(), x))

    # Move the best scorers to head of list
    result = heapq.nlargest(n, result)
    # Strip scores for the best n matches
    return [x for score, x in result]

def _count_leading(line, ch):
    """
    Return number of `ch` characters at the start of `line`.

    Example:

    >>> _count_leading('   abc', ' ')
    3
    """

    i, n = 0, len(line)
    while i < n and line[i] == ch:
        i += 1
    return i

class Differ:
    r"""
    Differ is a class for comparing sequences of lines of text, and
    producing human-readable differences or deltas.  Differ uses
    SequenceMatcher both to compare sequences of lines, and to compare
    sequences of characters within similar (near-matching) lines.

    Each line of a Differ delta begins with a two-letter code:

        '- '    line unique to sequence 1
        '+ '    line unique to sequence 2
        '  '    line common to both sequences
        '? '    line not present in either input sequence

    Lines beginning with '? ' attempt to guide the eye to intraline
    differences, and were not present in either input sequence.  These lines
    can be confusing if the sequences contain tab characters.

    Note that Differ makes no claim to produce a *minimal* diff.  To the
    contrary, minimal diffs are often counter-intuitive, because they synch
    up anywhere possible, sometimes accidental matches 100 pages apart.
    Restricting synch points to contiguous matches preserves some notion of
    locality, at the occasional cost of producing a longer diff.

    Example: Comparing two texts.

    First we set up the texts, sequences of individual single-line strings
    ending with newlines (such sequences can also be obtained from the
    `readlines()` method of file-like objects):

    >>> text1 = '''  1. Beautiful is better than ugly.
    ...   2. Explicit is better than implicit.
    ...   3. Simple is better than complex.
    ...   4. Complex is better than complicated.
    ... '''.splitlines(keepends=True)
    >>> len(text1)
    4
    >>> text1[0][-1]
    '\n'
    >>> text2 = '''  1. Beautiful is better than ugly.
    ...   3.   Simple is better than complex.
    ...   4. Complicated is better than complex.
    ...   5. Flat is better than nested.
    ... '''.splitlines(keepends=True)

    Next we instantiate a Differ object:

    >>> d = Differ()

    Note that when instantiating a Differ object we may pass functions to
    filter out line and character 'junk'.  See Differ.__init__ for details.

    Finally, we compare the two:

    >>> result = list(d.compare(text1, text2))

    'result' is a list of strings, so let's pretty-print it:

    >>> from pprint import pprint as _pprint
    >>> _pprint(result)
    ['    1. Beautiful is better than ugly.\n',
     '-   2. Explicit is better than implicit.\n',
     '-   3. Simple is better than complex.\n',
     '+   3.   Simple is better than complex.\n',
     '?     ++\n',
     '-   4. Complex is better than complicated.\n',
     '?            ^                     ---- ^\n',
     '+   4. Complicated is better than complex.\n',
     '?           ++++ ^                      ^\n',
     '+   5. Flat is better than nested.\n']

    As a single multi-line string it looks like this:

    >>> print(''.join(result), end="")
        1. Beautiful is better than ugly.
    -   2. Explicit is better than implicit.
    -   3. Simple is better than complex.
    +   3.   Simple is better than complex.
    ?     ++
    -   4. Complex is better than complicated.
    ?            ^                     ---- ^
    +   4. Complicated is better than complex.
    ?           ++++ ^                      ^
    +   5. Flat is better than nested.

    Methods:

    __init__(linejunk=None, charjunk=None)
        Construct a text differencer, with optional filters.

    compare(a, b)
        Compare two sequences of lines; generate the resulting delta.
    """

    def __init__(self, linejunk=None, charjunk=None):
        """
        Construct a text differencer, with optional filters.

        The two optional keyword parameters are for filter functions:

        - `linejunk`: A function that should accept a single string argument,
          and return true iff the string is junk. The module-level function
          `IS_LINE_JUNK` may be used to filter out lines without visible
          characters, except for at most one splat ('#').  It is recommended
          to leave linejunk None; as of Python 2.3, the underlying
          SequenceMatcher class has grown an adaptive notion of "noise" lines
          that's better than any static definition the author has ever been
          able to craft.

        - `charjunk`: A function that should accept a string of length 1. The
          module-level function `IS_CHARACTER_JUNK` may be used to filter out
          whitespace characters (a blank or tab; **note**: bad idea to include
          newline in this!).  Use of IS_CHARACTER_JUNK is recommended.
        """

        self.linejunk = linejunk
        self.charjunk = charjunk

    def compare(self, a, b):
        r"""
        Compare two sequences of lines; generate the resulting delta.

        Each sequence must contain individual single-line strings ending with
        newlines. Such sequences can be obtained from the `readlines()` method
        of file-like objects.  The delta generated also consists of newline-
        terminated strings, ready to be printed as-is via the writeline()
        method of a file-like object.

        Example:

        >>> print(''.join(Differ().compare('one\ntwo\nthree\n'.splitlines(True),
        ...                                'ore\ntree\nemu\n'.splitlines(True))),
        ...       end="")
        - one
        ?  ^
        + ore
        ?  ^
        - two
        - three
        ?  -
        + tree
        + emu
        """

        cruncher = SequenceMatcher(self.linejunk, a, b)
        for tag, alo, ahi, blo, bhi in cruncher.get_opcodes():
            if tag == 'replace':
                g = self._fancy_replace(a, alo, ahi, b, blo, bhi)
            elif tag == 'delete':
                g = self._dump('-', a, alo, ahi)
            elif tag == 'insert':
                g = self._dump('+', b, blo, bhi)
            elif tag == 'equal':
                g = self._dump(' ', a, alo, ahi)
            else:
                raise ValueError('unknown tag %r' % (tag,))

            for line in g:
                yield line

    def _dump(self, tag, x, lo, hi):
        """Generate comparison results for a same-tagged range."""
        for i in range(lo, hi):
            yield '%s %s' % (tag, x[i])

    def _plain_replace(self, a, alo, ahi, b, blo, bhi):
        assert alo < ahi and blo < bhi
        # dump the shorter block first -- reduces the burden on short-term
        # memory if the blocks are of very different sizes
        if bhi - blo < ahi - alo:
            first  = self._dump('+', b, blo, bhi)
            second = self._dump('-', a, alo, ahi)
        else:
            first  = self._dump('-', a, alo, ahi)
            second = self._dump('+', b, blo, bhi)

        for g in first, second:
            for line in g:
                yield line

    def _fancy_replace(self, a, alo, ahi, b, blo, bhi):
        r"""
        When replacing one block of lines with another, search the blocks
        for *similar* lines; the best-matching pair (if any) is used as a
        synch point, and intraline difference marking is done on the
        similar pair. Lots of work, but often worth it.

        Example:

        >>> d = Differ()
        >>> results = d._fancy_replace(['abcDefghiJkl\n'], 0, 1,
        ...                            ['abcdefGhijkl\n'], 0, 1)
        >>> print(''.join(results), end="")
        - abcDefghiJkl
        ?    ^  ^  ^
        + abcdefGhijkl
        ?    ^  ^  ^
        """

        # don't synch up unless the lines have a similarity score of at
        # least cutoff; best_ratio tracks the best score seen so far
        best_ratio, cutoff = 0.74, 0.75
        cruncher = SequenceMatcher(self.charjunk)
        eqi, eqj = None, None   # 1st indices of equal lines (if any)

        # search for the pair that matches best without being identical
        # (identical lines must be junk lines, & we don't want to synch up
        # on junk -- unless we have to)
        for j in range(blo, bhi):
            bj = b[j]
            cruncher.set_seq2(bj)
            for i in range(alo, ahi):
                ai = a[i]
                if ai == bj:
                    if eqi is None:
                        eqi, eqj = i, j
                    continue
                cruncher.set_seq1(ai)
                # computing similarity is expensive, so use the quick
                # upper bounds first -- have seen this speed up messy
                # compares by a factor of 3.
                # note that ratio() is only expensive to compute the first
                # time it's called on a sequence pair; the expensive part
                # of the computation is cached by cruncher
                if cruncher.real_quick_ratio() > best_ratio and \
                      cruncher.quick_ratio() > best_ratio and \
                      cruncher.ratio() > best_ratio:
                    best_ratio, best_i, best_j = cruncher.ratio(), i, j
        if best_ratio < cutoff:
            # no non-identical "pretty close" pair
            if eqi is None:
                # no identical pair either -- treat it as a straight replace
                for line in self._plain_replace(a, alo, ahi, b, blo, bhi):
                    yield line
                return
            # no close pair, but an identical pair -- synch up on that
            best_i, best_j, best_ratio = eqi, eqj, 1.0
        else:
            # there's a close pair, so forget the identical pair (if any)
            eqi = None

        # a[best_i] very similar to b[best_j]; eqi is None iff they're not
        # identical

        # pump out diffs from before the synch point
        for line in self._fancy_helper(a, alo, best_i, b, blo, best_j):
            yield line

        # do intraline marking on the synch pair
        aelt, belt = a[best_i], b[best_j]
        if eqi is None:
            # pump out a '-', '?', '+', '?' quad for the synched lines
            atags = btags = ""
            cruncher.set_seqs(aelt, belt)
            for tag, ai1, ai2, bj1, bj2 in cruncher.get_opcodes():
                la, lb = ai2 - ai1, bj2 - bj1
                if tag == 'replace':
                    atags += '^' * la
                    btags += '^' * lb
                elif tag == 'delete':
                    atags += '-' * la
                elif tag == 'insert':
                    btags += '+' * lb
                elif tag == 'equal':
                    atags += ' ' * la
                    btags += ' ' * lb
                else:
                    raise ValueError('unknown tag %r' % (tag,))
            for line in self._qformat(aelt, belt, atags, btags):
                yield line
        else:
            # the synch pair is identical
            yield '  ' + aelt

        # pump out diffs from after the synch point
        for line in self._fancy_helper(a, best_i+1, ahi, b, best_j+1, bhi):
            yield line

    def _fancy_helper(self, a, alo, ahi, b, blo, bhi):
        g = []
        if alo < ahi:
            if blo < bhi:
                g = self._fancy_replace(a, alo, ahi, b, blo, bhi)
            else:
                g = self._dump('-', a, alo, ahi)
        elif blo < bhi:
            g = self._dump('+', b, blo, bhi)

        for line in g:
            yield line

    def _qformat(self, aline, bline, atags, btags):
        r"""
        Format "?" output and deal with leading tabs.

        Example:

        >>> d = Differ()
        >>> results = d._qformat('\tabcDefghiJkl\n', '\tabcdefGhijkl\n',
        ...                      '  ^ ^  ^      ', '  ^ ^  ^      ')
        >>> for line in results: print(repr(line))
        ...
        '- \tabcDefghiJkl\n'
        '? \t ^ ^  ^\n'
        '+ \tabcdefGhijkl\n'
        '? \t ^ ^  ^\n'
        """

        # Can hurt, but will probably help most of the time.
        common = min(_count_leading(aline, "\t"),
                     _count_leading(bline, "\t"))
        common = min(common, _count_leading(atags[:common], " "))
        common = min(common, _count_leading(btags[:common], " "))
        atags = atags[common:].rstrip()
        btags = btags[common:].rstrip()

        yield "- " + aline
        if atags:
            yield "? %s%s\n" % ("\t" * common, atags)

        yield "+ " + bline
        if btags:
            yield "? %s%s\n" % ("\t" * common, btags)

# With respect to junk, an earlier version of ndiff simply refused to
# *start* a match with a junk element.  The result was cases like this:
#     before: private Thread currentThread;
#     after:  private volatile Thread currentThread;
# If you consider whitespace to be junk, the longest contiguous match
# not starting with junk is "e Thread currentThread".  So ndiff reported
# that "e volatil" was inserted between the 't' and the 'e' in "private".
# While an accurate view, to people that's absurd.  The current version
# looks for matching blocks that are entirely junk-free, then extends the
# longest one of those as far as possible but only with matching junk.
# So now "currentThread" is matched, then extended to suck up the
# preceding blank; then "private" is matched, and extended to suck up the
# following blank; then "Thread" is matched; and finally ndiff reports
# that "volatile " was inserted before "Thread".  The only quibble
# remaining is that perhaps it was really the case that " volatile"
# was inserted after "private".  I can live with that <wink>.

import re

def IS_LINE_JUNK(line, pat=re.compile(r"\s*#?\s*$").match):
    r"""
    Return 1 for ignorable line: iff `line` is blank or contains a single '#'.

    Examples:

    >>> IS_LINE_JUNK('\n')
    True
    >>> IS_LINE_JUNK('  #   \n')
    True
    >>> IS_LINE_JUNK('hello\n')
    False
    """

    return pat(line) is not None

def IS_CHARACTER_JUNK(ch, ws=" \t"):
    r"""
    Return 1 for ignorable character: iff `ch` is a space or tab.

    Examples:

    >>> IS_CHARACTER_JUNK(' ')
    True
    >>> IS_CHARACTER_JUNK('\t')
    True
    >>> IS_CHARACTER_JUNK('\n')
    False
    >>> IS_CHARACTER_JUNK('x')
    False
    """

    return ch in ws


########################################################################
###  Unified Diff
########################################################################

def _format_range_unified(start, stop):
    'Convert range to the "ed" format'
    # Per the diff spec at http://www.unix.org/single_unix_specification/
    beginning = start + 1     # lines start numbering with one
    length = stop - start
    if length == 1:
        return '{}'.format(beginning)
    if not length:
        beginning -= 1        # empty ranges begin at line just before the range
    return '{},{}'.format(beginning, length)

def unified_diff(a, b, fromfile='', tofile='', fromfiledate='',
                 tofiledate='', n=3, lineterm='\n'):
    r"""
    Compare two sequences of lines; generate the delta as a unified diff.

    Unified diffs are a compact way of showing line changes and a few
    lines of context.  The number of context lines is set by 'n' which
    defaults to three.

    By default, the diff control lines (those with ---, +++, or @@) are
    created with a trailing newline.  This is helpful so that inputs
    created from file.readlines() result in diffs that are suitable for
    file.writelines() since both the inputs and outputs have trailing
    newlines.

    For inputs that do not have trailing newlines, set the lineterm
    argument to "" so that the output will be uniformly newline free.

    The unidiff format normally has a header for filenames and modification
    times.  Any or all of these may be specified using strings for
    'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
    The modification times are normally expressed in the ISO 8601 format.

    Example:

    >>> for line in unified_diff('one two three four'.split(),
    ...             'zero one tree four'.split(), 'Original', 'Current',
    ...             '2005-01-26 23:30:50', '2010-04-02 10:20:52',
    ...             lineterm=''):
    ...     print(line)                 # doctest: +NORMALIZE_WHITESPACE
    --- Original        2005-01-26 23:30:50
    +++ Current         2010-04-02 10:20:52
    @@ -1,4 +1,4 @@
    +zero
     one
    -two
    -three
    +tree
     four
    """

    started = False
    for group in SequenceMatcher(None,a,b).get_grouped_opcodes(n):
        if not started:
            started = True
            fromdate = '\t{}'.format(fromfiledate) if fromfiledate else ''
            todate = '\t{}'.format(tofiledate) if tofiledate else ''
            yield '--- {}{}{}'.format(fromfile, fromdate, lineterm)
            yield '+++ {}{}{}'.format(tofile, todate, lineterm)

        first, last = group[0], group[-1]
        file1_range = _format_range_unified(first[1], last[2])
        file2_range = _format_range_unified(first[3], last[4])
        yield '@@ -{} +{} @@{}'.format(file1_range, file2_range, lineterm)

        for tag, i1, i2, j1, j2 in group:
            if tag == 'equal':
                for line in a[i1:i2]:
                    yield ' ' + line
                continue
            if tag in {'replace', 'delete'}:
                for line in a[i1:i2]:
                    yield '-' + line
            if tag in {'replace', 'insert'}:
                for line in b[j1:j2]:
                    yield '+' + line


########################################################################
###  Context Diff
########################################################################

def _format_range_context(start, stop):
    'Convert range to the "ed" format'
    # Per the diff spec at http://www.unix.org/single_unix_specification/
    beginning = start + 1     # lines start numbering with one
    length = stop - start
    if not length:
        beginning -= 1        # empty ranges begin at line just before the range
    if length <= 1:
        return '{}'.format(beginning)
    return '{},{}'.format(beginning, beginning + length - 1)

# See http://www.unix.org/single_unix_specification/
def context_diff(a, b, fromfile='', tofile='',
                 fromfiledate='', tofiledate='', n=3, lineterm='\n'):
    r"""
    Compare two sequences of lines; generate the delta as a context diff.

    Context diffs are a compact way of showing line changes and a few
    lines of context.  The number of context lines is set by 'n' which
    defaults to three.

    By default, the diff control lines (those with *** or ---) are
    created with a trailing newline.  This is helpful so that inputs
    created from file.readlines() result in diffs that are suitable for
    file.writelines() since both the inputs and outputs have trailing
    newlines.

    For inputs that do not have trailing newlines, set the lineterm
    argument to "" so that the output will be uniformly newline free.

    The context diff format normally has a header for filenames and
    modification times.  Any or all of these may be specified using
    strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
    The modification times are normally expressed in the ISO 8601 format.
    If not specified, the strings default to blanks.

    Example:

    >>> print(''.join(context_diff('one\ntwo\nthree\nfour\n'.splitlines(True),
    ...       'zero\none\ntree\nfour\n'.splitlines(True), 'Original', 'Current')),
    ...       end="")
    *** Original
    --- Current
    ***************
    *** 1,4 ****
      one
    ! two
    ! three
      four
    --- 1,4 ----
    + zero
      one
    ! tree
      four
    """

    prefix = dict(insert='+ ', delete='- ', replace='! ', equal='  ')
    started = False
    for group in SequenceMatcher(None,a,b).get_grouped_opcodes(n):
        if not started:
            started = True
            fromdate = '\t{}'.format(fromfiledate) if fromfiledate else ''
            todate = '\t{}'.format(tofiledate) if tofiledate else ''
            yield '*** {}{}{}'.format(fromfile, fromdate, lineterm)
            yield '--- {}{}{}'.format(tofile, todate, lineterm)

        first, last = group[0], group[-1]
        yield '***************' + lineterm

        file1_range = _format_range_context(first[1], last[2])
        yield '*** {} ****{}'.format(file1_range, lineterm)

        if any(tag in {'replace', 'delete'} for tag, _, _, _, _ in group):
            for tag, i1, i2, _, _ in group:
                if tag != 'insert':
                    for line in a[i1:i2]:
                        yield prefix[tag] + line

        file2_range = _format_range_context(first[3], last[4])
        yield '--- {} ----{}'.format(file2_range, lineterm)

        if any(tag in {'replace', 'insert'} for tag, _, _, _, _ in group):
            for tag, _, _, j1, j2 in group:
                if tag != 'delete':
                    for line in b[j1:j2]:
                        yield prefix[tag] + line

def ndiff(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK):
    r"""
    Compare `a` and `b` (lists of strings); return a `Differ`-style delta.

    Optional keyword parameters `linejunk` and `charjunk` are for filter
    functions (or None):

    - linejunk: A function that should accept a single string argument, and
      return true iff the string is junk.  The default is None, and is
      recommended; as of Python 2.3, an adaptive notion of "noise" lines is
      used that does a good job on its own.

    - charjunk: A function that should accept a string of length 1. The
      default is module-level function IS_CHARACTER_JUNK, which filters out
      whitespace characters (a blank or tab; note: bad idea to include newline
      in this!).

    Tools/scripts/ndiff.py is a command-line front-end to this function.

    Example:

    >>> diff = ndiff('one\ntwo\nthree\n'.splitlines(keepends=True),
    ...              'ore\ntree\nemu\n'.splitlines(keepends=True))
    >>> print(''.join(diff), end="")
    - one
    ?  ^
    + ore
    ?  ^
    - two
    - three
    ?  -
    + tree
    + emu
    """
    return Differ(linejunk, charjunk).compare(a, b)

def _mdiff(fromlines, tolines, context=None, linejunk=None,
           charjunk=IS_CHARACTER_JUNK):
    r"""Returns generator yielding marked up from/to side by side differences.

    Arguments:
    fromlines -- list of text lines to compared to tolines
    tolines -- list of text lines to be compared to fromlines
    context -- number of context lines to display on each side of difference,
               if None, all from/to text lines will be generated.
    linejunk -- passed on to ndiff (see ndiff documentation)
    charjunk -- passed on to ndiff (see ndiff documentation)

    This function returns an iterator which returns a tuple:
    (from line tuple, to line tuple, boolean flag)

    from/to line tuple -- (line num, line text)
        line num -- integer or None (to indicate a context separation)
        line text -- original line text with following markers inserted:
            '\0+' -- marks start of added text
            '\0-' -- marks start of deleted text
            '\0^' -- marks start of changed text
            '\1' -- marks end of added/deleted/changed text

    boolean flag -- None indicates context separation, True indicates
        either "from" or "to" line contains a change, otherwise False.

    This function/iterator was originally developed to generate side by side
    file difference for making HTML pages (see HtmlDiff class for example
    usage).

    Note, this function utilizes the ndiff function to generate the side by
    side difference markup.  Optional ndiff arguments may be passed to this
    function and they in turn will be passed to ndiff.
    """
    import re

    # regular expression for finding intraline change indices
    change_re = re.compile('(\++|\-+|\^+)')

    # create the difference iterator to generate the differences
    diff_lines_iterator = ndiff(fromlines,tolines,linejunk,charjunk)

    def _make_line(lines, format_key, side, num_lines=[0,0]):
        """Returns line of text with user's change markup and line formatting.

        lines -- list of lines from the ndiff generator to produce a line of
                 text from.  When producing the line of text to return, the
                 lines used are removed from this list.
        format_key -- '+' return first line in list with "add" markup around
                          the entire line.
                      '-' return first line in list with "delete" markup around
                          the entire line.
                      '?' return first line in list with add/delete/change
                          intraline markup (indices obtained from second line)
                      None return first line in list with no markup
        side -- indice into the num_lines list (0=from,1=to)
        num_lines -- from/to current line number.  This is NOT intended to be a
                     passed parameter.  It is present as a keyword argument to
                     maintain memory of the current line numbers between calls
                     of this function.

        Note, this function is purposefully not defined at the module scope so
        that data it needs from its parent function (within whose context it
        is defined) does not need to be of module scope.
        """
        num_lines[side] += 1
        # Handle case where no user markup is to be added, just return line of
        # text with user's line format to allow for usage of the line number.
        if format_key is None:
            return (num_lines[side],lines.pop(0)[2:])
        # Handle case of intraline changes
        if format_key == '?':
            text, markers = lines.pop(0), lines.pop(0)
            # find intraline changes (store change type and indices in tuples)
            sub_info = []
            def record_sub_info(match_object,sub_info=sub_info):
                sub_info.append([match_object.group(1)[0],match_object.span()])
                return match_object.group(1)
            change_re.sub(record_sub_info,markers)
            # process each tuple inserting our special marks that won't be
            # noticed by an xml/html escaper.
            for key,(begin,end) in sub_info[::-1]:
                text = text[0:begin]+'\0'+key+text[begin:end]+'\1'+text[end:]
            text = text[2:]
        # Handle case of add/delete entire line
        else:
            text = lines.pop(0)[2:]
            # if line of text is just a newline, insert a space so there is
            # something for the user to highlight and see.
            if not text:
                text = ' '
            # insert marks that won't be noticed by an xml/html escaper.
            text = '\0' + format_key + text + '\1'
        # Return line of text, first allow user's line formatter to do its
        # thing (such as adding the line number) then replace the special
        # marks with what the user's change markup.
        return (num_lines[side],text)

    def _line_iterator():
        """Yields from/to lines of text with a change indication.

        This function is an iterator.  It itself pulls lines from a
        differencing iterator, processes them and yields them.  When it can
        it yields both a "from" and a "to" line, otherwise it will yield one
        or the other.  In addition to yielding the lines of from/to text, a
        boolean flag is yielded to indicate if the text line(s) have
        differences in them.

        Note, this function is purposefully not defined at the module scope so
        that data it needs from its parent function (within whose context it
        is defined) does not need to be of module scope.
        """
        lines = []
        num_blanks_pending, num_blanks_to_yield = 0, 0
        while True:
            # Load up next 4 lines so we can look ahead, create strings which
            # are a concatenation of the first character of each of the 4 lines
            # so we can do some very readable comparisons.
            while len(lines) < 4:
                try:
                    lines.append(next(diff_lines_iterator))
                except StopIteration:
                    lines.append('X')
            s = ''.join([line[0] for line in lines])
            if s.startswith('X'):
                # When no more lines, pump out any remaining blank lines so the
                # corresponding add/delete lines get a matching blank line so
                # all line pairs get yielded at the next level.
                num_blanks_to_yield = num_blanks_pending
            elif s.startswith('-?+?'):
                # simple intraline change
                yield _make_line(lines,'?',0), _make_line(lines,'?',1), True
                continue
            elif s.startswith('--++'):
                # in delete block, add block coming: we do NOT want to get
                # caught up on blank lines yet, just process the delete line
                num_blanks_pending -= 1
                yield _make_line(lines,'-',0), None, True
                continue
            elif s.startswith(('--?+', '--+', '- ')):
                # in delete block and see a intraline change or unchanged line
                # coming: yield the delete line and then blanks
                from_line,to_line = _make_line(lines,'-',0), None
                num_blanks_to_yield,num_blanks_pending = num_blanks_pending-1,0
            elif s.startswith('-+?'):
                # intraline change
                yield _make_line(lines,None,0), _make_line(lines,'?',1), True
                continue
            elif s.startswith('-?+'):
                # intraline change
                yield _make_line(lines,'?',0), _make_line(lines,None,1), True
                continue
            elif s.startswith('-'):
                # delete FROM line
                num_blanks_pending -= 1
                yield _make_line(lines,'-',0), None, True
                continue
            elif s.startswith('+--'):
                # in add block, delete block coming: we do NOT want to get
                # caught up on blank lines yet, just process the add line
                num_blanks_pending += 1
                yield None, _make_line(lines,'+',1), True
                continue
            elif s.startswith(('+ ', '+-')):
                # will be leaving an add block: yield blanks then add line
                from_line, to_line = None, _make_line(lines,'+',1)
                num_blanks_to_yield,num_blanks_pending = num_blanks_pending+1,0
            elif s.startswith('+'):
                # inside an add block, yield the add line
                num_blanks_pending += 1
                yield None, _make_line(lines,'+',1), True
                continue
            elif s.startswith(' '):
                # unchanged text, yield it to both sides
                yield _make_line(lines[:],None,0),_make_line(lines,None,1),False
                continue
            # Catch up on the blank lines so when we yield the next from/to
            # pair, they are lined up.
            while(num_blanks_to_yield < 0):
                num_blanks_to_yield += 1
                yield None,('','\n'),True
            while(num_blanks_to_yield > 0):
                num_blanks_to_yield -= 1
                yield ('','\n'),None,True
            if s.startswith('X'):
                raise StopIteration
            else:
                yield from_line,to_line,True

    def _line_pair_iterator():
        """Yields from/to lines of text with a change indication.

        This function is an iterator.  It itself pulls lines from the line
        iterator.  Its difference from that iterator is that this function
        always yields a pair of from/to text lines (with the change
        indication).  If necessary it will collect single from/to lines
        until it has a matching pair from/to pair to yield.

        Note, this function is purposefully not defined at the module scope so
        that data it needs from its parent function (within whose context it
        is defined) does not need to be of module scope.
        """
        line_iterator = _line_iterator()
        fromlines,tolines=[],[]
        while True:
            # Collecting lines of text until we have a from/to pair
            while (len(fromlines)==0 or len(tolines)==0):
                from_line, to_line, found_diff = next(line_iterator)
                if from_line is not None:
                    fromlines.append((from_line,found_diff))
                if to_line is not None:
                    tolines.append((to_line,found_diff))
            # Once we have a pair, remove them from the collection and yield it
            from_line, fromDiff = fromlines.pop(0)
            to_line, to_diff = tolines.pop(0)
            yield (from_line,to_line,fromDiff or to_diff)

    # Handle case where user does not want context differencing, just yield
    # them up without doing anything else with them.
    line_pair_iterator = _line_pair_iterator()
    if context is None:
        while True:
            yield next(line_pair_iterator)
    # Handle case where user wants context differencing.  We must do some
    # storage of lines until we know for sure that they are to be yielded.
    else:
        context += 1
        lines_to_write = 0
        while True:
            # Store lines up until we find a difference, note use of a
            # circular queue because we only need to keep around what
            # we need for context.
            index, contextLines = 0, [None]*(context)
            found_diff = False
            while(found_diff is False):
                from_line, to_line, found_diff = next(line_pair_iterator)
                i = index % context
                contextLines[i] = (from_line, to_line, found_diff)
                index += 1
            # Yield lines that we have collected so far, but first yield
            # the user's separator.
            if index > context:
                yield None, None, None
                lines_to_write = context
            else:
                lines_to_write = index
                index = 0
            while(lines_to_write):
                i = index % context
                index += 1
                yield contextLines[i]
                lines_to_write -= 1
            # Now yield the context lines after the change
            lines_to_write = context-1
            while(lines_to_write):
                from_line, to_line, found_diff = next(line_pair_iterator)
                # If another change within the context, extend the context
                if found_diff:
                    lines_to_write = context-1
                else:
                    lines_to_write -= 1
                yield from_line, to_line, found_diff


_file_template = """
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>

<head>
    <meta http-equiv="Content-Type"
          content="text/html; charset=ISO-8859-1" />
    <title></title>
    <style type="text/css">%(styles)s
    </style>
</head>

<body>
    %(table)s%(legend)s
</body>

</html>"""

_styles = """
        table.diff {font-family:Courier; border:medium;}
        .diff_header {background-color:#e0e0e0}
        td.diff_header {text-align:right}
        .diff_next {background-color:#c0c0c0}
        .diff_add {background-color:#aaffaa}
        .diff_chg {background-color:#ffff77}
        .diff_sub {background-color:#ffaaaa}"""

_table_template = """
    <table class="diff" id="difflib_chg_%(prefix)s_top"
           cellspacing="0" cellpadding="0" rules="groups" >
        <colgroup></colgroup> <colgroup></colgroup> <colgroup></colgroup>
        <colgroup></colgroup> <colgroup></colgroup> <colgroup></colgroup>
        %(header_row)s
        <tbody>
%(data_rows)s        </tbody>
    </table>"""

_legend = """
    <table class="diff" summary="Legends">
        <tr> <th colspan="2"> Legends </th> </tr>
        <tr> <td> <table border="" summary="Colors">
                      <tr><th> Colors </th> </tr>
                      <tr><td class="diff_add">&nbsp;Added&nbsp;</td></tr>
                      <tr><td class="diff_chg">Changed</td> </tr>
                      <tr><td class="diff_sub">Deleted</td> </tr>
                  </table></td>
             <td> <table border="" summary="Links">
                      <tr><th colspan="2"> Links </th> </tr>
                      <tr><td>(f)irst change</td> </tr>
                      <tr><td>(n)ext change</td> </tr>
                      <tr><td>(t)op</td> </tr>
                  </table></td> </tr>
    </table>"""

class HtmlDiff(object):
    """For producing HTML side by side comparison with change highlights.

    This class can be used to create an HTML table (or a complete HTML file
    containing the table) showing a side by side, line by line comparison
    of text with inter-line and intra-line change highlights.  The table can
    be generated in either full or contextual difference mode.

    The following methods are provided for HTML generation:

    make_table -- generates HTML for a single side by side table
    make_file -- generates complete HTML file with a single side by side table

    See tools/scripts/diff.py for an example usage of this class.
    """

    _file_template = _file_template
    _styles = _styles
    _table_template = _table_template
    _legend = _legend
    _default_prefix = 0

    def __init__(self,tabsize=8,wrapcolumn=None,linejunk=None,
                 charjunk=IS_CHARACTER_JUNK):
        """HtmlDiff instance initializer

        Arguments:
        tabsize -- tab stop spacing, defaults to 8.
        wrapcolumn -- column number where lines are broken and wrapped,
            defaults to None where lines are not wrapped.
        linejunk,charjunk -- keyword arguments passed into ndiff() (used to by
            HtmlDiff() to generate the side by side HTML differences).  See
            ndiff() documentation for argument default values and descriptions.
        """
        self._tabsize = tabsize
        self._wrapcolumn = wrapcolumn
        self._linejunk = linejunk
        self._charjunk = charjunk

    def make_file(self,fromlines,tolines,fromdesc='',todesc='',context=False,
                  numlines=5):
        """Returns HTML file of side by side comparison with change highlights

        Arguments:
        fromlines -- list of "from" lines
        tolines -- list of "to" lines
        fromdesc -- "from" file column header string
        todesc -- "to" file column header string
        context -- set to True for contextual differences (defaults to False
            which shows full differences).
        numlines -- number of context lines.  When context is set True,
            controls number of lines displayed before and after the change.
            When context is False, controls the number of lines to place
            the "next" link anchors before the next change (so click of
            "next" link jumps to just before the change).
        """

        return self._file_template % dict(
            styles = self._styles,
            legend = self._legend,
            table = self.make_table(fromlines,tolines,fromdesc,todesc,
                                    context=context,numlines=numlines))

    def _tab_newline_replace(self,fromlines,tolines):
        """Returns from/to line lists with tabs expanded and newlines removed.

        Instead of tab characters being replaced by the number of spaces
        needed to fill in to the next tab stop, this function will fill
        the space with tab characters.  This is done so that the difference
        algorithms can identify changes in a file when tabs are replaced by
        spaces and vice versa.  At the end of the HTML generation, the tab
        characters will be replaced with a nonbreakable space.
        """
        def expand_tabs(line):
            # hide real spaces
            line = line.replace(' ','\0')
            # expand tabs into spaces
            line = line.expandtabs(self._tabsize)
            # replace spaces from expanded tabs back into tab characters
            # (we'll replace them with markup after we do differencing)
            line = line.replace(' ','\t')
            return line.replace('\0',' ').rstrip('\n')
        fromlines = [expand_tabs(line) for line in fromlines]
        tolines = [expand_tabs(line) for line in tolines]
        return fromlines,tolines

    def _split_line(self,data_list,line_num,text):
        """Builds list of text lines by splitting text lines at wrap point

        This function will determine if the input text line needs to be
        wrapped (split) into separate lines.  If so, the first wrap point
        will be determined and the first line appended to the output
        text line list.  This function is used recursively to handle
        the second part of the split line to further split it.
        """
        # if blank line or context separator, just add it to the output list
        if not line_num:
            data_list.append((line_num,text))
            return

        # if line text doesn't need wrapping, just add it to the output list
        size = len(text)
        max = self._wrapcolumn
        if (size <= max) or ((size -(text.count('\0')*3)) <= max):
            data_list.append((line_num,text))
            return

        # scan text looking for the wrap point, keeping track if the wrap
        # point is inside markers
        i = 0
        n = 0
        mark = ''
        while n < max and i < size:
            if text[i] == '\0':
                i += 1
                mark = text[i]
                i += 1
            elif text[i] == '\1':
                i += 1
                mark = ''
            else:
                i += 1
                n += 1

        # wrap point is inside text, break it up into separate lines
        line1 = text[:i]
        line2 = text[i:]

        # if wrap point is inside markers, place end marker at end of first
        # line and start marker at beginning of second line because each
        # line will have its own table tag markup around it.
        if mark:
            line1 = line1 + '\1'
            line2 = '\0' + mark + line2

        # tack on first line onto the output list
        data_list.append((line_num,line1))

        # use this routine again to wrap the remaining text
        self._split_line(data_list,'>',line2)

    def _line_wrapper(self,diffs):
        """Returns iterator that splits (wraps) mdiff text lines"""

        # pull from/to data and flags from mdiff iterator
        for fromdata,todata,flag in diffs:
            # check for context separators and pass them through
            if flag is None:
                yield fromdata,todata,flag
                continue
            (fromline,fromtext),(toline,totext) = fromdata,todata
            # for each from/to line split it at the wrap column to form
            # list of text lines.
            fromlist,tolist = [],[]
            self._split_line(fromlist,fromline,fromtext)
            self._split_line(tolist,toline,totext)
            # yield from/to line in pairs inserting blank lines as
            # necessary when one side has more wrapped lines
            while fromlist or tolist:
                if fromlist:
                    fromdata = fromlist.pop(0)
                else:
                    fromdata = ('',' ')
                if tolist:
                    todata = tolist.pop(0)
                else:
                    todata = ('',' ')
                yield fromdata,todata,flag

    def _collect_lines(self,diffs):
        """Collects mdiff output into separate lists

        Before storing the mdiff from/to data into a list, it is converted
        into a single line of text with HTML markup.
        """

        fromlist,tolist,flaglist = [],[],[]
        # pull from/to data and flags from mdiff style iterator
        for fromdata,todata,flag in diffs:
            try:
                # store HTML markup of the lines into the lists
                fromlist.append(self._format_line(0,flag,*fromdata))
                tolist.append(self._format_line(1,flag,*todata))
            except TypeError:
                # exceptions occur for lines where context separators go
                fromlist.append(None)
                tolist.append(None)
            flaglist.append(flag)
        return fromlist,tolist,flaglist

    def _format_line(self,side,flag,linenum,text):
        """Returns HTML markup of "from" / "to" text lines

        side -- 0 or 1 indicating "from" or "to" text
        flag -- indicates if difference on line
        linenum -- line number (used for line number column)
        text -- line text to be marked up
        """
        try:
            linenum = '%d' % linenum
            id = ' id="%s%s"' % (self._prefix[side],linenum)
        except TypeError:
            # handle blank lines where linenum is '>' or ''
            id = ''
        # replace those things that would get confused with HTML symbols
        text=text.replace("&","&amp;").replace(">","&gt;").replace("<","&lt;")

        # make space non-breakable so they don't get compressed or line wrapped
        text = text.replace(' ','&nbsp;').rstrip()

        return '<td class="diff_header"%s>%s</td><td nowrap="nowrap">%s</td>' \
               % (id,linenum,text)

    def _make_prefix(self):
        """Create unique anchor prefixes"""

        # Generate a unique anchor prefix so multiple tables
        # can exist on the same HTML page without conflicts.
        fromprefix = "from%d_" % HtmlDiff._default_prefix
        toprefix = "to%d_" % HtmlDiff._default_prefix
        HtmlDiff._default_prefix += 1
        # store prefixes so line format method has access
        self._prefix = [fromprefix,toprefix]

    def _convert_flags(self,fromlist,tolist,flaglist,context,numlines):
        """Makes list of "next" links"""

        # all anchor names will be generated using the unique "to" prefix
        toprefix = self._prefix[1]

        # process change flags, generating middle column of next anchors/links
        next_id = ['']*len(flaglist)
        next_href = ['']*len(flaglist)
        num_chg, in_change = 0, False
        last = 0
        for i,flag in enumerate(flaglist):
            if flag:
                if not in_change:
                    in_change = True
                    last = i
                    # at the beginning of a change, drop an anchor a few lines
                    # (the context lines) before the change for the previous
                    # link
                    i = max([0,i-numlines])
                    next_id[i] = ' id="difflib_chg_%s_%d"' % (toprefix,num_chg)
                    # at the beginning of a change, drop a link to the next
                    # change
                    num_chg += 1
                    next_href[last] = '<a href="#difflib_chg_%s_%d">n</a>' % (
                         toprefix,num_chg)
            else:
                in_change = False
        # check for cases where there is no content to avoid exceptions
        if not flaglist:
            flaglist = [False]
            next_id = ['']
            next_href = ['']
            last = 0
            if context:
                fromlist = ['<td></td><td>&nbsp;No Differences Found&nbsp;</td>']
                tolist = fromlist
            else:
                fromlist = tolist = ['<td></td><td>&nbsp;Empty File&nbsp;</td>']
        # if not a change on first line, drop a link
        if not flaglist[0]:
            next_href[0] = '<a href="#difflib_chg_%s_0">f</a>' % toprefix
        # redo the last link to link to the top
        next_href[last] = '<a href="#difflib_chg_%s_top">t</a>' % (toprefix)

        return fromlist,tolist,flaglist,next_href,next_id

    def make_table(self,fromlines,tolines,fromdesc='',todesc='',context=False,
                   numlines=5):
        """Returns HTML table of side by side comparison with change highlights

        Arguments:
        fromlines -- list of "from" lines
        tolines -- list of "to" lines
        fromdesc -- "from" file column header string
        todesc -- "to" file column header string
        context -- set to True for contextual differences (defaults to False
            which shows full differences).
        numlines -- number of context lines.  When context is set True,
            controls number of lines displayed before and after the change.
            When context is False, controls the number of lines to place
            the "next" link anchors before the next change (so click of
            "next" link jumps to just before the change).
        """

        # make unique anchor prefixes so that multiple tables may exist
        # on the same page without conflict.
        self._make_prefix()

        # change tabs to spaces before it gets more difficult after we insert
        # markup
        fromlines,tolines = self._tab_newline_replace(fromlines,tolines)

        # create diffs iterator which generates side by side from/to data
        if context:
            context_lines = numlines
        else:
            context_lines = None
        diffs = _mdiff(fromlines,tolines,context_lines,linejunk=self._linejunk,
                      charjunk=self._charjunk)

        # set up iterator to wrap lines that exceed desired width
        if self._wrapcolumn:
            diffs = self._line_wrapper(diffs)

        # collect up from/to lines and flags into lists (also format the lines)
        fromlist,tolist,flaglist = self._collect_lines(diffs)

        # process change flags, generating middle column of next anchors/links
        fromlist,tolist,flaglist,next_href,next_id = self._convert_flags(
            fromlist,tolist,flaglist,context,numlines)

        s = []
        fmt = '            <tr><td class="diff_next"%s>%s</td>%s' + \
              '<td class="diff_next">%s</td>%s</tr>\n'
        for i in range(len(flaglist)):
            if flaglist[i] is None:
                # mdiff yields None on separator lines skip the bogus ones
                # generated for the first line
                if i > 0:
                    s.append('        </tbody>        \n        <tbody>\n')
            else:
                s.append( fmt % (next_id[i],next_href[i],fromlist[i],
                                           next_href[i],tolist[i]))
        if fromdesc or todesc:
            header_row = '<thead><tr>%s%s%s%s</tr></thead>' % (
                '<th class="diff_next"><br /></th>',
                '<th colspan="2" class="diff_header">%s</th>' % fromdesc,
                '<th class="diff_next"><br /></th>',
                '<th colspan="2" class="diff_header">%s</th>' % todesc)
        else:
            header_row = ''

        table = self._table_template % dict(
            data_rows=''.join(s),
            header_row=header_row,
            prefix=self._prefix[1])

        return table.replace('\0+','<span class="diff_add">'). \
                     replace('\0-','<span class="diff_sub">'). \
                     replace('\0^','<span class="diff_chg">'). \
                     replace('\1','</span>'). \
                     replace('\t','&nbsp;')

del re

def restore(delta, which):
    r"""
    Generate one of the two sequences that generated a delta.

    Given a `delta` produced by `Differ.compare()` or `ndiff()`, extract
    lines originating from file 1 or 2 (parameter `which`), stripping off line
    prefixes.

    Examples:

    >>> diff = ndiff('one\ntwo\nthree\n'.splitlines(keepends=True),
    ...              'ore\ntree\nemu\n'.splitlines(keepends=True))
    >>> diff = list(diff)
    >>> print(''.join(restore(diff, 1)), end="")
    one
    two
    three
    >>> print(''.join(restore(diff, 2)), end="")
    ore
    tree
    emu
    """
    try:
        tag = {1: "- ", 2: "+ "}[int(which)]
    except KeyError:
        raise ValueError('unknown delta choice (must be 1 or 2): %r'
                           % which)
    prefixes = ("  ", tag)
    for line in delta:
        if line[:2] in prefixes:
            yield line[2:]

def _test():
    import doctest, difflib
    return doctest.testmod(difflib)

if __name__ == "__main__":
    _test()