Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

34 files changed, 29621 insertions, 0 deletions

diff --git a/src/bldprogs/Makefile.kmk b/src/bldprogs/Makefile.kmk
new file mode 100644
index 00000000..37f5ad31
--- /dev/null
+++ b/src/bldprogs/Makefile.kmk
@@ -0,0 +1,119 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for various generic build tools (there is currently only one of them).
+#
+
+#
+# Copyright (C) 2006-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# 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, in version 3 of the
+# License.
+#
+# 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 <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+SUB_DEPTH = ../..
+include $(KBUILD_PATH)/subheader.kmk
+
+BLDPROGS += bin2c
+ifn1of ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH), solaris.sparc64)
+ BLDPROGS += biossums filesplitter genalias VBoxCmp
+endif
+
+bin2c_TEMPLATE = VBoxBldProg
+bin2c_SOURCES = \
+	bin2c.c
+
+biossums_TEMPLATE = VBoxBldProg
+biossums_SOURCES = biossums.c
+
+filesplitter_TEMPLATE = VBoxBldProg
+filesplitter_SOURCES = filesplitter.cpp
+
+genalias_TEMPLATE = VBoxBldProg
+genalias_SOURCES = genalias.cpp
+
+VBoxCmp_TEMPLATE = VBoxBldProg
+VBoxCmp_SOURCES = VBoxCmp.cpp
+
+ifndef VBOX_ONLY_BUILD
+ PROGRAMS += scm
+ scm_TEMPLATE = VBoxR3Tool
+ scm_SOURCES = \
+ 	scm.cpp \
+ 	scmdiff.cpp \
+ 	scmrw.cpp \
+ 	scmrw-kmk.cpp \
+ 	scmparser.cpp \
+ 	scmstream.cpp \
+ 	scmsubversion.cpp
+ ifdef VBOX_PATH_SUBVERSION_INCS
+  scm_INCS += $(VBOX_PATH_SUBVERSION_INCS) $(VBOX_PATH_APACHE_RUNTIME_INCS)
+  scm_DEFS += SCM_WITH_SVN_HEADERS
+ endif
+
+ BLDPROGS += VBoxCPP
+ VBoxCPP_TEMPLATE = VBoxAdvBldProg
+ VBoxCPP_SOURCES = \
+ 	VBoxCPP.cpp \
+ 	scmstream.cpp
+endif
+
+if !defined(VBOX_ONLY_BUILD) || defined(VBOX_ONLY_EXTPACKS)
+ BLDPROGS += VBoxTpG
+ VBoxTpG_TEMPLATE = VBoxAdvBldProg
+ VBoxTpG_SOURCES = \
+ 	VBoxTpG.cpp \
+ 	scmstream.cpp
+endif
+
+ifeq ($(KBUILD_TARGET),win)
+ BLDPROGS += VBoxPeSetVersion
+endif
+VBoxPeSetVersion_TEMPLATE = VBoxBldProg
+VBoxPeSetVersion_SOURCES  = VBoxPeSetVersion.cpp
+
+BLDPROGS.win += VBoxCheckImports
+VBoxCheckImports_TEMPLATE = VBoxBldProg
+VBoxCheckImports_SOURCES  = VBoxCheckImports.cpp
+
+ifneq ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH),solaris.sparc64)
+ BLDPROGS += VBoxDef2LazyLoad
+endif
+VBoxDef2LazyLoad_TEMPLATE = VBoxBldProg
+VBoxDef2LazyLoad_SOURCES  = VBoxDef2LazyLoad.cpp
+
+ifeq ($(KBUILD_TARGET),win)
+ BLDPROGS += VBoxEditCoffLib
+endif
+VBoxEditCoffLib_TEMPLATE = VBoxBldProg
+VBoxEditCoffLib_SOURCES  = VBoxEditCoffLib.cpp
+
+# temp hack.
+VBoxCompilerPlugInsGcc.o VBoxCompilerPlugInsCommon.o VBoxCompilerPlugIns.o gccplugin: gccplugin$(SUFF_DLL)
+gccplugin$(SUFF_DLL): VBoxCompilerPlugInsGcc.cpp VBoxCompilerPlugInsCommon.cpp VBoxCompilerPlugIns.h
+	$(TOOL_GXX3_CXX) -shared -fPIC -fno-rtti -g \
+		-DIN_RING3 \
+		$(if-expr "$(KBUILD_TYPE)" != "release",-DDEBUG,) \
+		-I$(shell $(TOOL_GXX3_CXX) -print-file-name=plugin)/include \
+		-I$(PATH_ROOT)/include \
+		$(if-expr "$(KBUILD_HOST)" == "solaris", -I/usr/include/gmp -I$(PATH_ROOT)/src/bldprogs/solgcc/,) \
+		-o $@ \
+		VBoxCompilerPlugInsGcc.cpp \
+		VBoxCompilerPlugInsCommon.cpp
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/bldprogs/VBoxCPP.cpp b/src/bldprogs/VBoxCPP.cpp
new file mode 100644
index 00000000..eb5a7d44
--- /dev/null
+++ b/src/bldprogs/VBoxCPP.cpp
@@ -0,0 +1,5542 @@
+/* $Id: VBoxCPP.cpp $ */
+/** @file
+ * VBox Build Tool - A mini C Preprocessor.
+ *
+ * Purposes to which this preprocessor will be put:
+ *      - Preprocessig vm.h into dtrace/lib/vm.d so we can access the VM
+ *        structure (as well as substructures) from DTrace without having
+ *        to handcraft it all.
+ *      - Removing \#ifdefs relating to a new feature that has become
+ *        stable and no longer needs \#ifdef'ing.
+ *      - Pretty printing preprocessor directives.  This will be used by
+ *        SCM.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <VBox/VBoxTpG.h>
+
+#include <iprt/alloca.h>
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+#include <iprt/ctype.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/list.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/path.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scmstream.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** The bitmap type. */
+#define VBCPP_BITMAP_TYPE                   uint64_t
+/** The bitmap size as a multiple of VBCPP_BITMAP_TYPE. */
+#define VBCPP_BITMAP_SIZE                   (128 / 64)
+/** Checks if a bit is set. */
+#define VBCPP_BITMAP_IS_SET(a_bm, a_ch)     ASMBitTest(a_bm, (a_ch) & 0x7f)
+/** Sets a bit. */
+#define VBCPP_BITMAP_SET(a_bm, a_ch)        ASMBitSet(a_bm, (a_ch) & 0x7f)
+/** Empties the bitmap. */
+#define VBCPP_BITMAP_EMPTY(a_bm)            do { (a_bm)[0] = 0; (a_bm)[1] = 0; } while (0)
+/** Joins to bitmaps by OR'ing their values.. */
+#define VBCPP_BITMAP_OR(a_bm1, a_bm2)       do { (a_bm1)[0] |= (a_bm2)[0]; (a_bm1)[1] |= (a_bm2)[1]; } while (0)
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** Pointer to the C preprocessor instance data. */
+typedef struct VBCPP *PVBCPP;
+
+
+/**
+ * Variable string buffer (very simple version of SCMSTREAM).
+ */
+typedef struct VBCPPSTRBUF
+{
+    /** The preprocessor instance (for error reporting). */
+    struct VBCPP   *pThis;
+    /** The length of the string in the buffer. */
+    size_t          cchBuf;
+    /** The string storage. */
+    char           *pszBuf;
+    /** Allocated buffer space. */
+    size_t          cbBufAllocated;
+} VBCPPSTRBUF;
+/** Pointer to a variable string buffer. */
+typedef VBCPPSTRBUF *PVBCPPSTRBUF;
+
+
+/**
+ * The preprocessor mode.
+ */
+typedef enum VBCPPMODE
+{
+    kVBCppMode_Invalid = 0,
+    kVBCppMode_Standard,
+    kVBCppMode_Selective,
+    kVBCppMode_SelectiveD,
+    kVBCppMode_End
+} VBCPPMODE;
+
+
+/**
+ * A macro (aka define).
+ */
+typedef struct VBCPPMACRO
+{
+    /** The string space core. */
+    RTSTRSPACECORE      Core;
+#if 0
+    /** For linking macros that have the fExpanding flag set. */
+    struct VBCPPMACRO  *pUpExpanding;
+#endif
+    /** Whether it's a function. */
+    bool                fFunction;
+    /** Variable argument count. */
+    bool                fVarArg;
+    /** Set if originating on the command line. */
+    bool                fCmdLine;
+    /** Set if this macro is currently being expanded and should not be
+     * recursively applied. */
+    bool                fExpanding;
+    /** The number of known arguments. */
+    uint32_t            cArgs;
+    /** Pointer to a list of argument names. */
+    const char        **papszArgs;
+    /** Lead character bitmap for the argument names. */
+    VBCPP_BITMAP_TYPE   bmArgs[VBCPP_BITMAP_SIZE];
+    /** The value length. */
+    size_t              cchValue;
+    /** The define value.  (This is followed by the name and arguments.) */
+    char                szValue[1];
+} VBCPPMACRO;
+/** Pointer to a macro. */
+typedef VBCPPMACRO *PVBCPPMACRO;
+
+
+/**
+ * Macro expansion data.
+ */
+typedef struct VBCPPMACROEXP
+{
+    /** The expansion buffer. */
+    VBCPPSTRBUF     StrBuf;
+#if 0
+    /** List of expanding macros (Stack). */
+    PVBCPPMACRO     pMacroStack;
+#endif
+    /** The input stream (in case we want to look for parameter lists). */
+    PSCMSTREAM      pStrmInput;
+    /** Array of argument values.  Used when expanding function style macros.  */
+    char          **papszArgs;
+    /** The number of argument values current in papszArgs. */
+    uint32_t        cArgs;
+    /** The number of argument values papszArgs can currently hold  */
+    uint32_t        cArgsAlloced;
+} VBCPPMACROEXP;
+/** Pointer to macro expansion data. */
+typedef VBCPPMACROEXP *PVBCPPMACROEXP;
+
+
+/**
+ * The vbcppMacroExpandReScan mode of operation.
+ */
+typedef enum VBCPPMACRORESCANMODE
+{
+    /** Invalid mode.  */
+    kMacroReScanMode_Invalid = 0,
+    /** Normal expansion mode. */
+    kMacroReScanMode_Normal,
+    /** Replaces known macros and heeds the 'defined' operator. */
+    kMacroReScanMode_Expression,
+    /** End of valid modes. */
+    kMacroReScanMode_End
+} VBCPPMACRORESCANMODE;
+
+
+/**
+ * Expression node type.
+ */
+typedef enum VBCPPEXPRKIND
+{
+    kVBCppExprKind_Invalid = 0,
+    kVBCppExprKind_Unary,
+    kVBCppExprKind_Binary,
+    kVBCppExprKind_Ternary,
+    kVBCppExprKind_SignedValue,
+    kVBCppExprKind_UnsignedValue,
+    kVBCppExprKind_End
+} VBCPPEXPRKIND;
+
+
+/** Macro used for the precedence field. */
+#define VBCPPOP_PRECEDENCE(a_iPrecedence)   ((a_iPrecedence) << 8)
+/** Mask for getting the precedence field value. */
+#define VBCPPOP_PRECEDENCE_MASK             0xff00
+/** Operator associativity - Left to right. */
+#define VBCPPOP_L2R                         (1 << 16)
+/** Operator associativity - Right to left. */
+#define VBCPPOP_R2L                         (2 << 16)
+
+/**
+ * Unary operators.
+ */
+typedef enum VBCPPUNARYOP
+{
+    kVBCppUnaryOp_Invalid = 0,
+    kVBCppUnaryOp_Pluss             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  5,
+    kVBCppUnaryOp_Minus             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  6,
+    kVBCppUnaryOp_LogicalNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  7,
+    kVBCppUnaryOp_BitwiseNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  8,
+    kVBCppUnaryOp_Parenthesis       = VBCPPOP_R2L | VBCPPOP_PRECEDENCE(15) |  9,
+    kVBCppUnaryOp_End
+} VBCPPUNARYOP;
+
+/**
+ * Binary operators.
+ */
+typedef enum VBCPPBINARYOP
+{
+    kVBCppBinary_Invalid = 0,
+    kVBCppBinary_Multiplication     = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  2,
+    kVBCppBinary_Division           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  4,
+    kVBCppBinary_Modulo             = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  5,
+    kVBCppBinary_Addition           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  6,
+    kVBCppBinary_Subtraction        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  7,
+    kVBCppBinary_LeftShift          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  8,
+    kVBCppBinary_RightShift         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  9,
+    kVBCppBinary_LessThan           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 10,
+    kVBCppBinary_LessThanOrEqual    = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 11,
+    kVBCppBinary_GreaterThan        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 12,
+    kVBCppBinary_GreaterThanOrEqual = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 13,
+    kVBCppBinary_EqualTo            = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 14,
+    kVBCppBinary_NotEqualTo         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 15,
+    kVBCppBinary_BitwiseAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(10) | 16,
+    kVBCppBinary_BitwiseXor         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(11) | 17,
+    kVBCppBinary_BitwiseOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(12) | 18,
+    kVBCppBinary_LogicalAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(13) | 19,
+    kVBCppBinary_LogicalOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(14) | 20,
+    kVBCppBinary_End
+} VBCPPBINARYOP;
+
+/** The precedence of the ternary operator (expr ? true : false). */
+#define VBCPPTERNAROP_PRECEDENCE   VBCPPOP_PRECEDENCE(16)
+
+
+/** Pointer to an expression parsing node. */
+typedef struct VBCPPEXPR *PVBCPPEXPR;
+/**
+ * Expression parsing node.
+ */
+typedef struct VBCPPEXPR
+{
+    /** Parent expression. */
+    PVBCPPEXPR          pParent;
+    /** Whether the expression is complete or not. */
+    bool                fComplete;
+    /** The kind of expression. */
+    VBCPPEXPRKIND       enmKind;
+    /** Kind specific content. */
+    union
+    {
+        /** kVBCppExprKind_Unary */
+        struct
+        {
+            VBCPPUNARYOP    enmOperator;
+            PVBCPPEXPR      pArg;
+        } Unary;
+
+        /** kVBCppExprKind_Binary */
+        struct
+        {
+            VBCPPBINARYOP   enmOperator;
+            PVBCPPEXPR      pLeft;
+            PVBCPPEXPR      pRight;
+        } Binary;
+
+        /** kVBCppExprKind_Ternary */
+        struct
+        {
+            PVBCPPEXPR      pExpr;
+            PVBCPPEXPR      pTrue;
+            PVBCPPEXPR      pFalse;
+        } Ternary;
+
+        /** kVBCppExprKind_SignedValue */
+        struct
+        {
+            int64_t         s64;
+        } SignedValue;
+
+        /** kVBCppExprKind_UnsignedValue */
+        struct
+        {
+            uint64_t        u64;
+        } UnsignedValue;
+    } u;
+} VBCPPEXPR;
+
+
+/**
+ * Operator return statuses.
+ */
+typedef enum VBCPPEXPRRET
+{
+    kExprRet_Error = -1,
+    kExprRet_Ok = 0,
+    kExprRet_UnaryOperator,
+    kExprRet_Value,
+    kExprRet_EndOfExpr,
+    kExprRet_End
+} VBCPPEXPRRET;
+
+/**
+ * Expression parser context.
+ */
+typedef struct VBCPPEXPRPARSER
+{
+    /** The current expression posistion. */
+    const char         *pszCur;
+    /** The root node. */
+    PVBCPPEXPR          pRoot;
+    /** The current expression node. */
+    PVBCPPEXPR          pCur;
+    /** Where to insert the next expression. */
+    PVBCPPEXPR         *ppCur;
+    /** The expression. */
+    const char         *pszExpr;
+    /** The number of undefined macros we've encountered while parsing. */
+    size_t              cUndefined;
+    /** Pointer to the C preprocessor instance. */
+    PVBCPP              pThis;
+} VBCPPEXPRPARSER;
+/** Pointer to an expression parser context. */
+typedef VBCPPEXPRPARSER *PVBCPPEXPRPARSER;
+
+
+/**
+ * Evaluation result.
+ */
+typedef enum VBCPPEVAL
+{
+    kVBCppEval_Invalid = 0,
+    kVBCppEval_True,
+    kVBCppEval_False,
+    kVBCppEval_Undecided,
+    kVBCppEval_End
+} VBCPPEVAL;
+
+
+/**
+ * The condition kind.
+ */
+typedef enum VBCPPCONDKIND
+{
+    kVBCppCondKind_Invalid = 0,
+    /** \#if expr  */
+    kVBCppCondKind_If,
+    /** \#ifdef define  */
+    kVBCppCondKind_IfDef,
+    /** \#ifndef define  */
+    kVBCppCondKind_IfNDef,
+    /** \#elif expr */
+    kVBCppCondKind_ElIf,
+    /** The end of valid values. */
+    kVBCppCondKind_End
+} VBCPPCONDKIND;
+
+
+/**
+ * Conditional stack entry.
+ */
+typedef struct VBCPPCOND
+{
+    /** The next conditional on the stack. */
+    struct VBCPPCOND   *pUp;
+    /** The kind of conditional. This changes on encountering \#elif. */
+    VBCPPCONDKIND       enmKind;
+    /** Evaluation result. */
+    VBCPPEVAL           enmResult;
+    /** The evaluation result of the whole stack. */
+    VBCPPEVAL           enmStackResult;
+
+    /** Whether we've seen the last else. */
+    bool                fSeenElse;
+    /** Set if we have an else if which has already been decided. */
+    bool                fElIfDecided;
+    /** The nesting level of this condition. */
+    uint16_t            iLevel;
+    /** The nesting level of this condition wrt the ones we keep. */
+    uint16_t            iKeepLevel;
+
+    /** The condition string. (Points within the stream buffer.) */
+    const char         *pchCond;
+    /** The condition length. */
+    size_t              cchCond;
+} VBCPPCOND;
+/** Pointer to a conditional stack entry. */
+typedef VBCPPCOND *PVBCPPCOND;
+
+
+/**
+ * Input buffer stack entry.
+ */
+typedef struct VBCPPINPUT
+{
+    /** Pointer to the next input on the stack. */
+    struct VBCPPINPUT  *pUp;
+    /** The input stream. */
+    SCMSTREAM           StrmInput;
+    /** Pointer into szName to the part which was specified. */
+    const char         *pszSpecified;
+    /** The input file name with include path. */
+    char                szName[1];
+} VBCPPINPUT;
+/** Pointer to a input buffer stack entry */
+typedef VBCPPINPUT *PVBCPPINPUT;
+
+
+/**
+ * The action to take with \#include.
+ */
+typedef enum VBCPPINCLUDEACTION
+{
+    kVBCppIncludeAction_Invalid = 0,
+    kVBCppIncludeAction_Include,
+    kVBCppIncludeAction_PassThru,
+    kVBCppIncludeAction_Drop,
+    kVBCppIncludeAction_End
+} VBCPPINCLUDEACTION;
+
+
+/**
+ * C Preprocessor instance data.
+ */
+typedef struct VBCPP
+{
+    /** @name Options
+     * @{ */
+    /** The preprocessing mode. */
+    VBCPPMODE           enmMode;
+    /** Whether to keep comments. */
+    bool                fKeepComments;
+    /** Whether to respect source defines. */
+    bool                fRespectSourceDefines;
+    /** Whether to let source defines overrides the ones on the command
+     *  line. */
+    bool                fAllowRedefiningCmdLineDefines;
+    /** Whether to pass thru defines. */
+    bool                fPassThruDefines;
+    /** Whether to allow undecided conditionals. */
+    bool                fUndecidedConditionals;
+    /** Whether to pass thru D pragmas. */
+    bool                fPassThruPragmaD;
+    /** Whether to pass thru STD pragmas. */
+    bool                fPassThruPragmaSTD;
+    /** Whether to pass thru other pragmas. */
+    bool                fPassThruPragmaOther;
+    /** Whether to remove dropped lines from the output. */
+    bool                fRemoveDroppedLines;
+    /** Whether to preforme line splicing.
+     * @todo implement line splicing  */
+    bool                fLineSplicing;
+    /** What to do about include files. */
+    VBCPPINCLUDEACTION  enmIncludeAction;
+
+    /** The number of include directories. */
+    uint32_t            cIncludes;
+    /** Array of directories to search for include files. */
+    char              **papszIncludes;
+
+    /** The name of the input file. */
+    const char         *pszInput;
+    /** The name of the output file. NULL if stdout. */
+    const char         *pszOutput;
+    /** @} */
+
+    /** The define string space. */
+    RTSTRSPACE          StrSpace;
+    /** The string space holding explicitly undefined macros for selective
+     * preprocessing runs. */
+    RTSTRSPACE          UndefStrSpace;
+    /** Indicates whether a C-word might need expansion.
+     * The bitmap is indexed by C-word lead character.  Bits that are set
+     * indicates that the lead character is used in a \#define that we know and
+     * should expand. */
+    VBCPP_BITMAP_TYPE   bmDefined[VBCPP_BITMAP_SIZE];
+
+    /** The current depth of the conditional stack. */
+    uint32_t            cCondStackDepth;
+    /** Conditional stack. */
+    PVBCPPCOND          pCondStack;
+    /** The current condition evaluates to kVBCppEval_False, don't output. */
+    bool                fIf0Mode;
+    /** Just dropped a line and should maybe drop the current line. */
+    bool                fJustDroppedLine;
+
+    /** Whether the current line could be a preprocessor line.
+     * This is set when EOL is encountered and cleared again when a
+     * non-comment-or-space character is encountered.  See vbcppPreprocess. */
+    bool                fMaybePreprocessorLine;
+
+    /** The input stack depth */
+    uint32_t            cInputStackDepth;
+    /** The input buffer stack. */
+    PVBCPPINPUT         pInputStack;
+
+    /** The output stream. */
+    SCMSTREAM           StrmOutput;
+
+    /** The status of the whole job, as far as we know. */
+    RTEXITCODE          rcExit;
+    /** Whether StrmOutput is valid (for vbcppTerm). */
+    bool                fStrmOutputValid;
+} VBCPP;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static PVBCPPMACRO  vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine);
+static RTEXITCODE   vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro, size_t offParameters);
+static RTEXITCODE   vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements);
+static void         vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp);
+
+
+
+/*
+ *
+ *
+ * Message Handling.
+ * Message Handling.
+ * Message Handling.
+ * Message Handling.
+ * Message Handling.
+ *
+ *
+ */
+
+
+/**
+ * Displays an error message.
+ *
+ * @returns RTEXITCODE_FAILURE
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszMsg              The message.
+ * @param   va                  Message arguments.
+ */
+static RTEXITCODE vbcppErrorV(PVBCPP pThis, const char *pszMsg, va_list va)
+{
+    NOREF(pThis);
+    if (pThis->pInputStack)
+    {
+        PSCMSTREAM pStrm = &pThis->pInputStack->StrmInput;
+
+        size_t const off     = ScmStreamTell(pStrm);
+        size_t const iLine   = ScmStreamTellLine(pStrm);
+        ScmStreamSeekByLine(pStrm, iLine);
+        size_t const offLine = ScmStreamTell(pStrm);
+
+        RTPrintf("%s:%d:%zd: error: %N.\n", pThis->pInputStack->szName, iLine + 1, off - offLine + 1, pszMsg, va);
+
+        size_t cchLine;
+        SCMEOL enmEof;
+        const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
+        if (pszLine)
+            RTPrintf("  %.*s\n"
+                     "  %*s^\n",
+                     cchLine, pszLine, off - offLine, "");
+
+        ScmStreamSeekAbsolute(pStrm, off);
+    }
+    else
+        RTMsgErrorV(pszMsg, va);
+    return pThis->rcExit = RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Displays an error message.
+ *
+ * @returns RTEXITCODE_FAILURE
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszMsg              The message.
+ * @param   ...                 Message arguments.
+ */
+static RTEXITCODE vbcppError(PVBCPP pThis, const char *pszMsg, ...)
+{
+    va_list va;
+    va_start(va, pszMsg);
+    RTEXITCODE rcExit = vbcppErrorV(pThis, pszMsg, va);
+    va_end(va);
+    return rcExit;
+}
+
+
+/**
+ * Displays an error message.
+ *
+ * @returns RTEXITCODE_FAILURE
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszPos              Pointer to the offending character.
+ * @param   pszMsg              The message.
+ * @param   ...                 Message arguments.
+ */
+static RTEXITCODE vbcppErrorPos(PVBCPP pThis, const char *pszPos, const char *pszMsg, ...)
+{
+    NOREF(pszPos); NOREF(pThis);
+    va_list va;
+    va_start(va, pszMsg);
+    RTMsgErrorV(pszMsg, va);
+    va_end(va);
+    return pThis->rcExit = RTEXITCODE_FAILURE;
+}
+
+
+
+
+
+
+
+/*
+ *
+ *
+ * Variable String Buffers.
+ * Variable String Buffers.
+ * Variable String Buffers.
+ * Variable String Buffers.
+ * Variable String Buffers.
+ *
+ *
+ */
+
+
+/**
+ * Initializes a string buffer.
+ *
+ * @param   pStrBuf             The buffer structure to initialize.
+ * @param   pThis               The C preprocessor instance.
+ */
+static void vbcppStrBufInit(PVBCPPSTRBUF pStrBuf, PVBCPP pThis)
+{
+    pStrBuf->pThis              = pThis;
+    pStrBuf->cchBuf             = 0;
+    pStrBuf->cbBufAllocated     = 0;
+    pStrBuf->pszBuf             = NULL;
+}
+
+
+/**
+ * Deletes a string buffer.
+ *
+ * @param   pStrBuf             Pointer to the string buffer.
+ */
+static void vbcppStrBufDelete(PVBCPPSTRBUF pStrBuf)
+{
+    RTMemFree(pStrBuf->pszBuf);
+    pStrBuf->pszBuf = NULL;
+}
+
+
+/**
+ * Ensures that sufficient bufferspace is available, growing the buffer if
+ * necessary.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pStrBuf             Pointer to the string buffer.
+ * @param   cbMin               The minimum buffer size.
+ */
+static RTEXITCODE vbcppStrBufGrow(PVBCPPSTRBUF pStrBuf, size_t cbMin)
+{
+    if (pStrBuf->cbBufAllocated >= cbMin)
+        return RTEXITCODE_SUCCESS;
+
+    size_t cbNew = pStrBuf->cbBufAllocated * 2;
+    if (cbNew < cbMin)
+        cbNew = RT_ALIGN_Z(cbMin, _1K);
+    void *pv = RTMemRealloc(pStrBuf->pszBuf, cbNew);
+    if (!pv)
+        return vbcppError(pStrBuf->pThis, "out of memory (%zu bytes)", cbNew);
+
+    pStrBuf->pszBuf         = (char *)pv;
+    pStrBuf->cbBufAllocated = cbNew;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Appends a substring.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pStrBuf             Pointer to the string buffer.
+ * @param   pchSrc              Pointer to the first character in the substring.
+ * @param   cchSrc              The length of the substring.
+ */
+static RTEXITCODE vbcppStrBufAppendN(PVBCPPSTRBUF pStrBuf, const char *pchSrc, size_t cchSrc)
+{
+    size_t cchBuf = pStrBuf->cchBuf;
+    if (cchBuf + cchSrc + 1 > pStrBuf->cbBufAllocated)
+    {
+        RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + cchSrc + 1);
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+    }
+
+    memcpy(&pStrBuf->pszBuf[cchBuf], pchSrc, cchSrc);
+    cchBuf += cchSrc;
+    pStrBuf->pszBuf[cchBuf] = '\0';
+    pStrBuf->cchBuf = cchBuf;
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Appends a character.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pStrBuf             Pointer to the string buffer.
+ * @param   ch                  The charater to append.
+ */
+static RTEXITCODE vbcppStrBufAppendCh(PVBCPPSTRBUF pStrBuf, char ch)
+{
+    size_t cchBuf = pStrBuf->cchBuf;
+    if (cchBuf + 2 > pStrBuf->cbBufAllocated)
+    {
+        RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + 2);
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+    }
+
+    pStrBuf->pszBuf[cchBuf++] = ch;
+    pStrBuf->pszBuf[cchBuf] = '\0';
+    pStrBuf->cchBuf = cchBuf;
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Appends a string to the buffer.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pStrBuf             Pointer to the string buffer.
+ * @param   psz                 The string to append.
+ */
+static RTEXITCODE vbcppStrBufAppend(PVBCPPSTRBUF pStrBuf, const char *psz)
+{
+    return vbcppStrBufAppendN(pStrBuf, psz, strlen(psz));
+}
+
+
+/**
+ * Gets the last char in the buffer.
+ *
+ * @returns Last character, 0 if empty.
+ * @param   pStrBuf             Pointer to the string buffer.
+ */
+static char vbcppStrBufLastCh(PVBCPPSTRBUF pStrBuf)
+{
+    if (!pStrBuf->cchBuf)
+        return '\0';
+    return pStrBuf->pszBuf[pStrBuf->cchBuf - 1];
+}
+
+
+
+
+
+
+
+/*
+ *
+ *
+ * C Identifier/Word Parsing.
+ * C Identifier/Word Parsing.
+ * C Identifier/Word Parsing.
+ * C Identifier/Word Parsing.
+ * C Identifier/Word Parsing.
+ *
+ *
+ */
+
+
+/**
+ * Checks if the given character is a valid C identifier lead character.
+ *
+ * @returns true / false.
+ * @param   ch                  The character to inspect.
+ */
+DECLINLINE(bool) vbcppIsCIdentifierLeadChar(char ch)
+{
+    return RT_C_IS_ALPHA(ch)
+        || ch == '_';
+}
+
+
+/**
+ * Checks if the given character is a valid C identifier character.
+ *
+ * @returns true / false.
+ * @param   ch                  The character to inspect.
+ */
+DECLINLINE(bool) vbcppIsCIdentifierChar(char ch)
+{
+    return RT_C_IS_ALNUM(ch)
+        || ch == '_';
+}
+
+
+
+/**
+ *
+ * @returns @c true if valid, @c false if not. Error message already displayed
+ *          on failure.
+ * @param   pThis           The C preprocessor instance.
+ * @param   pchIdentifier   The start of the identifier to validate.
+ * @param   cchIdentifier   The length of the identifier. RTSTR_MAX if not
+ *                          known.
+ */
+static bool vbcppValidateCIdentifier(PVBCPP pThis, const char *pchIdentifier, size_t cchIdentifier)
+{
+    if (cchIdentifier == RTSTR_MAX)
+        cchIdentifier = strlen(pchIdentifier);
+
+    if (cchIdentifier == 0)
+    {
+        vbcppErrorPos(pThis, pchIdentifier, "Zero length identifier");
+        return false;
+    }
+
+    if (!vbcppIsCIdentifierLeadChar(*pchIdentifier))
+    {
+        vbcppErrorPos(pThis, pchIdentifier, "Bad lead chararacter in identifier: '%.*s'", cchIdentifier, pchIdentifier);
+        return false;
+    }
+
+    for (size_t off = 1; off < cchIdentifier; off++)
+    {
+        if (!vbcppIsCIdentifierChar(pchIdentifier[off]))
+        {
+            vbcppErrorPos(pThis, pchIdentifier + off, "Illegal chararacter in identifier: '%.*s' (#%zu)", cchIdentifier, pchIdentifier, off + 1);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#if 0
+
+/**
+ * Checks if the given character is valid C punctuation.
+ *
+ * @returns true / false.
+ * @param   ch                  The character to inspect.
+ */
+DECLINLINE(bool) vbcppIsCPunctuationLeadChar(char ch)
+{
+    switch (ch)
+    {
+        case '!':
+        case '#':
+        case '%':
+        case '&':
+        case '(':
+        case ')':
+        case '*':
+        case '+':
+        case ',':
+        case '-':
+        case '.':
+        case '/':
+        case ':':
+        case ';':
+        case '<':
+        case '=':
+        case '>':
+        case '?':
+        case '[':
+        case ']':
+        case '^':
+        case '{':
+        case '|':
+        case '}':
+        case '~':
+            return true;
+        default:
+            return false;
+    }
+}
+
+
+/**
+ * Checks if the given string start with valid C punctuation.
+ *
+ * @returns 0 if not, otherwise the length of the punctuation.
+ * @param   pch                 The which start we should evaluate.
+ * @param   cchMax              The maximum string length.
+ */
+static size_t vbcppIsCPunctuationLeadChar(const char *psz, size_t cchMax)
+{
+    if (!cchMax)
+        return 0;
+
+    switch (psz[0])
+    {
+        case '!':
+        case '*':
+        case '/':
+        case '=':
+        case '^':
+            if (cchMax >= 2 && psz[1] == '=')
+                return 2;
+            return 1;
+
+        case '#':
+            if (cchMax >= 2 && psz[1] == '#')
+                return 2;
+            return 1;
+
+        case '%':
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '>'))
+                return 2;
+            if (cchMax >= 2 && psz[1] == ':')
+            {
+                if (cchMax >= 4 && psz[2] == '%' && psz[3] == ':')
+                    return 4;
+                return 2;
+            }
+            return 1;
+
+        case '&':
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '&'))
+                return 2;
+            return 1;
+
+        case '(':
+        case ')':
+        case ',':
+        case '?':
+        case '[':
+        case ']':
+        case '{':
+        case '}':
+            return 1;
+
+        case '+':
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '+'))
+                return 2;
+            return 1;
+
+        case '-':
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '-' || psz[1] == '>'))
+                return 2;
+            return 1;
+
+        case ':':
+            if (cchMax >= 2 && psz[1] == '>')
+                return 2;
+            return 1;
+
+        case ';':
+            return 1;
+
+        case '<':
+            if (cchMax >= 2 && psz[1] == '<')
+            {
+                if (cchMax >= 3 && psz[2] == '=')
+                    return 3;
+                return 2;
+            }
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == ':' || psz[1] == '%'))
+                return 2;
+            return 1;
+
+        case '.':
+            if (cchMax >= 3 && psz[1] == '.' && psz[2] == '.')
+                return 3;
+            return 1;
+
+        case '>':
+            if (cchMax >= 2 && psz[1] == '>')
+            {
+                if (cchMax >= 3 && psz[2] == '=')
+                    return 3;
+                return 2;
+            }
+            if (cchMax >= 2 && psz[1] == '=')
+                return 2;
+            return 1;
+
+        case '|':
+            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '|'))
+                return 2;
+            return 1;
+
+        case '~':
+            return 1;
+
+        default:
+            return 0;
+    }
+}
+
+#endif
+
+
+
+
+
+/*
+ *
+ *
+ * Output
+ * Output
+ * Output
+ * Output
+ * Output
+ *
+ *
+ */
+
+
+/**
+ * Outputs a character.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   ch                  The character to output.
+ */
+static RTEXITCODE vbcppOutputCh(PVBCPP pThis, char ch)
+{
+    int rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
+    if (RT_SUCCESS(rc))
+        return RTEXITCODE_SUCCESS;
+    return vbcppError(pThis, "Output error: %Rrc", rc);
+}
+
+
+/**
+ * Outputs a string.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pch                 The string.
+ * @param   cch                 The number of characters to write.
+ */
+static RTEXITCODE vbcppOutputWrite(PVBCPP pThis, const char *pch, size_t cch)
+{
+    int rc = ScmStreamWrite(&pThis->StrmOutput, pch, cch);
+    if (RT_SUCCESS(rc))
+        return RTEXITCODE_SUCCESS;
+    return vbcppError(pThis, "Output error: %Rrc", rc);
+}
+
+
+static RTEXITCODE vbcppOutputComment(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart, size_t cchOutputted,
+                                     size_t cchMinIndent)
+{
+    RT_NOREF_PV(cchMinIndent); /** @todo  cchMinIndent */
+
+    size_t offCur = ScmStreamTell(pStrmInput);
+    if (offStart < offCur)
+    {
+        int rc = ScmStreamSeekAbsolute(pStrmInput, offStart);
+        AssertRCReturn(rc, vbcppError(pThis, "Input seek error: %Rrc", rc));
+
+        /*
+         * Use the same indent, if possible.
+         */
+        size_t cchIndent = offStart - ScmStreamTellOffsetOfLine(pStrmInput, ScmStreamTellLine(pStrmInput));
+        if (cchOutputted < cchIndent)
+            rc = ScmStreamPrintf(&pThis->StrmOutput, "%*s", cchIndent - cchOutputted, "");
+        else
+            rc = ScmStreamPutCh(&pThis->StrmOutput, ' ');
+        if (RT_FAILURE(rc))
+            return vbcppError(pThis, "Output error: %Rrc", rc);
+
+        /*
+         * Copy the bytes.
+         */
+        while (ScmStreamTell(pStrmInput) < offCur)
+        {
+            unsigned ch = ScmStreamGetCh(pStrmInput);
+            if (ch == ~(unsigned)0)
+                return vbcppError(pThis, "Input error: %Rrc", rc);
+            rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
+            if (RT_FAILURE(rc))
+                return vbcppError(pThis, "Output error: %Rrc", rc);
+        }
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+
+
+
+/*
+ *
+ *
+ * Input
+ * Input
+ * Input
+ * Input
+ * Input
+ *
+ *
+ */
+
+
+#if 0 /* unused */
+/**
+ * Skips white spaces, including escaped new-lines.
+ *
+ * @param   pStrmInput          The input stream.
+ */
+static void vbcppProcessSkipWhiteAndEscapedEol(PSCMSTREAM pStrmInput)
+{
+    unsigned chPrev = ~(unsigned)0;
+    unsigned ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (ch == '\r' || ch == '\n')
+        {
+            if (chPrev != '\\')
+                break;
+            chPrev = ch;
+            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+        }
+        else if (RT_C_IS_SPACE(ch))
+        {
+            chPrev = ch;
+            ch = ScmStreamGetCh(pStrmInput);
+            Assert(ch == chPrev);
+        }
+        else
+            break;
+    }
+}
+#endif
+
+
+/**
+ * Skips white spaces, escaped new-lines and multi line comments.
+ *
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndComments(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    unsigned chPrev = ~(unsigned)0;
+    unsigned ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (!RT_C_IS_SPACE(ch))
+        {
+            /* Multi-line Comment? */
+            if (ch != '/')
+                break;                  /* most definitely, not. */
+
+            size_t offSaved = ScmStreamTell(pStrmInput);
+            ScmStreamGetCh(pStrmInput);
+            if (ScmStreamPeekCh(pStrmInput) != '*')
+            {
+                ScmStreamSeekAbsolute(pStrmInput, offSaved);
+                break;              /* no */
+            }
+
+            /* Skip to the end of the comment. */
+            while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
+            {
+                if (ch == '*')
+                {
+                    ch = ScmStreamGetCh(pStrmInput);
+                    if (ch == '/')
+                        break;
+                    if (ch == ~(unsigned)0)
+                        break;
+                }
+            }
+            if (ch == ~(unsigned)0)
+                return vbcppError(pThis, "unterminated multi-line comment");
+            chPrev = '/';
+        }
+        /* New line (also matched by RT_C_IS_SPACE). */
+        else if (ch == '\r' || ch == '\n')
+        {
+            /* Stop if not escaped. */
+            if (chPrev != '\\')
+                break;
+            chPrev = ch;
+            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+        }
+        /* Real space char. */
+        else
+        {
+            chPrev = ch;
+            ch = ScmStreamGetCh(pStrmInput);
+            Assert(ch == chPrev);
+        }
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Skips white spaces, escaped new-lines, and multi line comments, then checking
+ * that we're at the end of a line.
+ *
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        unsigned ch = ScmStreamPeekCh(pStrmInput);
+        if (   ch != ~(unsigned)0
+            && ch != '\r'
+            && ch != '\n')
+            rcExit = vbcppError(pThis, "Did not expected anything more on this line");
+    }
+    return rcExit;
+}
+
+
+/**
+ * Skips white spaces.
+ *
+ * @returns The current location upon return.
+ * @param   pStrmInput          The input stream.
+ */
+static size_t vbcppProcessSkipWhite(PSCMSTREAM pStrmInput)
+{
+    unsigned ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (!RT_C_IS_SPACE(ch) || ch == '\r' || ch == '\n')
+            break;
+        unsigned chCheck = ScmStreamGetCh(pStrmInput);
+        AssertBreak(chCheck == ch);
+    }
+    return ScmStreamTell(pStrmInput);
+}
+
+
+/**
+ * Looks for a left parenthesis in the input stream.
+ *
+ * Used during macro expansion.  Will ignore comments, newlines and other
+ * whitespace.
+ *
+ * @retval  true if found. The stream position at opening parenthesis.
+ * @retval  false if not found. The stream position is unchanged.
+ *
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static bool vbcppInputLookForLeftParenthesis(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    size_t offSaved = ScmStreamTell(pStrmInput);
+    /*RTEXITCODE rcExit =*/ vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    unsigned ch = ScmStreamPeekCh(pStrmInput);
+    if (ch == '(')
+        return true;
+
+    int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
+    AssertFatalRC(rc);
+    return false;
+}
+
+
+/**
+ * Skips input until the real end of the current directive line has been
+ * reached.
+ *
+ * This includes multiline comments starting on the same line
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   poffComment         Where to note down the position of the final
+ *                              comment. Optional.
+ */
+static RTEXITCODE vbcppInputSkipToEndOfDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t *poffComment)
+{
+    if (poffComment)
+        *poffComment = ~(size_t)0;
+
+    RTEXITCODE  rcExit      = RTEXITCODE_SUCCESS;
+    bool        fInComment  = false;
+    unsigned    chPrev      = 0;
+    unsigned    ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (ch == '\r' || ch == '\n')
+        {
+            if (chPrev == '\\')
+            {
+                ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+                continue;
+            }
+            if (!fInComment)
+                break;
+            /* The expression continues after multi-line comments. Cool. :-) */
+        }
+        else if (!fInComment)
+        {
+            if (chPrev == '/' && ch == '*' )
+            {
+                fInComment = true;
+                if (poffComment)
+                    *poffComment = ScmStreamTell(pStrmInput) - 1;
+            }
+            else if (chPrev == '/' && ch == '/')
+            {
+                if (poffComment)
+                    *poffComment = ScmStreamTell(pStrmInput) - 1;
+                rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+                break;                  /* done */
+            }
+        }
+        else if (ch == '/' && chPrev == '*')
+            fInComment = false;
+
+        /* advance */
+        chPrev = ch;
+        ch = ScmStreamGetCh(pStrmInput); Assert(ch == chPrev);
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a multi-line comment.
+ *
+ * Must either string the comment or keep it. If the latter, we must refrain
+ * from replacing C-words in it.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessMultiLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    /* The open comment sequence. */
+    ScmStreamGetCh(pStrmInput);         /* '*' */
+    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
+    if (   pThis->fKeepComments
+        && !pThis->fIf0Mode)
+        rcExit = vbcppOutputWrite(pThis, "/*", 2);
+
+    /* The comment.*/
+    unsigned ch;
+    while (   rcExit == RTEXITCODE_SUCCESS
+           && (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0 )
+    {
+        if (ch == '*')
+        {
+            /* Closing sequence? */
+            unsigned ch2 = ScmStreamPeekCh(pStrmInput);
+            if (ch2 == '/')
+            {
+                ScmStreamGetCh(pStrmInput);
+                if (   pThis->fKeepComments
+                    && !pThis->fIf0Mode)
+                    rcExit = vbcppOutputWrite(pThis, "*/", 2);
+                break;
+            }
+        }
+
+        if (ch == '\r' || ch == '\n')
+        {
+            if (   (   pThis->fKeepComments
+                    && !pThis->fIf0Mode)
+                || !pThis->fRemoveDroppedLines
+                || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
+                rcExit = vbcppOutputCh(pThis, ch);
+            pThis->fJustDroppedLine       = false;
+            pThis->fMaybePreprocessorLine = true;
+        }
+        else if (   pThis->fKeepComments
+                 && !pThis->fIf0Mode)
+            rcExit = vbcppOutputCh(pThis, ch);
+
+        if (rcExit != RTEXITCODE_SUCCESS)
+            break;
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a single line comment.
+ *
+ * Must either string the comment or keep it. If the latter, we must refrain
+ * from replacing C-words in it.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessOneLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol); Assert(pszLine);
+    pszLine--; cchLine++;               /* unfetching the first slash. */
+    for (;;)
+    {
+        if (   pThis->fKeepComments
+            && !pThis->fIf0Mode)
+            rcExit = vbcppOutputWrite(pThis, pszLine, cchLine + enmEol);
+        else if (   !pThis->fIf0Mode
+                 || !pThis->fRemoveDroppedLines
+                 || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput) )
+            rcExit = vbcppOutputWrite(pThis, pszLine + cchLine, enmEol);
+        if (rcExit != RTEXITCODE_SUCCESS)
+            break;
+        if (   cchLine == 0
+            || pszLine[cchLine - 1] != '\\')
+            break;
+
+        pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol);
+        if (!pszLine)
+            break;
+    }
+    pThis->fJustDroppedLine       = false;
+    pThis->fMaybePreprocessorLine = true;
+    return rcExit;
+}
+
+
+/**
+ * Processes a double quoted string.
+ *
+ * Must not replace any C-words in strings.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessStringLitteral(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RTEXITCODE rcExit = vbcppOutputCh(pThis, '"');
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        bool fEscaped = false;
+        for (;;)
+        {
+            unsigned ch = ScmStreamGetCh(pStrmInput);
+            if (ch == ~(unsigned)0)
+            {
+                rcExit = vbcppError(pThis, "Unterminated double quoted string");
+                break;
+            }
+
+            rcExit = vbcppOutputCh(pThis, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                break;
+
+            if (ch == '"' && !fEscaped)
+                break;
+            fEscaped = !fEscaped && ch == '\\';
+        }
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a single quoted constant.
+ *
+ * Must not replace any C-words in character constants.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessCharacterConstant(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RTEXITCODE rcExit = vbcppOutputCh(pThis, '\'');
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        bool fEscaped = false;
+        for (;;)
+        {
+            unsigned ch = ScmStreamGetCh(pStrmInput);
+            if (ch == ~(unsigned)0)
+            {
+                rcExit = vbcppError(pThis, "Unterminated singled quoted string");
+                break;
+            }
+
+            rcExit = vbcppOutputCh(pThis, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                break;
+
+            if (ch == '\'' && !fEscaped)
+                break;
+            fEscaped = !fEscaped && ch == '\\';
+        }
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a integer or floating point number constant.
+ *
+ * Must not replace the type suffix.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   chFirst             The first character.
+ */
+static RTEXITCODE vbcppProcessNumber(PVBCPP pThis, PSCMSTREAM pStrmInput, char chFirst)
+{
+    RTEXITCODE rcExit = vbcppOutputCh(pThis, chFirst);
+
+    unsigned ch;
+    while (   rcExit == RTEXITCODE_SUCCESS
+           && (ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (   !vbcppIsCIdentifierChar(ch)
+            && ch != '.')
+            break;
+
+        unsigned ch2 = ScmStreamGetCh(pStrmInput);
+        AssertBreakStmt(ch2 == ch, rcExit = vbcppError(pThis, "internal error"));
+        rcExit = vbcppOutputCh(pThis, ch);
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Processes a identifier, possibly replacing it with a definition.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessIdentifier(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RTEXITCODE  rcExit;
+    size_t      cchDefine;
+    const char *pchDefine = ScmStreamCGetWordM1(pStrmInput, &cchDefine);
+    AssertReturn(pchDefine, vbcppError(pThis, "Internal error in ScmStreamCGetWordM1"));
+
+    /*
+     * Does this look like a define we know?
+     */
+    PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
+    if (   pMacro
+        && (   !pMacro->fFunction
+            || vbcppInputLookForLeftParenthesis(pThis, pStrmInput)) )
+    {
+        /*
+         * Expand it.
+         */
+        VBCPPMACROEXP ExpCtx;
+#if 0
+        ExpCtx.pMacroStack    = NULL;
+#endif
+        ExpCtx.pStrmInput     = pStrmInput;
+        ExpCtx.papszArgs      = NULL;
+        ExpCtx.cArgs          = 0;
+        ExpCtx.cArgsAlloced   = 0;
+        vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
+        rcExit = vbcppStrBufAppendN(&ExpCtx.StrBuf, pchDefine, cchDefine);
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = vbcppMacroExpandIt(pThis, &ExpCtx, 0 /* offset */, pMacro, cchDefine);
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Normal, NULL);
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            /*
+             * Insert it into the output stream.  Make sure there is a
+             * whitespace following it.
+             */
+            int rc = ScmStreamWrite(&pThis->StrmOutput, ExpCtx.StrBuf.pszBuf, ExpCtx.StrBuf.cchBuf);
+            if (RT_SUCCESS(rc))
+            {
+                unsigned chAfter = ScmStreamPeekCh(pStrmInput);
+                if (chAfter != ~(unsigned)0 && !RT_C_IS_SPACE(chAfter))
+                    rcExit = vbcppOutputCh(pThis, ' ');
+            }
+            else
+                rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
+        }
+        vbcppMacroExpandCleanup(&ExpCtx);
+    }
+    else
+    {
+        /*
+         * Not a macro or a function-macro name match but no invocation, just
+         * output the text unchanged.
+         */
+        int rc = ScmStreamWrite(&pThis->StrmOutput, pchDefine, cchDefine);
+        if (RT_SUCCESS(rc))
+            rcExit = RTEXITCODE_SUCCESS;
+        else
+            rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
+    }
+    return rcExit;
+}
+
+
+
+
+
+
+
+/*
+ *
+ *
+ * D E F I N E S   /   M A C R O S
+ * D E F I N E S   /   M A C R O S
+ * D E F I N E S   /   M A C R O S
+ * D E F I N E S   /   M A C R O S
+ * D E F I N E S   /   M A C R O S
+ *
+ *
+ */
+
+
+/**
+ * Checks if a define exists.
+ *
+ * @returns true or false.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDefine           The define name and optionally the argument
+ *                              list.
+ * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
+ */
+static bool vbcppMacroExists(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
+{
+    return cchDefine > 0
+        && VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine)
+        && RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine) != NULL;
+}
+
+
+/**
+ * Looks up a define.
+ *
+ * @returns Pointer to the define if found, NULL if not.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDefine           The define name and optionally the argument
+ *                              list.
+ * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
+ */
+static PVBCPPMACRO vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
+{
+    if (!cchDefine)
+        return NULL;
+    if (!VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine))
+        return NULL;
+    return (PVBCPPMACRO)RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
+}
+
+
+static uint32_t vbcppMacroLookupArg(PVBCPPMACRO pMacro, const char *pchName, size_t cchName)
+{
+    Assert(cchName > 0);
+
+    char const ch = *pchName;
+    for (uint32_t i = 0; i < pMacro->cArgs; i++)
+        if (   pMacro->papszArgs[i][0] == ch
+            && !strncmp(pMacro->papszArgs[i], pchName, cchName)
+            && pMacro->papszArgs[i][cchName] == '\0')
+            return i;
+
+    if (   pMacro->fVarArg
+        && cchName == sizeof("__VA_ARGS__") - 1
+        && !strncmp(pchName, "__VA_ARGS__", sizeof("__VA_ARGS__") - 1) )
+        return pMacro->cArgs;
+
+    return UINT32_MAX;
+}
+
+
+static RTEXITCODE vbcppMacroExpandReplace(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t off, size_t cchToReplace,
+                                          const char *pchReplacement, size_t cchReplacement)
+{
+    RT_NOREF_PV(pThis);
+
+    /*
+     * Figure how much space we actually need.
+     * (Hope this whitespace stuff is correct...)
+     */
+    bool const fLeadingSpace            = off > 0
+                                       && !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off - 1]);
+    bool const fTrailingSpace           = off + cchToReplace < pExp->StrBuf.cchBuf
+                                       && !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off + cchToReplace]);
+    size_t const cchActualReplacement   = fLeadingSpace + cchReplacement + fTrailingSpace;
+
+    /*
+     * Adjust the buffer size and contents.
+     */
+    if (cchActualReplacement > cchToReplace)
+    {
+        size_t const offMore = cchActualReplacement - cchToReplace;
+
+        /* Ensure enough buffer space. */
+        size_t cbMinBuf = offMore + pExp->StrBuf.cchBuf + 1;
+        RTEXITCODE rcExit = vbcppStrBufGrow(&pExp->StrBuf, cbMinBuf);
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+
+        /* Push the chars following the replacement area down to make room. */
+        memmove(&pExp->StrBuf.pszBuf[off + cchToReplace + offMore],
+                &pExp->StrBuf.pszBuf[off + cchToReplace],
+                pExp->StrBuf.cchBuf - off - cchToReplace + 1);
+        pExp->StrBuf.cchBuf += offMore;
+
+    }
+    else if (cchActualReplacement < cchToReplace)
+    {
+        size_t const offLess = cchToReplace - cchActualReplacement;
+
+        /* Pull the chars following the replacement area up. */
+        memmove(&pExp->StrBuf.pszBuf[off + cchToReplace - offLess],
+                &pExp->StrBuf.pszBuf[off + cchToReplace],
+                pExp->StrBuf.cchBuf - off - cchToReplace + 1);
+        pExp->StrBuf.cchBuf -= offLess;
+    }
+
+    /*
+     * Insert the replacement string.
+     */
+    char *pszCur = &pExp->StrBuf.pszBuf[off];
+    if (fLeadingSpace)
+        *pszCur++ = ' ';
+    memcpy(pszCur, pchReplacement, cchReplacement);
+    if (fTrailingSpace)
+        *pszCur++ = ' ';
+
+    Assert(strlen(pExp->StrBuf.pszBuf) == pExp->StrBuf.cchBuf);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static unsigned vbcppMacroExpandPeekCh(PVBCPPMACROEXP pExp, size_t *poff)
+{
+    size_t off = *poff;
+    if (off >= pExp->StrBuf.cchBuf)
+        return pExp->pStrmInput ? ScmStreamPeekCh(pExp->pStrmInput) : ~(unsigned)0;
+    return pExp->StrBuf.pszBuf[off];
+}
+
+
+static unsigned vbcppMacroExpandGetCh(PVBCPPMACROEXP pExp, size_t *poff)
+{
+    size_t off = *poff;
+    if (off >= pExp->StrBuf.cchBuf)
+        return pExp->pStrmInput ? ScmStreamGetCh(pExp->pStrmInput) : ~(unsigned)0;
+    *poff = off + 1;
+    return pExp->StrBuf.pszBuf[off];
+}
+
+
+static RTEXITCODE vbcppMacroExpandSkipEolEx(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, unsigned chFirst)
+{
+    if (chFirst == '\r')
+    {
+        unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
+        if (ch2 == '\n')
+        {
+            ch2 = ScmStreamGetCh(pExp->pStrmInput);
+            AssertReturn(ch2 == '\n', vbcppError(pThis, "internal error"));
+        }
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE vbcppMacroExpandSkipEol(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
+{
+    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
+    AssertReturn(ch == '\r' || ch == '\n', vbcppError(pThis, "internal error"));
+    return vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
+}
+
+
+static RTEXITCODE vbcppMacroExpandSkipCommentLine(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
+{
+    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
+    AssertReturn(ch == '/', vbcppError(pThis, "Internal error - expected '/' got '%c'", ch));
+
+    unsigned chPrev = 0;
+    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+    {
+        if (ch == '\r' || ch == '\n')
+        {
+            RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+            if (chPrev != '\\')
+                break;
+        }
+
+        chPrev = ch;
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE vbcppMacroExpandSkipComment(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
+{
+    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
+    AssertReturn(ch == '*', vbcppError(pThis, "Internal error - expected '*' got '%c'", ch));
+
+    unsigned chPrev2 = 0;
+    unsigned chPrev  = 0;
+    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+    {
+        if (ch == '/' && chPrev == '*')
+            break;
+
+        if (ch == '\r' || ch == '\n')
+        {
+            RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+            if (chPrev == '\\')
+            {
+                chPrev = chPrev2;       /* for line splicing */
+                continue;
+            }
+        }
+
+        chPrev2 = chPrev;
+        chPrev  = ch;
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE vbcppMacroExpandGrowArgArray(PVBCPP pThis, PVBCPPMACROEXP pExp, uint32_t cMinArgs)
+{
+    if (cMinArgs > pExp->cArgsAlloced)
+    {
+        void *pv = RTMemRealloc(pExp->papszArgs, cMinArgs * sizeof(char *));
+        if (!pv)
+            return vbcppError(pThis, "out of memory");
+        pExp->papszArgs = (char **)pv;
+        pExp->cArgsAlloced = cMinArgs;
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE vbcppMacroExpandAddEmptyParameter(PVBCPP pThis, PVBCPPMACROEXP pExp)
+{
+    RTEXITCODE rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, pExp->cArgs + 1);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        char *pszArg = (char *)RTMemAllocZ(1);
+        if (pszArg)
+            pExp->papszArgs[pExp->cArgs++] = pszArg;
+        else
+            rcExit = vbcppError(pThis, "out of memory");
+    }
+    return rcExit;
+}
+
+
+static RTEXITCODE vbcppMacroExpandGatherParameters(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, uint32_t cArgsHint)
+{
+    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
+
+    /*
+     * Free previous argument values.
+     */
+    while (pExp->cArgs > 0)
+    {
+        RTMemFree(pExp->papszArgs[--pExp->cArgs]);
+        pExp->papszArgs[pExp->cArgs] = NULL;
+    }
+
+    /*
+     * The current character should be an opening parenthsis.
+     */
+    unsigned    ch = vbcppMacroExpandGetCh(pExp, poff);
+    if (ch != '(')
+        return vbcppError(pThis, "Internal error - expected '(', found '%c' (#x)", ch, ch);
+
+    /*
+     * Parse the argument list.
+     */
+    char        chQuote      = 0;
+    size_t      cbArgAlloc   = 0;
+    size_t      cchArg       = 0;
+    char       *pszArg       = NULL;
+    size_t      cParentheses = 1;
+    unsigned    chPrev       = 0;
+    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+    {
+/** @todo check for '#directives'! */
+        if (ch == ')' && !chQuote)
+        {
+            Assert(cParentheses >= 1);
+            cParentheses--;
+
+            /* The end? */
+            if (!cParentheses)
+            {
+                if (cchArg)
+                    while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
+                        pszArg[--cchArg] = '\0';
+                else if (pExp->cArgs || cArgsHint > 0)
+                    rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
+                break;
+            }
+        }
+        else if (ch == '('  && !chQuote)
+            cParentheses++;
+        else if (ch == ',' && cParentheses == 1 && !chQuote)
+        {
+            /* End of one argument, start of the next. */
+            if (cchArg)
+                while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
+                    pszArg[--cchArg] = '\0';
+            else
+            {
+                rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    break;
+            }
+
+            cbArgAlloc = 0;
+            cchArg     = 0;
+            pszArg     = NULL;
+            continue;
+        }
+        else if (ch == '/' && !chQuote)
+        {
+            /* Comment? */
+            unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
+            /** @todo This ain't right wrt line splicing. */
+            if (ch2 == '/' || ch == '*')
+            {
+                if (ch2 == '/')
+                    rcExit = vbcppMacroExpandSkipCommentLine(pThis, pExp, poff);
+                else
+                    rcExit = vbcppMacroExpandSkipComment(pThis, pExp, poff);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    break;
+                continue;
+            }
+        }
+        else if (ch == '"')
+        {
+            if (!chQuote)
+                chQuote = '"';
+            else if (chPrev != '\\')
+                chQuote = 0;
+        }
+        else if (ch == '\'')
+        {
+            if (!chQuote)
+                chQuote = '\'';
+            else if (chPrev != '\\')
+                chQuote = 0;
+        }
+        else if (ch == '\\')
+        {
+            /* Splice lines? */
+            unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
+            if (ch2 == '\r' || ch2 == '\n')
+            {
+                rcExit = vbcppMacroExpandSkipEol(pThis, pExp, poff);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    break;
+                continue;
+            }
+        }
+        else if (cchArg == 0 && RT_C_IS_SPACE(ch))
+            continue; /* ignore spaces leading up to an argument value */
+
+        /* Append the character to the argument value, adding the argument
+           to the output array if it's first character in it. */
+        if (cchArg + 1 >= cbArgAlloc)
+        {
+            /* Add argument to the vector. */
+            if (!cchArg)
+            {
+                rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, RT_MAX(pExp->cArgs + 1, cArgsHint));
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    break;
+                pExp->papszArgs[pExp->cArgs++] = pszArg;
+            }
+
+            /* Resize the argument value buffer. */
+            cbArgAlloc = cbArgAlloc ? cbArgAlloc * 2 : 16;
+            pszArg = (char *)RTMemRealloc(pszArg, cbArgAlloc);
+            if (!pszArg)
+            {
+                rcExit = vbcppError(pThis, "out of memory");
+                break;
+            }
+            pExp->papszArgs[pExp->cArgs - 1] = pszArg;
+        }
+
+        pszArg[cchArg++] = ch;
+        pszArg[cchArg]   = '\0';
+    }
+
+    /*
+     * Check that we're leaving on good terms.
+     */
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        if (cParentheses)
+            rcExit = vbcppError(pThis, "Missing ')'");
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Expands the arguments referenced in the macro value.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pExp                The expansion context.
+ * @param   pMacro              The macro.  Must be a function macro.
+ * @param   pStrBuf             String buffer containing the result. The caller
+ *                              should initialize and destroy this!
+ */
+static RTEXITCODE vbcppMacroExpandValueWithArguments(PVBCPP pThis, PVBCPPMACROEXP pExp, PVBCPPMACRO pMacro,
+                                                     PVBCPPSTRBUF pStrBuf)
+{
+    Assert(pMacro->fFunction);
+
+    /*
+     * Empty?
+     */
+    if (   !pMacro->cchValue
+        || (pMacro->cchValue == 1 && pMacro->szValue[0] == '#'))
+        return RTEXITCODE_SUCCESS;
+
+    /*
+     * Parse the value.
+     */
+    RTEXITCODE  rcExit    = RTEXITCODE_SUCCESS;
+    const char *pszSrc    = pMacro->szValue;
+    const char *pszSrcSeq;
+    char        ch;
+    while ((ch = *pszSrc++) != '\0')
+    {
+        Assert(ch != '\r'); Assert(ch != '\n'); /* probably not true atm. */
+        if (ch == '#')
+        {
+            if (*pszSrc == '#')
+            {
+                /* Concatenate operator. */
+                rcExit = vbcppError(pThis, "The '##' operatore is not yet implemented");
+            }
+            else
+            {
+                /* Stringify macro argument. */
+                rcExit = vbcppError(pThis, "The '#' operatore is not yet implemented");
+            }
+            return rcExit;
+        }
+        else if (ch == '"')
+        {
+            /* String litteral. */
+            pszSrcSeq = pszSrc - 1;
+            while ((ch = *pszSrc++) != '"')
+            {
+                if (ch == '\\')
+                    ch = *pszSrc++;
+                if (ch == '\0')
+                {
+                    rcExit = vbcppError(pThis, "String litteral is missing closing quote (\").");
+                    break;
+                }
+            }
+            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
+        }
+        else if (ch == '\'')
+        {
+            /* Character constant. */
+            pszSrcSeq = pszSrc - 1;
+            while ((ch = *pszSrc++) != '\'')
+            {
+                if (ch == '\\')
+                    ch = *pszSrc++;
+                if (ch == '\0')
+                {
+                    rcExit = vbcppError(pThis, "Character constant is missing closing quote (').");
+                    break;
+                }
+            }
+            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
+        }
+        else if (RT_C_IS_DIGIT(ch))
+        {
+            /* Process numerical constants correctly (i.e. don't mess with the suffix). */
+            pszSrcSeq = pszSrc - 1;
+            while (   (ch = *pszSrc) != '\0'
+                   && (   vbcppIsCIdentifierChar(ch)
+                       || ch == '.') )
+                pszSrc++;
+            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
+        }
+        else if (RT_C_IS_SPACE(ch))
+        {
+            /* join spaces */
+            if (RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf)))
+                continue;
+            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
+        }
+        else if (vbcppIsCIdentifierLeadChar(ch))
+        {
+            /* Something we should replace? */
+            pszSrcSeq = pszSrc - 1;
+            while (   (ch = *pszSrc) != '\0'
+                   && vbcppIsCIdentifierChar(ch))
+                pszSrc++;
+            size_t      cchDefine = pszSrc - pszSrcSeq;
+            uint32_t    iArg;
+            if (   VBCPP_BITMAP_IS_SET(pMacro->bmArgs, *pszSrcSeq)
+                && (iArg = vbcppMacroLookupArg(pMacro, pszSrcSeq, cchDefine)) != UINT32_MAX)
+            {
+                /** @todo check out spaces here! */
+                if (iArg < pMacro->cArgs)
+                {
+                    Assert(iArg < pExp->cArgs);
+                    rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
+                    if (*pExp->papszArgs[iArg] != '\0' && rcExit == RTEXITCODE_SUCCESS)
+                        rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
+                }
+                else
+                {
+                    /* __VA_ARGS__ */
+                    if (iArg < pExp->cArgs)
+                    {
+                        for (;;)
+                        {
+                            rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
+                            if (rcExit != RTEXITCODE_SUCCESS)
+                                break;
+                            iArg++;
+                            if (iArg >= pExp->cArgs)
+                                break;
+                            rcExit = vbcppStrBufAppendCh(pStrBuf, ',');
+                            if (rcExit != RTEXITCODE_SUCCESS)
+                                break;
+                        }
+                    }
+                    if (rcExit == RTEXITCODE_SUCCESS)
+                        rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
+                }
+            }
+            /* Not an argument needing replacing. */
+            else
+                rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, cchDefine);
+        }
+        else
+        {
+            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
+        }
+    }
+
+    return rcExit;
+}
+
+
+
+/**
+ * Expands the given macro.
+ *
+ * Caller already checked if a function macro should be expanded, i.e. whether
+ * there is a parameter list.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pExp                The expansion context.
+ * @param   offMacro            Offset into the expansion buffer of the macro
+ *                              invocation.
+ * @param   pMacro              The macro.
+ * @param   offParameters       The start of the parameter list if applicable.
+ *                              Ignored if not function macro.  If the
+ *                              parameter list starts at the current stream
+ *                              position shall be at the end of the expansion
+ *                              buffer.
+ */
+static RTEXITCODE vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro,
+                                     size_t offParameters)
+{
+    RTEXITCODE rcExit;
+    Assert(offMacro + pMacro->Core.cchString <= pExp->StrBuf.cchBuf);
+    Assert(!pMacro->fExpanding);
+
+    /*
+     * Function macros are kind of difficult...
+     */
+    if (pMacro->fFunction)
+    {
+        rcExit = vbcppMacroExpandGatherParameters(pThis, pExp, &offParameters, pMacro->cArgs + pMacro->fVarArg);
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            if (pExp->cArgs > pMacro->cArgs && !pMacro->fVarArg)
+                rcExit = vbcppError(pThis, "Too many arguments to macro '%s' - found %u, expected %u",
+                                    pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
+            else if (pExp->cArgs < pMacro->cArgs)
+                rcExit = vbcppError(pThis, "Too few arguments to macro '%s' - found %u, expected %u",
+                                    pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
+        }
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            VBCPPSTRBUF ValueBuf;
+            vbcppStrBufInit(&ValueBuf, pThis);
+            rcExit = vbcppMacroExpandValueWithArguments(pThis, pExp, pMacro, &ValueBuf);
+            if (rcExit == RTEXITCODE_SUCCESS)
+                rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, offParameters - offMacro,
+                                                 ValueBuf.pszBuf, ValueBuf.cchBuf);
+            vbcppStrBufDelete(&ValueBuf);
+        }
+    }
+    /*
+     * Object-like macros are easy. :-)
+     */
+    else
+        rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, pMacro->Core.cchString, pMacro->szValue, pMacro->cchValue);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+#if 0 /* wrong */
+        /*
+         * Push the macro onto the stack.
+         */
+        pMacro->fExpanding   = true;
+        pMacro->pUpExpanding = pExp->pMacroStack;
+        pExp->pMacroStack    = pMacro;
+#endif
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Looks for a left parenthesis in the macro expansion buffer and the input
+ * stream.
+ *
+ * @retval  true if found. The stream position at opening parenthesis.
+ * @retval  false if not found. The stream position is unchanged.
+ *
+ * @param   pThis               The C preprocessor instance.
+ * @param   pExp                The expansion context.
+ * @param   poff                The current offset in the expansion context.
+ *                              Will be updated on success.
+ *
+ * @sa vbcppInputLookForLeftParenthesis
+ */
+static bool vbcppMacroExpandLookForLeftParenthesis(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
+{
+    /*
+     * Search the buffer first. (No comments there.)
+     */
+    size_t off = *poff;
+    while (off < pExp->StrBuf.cchBuf)
+    {
+        char ch = pExp->StrBuf.pszBuf[off];
+        if (!RT_C_IS_SPACE(ch))
+        {
+            if (ch == '(')
+            {
+                *poff = off;
+                return true;
+            }
+            return false;
+        }
+        off++;
+    }
+
+    /*
+     * Reached the end of the buffer, continue searching in the stream.
+     */
+    PSCMSTREAM pStrmInput = pExp->pStrmInput;
+    size_t     offSaved   = ScmStreamTell(pStrmInput);
+    /*RTEXITCODE rcExit = */ vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    unsigned ch = ScmStreamPeekCh(pStrmInput);
+    if (ch == '(')
+    {
+        *poff = pExp->StrBuf.cchBuf;
+        return true;
+    }
+
+    int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
+    AssertFatalRC(rc);
+    return false;
+}
+
+
+/**
+ * Implements the 'defined' unary operator for \#if and \#elif expressions.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pExp                The expansion context.
+ * @param   offStart            The expansion buffer offset where the 'defined'
+ *                              occurs.
+ * @param   poff                Where to store the offset at which the re-scan
+ *                              shall resume upon return.
+ */
+static RTEXITCODE vbcppMacroExpandDefinedOperator(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offStart, size_t *poff)
+{
+    Assert(!pExp->pStrmInput); /* offset usage below. */
+
+    /*
+     * Skip white space.
+     */
+    unsigned ch;
+    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+        if (!RT_C_IS_SPACE(ch))
+            break;
+    bool const fWithParenthesis = ch == '(';
+    if (fWithParenthesis)
+        while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+            if (!RT_C_IS_SPACE(ch))
+                break;
+
+    /*
+     * Macro identifier.
+     */
+    if (!vbcppIsCIdentifierLeadChar(ch))
+        return vbcppError(pThis, "Expected macro name after 'defined' operator");
+
+    size_t const offDefine = *poff - 1;
+    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
+        if (!vbcppIsCIdentifierChar(ch))
+            break;
+    size_t const cchDefine = *poff - offDefine - 1;
+
+    /*
+     * Check for closing parenthesis.
+     */
+    if (fWithParenthesis)
+    {
+        while (RT_C_IS_SPACE(ch))
+            ch = vbcppMacroExpandGetCh(pExp, poff);
+        if (ch != ')')
+            return vbcppError(pThis, "Expected closing parenthesis after macro name");
+    }
+
+    /*
+     * Do the job.
+     */
+    const char *pszResult = vbcppMacroExists(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine)
+                          ? "1" : "0";
+    RTEXITCODE  rcExit    = vbcppMacroExpandReplace(pThis, pExp, offStart, *poff - offStart, pszResult, 1);
+    *poff = offStart + 1;
+    return rcExit;
+}
+
+
+/**
+ * Re-scan the expanded macro.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pExp                The expansion context.
+ * @param   enmMode             The re-scan mode.
+ * @param   pcReplacements      Where to return the number of replacements
+ *                              performed.  Optional.
+ */
+static RTEXITCODE vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements)
+{
+    RTEXITCODE  rcExit        = RTEXITCODE_SUCCESS;
+    size_t      cReplacements = 0;
+    size_t      off           = 0;
+    unsigned    ch;
+    while (   off < pExp->StrBuf.cchBuf
+           && (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
+    {
+        /*
+         * String litteral or character constant.
+         */
+        if (ch == '\'' || ch == '"')
+        {
+            unsigned const chEndQuote = ch;
+            while (   off < pExp->StrBuf.cchBuf
+                   && (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
+            {
+                if (ch == '\\')
+                {
+                    ch = vbcppMacroExpandGetCh(pExp, &off);
+                    if (ch == ~(unsigned)0)
+                        break;
+                }
+                else if (ch == chEndQuote)
+                    break;
+            }
+            if (ch == ~(unsigned)0)
+                return vbcppError(pThis, "Missing end quote (%c)", chEndQuote);
+        }
+        /*
+         * Number constant.
+         */
+        else if (   RT_C_IS_DIGIT(ch)
+                 || (   ch == '.'
+                     && off + 1 < pExp->StrBuf.cchBuf
+                     && RT_C_IS_DIGIT(vbcppMacroExpandPeekCh(pExp, &off))
+                    )
+                )
+        {
+            while (   off < pExp->StrBuf.cchBuf
+                   && (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
+                   && vbcppIsCIdentifierChar(ch) )
+                vbcppMacroExpandGetCh(pExp, &off);
+        }
+        /*
+         * Something that can be replaced?
+         */
+        else if (vbcppIsCIdentifierLeadChar(ch))
+        {
+            size_t offDefine = off - 1;
+            while (   off < pExp->StrBuf.cchBuf
+                   && (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
+                   && vbcppIsCIdentifierChar(ch) )
+                vbcppMacroExpandGetCh(pExp, &off);
+            size_t cchDefine = off - offDefine;
+
+            PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine);
+            if (   pMacro
+                && (   !pMacro->fFunction
+                    || vbcppMacroExpandLookForLeftParenthesis(pThis, pExp, &off)) )
+            {
+                cReplacements++;
+                rcExit = vbcppMacroExpandIt(pThis, pExp, offDefine, pMacro, off);
+                off = offDefine;
+            }
+            else
+            {
+                if (   !pMacro
+                         && enmMode == kMacroReScanMode_Expression
+                         && cchDefine == sizeof("defined") - 1
+                         && !strncmp(&pExp->StrBuf.pszBuf[offDefine], "defined", cchDefine))
+                {
+                    cReplacements++;
+                    rcExit = vbcppMacroExpandDefinedOperator(pThis, pExp, offDefine, &off);
+                }
+                else
+                    off = offDefine + cchDefine;
+            }
+        }
+        else
+        {
+            Assert(RT_C_IS_SPACE(ch) || RT_C_IS_PUNCT(ch));
+            Assert(ch != '\r' && ch != '\n');
+        }
+    }
+
+    if (pcReplacements)
+        *pcReplacements = cReplacements;
+    return rcExit;
+}
+
+
+/**
+ * Cleans up the expansion context.
+ *
+ * This involves clearing VBCPPMACRO::fExpanding and VBCPPMACRO::pUpExpanding,
+ * and freeing the memory resources associated with the expansion context.
+ *
+ * @param   pExp                The expansion context.
+ */
+static void vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp)
+{
+#if 0
+    while (pExp->pMacroStack)
+    {
+        PVBCPPMACRO pMacro = pExp->pMacroStack;
+        pExp->pMacroStack = pMacro->pUpExpanding;
+
+        pMacro->fExpanding   = false;
+        pMacro->pUpExpanding = NULL;
+    }
+#endif
+
+    while (pExp->cArgs > 0)
+    {
+        RTMemFree(pExp->papszArgs[--pExp->cArgs]);
+        pExp->papszArgs[pExp->cArgs] = NULL;
+    }
+
+    RTMemFree(pExp->papszArgs);
+    pExp->papszArgs = NULL;
+
+    vbcppStrBufDelete(&pExp->StrBuf);
+}
+
+
+
+/**
+ * Frees a define.
+ *
+ * @returns VINF_SUCCESS (used when called by RTStrSpaceDestroy)
+ * @param   pStr                Pointer to the VBCPPMACRO::Core member.
+ * @param   pvUser              Unused.
+ */
+static DECLCALLBACK(int) vbcppMacroFree(PRTSTRSPACECORE pStr, void *pvUser)
+{
+    RTMemFree(pStr);
+    NOREF(pvUser);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Removes a define.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDefine           The define name, no argument list or anything.
+ * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
+ * @param   fExplicitUndef      Explicit undefinition, that is, in a selective
+ *                              preprocessing run it will evaluate to undefined.
+ */
+static RTEXITCODE vbcppMacroUndef(PVBCPP pThis, const char *pszDefine, size_t cchDefine, bool fExplicitUndef)
+{
+    PRTSTRSPACECORE pHit = RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
+    if (pHit)
+    {
+        RTStrSpaceRemove(&pThis->StrSpace, pHit->pszString);
+        vbcppMacroFree(pHit, NULL);
+    }
+
+    if (fExplicitUndef)
+    {
+        if (cchDefine == RTSTR_MAX)
+            cchDefine = strlen(pszDefine);
+
+        PRTSTRSPACECORE pStr = (PRTSTRSPACECORE)RTMemAlloc(sizeof(*pStr) + cchDefine + 1);
+        if (!pStr)
+            return vbcppError(pThis, "out of memory");
+        char *pszDst = (char *)(pStr + 1);
+        pStr->pszString = pszDst;
+        memcpy(pszDst, pszDefine, cchDefine);
+        pszDst[cchDefine] = '\0';
+        if (!RTStrSpaceInsert(&pThis->UndefStrSpace, pStr))
+            RTMemFree(pStr);
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Inserts a define (rejecting and freeing it in some case).
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pMacro              The define to insert.
+ */
+static RTEXITCODE vbcppMacroInsert(PVBCPP pThis, PVBCPPMACRO pMacro)
+{
+    /*
+     * Reject illegal macro names.
+     */
+    if (!strcmp(pMacro->Core.pszString, "defined"))
+    {
+        RTEXITCODE rcExit = vbcppError(pThis, "Cannot use '%s' as a macro name", pMacro->Core.pszString);
+        vbcppMacroFree(&pMacro->Core, NULL);
+        return rcExit;
+    }
+
+    /*
+     * Ignore in source-file defines when doing selective preprocessing.
+     */
+    if (   !pThis->fRespectSourceDefines
+        && !pMacro->fCmdLine)
+    {
+        /* Ignore*/
+        vbcppMacroFree(&pMacro->Core, NULL);
+        return RTEXITCODE_SUCCESS;
+    }
+
+    /*
+     * Insert it and update the lead character hint bitmap.
+     */
+    if (RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core))
+        VBCPP_BITMAP_SET(pThis->bmDefined, *pMacro->Core.pszString);
+    else
+    {
+        /*
+         * Duplicate. When doing selective D preprocessing, let the command
+         * line take precendece.
+         */
+        PVBCPPMACRO pOld = (PVBCPPMACRO)RTStrSpaceGet(&pThis->StrSpace, pMacro->Core.pszString); Assert(pOld);
+        if (   pThis->fAllowRedefiningCmdLineDefines
+            || pMacro->fCmdLine == pOld->fCmdLine)
+        {
+            if (pMacro->fCmdLine)
+                RTMsgWarning("Redefining '%s'", pMacro->Core.pszString);
+
+            RTStrSpaceRemove(&pThis->StrSpace, pOld->Core.pszString);
+            vbcppMacroFree(&pOld->Core, NULL);
+
+            bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core);
+            Assert(fRc); NOREF(fRc);
+        }
+        else
+        {
+            RTMsgWarning("Ignoring redefinition of '%s'", pMacro->Core.pszString);
+            vbcppMacroFree(&pMacro->Core, NULL);
+        }
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Adds a define.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDefine           The define name, no parameter list.
+ * @param   cchDefine           The length of the name.
+ * @param   pszParams           The parameter list.
+ * @param   cchParams           The length of the parameter list.
+ * @param   pszValue            The value.
+ * @param   cchDefine           The length of the value.
+ * @param   fCmdLine            Set if originating on the command line.
+ */
+static RTEXITCODE vbcppMacroAddFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
+                                  const char *pszParams, size_t cchParams,
+                                  const char *pszValue, size_t cchValue,
+                                  bool fCmdLine)
+
+{
+    Assert(RTStrNLen(pszDefine, cchDefine) == cchDefine);
+    Assert(RTStrNLen(pszParams, cchParams) == cchParams);
+    Assert(RTStrNLen(pszValue,  cchValue)  == cchValue);
+
+    /*
+     * Determin the number of arguments and how much space their names
+     * requires.  Performing syntax validation while parsing.
+     */
+    uint32_t cchArgNames = 0;
+    uint32_t cArgs       = 0;
+    for (size_t off = 0; off < cchParams; off++)
+    {
+        /* Skip blanks and maybe one comma. */
+        bool fIgnoreComma = cArgs != 0;
+        while (off < cchParams)
+        {
+            if (!RT_C_IS_SPACE(pszParams[off]))
+            {
+                if (pszParams[off] != ',' || !fIgnoreComma)
+                {
+                    if (vbcppIsCIdentifierLeadChar(pszParams[off]))
+                        break;
+                    /** @todo variadic macros. */
+                    return vbcppErrorPos(pThis, &pszParams[off], "Unexpected character");
+                }
+                fIgnoreComma = false;
+            }
+            off++;
+        }
+        if (off >= cchParams)
+            break;
+
+        /* Found and argument. First character is already validated. */
+        cArgs++;
+        cchArgNames += 2;
+        off++;
+        while (   off < cchParams
+               && vbcppIsCIdentifierChar(pszParams[off]))
+            off++, cchArgNames++;
+    }
+
+    /*
+     * Allocate a structure.
+     */
+    size_t    cbDef = RT_UOFFSETOF_DYN(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1 + cchArgNames])
+                    + sizeof(const char *) * cArgs;
+    cbDef = RT_ALIGN_Z(cbDef, sizeof(const char *));
+    PVBCPPMACRO pMacro  = (PVBCPPMACRO)RTMemAlloc(cbDef);
+    if (!pMacro)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
+
+    char *pszDst = &pMacro->szValue[cchValue + 1];
+    pMacro->Core.pszString = pszDst;
+    memcpy(pszDst, pszDefine, cchDefine);
+    pszDst += cchDefine;
+    *pszDst++ = '\0';
+    pMacro->fFunction   = true;
+    pMacro->fVarArg     = false;
+    pMacro->fCmdLine    = fCmdLine;
+    pMacro->fExpanding  = false;
+    pMacro->cArgs       = cArgs;
+    pMacro->papszArgs   = (const char **)((uintptr_t)pMacro + cbDef - sizeof(const char *) * cArgs);
+    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
+    pMacro->cchValue    = cchValue;
+    memcpy(pMacro->szValue, pszValue, cchValue);
+    pMacro->szValue[cchValue] = '\0';
+
+    /*
+     * Set up the arguments.
+     */
+    uint32_t iArg = 0;
+    for (size_t off = 0; off < cchParams; off++)
+    {
+        /* Skip blanks and maybe one comma. */
+        bool fIgnoreComma = cArgs != 0;
+        while (off < cchParams)
+        {
+            if (!RT_C_IS_SPACE(pszParams[off]))
+            {
+                if (pszParams[off] != ',' || !fIgnoreComma)
+                    break;
+                fIgnoreComma = false;
+            }
+            off++;
+        }
+        if (off >= cchParams)
+            break;
+
+        /* Found and argument. First character is already validated. */
+        VBCPP_BITMAP_SET(pMacro->bmArgs, pszParams[off]);
+        pMacro->papszArgs[iArg] = pszDst;
+        do
+        {
+            *pszDst++ = pszParams[off++];
+        } while (   off < cchParams
+                 && vbcppIsCIdentifierChar(pszParams[off]));
+        *pszDst++ = '\0';
+        iArg++;
+    }
+    Assert((uintptr_t)pszDst <= (uintptr_t)pMacro->papszArgs);
+
+    return vbcppMacroInsert(pThis, pMacro);
+}
+
+
+/**
+ * Adds a define.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDefine           The define name and optionally the argument
+ *                              list.
+ * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
+ * @param   pszValue            The value.
+ * @param   cchDefine           The length of the value. RTSTR_MAX is ok.
+ * @param   fCmdLine            Set if originating on the command line.
+ */
+static RTEXITCODE vbcppMacroAdd(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
+                                const char *pszValue, size_t cchValue, bool fCmdLine)
+{
+    /*
+     * We need the lengths. Trim the input.
+     */
+    if (cchDefine == RTSTR_MAX)
+        cchDefine = strlen(pszDefine);
+    while (cchDefine > 0 && RT_C_IS_SPACE(*pszDefine))
+        pszDefine++, cchDefine--;
+    while (cchDefine > 0 && RT_C_IS_SPACE(pszDefine[cchDefine - 1]))
+        cchDefine--;
+    if (!cchDefine)
+        return vbcppErrorPos(pThis, pszDefine, "The define has no name");
+
+    if (cchValue == RTSTR_MAX)
+        cchValue = strlen(pszValue);
+    while (cchValue > 0 && RT_C_IS_SPACE(*pszValue))
+        pszValue++, cchValue--;
+    while (cchValue > 0 && RT_C_IS_SPACE(pszValue[cchValue - 1]))
+        cchValue--;
+
+    /*
+     * Arguments make the job a bit more annoying.  Handle that elsewhere
+     */
+    const char *pszParams = (const char *)memchr(pszDefine, '(', cchDefine);
+    if (pszParams)
+    {
+        size_t cchParams = pszDefine + cchDefine - pszParams;
+        cchDefine -= cchParams;
+        if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
+            return RTEXITCODE_FAILURE;
+        if (pszParams[cchParams - 1] != ')')
+            return vbcppErrorPos(pThis, pszParams + cchParams - 1, "Missing closing parenthesis");
+        pszParams++;
+        cchParams -= 2;
+        return vbcppMacroAddFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue, fCmdLine);
+    }
+
+    /*
+     * Simple define, no arguments.
+     */
+    if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
+        return RTEXITCODE_FAILURE;
+
+    PVBCPPMACRO pMacro = (PVBCPPMACRO)RTMemAlloc(RT_UOFFSETOF_DYN(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1]));
+    if (!pMacro)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
+
+    pMacro->Core.pszString = &pMacro->szValue[cchValue + 1];
+    memcpy((char *)pMacro->Core.pszString, pszDefine, cchDefine);
+    ((char *)pMacro->Core.pszString)[cchDefine] = '\0';
+    pMacro->fFunction   = false;
+    pMacro->fVarArg     = false;
+    pMacro->fCmdLine    = fCmdLine;
+    pMacro->fExpanding  = false;
+    pMacro->cArgs       = 0;
+    pMacro->papszArgs   = NULL;
+    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
+    pMacro->cchValue    = cchValue;
+    memcpy(pMacro->szValue, pszValue, cchValue);
+    pMacro->szValue[cchValue] = '\0';
+
+    return vbcppMacroInsert(pThis, pMacro);
+}
+
+
+/**
+ * Tries to convert a define into an inline D constant.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pMacro              The macro.
+ */
+static RTEXITCODE vbcppMacroTryConvertToInlineD(PVBCPP pThis, PVBCPPMACRO pMacro)
+{
+    AssertReturn(pMacro, vbcppError(pThis, "Internal error"));
+    if (pMacro->fFunction)
+        return RTEXITCODE_SUCCESS;
+
+    /*
+     * Do some simple macro resolving. (Mostly to make x86.h work.)
+     */
+    const char *pszDefine = pMacro->Core.pszString;
+    const char *pszValue  = pMacro->szValue;
+    size_t      cchValue  = pMacro->cchValue;
+
+    unsigned    i = 0;
+    PVBCPPMACRO pMacro2;
+    while (   i < 10
+           && cchValue > 0
+           && vbcppIsCIdentifierLeadChar(*pszValue)
+           && (pMacro2 = vbcppMacroLookup(pThis, pszValue, cchValue)) != NULL
+           && !pMacro2->fFunction )
+    {
+        pszValue = pMacro2->szValue;
+        cchValue = pMacro2->cchValue;
+        i++;
+    }
+
+    if (!pMacro->cchValue)
+        return RTEXITCODE_SUCCESS;
+
+
+    /*
+     * A lone value?
+     */
+    ssize_t  cch = 0;
+    uint64_t u64;
+    char    *pszNext;
+    int rc = RTStrToUInt64Ex(pszValue, &pszNext, 0, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        if (   rc == VWRN_TRAILING_SPACES
+            || rc == VWRN_NEGATIVE_UNSIGNED
+            || rc == VWRN_NUMBER_TOO_BIG)
+            return RTEXITCODE_SUCCESS;
+        const char *pszType;
+        if (rc == VWRN_TRAILING_CHARS)
+        {
+            if (!strcmp(pszNext, "u") || !strcmp(pszNext, "U"))
+                pszType = "uint32_t";
+            else if (!strcmp(pszNext, "ul") || !strcmp(pszNext, "UL"))
+                pszType = "uintptr_t";
+            else if (!strcmp(pszNext, "ull") || !strcmp(pszNext, "ULL"))
+                pszType = "uint64_t";
+            else
+                pszType = NULL;
+        }
+        else if (u64 <= UINT8_MAX)
+            pszType = "uint8_t";
+        else if (u64 <= UINT16_MAX)
+            pszType = "uint16_t";
+        else if (u64 <= UINT32_MAX)
+            pszType = "uint32_t";
+        else
+            pszType = "uint64_t";
+        if (!pszType)
+            return RTEXITCODE_SUCCESS;
+        cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
+                              pszType, pszDefine, pszNext - pszValue, pszValue);
+    }
+    /*
+     * A value wrapped in a constant macro?
+     */
+    else if (   (pszNext = (char *)strchr(pszValue, '(')) != NULL
+             && pszValue[cchValue - 1] == ')' )
+    {
+        size_t      cchPrefix = pszNext - pszValue;
+        size_t      cchInnerValue  = cchValue - cchPrefix - 2;
+        const char *pchInnerValue  = &pszValue[cchPrefix + 1];
+        while (cchInnerValue > 0 && RT_C_IS_SPACE(*pchInnerValue))
+            cchInnerValue--, pchInnerValue++;
+        while (cchInnerValue > 0 && RT_C_IS_SPACE(pchInnerValue[cchInnerValue - 1]))
+            cchInnerValue--;
+        if (!cchInnerValue || !RT_C_IS_XDIGIT(*pchInnerValue))
+            return RTEXITCODE_SUCCESS;
+
+        rc = RTStrToUInt64Ex(pchInnerValue, &pszNext, 0, &u64);
+        if (   RT_FAILURE(rc)
+            || rc == VWRN_TRAILING_SPACES
+            || rc == VWRN_NEGATIVE_UNSIGNED
+            || rc == VWRN_NUMBER_TOO_BIG)
+            return RTEXITCODE_SUCCESS;
+
+        const char *pszType;
+#define MY_MATCH_STR(a_sz)  (sizeof(a_sz) - 1 == cchPrefix && !strncmp(pszValue, a_sz, sizeof(a_sz) - 1))
+        if (MY_MATCH_STR("UINT8_C"))
+            pszType = "uint8_t";
+        else if (MY_MATCH_STR("UINT16_C"))
+            pszType = "uint16_t";
+        else if (MY_MATCH_STR("UINT32_C"))
+            pszType = "uint32_t";
+        else if (MY_MATCH_STR("UINT64_C"))
+            pszType = "uint64_t";
+        else
+            pszType = NULL;
+        if (pszType)
+            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
+                                  pszType, pszDefine, cchInnerValue, pchInnerValue);
+        else if (MY_MATCH_STR("RT_BIT") || MY_MATCH_STR("RT_BIT_32"))
+            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint32_t %s = 1U << %llu;\n",
+                                  pszDefine, u64);
+        else if (MY_MATCH_STR("RT_BIT_64"))
+            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint64_t %s = 1ULL << %llu;\n",
+                                  pszDefine, u64);
+        else
+            return RTEXITCODE_SUCCESS;
+#undef MY_MATCH_STR
+    }
+    /* Dunno what this is... */
+    else
+        return RTEXITCODE_SUCCESS;
+
+    /*
+     * Check for output error and clear the output suppression indicator.
+     */
+    if (cch < 0)
+        return vbcppError(pThis, "Output error");
+
+    pThis->fJustDroppedLine = false;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveDefine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+
+    /*
+     * Parse it.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchDefine;
+        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
+        if (pchDefine)
+        {
+            /* If it's a function style define, parse out the parameter list. */
+            size_t      cchParams = 0;
+            const char *pchParams = NULL;
+            unsigned    ch = ScmStreamPeekCh(pStrmInput);
+            if (ch == '(')
+            {
+                ScmStreamGetCh(pStrmInput);
+                pchParams = ScmStreamGetCur(pStrmInput);
+
+                unsigned chPrev = ch;
+                while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+                {
+                    if (ch == '\r' || ch == '\n')
+                    {
+                        if (chPrev != '\\')
+                        {
+                            rcExit = vbcppError(pThis, "Missing ')'");
+                            break;
+                        }
+                        ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+                    }
+                    if (ch == ')')
+                    {
+                        cchParams = ScmStreamGetCur(pStrmInput) - pchParams;
+                        ScmStreamGetCh(pStrmInput);
+                        break;
+                    }
+                    ScmStreamGetCh(pStrmInput);
+                }
+            }
+            /* The simple kind. */
+            else if (!RT_C_IS_SPACE(ch) && ch != ~(unsigned)0)
+                rcExit = vbcppError(pThis, "Expected whitespace after macro name");
+
+            /* Parse out the value. */
+            if (rcExit == RTEXITCODE_SUCCESS)
+                rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                size_t      offValue = ScmStreamTell(pStrmInput);
+                const char *pchValue = ScmStreamGetCur(pStrmInput);
+                unsigned    chPrev = ch;
+                while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+                {
+                    if (ch == '\r' || ch == '\n')
+                    {
+                        if (chPrev != '\\')
+                            break;
+                        ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+                    }
+                    chPrev = ScmStreamGetCh(pStrmInput);
+                }
+                size_t cchValue = ScmStreamGetCur(pStrmInput) - pchValue;
+
+                /*
+                 * Execute.
+                 */
+                if (pchParams)
+                    rcExit = vbcppMacroAddFn(pThis, pchDefine, cchDefine, pchParams, cchParams, pchValue, cchValue, false);
+                else
+                    rcExit = vbcppMacroAdd(pThis, pchDefine, cchDefine, pchValue, cchValue, false);
+
+                /*
+                 * Pass thru?
+                 */
+                if (   rcExit == RTEXITCODE_SUCCESS
+                    && pThis->fPassThruDefines)
+                {
+                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
+                    ssize_t  cch;
+                    if (pchParams)
+                        cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sdefine %.*s(%.*s)",
+                                              cchIndent, "", cchDefine, pchDefine, cchParams, pchParams);
+                    else
+                        cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sdefine %.*s",
+                                              cchIndent, "", cchDefine, pchDefine);
+                    if (cch > 0)
+                        vbcppOutputComment(pThis, pStrmInput, offValue, cch, 1);
+                    else
+                        rcExit = vbcppError(pThis, "output error");
+                }
+                else if (   rcExit == RTEXITCODE_SUCCESS
+                         && pThis->enmMode == kVBCppMode_SelectiveD)
+                    rcExit = vbcppMacroTryConvertToInlineD(pThis, vbcppMacroLookup(pThis, pchDefine, cchDefine));
+                else
+                    pThis->fJustDroppedLine = true;
+            }
+        }
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveUndef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+
+    /*
+     * Parse it.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchDefine;
+        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
+        if (pchDefine)
+        {
+            size_t offMaybeComment = vbcppProcessSkipWhite(pStrmInput);
+            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                /*
+                 * Take action.
+                 */
+                PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
+                if (    pMacro
+                    &&  pThis->fRespectSourceDefines
+                    &&  (   !pMacro->fCmdLine
+                         || pThis->fAllowRedefiningCmdLineDefines ) )
+                {
+                    RTStrSpaceRemove(&pThis->StrSpace, pMacro->Core.pszString);
+                    vbcppMacroFree(&pMacro->Core, NULL);
+                }
+
+                /*
+                 * Pass thru.
+                 */
+                if (   rcExit == RTEXITCODE_SUCCESS
+                    && pThis->fPassThruDefines)
+                {
+                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
+                    ssize_t  cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sundef %.*s",
+                                                   cchIndent, "", cchDefine, pchDefine);
+                    if (cch > 0)
+                        vbcppOutputComment(pThis, pStrmInput, offMaybeComment, cch, 1);
+                    else
+                        rcExit = vbcppError(pThis, "output error");
+                }
+
+            }
+        }
+        else
+            rcExit = vbcppError(pThis, "Malformed #ifndef");
+    }
+    return rcExit;
+
+}
+
+
+
+
+
+/*
+ *
+ *
+ * C O N D I T I O N A L S
+ * C O N D I T I O N A L S
+ * C O N D I T I O N A L S
+ * C O N D I T I O N A L S
+ * C O N D I T I O N A L S
+ *
+ *
+ */
+
+
+/**
+ * Combines current stack result with the one being pushed.
+ *
+ * @returns Combined result.
+ * @param   enmEvalPush         The result of the condition being pushed.
+ * @param   enmEvalStack        The current stack result.
+ */
+static VBCPPEVAL vbcppCondCombine(VBCPPEVAL enmEvalPush, VBCPPEVAL enmEvalStack)
+{
+    if (enmEvalStack == kVBCppEval_False)
+        return kVBCppEval_False;
+    return enmEvalPush;
+}
+
+
+/**
+ * Pushes an conditional onto the stack.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The current input stream.
+ * @param   offStart            Not currently used, using @a pchCondition and
+ *                              @a cchCondition instead.
+ * @param   enmKind             The kind of conditional.
+ * @param   enmResult           The result of the evaluation.
+ * @param   pchCondition        The raw condition.
+ * @param   cchCondition        The length of @a pchCondition.
+ */
+static RTEXITCODE vbcppCondPush(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
+                                VBCPPCONDKIND enmKind, VBCPPEVAL enmResult,
+                                const char *pchCondition, size_t cchCondition)
+{
+    RT_NOREF_PV(offStart); RT_NOREF_PV(pStrmInput);
+
+
+    if (pThis->cCondStackDepth >= _64K)
+        return vbcppError(pThis, "Too many nested #if/#ifdef/#ifndef statements");
+
+    /*
+     * Allocate a new entry and push it.
+     */
+    PVBCPPCOND pCond = (PVBCPPCOND)RTMemAlloc(sizeof(*pCond));
+    if (!pCond)
+        return vbcppError(pThis, "out of memory");
+
+    PVBCPPCOND pUp = pThis->pCondStack;
+    pCond->enmKind          = enmKind;
+    pCond->enmResult        = enmResult;
+    pCond->enmStackResult   = pUp ? vbcppCondCombine(enmResult, pUp->enmStackResult) : enmResult;
+    pCond->fSeenElse        = false;
+    pCond->fElIfDecided     = enmResult == kVBCppEval_True;
+    pCond->iLevel           = pThis->cCondStackDepth;
+    pCond->iKeepLevel       = (pUp ? pUp->iKeepLevel : 0) + enmResult == kVBCppEval_Undecided;
+    pCond->pchCond          = pchCondition;
+    pCond->cchCond          = cchCondition;
+
+    pCond->pUp              = pThis->pCondStack;
+    pThis->pCondStack       = pCond;
+    pThis->fIf0Mode         = pCond->enmStackResult == kVBCppEval_False;
+
+    /*
+     * Do pass thru.
+     */
+    if (   !pThis->fIf0Mode
+        && enmResult == kVBCppEval_Undecided)
+    {
+        /** @todo this is stripping comments of \#ifdef and \#ifndef atm. */
+        const char *pszDirective;
+        switch (enmKind)
+        {
+            case kVBCppCondKind_If:     pszDirective = "if"; break;
+            case kVBCppCondKind_IfDef:  pszDirective = "ifdef"; break;
+            case kVBCppCondKind_IfNDef: pszDirective = "ifndef"; break;
+            case kVBCppCondKind_ElIf:   pszDirective = "elif"; break;
+            default: AssertFailedReturn(RTEXITCODE_FAILURE);
+        }
+        ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*s%s %.*s",
+                                      pCond->iKeepLevel - 1, "", pszDirective, cchCondition, pchCondition);
+        if (cch < 0)
+            return vbcppError(pThis, "Output error %Rrc", (int)cch);
+    }
+    else
+        pThis->fJustDroppedLine = true;
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Recursively destroys the expression tree.
+ *
+ * @param   pExpr               The root of the expression tree to destroy.
+ */
+static void vbcppExprDestoryTree(PVBCPPEXPR pExpr)
+{
+    if (!pExpr)
+        return;
+
+    switch (pExpr->enmKind)
+    {
+        case kVBCppExprKind_Unary:
+            vbcppExprDestoryTree(pExpr->u.Unary.pArg);
+            break;
+        case kVBCppExprKind_Binary:
+            vbcppExprDestoryTree(pExpr->u.Binary.pLeft);
+            vbcppExprDestoryTree(pExpr->u.Binary.pRight);
+            break;
+        case kVBCppExprKind_Ternary:
+            vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
+            vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
+            vbcppExprDestoryTree(pExpr->u.Ternary.pFalse);
+            break;
+        case kVBCppExprKind_SignedValue:
+        case kVBCppExprKind_UnsignedValue:
+            break;
+        default:
+            AssertFailed();
+            return;
+    }
+    RTMemFree(pExpr);
+}
+
+
+/**
+ * Report error during expression parsing.
+ *
+ * @returns kExprRet_Error
+ * @param   pParser             The parser instance.
+ * @param   pszMsg              The error message.
+ * @param   ...                 Format arguments.
+ */
+static VBCPPEXPRRET vbcppExprParseError(PVBCPPEXPRPARSER pParser, const char *pszMsg, ...)
+{
+    va_list va;
+    va_start(va, pszMsg);
+    vbcppErrorV(pParser->pThis, pszMsg, va);
+    va_end(va);
+    return kExprRet_Error;
+}
+
+
+/**
+ * Skip white space.
+ *
+ * @param   pParser             The parser instance.
+ */
+static void vbcppExprParseSkipWhiteSpace(PVBCPPEXPRPARSER pParser)
+{
+    while (RT_C_IS_SPACE(*pParser->pszCur))
+        pParser->pszCur++;
+}
+
+
+/**
+ * Allocate a new
+ *
+ * @returns Pointer to the node. NULL+msg on failure.
+ * @param   pParser             The parser instance.
+ */
+static PVBCPPEXPR vbcppExprParseAllocNode(PVBCPPEXPRPARSER pParser)
+{
+    PVBCPPEXPR pExpr = (PVBCPPEXPR)RTMemAllocZ(sizeof(*pExpr));
+    if (!pExpr)
+        vbcppExprParseError(pParser, "out of memory (expression node)");
+    return pExpr;
+}
+
+
+/**
+ * Looks for right parentheses and/or end of expression.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Ok
+ * @retval  kExprRet_Error with msg.
+ * @retval  kExprRet_EndOfExpr
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseMaybeRParenOrEoe(PVBCPPEXPRPARSER pParser)
+{
+    Assert(!pParser->ppCur);
+    for (;;)
+    {
+        vbcppExprParseSkipWhiteSpace(pParser);
+        char ch = *pParser->pszCur;
+        if (ch == '\0')
+            return kExprRet_EndOfExpr;
+        if (ch != ')')
+            break;
+        pParser->pszCur++;
+
+        PVBCPPEXPR pCur = pParser->pCur;
+        while (   pCur
+               && (   pCur->enmKind != kVBCppExprKind_Unary
+                   || pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis))
+        {
+            switch (pCur->enmKind)
+            {
+                case kVBCppExprKind_SignedValue:
+                case kVBCppExprKind_UnsignedValue:
+                    Assert(pCur->fComplete);
+                    break;
+                case kVBCppExprKind_Unary:
+                    AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
+                    pCur->fComplete = true;
+                    break;
+                case kVBCppExprKind_Binary:
+                    AssertReturn(pCur->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
+                    AssertReturn(pCur->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
+                    pCur->fComplete = true;
+                    break;
+                case kVBCppExprKind_Ternary:
+#if 1 /** @todo Check out the ternary operator implementation. */
+                    return vbcppExprParseError(pParser, "The ternary operator is not implemented");
+#else
+                    Assert(pCur->u.Ternary.pExpr);
+                    if (!pCur->u.Ternary.pTrue)
+                        return vbcppExprParseError(pParser, "?!?!?");
+                    if (!pCur->u.Ternary.pFalse)
+                        return vbcppExprParseError(pParser, "?!?!?!?");
+                    pCur->fComplete = true;
+#endif
+                    break;
+                default:
+                    return vbcppExprParseError(pParser, "Internal error (enmKind=%d)", pCur->enmKind);
+            }
+            pCur = pCur->pParent;
+        }
+        if (!pCur)
+            return vbcppExprParseError(pParser, "Right parenthesis without a left one");
+        pCur->fComplete = true;
+
+        while (   pCur->enmKind == kVBCppExprKind_Unary
+               && pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis
+               && pCur->pParent)
+        {
+            AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
+            pCur->fComplete = true;
+            pCur = pCur->pParent;
+        }
+    }
+
+    return kExprRet_Ok;
+}
+
+
+/**
+ * Parses an binary operator.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Ok
+ * @retval  kExprRet_Error with msg.
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseBinaryOperator(PVBCPPEXPRPARSER pParser)
+{
+    /*
+     * Binary or ternary operator should follow now.
+     */
+    VBCPPBINARYOP enmOp;
+    char ch = *pParser->pszCur;
+    switch (ch)
+    {
+        case '*':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by product operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_Multiplication;
+            break;
+        case '/':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by quotient operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_Division;
+            break;
+        case '%':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by remainder operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_Modulo;
+            break;
+        case '+':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by sum operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_Addition;
+            break;
+        case '-':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by difference operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_Subtraction;
+            break;
+        case '<':
+            enmOp = kVBCppBinary_LessThan;
+            if (pParser->pszCur[1] == '=')
+            {
+                pParser->pszCur++;
+                enmOp = kVBCppBinary_LessThanOrEqual;
+            }
+            else if (pParser->pszCur[1] == '<')
+            {
+                pParser->pszCur++;
+                if (pParser->pszCur[1] == '=')
+                    return vbcppExprParseError(pParser, "The assignment by bitwise left shift operator is not valid in a preprocessor expression");
+                enmOp = kVBCppBinary_LeftShift;
+            }
+            break;
+        case '>':
+            enmOp = kVBCppBinary_GreaterThan;
+            if (pParser->pszCur[1] == '=')
+            {
+                pParser->pszCur++;
+                enmOp = kVBCppBinary_GreaterThanOrEqual;
+            }
+            else if (pParser->pszCur[1] == '<')
+            {
+                pParser->pszCur++;
+                if (pParser->pszCur[1] == '=')
+                    return vbcppExprParseError(pParser, "The assignment by bitwise right shift operator is not valid in a preprocessor expression");
+                enmOp = kVBCppBinary_LeftShift;
+            }
+            break;
+        case '=':
+            if (pParser->pszCur[1] != '=')
+                return vbcppExprParseError(pParser, "The assignment operator is not valid in a preprocessor expression");
+            pParser->pszCur++;
+            enmOp = kVBCppBinary_EqualTo;
+            break;
+
+        case '!':
+            if (pParser->pszCur[1] != '=')
+                return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator logical NOT");
+            pParser->pszCur++;
+            enmOp = kVBCppBinary_NotEqualTo;
+            break;
+
+        case '&':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
+            if (pParser->pszCur[1] == '&')
+            {
+                pParser->pszCur++;
+                enmOp = kVBCppBinary_LogicalAnd;
+            }
+            else
+                enmOp = kVBCppBinary_BitwiseAnd;
+            break;
+        case '^':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by bitwise XOR operator is not valid in a preprocessor expression");
+            enmOp = kVBCppBinary_BitwiseXor;
+            break;
+        case '|':
+            if (pParser->pszCur[1] == '=')
+                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
+            if (pParser->pszCur[1] == '|')
+            {
+                pParser->pszCur++;
+                enmOp = kVBCppBinary_LogicalOr;
+            }
+            else
+                enmOp = kVBCppBinary_BitwiseOr;
+            break;
+        case '~':
+            return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator bitwise NOT");
+
+        case ':':
+        case '?':
+            return vbcppExprParseError(pParser, "The ternary operator is not yet implemented");
+
+        default:
+            return vbcppExprParseError(pParser, "Expected binary operator, found '%.20s'", pParser->pszCur);
+    }
+    pParser->pszCur++;
+
+    /*
+     * Create a binary operator node.
+     */
+    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
+    if (!pExpr)
+        return kExprRet_Error;
+    pExpr->fComplete            = true;
+    pExpr->enmKind              = kVBCppExprKind_Binary;
+    pExpr->u.Binary.enmOperator = enmOp;
+    pExpr->u.Binary.pLeft       = NULL;
+    pExpr->u.Binary.pRight      = NULL;
+
+    /*
+     * Back up the tree until we find our spot.
+     */
+    PVBCPPEXPR *ppPlace = NULL;
+    PVBCPPEXPR  pChild  = NULL;
+    PVBCPPEXPR  pParent = pParser->pCur;
+    while (pParent)
+    {
+        if (pParent->enmKind == kVBCppExprKind_Unary)
+        {
+            if (pParent->u.Unary.enmOperator == kVBCppUnaryOp_Parenthesis)
+            {
+                ppPlace = &pParent->u.Unary.pArg;
+                break;
+            }
+            AssertReturn(pParent->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
+            pParent->fComplete = true;
+        }
+        else if (pParent->enmKind == kVBCppExprKind_Binary)
+        {
+            AssertReturn(pParent->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
+            AssertReturn(pParent->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
+            if ((pParent->u.Binary.enmOperator & VBCPPOP_PRECEDENCE_MASK) >= (enmOp & VBCPPOP_PRECEDENCE_MASK))
+            {
+                AssertReturn(pChild, vbcppExprParseError(pParser, "internal error"));
+
+                if (pParent->u.Binary.pRight == pChild)
+                    ppPlace = &pParent->u.Binary.pRight;
+                else
+                    ppPlace = &pParent->u.Binary.pLeft;
+                AssertReturn(*ppPlace == pChild, vbcppExprParseError(pParser, "internal error"));
+                break;
+            }
+            pParent->fComplete = true;
+        }
+        else if (pParent->enmKind == kVBCppExprKind_Ternary)
+        {
+            return vbcppExprParseError(pParser, "The ternary operator is not implemented");
+        }
+        else
+            AssertReturn(   pParent->enmKind == kVBCppExprKind_SignedValue
+                         || pParent->enmKind == kVBCppExprKind_UnsignedValue,
+                         vbcppExprParseError(pParser, "internal error"));
+
+        /* Up on level */
+        pChild  = pParent;
+        pParent = pParent->pParent;
+    }
+
+    /*
+     * Do the rotation.
+     */
+    Assert(pChild);
+    Assert(pChild->pParent == pParent);
+    pChild->pParent       = pExpr;
+
+    pExpr->u.Binary.pLeft = pChild;
+    pExpr->pParent        = pParent;
+
+    if (!pParent)
+        pParser->pRoot    = pExpr;
+    else
+        *ppPlace          = pExpr;
+
+    pParser->ppCur = &pExpr->u.Binary.pRight;
+    pParser->pCur  = pExpr;
+
+    return kExprRet_Ok;
+}
+
+
+/**
+ * Deals with right paretheses or/and end of expression, looks for binary
+ * operators.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Ok if binary operator was found processed.
+ * @retval  kExprRet_Error with msg.
+ * @retval  kExprRet_EndOfExpr
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseBinaryOrEoeOrRparen(PVBCPPEXPRPARSER pParser)
+{
+    VBCPPEXPRRET enmRet = vbcppExprParseMaybeRParenOrEoe(pParser);
+    if (enmRet != kExprRet_Ok)
+        return enmRet;
+    return vbcppExprParseBinaryOperator(pParser);
+}
+
+
+/**
+ * Parses an identifier in the expression, replacing it by 0.
+ *
+ * All known identifiers has already been replaced by their macro values, so
+ * what's left are unknown macros.  These are replaced by 0.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Value
+ * @retval  kExprRet_Error with msg.
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseIdentifier(PVBCPPEXPRPARSER pParser)
+{
+/** @todo don't increment if it's an actively undefined macro. Need to revise
+ *        the expression related code wrt selective preprocessing. */
+    pParser->cUndefined++;
+
+    /* Find the end. */
+    const char *pszMacro = pParser->pszCur;
+    const char *pszNext  = pszMacro + 1;
+    while (vbcppIsCIdentifierChar(*pszNext))
+        pszNext++;
+    size_t cchMacro = pszNext - pszMacro;
+
+    /* Create a signed value node. */
+    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
+    if (!pExpr)
+        return kExprRet_Error;
+    pExpr->fComplete            = true;
+    pExpr->enmKind              = kVBCppExprKind_UnsignedValue;
+    pExpr->u.UnsignedValue.u64  = 0;
+
+    /* Link it. */
+    pExpr->pParent              = pParser->pCur;
+    pParser->pCur               = pExpr;
+    *pParser->ppCur             = pExpr;
+    pParser->ppCur              = NULL;
+
+    /* Skip spaces and check for parenthesis. */
+    pParser->pszCur = pszNext;
+    vbcppExprParseSkipWhiteSpace(pParser);
+    if (*pParser->pszCur == '(')
+        return vbcppExprParseError(pParser, "Unknown unary operator '%.*s'", cchMacro, pszMacro);
+
+    return kExprRet_Value;
+}
+
+
+/**
+ * Parses an numeric constant in the expression.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Value
+ * @retval  kExprRet_Error with msg.
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseNumber(PVBCPPEXPRPARSER pParser)
+{
+    bool        fSigned;
+    char       *pszNext;
+    uint64_t    u64;
+    char        ch    = *pParser->pszCur++;
+    char        ch2   = *pParser->pszCur;
+    if (   ch == '0'
+        && (ch == 'x' || ch == 'X'))
+    {
+        ch2 = *++pParser->pszCur;
+        if (!RT_C_IS_XDIGIT(ch2))
+            return vbcppExprParseError(pParser, "Expected hex digit following '0x'");
+        int rc = RTStrToUInt64Ex(pParser->pszCur, &pszNext, 16, &u64);
+        if (   RT_FAILURE(rc)
+            || rc == VWRN_NUMBER_TOO_BIG)
+            return vbcppExprParseError(pParser, "Invalid hex value '%.20s...' (%Rrc)", pParser->pszCur, rc);
+        fSigned = false;
+    }
+    else if (ch == '0')
+    {
+        int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 8, &u64);
+        if (   RT_FAILURE(rc)
+            || rc == VWRN_NUMBER_TOO_BIG)
+            return vbcppExprParseError(pParser, "Invalid octal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
+        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
+    }
+    else
+    {
+        int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 10, &u64);
+        if (   RT_FAILURE(rc)
+            || rc == VWRN_NUMBER_TOO_BIG)
+            return vbcppExprParseError(pParser, "Invalid decimal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
+        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
+    }
+
+    /* suffix. */
+    if (vbcppIsCIdentifierLeadChar(*pszNext))
+    {
+        size_t cchSuffix = 1;
+        while (vbcppIsCIdentifierLeadChar(pszNext[cchSuffix]))
+            cchSuffix++;
+
+        if (cchSuffix == '1' && (*pszNext == 'u' || *pszNext == 'U'))
+            fSigned = false;
+        else if (   cchSuffix == '1'
+                 && (*pszNext == 'l' || *pszNext == 'L'))
+            fSigned = true;
+        else if (   cchSuffix == '2'
+                 && (!strncmp(pszNext, "ul", 2) || !strncmp(pszNext, "UL", 2)))
+            fSigned = false;
+        else if (   cchSuffix == '2'
+                 && (!strncmp(pszNext, "ll", 2) || !strncmp(pszNext, "LL", 2)))
+            fSigned = true;
+        else if (   cchSuffix == '3'
+                 && (!strncmp(pszNext, "ull", 3) || !strncmp(pszNext, "ULL", 3)))
+            fSigned = false;
+        else
+            return vbcppExprParseError(pParser, "Invalid number suffix '%.*s'", cchSuffix, pszNext);
+
+        pszNext += cchSuffix;
+    }
+    pParser->pszCur = pszNext;
+
+    /* Create a signed value node. */
+    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
+    if (!pExpr)
+        return kExprRet_Error;
+    pExpr->fComplete            = true;
+    if (fSigned)
+    {
+        pExpr->enmKind              = kVBCppExprKind_SignedValue;
+        pExpr->u.SignedValue.s64    = (int64_t)u64;
+    }
+    else
+    {
+        pExpr->enmKind              = kVBCppExprKind_UnsignedValue;
+        pExpr->u.UnsignedValue.u64  = u64;
+    }
+
+    /* Link it. */
+    pExpr->pParent              = pParser->pCur;
+    pParser->pCur               = pExpr;
+    *pParser->ppCur             = pExpr;
+    pParser->ppCur              = NULL;
+
+    return kExprRet_Value;
+}
+
+
+/**
+ * Parses an character constant in the expression.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Value
+ * @retval  kExprRet_Error with msg.
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseCharacterConstant(PVBCPPEXPRPARSER pParser)
+{
+    Assert(*pParser->pszCur == '\'');
+    pParser->pszCur++;
+    char ch2 = *pParser->pszCur++;
+    if (ch2 == '\'')
+        return vbcppExprParseError(pParser, "Empty character constant");
+    int64_t s64;
+    if (ch2 == '\\')
+    {
+        ch2 = *pParser->pszCur++;
+        switch (ch2)
+        {
+            case '0': s64 = 0x00; break;
+            case 'n': s64 = 0x0d; break;
+            case 'r': s64 = 0x0a; break;
+            case 't': s64 = 0x09; break;
+            default:
+                return vbcppExprParseError(pParser, "Escape character '%c' is not implemented", ch2);
+        }
+    }
+    else
+        s64 = ch2;
+    if (*pParser->pszCur != '\'')
+        return vbcppExprParseError(pParser, "Character constant contains more than one character");
+
+    /* Create a signed value node. */
+    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
+    if (!pExpr)
+        return kExprRet_Error;
+    pExpr->fComplete            = true;
+    pExpr->enmKind              = kVBCppExprKind_SignedValue;
+    pExpr->u.SignedValue.s64    = s64;
+
+    /* Link it. */
+    pExpr->pParent              = pParser->pCur;
+    pParser->pCur               = pExpr;
+    *pParser->ppCur             = pExpr;
+    pParser->ppCur              = NULL;
+
+    return kExprRet_Value;
+}
+
+
+/**
+ * Parses a unary operator or a value.
+ *
+ * @returns Expression status.
+ * @retval  kExprRet_Value if value was found and processed.
+ * @retval  kExprRet_UnaryOperator if an unary operator was found and processed.
+ * @retval  kExprRet_Error with msg.
+ * @param   pParser             The parser instance.
+ */
+static VBCPPEXPRRET vbcppExprParseUnaryOrValue(PVBCPPEXPRPARSER pParser)
+{
+    vbcppExprParseSkipWhiteSpace(pParser);
+    char ch = *pParser->pszCur;
+    if (ch == '\0')
+        return vbcppExprParseError(pParser, "Premature end of expression");
+
+    /*
+     * Value?
+     */
+    if (ch == '\'')
+        return vbcppExprParseCharacterConstant(pParser);
+    if (RT_C_IS_DIGIT(ch))
+        return vbcppExprParseNumber(pParser);
+    if (ch == '"')
+        return vbcppExprParseError(pParser, "String litteral");
+    if (vbcppIsCIdentifierLeadChar(ch))
+        return vbcppExprParseIdentifier(pParser);
+
+    /*
+     * Operator?
+     */
+    VBCPPUNARYOP enmOperator;
+    if (ch == '+')
+    {
+        enmOperator = kVBCppUnaryOp_Pluss;
+        if (pParser->pszCur[1] == '+')
+            return vbcppExprParseError(pParser, "The prefix increment operator is not valid in a preprocessor expression");
+    }
+    else if (ch == '-')
+    {
+        enmOperator = kVBCppUnaryOp_Minus;
+        if (pParser->pszCur[1] == '-')
+            return vbcppExprParseError(pParser, "The prefix decrement operator is not valid in a preprocessor expression");
+    }
+    else if (ch == '!')
+        enmOperator = kVBCppUnaryOp_LogicalNot;
+    else if (ch == '~')
+        enmOperator = kVBCppUnaryOp_BitwiseNot;
+    else if (ch == '(')
+        enmOperator = kVBCppUnaryOp_Parenthesis;
+    else
+        return vbcppExprParseError(pParser, "Unknown token '%.*s'", 32, pParser->pszCur - 1);
+    pParser->pszCur++;
+
+    /* Create an operator node. */
+    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
+    if (!pExpr)
+        return kExprRet_Error;
+    pExpr->fComplete            = false;
+    pExpr->enmKind              = kVBCppExprKind_Unary;
+    pExpr->u.Unary.enmOperator  = enmOperator;
+    pExpr->u.Unary.pArg         = NULL;
+
+    /* Link it into the tree. */
+    pExpr->pParent              = pParser->pCur;
+    pParser->pCur               = pExpr;
+    *pParser->ppCur             = pExpr;
+    pParser->ppCur              = &pExpr->u.Unary.pArg;
+
+    return kExprRet_UnaryOperator;
+}
+
+
+/**
+ * Parses an expanded preprocessor expression.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszExpr             The expression to parse.
+ * @param   cchExpr             The length of the expression in case we need it.
+ * @param   ppExprTree          Where to return the parse tree.
+ * @param   pcUndefined         Where to return the number of unknown undefined
+ *                              macros.  Optional.
+ */
+static RTEXITCODE vbcppExprParse(PVBCPP pThis, char *pszExpr, size_t cchExpr, PVBCPPEXPR *ppExprTree, size_t *pcUndefined)
+{
+    RTEXITCODE rcExit = RTEXITCODE_FAILURE;
+    NOREF(cchExpr);
+
+    /*
+     * Initialize the parser context structure.
+     */
+    VBCPPEXPRPARSER Parser;
+    Parser.pszCur       = pszExpr;
+    Parser.pRoot        = NULL;
+    Parser.pCur         = NULL;
+    Parser.ppCur        = &Parser.pRoot;
+    Parser.pszExpr      = pszExpr;
+    Parser.cUndefined   = 0;
+    Parser.pThis        = pThis;
+
+    /*
+     * Do the parsing.
+     */
+    VBCPPEXPRRET enmRet;
+    for (;;)
+    {
+        /*
+         * Eat unary operators until we hit a value.
+         */
+        do
+            enmRet = vbcppExprParseUnaryOrValue(&Parser);
+        while (enmRet == kExprRet_UnaryOperator);
+        if (enmRet == kExprRet_Error)
+            break;
+        AssertBreakStmt(enmRet == kExprRet_Value, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
+
+        /*
+         * Non-unary operator, right parenthesis or end of expression is up next.
+         */
+        enmRet = vbcppExprParseBinaryOrEoeOrRparen(&Parser);
+        if (enmRet == kExprRet_Error)
+            break;
+        if (enmRet == kExprRet_EndOfExpr)
+        {
+            /** @todo check if there are any open parentheses. */
+            rcExit = RTEXITCODE_SUCCESS;
+            break;
+        }
+        AssertBreakStmt(enmRet == kExprRet_Ok, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
+    }
+
+    if (rcExit != RTEXITCODE_SUCCESS)
+    {
+        vbcppExprDestoryTree(Parser.pRoot);
+        return rcExit;
+    }
+
+    if (pcUndefined)
+        *pcUndefined = Parser.cUndefined;
+    *ppExprTree = Parser.pRoot;
+    return rcExit;
+}
+
+
+/**
+ * Checks if an expression value value is evaluates to @c true or @c false.
+ *
+ * @returns @c true or @c false.
+ * @param   pExpr               The value expression.
+ */
+static bool vbcppExprIsExprTrue(PVBCPPEXPR pExpr)
+{
+    Assert(pExpr->enmKind == kVBCppExprKind_SignedValue || pExpr->enmKind == kVBCppExprKind_UnsignedValue);
+
+    return pExpr->enmKind == kVBCppExprKind_SignedValue
+         ? pExpr->u.SignedValue.s64   != 0
+         : pExpr->u.UnsignedValue.u64 != 0;
+}
+
+
+/**
+ * Evalutes a parse (sub-)tree.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pRoot               The root of the parse (sub-)tree.
+ * @param   pResult             Where to store the result value.
+ */
+static RTEXITCODE vbcppExprEvaluteTree(PVBCPP pThis, PVBCPPEXPR pRoot, PVBCPPEXPR pResult)
+{
+    RTEXITCODE rcExit;
+    switch (pRoot->enmKind)
+    {
+        case kVBCppExprKind_SignedValue:
+            pResult->enmKind                = kVBCppExprKind_SignedValue;
+            pResult->u.SignedValue.s64      = pRoot->u.SignedValue.s64;
+            return RTEXITCODE_SUCCESS;
+
+        case kVBCppExprKind_UnsignedValue:
+            pResult->enmKind                = kVBCppExprKind_UnsignedValue;
+            pResult->u.UnsignedValue.u64    = pRoot->u.UnsignedValue.u64;
+            return RTEXITCODE_SUCCESS;
+
+        case kVBCppExprKind_Unary:
+            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Unary.pArg, pResult);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+
+            /* Apply the unary operator to the value */
+            switch (pRoot->u.Unary.enmOperator)
+            {
+                case kVBCppUnaryOp_Minus:
+                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
+                        pResult->u.SignedValue.s64   = -pResult->u.SignedValue.s64;
+                    else
+                        pResult->u.UnsignedValue.u64 = (uint64_t)-(int64_t)pResult->u.UnsignedValue.u64;
+                    break;
+
+                case kVBCppUnaryOp_LogicalNot:
+                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
+                        pResult->u.SignedValue.s64   = !pResult->u.SignedValue.s64;
+                    else
+                        pResult->u.UnsignedValue.u64 = !pResult->u.UnsignedValue.u64;
+                    break;
+
+                case kVBCppUnaryOp_BitwiseNot:
+                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
+                        pResult->u.SignedValue.s64   = ~pResult->u.SignedValue.s64;
+                    else
+                        pResult->u.UnsignedValue.u64 = ~pResult->u.UnsignedValue.u64;
+                    break;
+
+                case kVBCppUnaryOp_Pluss:
+                case kVBCppUnaryOp_Parenthesis:
+                    /* do nothing. */
+                    break;
+
+                default:
+                    return vbcppError(pThis, "Internal error: u.Unary.enmOperator=%d", pRoot->u.Unary.enmOperator);
+            }
+            return RTEXITCODE_SUCCESS;
+
+        case kVBCppExprKind_Binary:
+        {
+            /* Always evalute the left side. */
+            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pLeft, pResult);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+
+            /* If logical AND or OR we can sometimes skip evaluting the right side. */
+            if (   pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalAnd
+                && !vbcppExprIsExprTrue(pResult))
+                return RTEXITCODE_SUCCESS;
+
+            if (   pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalOr
+                && vbcppExprIsExprTrue(pResult))
+                return RTEXITCODE_SUCCESS;
+
+            /* Evalute the right side. */
+            VBCPPEXPR Result2;
+            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pRight, &Result2);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+
+            /* If one of them is unsigned, promote the other to unsigned as well. */
+            if (   pResult->enmKind == kVBCppExprKind_UnsignedValue
+                && Result2.enmKind  == kVBCppExprKind_SignedValue)
+            {
+                Result2.enmKind              = kVBCppExprKind_UnsignedValue;
+                Result2.u.UnsignedValue.u64  = Result2.u.SignedValue.s64;
+            }
+            else if (   pResult->enmKind == kVBCppExprKind_SignedValue
+                     && Result2.enmKind  == kVBCppExprKind_UnsignedValue)
+            {
+                pResult->enmKind             = kVBCppExprKind_UnsignedValue;
+                pResult->u.UnsignedValue.u64 = pResult->u.SignedValue.s64;
+            }
+
+            /* Perform the operation. */
+            if (pResult->enmKind == kVBCppExprKind_UnsignedValue)
+            {
+                switch (pRoot->u.Binary.enmOperator)
+                {
+                    case kVBCppBinary_Multiplication:
+                        pResult->u.UnsignedValue.u64 *= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_Division:
+                        if (!Result2.u.UnsignedValue.u64)
+                            return vbcppError(pThis, "Divide by zero");
+                        pResult->u.UnsignedValue.u64 /= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_Modulo:
+                        if (!Result2.u.UnsignedValue.u64)
+                            return vbcppError(pThis, "Divide by zero");
+                        pResult->u.UnsignedValue.u64 %= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_Addition:
+                        pResult->u.UnsignedValue.u64 += Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_Subtraction:
+                        pResult->u.UnsignedValue.u64 -= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_LeftShift:
+                        pResult->u.UnsignedValue.u64 <<= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_RightShift:
+                        pResult->u.UnsignedValue.u64 >>= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_LessThan:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 < Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_LessThanOrEqual:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 <= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_GreaterThan:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 > Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_GreaterThanOrEqual:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 >= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_EqualTo:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 == Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_NotEqualTo:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 != Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_BitwiseAnd:
+                        pResult->u.UnsignedValue.u64 &= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_BitwiseXor:
+                        pResult->u.UnsignedValue.u64 ^= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_BitwiseOr:
+                        pResult->u.UnsignedValue.u64 |= Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_LogicalAnd:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 && Result2.u.UnsignedValue.u64;
+                        break;
+                    case kVBCppBinary_LogicalOr:
+                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 || Result2.u.UnsignedValue.u64;
+                        break;
+                    default:
+                        return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
+                }
+            }
+            else
+            {
+                switch (pRoot->u.Binary.enmOperator)
+                {
+                    case kVBCppBinary_Multiplication:
+                        pResult->u.SignedValue.s64 *= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_Division:
+                        if (!Result2.u.SignedValue.s64)
+                            return vbcppError(pThis, "Divide by zero");
+                        pResult->u.SignedValue.s64 /= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_Modulo:
+                        if (!Result2.u.SignedValue.s64)
+                            return vbcppError(pThis, "Divide by zero");
+                        pResult->u.SignedValue.s64 %= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_Addition:
+                        pResult->u.SignedValue.s64 += Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_Subtraction:
+                        pResult->u.SignedValue.s64 -= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_LeftShift:
+                        pResult->u.SignedValue.s64 <<= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_RightShift:
+                        pResult->u.SignedValue.s64 >>= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_LessThan:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 < Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_LessThanOrEqual:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 <= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_GreaterThan:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 > Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_GreaterThanOrEqual:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 >= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_EqualTo:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 == Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_NotEqualTo:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 != Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_BitwiseAnd:
+                        pResult->u.SignedValue.s64 &= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_BitwiseXor:
+                        pResult->u.SignedValue.s64 ^= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_BitwiseOr:
+                        pResult->u.SignedValue.s64 |= Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_LogicalAnd:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 && Result2.u.SignedValue.s64;
+                        break;
+                    case kVBCppBinary_LogicalOr:
+                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 || Result2.u.SignedValue.s64;
+                        break;
+                    default:
+                        return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
+                }
+            }
+            return rcExit;
+        }
+
+        case kVBCppExprKind_Ternary:
+            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pExpr, pResult);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+            if (vbcppExprIsExprTrue(pResult))
+                return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pTrue, pResult);
+            return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pFalse, pResult);
+
+        default:
+            return vbcppError(pThis, "Internal error: enmKind=%d", pRoot->enmKind);
+    }
+}
+
+
+/**
+ * Evalutes the expression.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszExpr             The expression.
+ * @param   cchExpr             The length of the expression.
+ * @param   penmResult          Where to store the result.
+ */
+static RTEXITCODE vbcppExprEval(PVBCPP pThis, char *pszExpr, size_t cchExpr, size_t cReplacements, VBCPPEVAL *penmResult)
+{
+    Assert(strlen(pszExpr) == cchExpr);
+    RT_NOREF_PV(cReplacements);
+
+    size_t      cUndefined;
+    PVBCPPEXPR  pExprTree;
+    RTEXITCODE  rcExit = vbcppExprParse(pThis, pszExpr, cchExpr, &pExprTree, &cUndefined);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        if (   !cUndefined
+            || pThis->enmMode == kVBCppMode_SelectiveD
+            || pThis->enmMode == kVBCppMode_Standard)
+        {
+            VBCPPEXPR Result;
+            rcExit = vbcppExprEvaluteTree(pThis, pExprTree, &Result);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                if (vbcppExprIsExprTrue(&Result))
+                    *penmResult = kVBCppEval_True;
+                else
+                    *penmResult = kVBCppEval_False;
+            }
+        }
+        else
+            *penmResult = kVBCppEval_Undecided;
+    }
+    return rcExit;
+}
+
+
+static RTEXITCODE vbcppExtractSkipCommentLine(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RT_NOREF_PV(pThis);
+
+    unsigned chPrev = ScmStreamGetCh(pStrmInput); Assert(chPrev == '/');
+    unsigned ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (ch == '\r' || ch == '\n')
+        {
+            if (chPrev != '\\')
+                break;
+            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+            chPrev = ch;
+        }
+        else
+        {
+            chPrev = ScmStreamGetCh(pStrmInput);
+            Assert(chPrev == ch);
+        }
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE vbcppExtractSkipComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    unsigned ch = ScmStreamGetCh(pStrmInput); Assert(ch == '*');
+    while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (ch == '*')
+        {
+            ch = ScmStreamGetCh(pStrmInput);
+            if (ch == '/')
+                return RTEXITCODE_SUCCESS;
+        }
+    }
+    return vbcppError(pThis, "Expected '*/'");
+}
+
+
+static RTEXITCODE vbcppExtractQuotedString(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf,
+                                           char chOpen, char chClose)
+{
+    unsigned ch = ScmStreamGetCh(pStrmInput);
+    Assert(ch == (unsigned)chOpen);
+
+    RTEXITCODE rcExit = vbcppStrBufAppendCh(pStrBuf, chOpen);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return rcExit;
+
+    for (;;)
+    {
+        ch = ScmStreamGetCh(pStrmInput);
+        if (ch == '\\')
+        {
+            ch = ScmStreamGetCh(pStrmInput);
+            if (ch == ~(unsigned)0)
+                break;
+            rcExit = vbcppStrBufAppendCh(pStrBuf, '\\');
+            if (rcExit == RTEXITCODE_SUCCESS)
+                rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+        }
+        else if (ch != ~(unsigned)0)
+        {
+            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+            if (ch == (unsigned)chClose)
+                return RTEXITCODE_SUCCESS;
+        }
+        else
+            break;
+    }
+
+    return vbcppError(pThis, "File ended with an open character constant");
+}
+
+
+/**
+ * Extracts a line from the stream, stripping it for comments and maybe
+ * optimzing some of the whitespace.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   pStrBuf             Where to store the extracted line. Caller must
+ *                              initialize this prior to the call an delete it
+ *                              after use (even on failure).
+ * @param   poffComment         Where to note down the position of the final
+ *                              comment. Optional.
+ */
+static RTEXITCODE vbcppExtractDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf, size_t *poffComment)
+{
+    size_t      offComment  = ~(size_t)0;
+    unsigned    ch;
+    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
+    {
+        RTEXITCODE rcExit;
+        if (ch == '/')
+        {
+            /* Comment? */
+            unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2); NOREF(ch2);
+            ch = ScmStreamPeekCh(pStrmInput);
+            if (ch == '*')
+            {
+                offComment = ScmStreamTell(pStrmInput) - 1;
+                rcExit = vbcppExtractSkipComment(pThis, pStrmInput);
+            }
+            else if (ch == '/')
+            {
+                offComment = ScmStreamTell(pStrmInput) - 1;
+                rcExit = vbcppExtractSkipCommentLine(pThis, pStrmInput);
+            }
+            else
+                rcExit = vbcppStrBufAppendCh(pStrBuf, '/');
+        }
+        else if (ch == '\'')
+        {
+            offComment = ~(size_t)0;
+            rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '\'', '\'');
+        }
+        else if (ch == '"')
+        {
+            offComment = ~(size_t)0;
+            rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '"', '"');
+        }
+        else if (ch == '\r' || ch == '\n')
+            break; /* done */
+        else if (   RT_C_IS_SPACE(ch)
+                 && (   RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf))
+                     || vbcppStrBufLastCh(pStrBuf) == '\0') )
+        {
+            unsigned ch2 = ScmStreamGetCh(pStrmInput);
+            Assert(ch == ch2); NOREF(ch2);
+            rcExit = RTEXITCODE_SUCCESS;
+        }
+        else
+        {
+            unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2);
+
+            /* Escaped newline? */
+            if (   ch == '\\'
+                && (   (ch2 = ScmStreamPeekCh(pStrmInput)) == '\r'
+                    || ch2 == '\n'))
+            {
+                ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
+                rcExit = RTEXITCODE_SUCCESS;
+            }
+            else
+            {
+                offComment = ~(size_t)0;
+                rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
+            }
+        }
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+    }
+
+    if (poffComment)
+        *poffComment = offComment;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ * @param   enmKind             The kind of directive we're processing.
+ */
+static RTEXITCODE vbcppDirectiveIfOrElif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
+                                         VBCPPCONDKIND enmKind)
+{
+    /*
+     * Check for missing #if if #elif.
+     */
+    if (   enmKind == kVBCppCondKind_ElIf
+        && !pThis->pCondStack )
+        return vbcppError(pThis, "#elif without #if");
+
+    /*
+     * Extract the expression string.
+     */
+    const char         *pchCondition = ScmStreamGetCur(pStrmInput);
+    size_t              offComment;
+    VBCPPMACROEXP       ExpCtx;
+#if 0
+    ExpCtx.pMacroStack    = NULL;
+#endif
+    ExpCtx.pStrmInput     = NULL;
+    ExpCtx.papszArgs      = NULL;
+    ExpCtx.cArgs          = 0;
+    ExpCtx.cArgsAlloced   = 0;
+    vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
+    RTEXITCODE  rcExit = vbcppExtractDirectiveLine(pThis, pStrmInput, &ExpCtx.StrBuf, &offComment);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t const    cchCondition = ScmStreamGetCur(pStrmInput) - pchCondition;
+
+        /*
+         * Expand known macros in it.
+         */
+        size_t          cReplacements;
+        rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Expression, &cReplacements);
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            /*
+             * Strip it and check that it's not empty.
+             */
+            char   *pszExpr = ExpCtx.StrBuf.pszBuf;
+            size_t  cchExpr = ExpCtx.StrBuf.cchBuf;
+            while (cchExpr > 0 && RT_C_IS_SPACE(*pszExpr))
+                pszExpr++, cchExpr--;
+
+            while (cchExpr > 0 && RT_C_IS_SPACE(pszExpr[cchExpr - 1]))
+            {
+                pszExpr[--cchExpr] = '\0';
+                ExpCtx.StrBuf.cchBuf--;
+            }
+            if (cchExpr)
+            {
+                /*
+                 * Now, evalute the expression.
+                 */
+                VBCPPEVAL enmResult;
+                rcExit = vbcppExprEval(pThis, pszExpr, cchExpr, cReplacements, &enmResult);
+                if (rcExit == RTEXITCODE_SUCCESS)
+                {
+                    /*
+                     * Take action.
+                     */
+                    if (enmKind != kVBCppCondKind_ElIf)
+                        rcExit = vbcppCondPush(pThis, pStrmInput, offComment, enmKind, enmResult,
+                                               pchCondition, cchCondition);
+                    else
+                    {
+                        PVBCPPCOND pCond = pThis->pCondStack;
+                        if (   pCond->enmResult != kVBCppEval_Undecided
+                            && (   !pCond->pUp
+                                || pCond->pUp->enmStackResult == kVBCppEval_True))
+                        {
+                            Assert(enmResult == kVBCppEval_True || enmResult == kVBCppEval_False);
+                            if (   pCond->enmResult == kVBCppEval_False
+                                && enmResult        == kVBCppEval_True
+                                && !pCond->fElIfDecided)
+                            {
+                                pCond->enmStackResult = kVBCppEval_True;
+                                pCond->fElIfDecided   = true;
+                            }
+                            else
+                                pCond->enmStackResult = kVBCppEval_False;
+                            pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
+                        }
+                        pCond->enmKind   = kVBCppCondKind_ElIf;
+                        pCond->enmResult = enmResult;
+                        pCond->pchCond   = pchCondition;
+                        pCond->cchCond   = cchCondition;
+
+                        /*
+                         * Do #elif pass thru.
+                         */
+                        if (   !pThis->fIf0Mode
+                            && pCond->enmResult == kVBCppEval_Undecided)
+                        {
+                            ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selif", pCond->iKeepLevel - 1, "");
+                            if (cch > 0)
+                                rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
+                            else
+                                rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
+                        }
+                        else
+                            pThis->fJustDroppedLine = true;
+                    }
+                }
+            }
+            else
+                rcExit = vbcppError(pThis, "Empty #if expression");
+        }
+    }
+    vbcppMacroExpandCleanup(&ExpCtx);
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveIfDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    /*
+     * Parse it.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchDefine;
+        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
+        if (pchDefine)
+        {
+            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                /*
+                 * Evaluate it.
+                 */
+                VBCPPEVAL enmEval;
+                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
+                    enmEval = kVBCppEval_True;
+                else if (   !pThis->fUndecidedConditionals
+                         || RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
+                    enmEval = kVBCppEval_False;
+                else
+                    enmEval = kVBCppEval_Undecided;
+                rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfDef, enmEval,
+                                       pchDefine, cchDefine);
+            }
+        }
+        else
+            rcExit = vbcppError(pThis, "Malformed #ifdef");
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveIfNDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    /*
+     * Parse it.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchDefine;
+        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
+        if (pchDefine)
+        {
+            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                /*
+                 * Evaluate it.
+                 */
+                VBCPPEVAL enmEval;
+                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
+                    enmEval = kVBCppEval_False;
+                else if (   !pThis->fUndecidedConditionals
+                         || RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
+                    enmEval = kVBCppEval_True;
+                else
+                    enmEval = kVBCppEval_Undecided;
+                rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfNDef, enmEval,
+                                       pchDefine, cchDefine);
+            }
+        }
+        else
+            rcExit = vbcppError(pThis, "Malformed #ifndef");
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveElse(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    /*
+     * Nothing to parse, just comment positions to find and note down.
+     */
+    offStart = vbcppProcessSkipWhite(pStrmInput);
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        /*
+         * Execute.
+         */
+        PVBCPPCOND pCond = pThis->pCondStack;
+        if (pCond)
+        {
+            if (!pCond->fSeenElse)
+            {
+                pCond->fSeenElse = true;
+                if (   pCond->enmResult != kVBCppEval_Undecided
+                    && (   !pCond->pUp
+                        || pCond->pUp->enmStackResult == kVBCppEval_True))
+                {
+                    if (   pCond->enmResult == kVBCppEval_True
+                        || pCond->fElIfDecided)
+
+                        pCond->enmStackResult = kVBCppEval_False;
+                    else
+                        pCond->enmStackResult = kVBCppEval_True;
+                    pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
+                }
+
+                /*
+                 * Do pass thru.
+                 */
+                if (   !pThis->fIf0Mode
+                    && pCond->enmResult == kVBCppEval_Undecided)
+                {
+                    ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selse", pCond->iKeepLevel - 1, "");
+                    if (cch > 0)
+                        rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
+                    else
+                        rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
+                }
+                else
+                    pThis->fJustDroppedLine = true;
+            }
+            else
+                rcExit = vbcppError(pThis, "Double #else or/and missing #endif");
+        }
+        else
+            rcExit = vbcppError(pThis, "#else without #if");
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveEndif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    /*
+     * Nothing to parse, just comment positions to find and note down.
+     */
+    offStart = vbcppProcessSkipWhite(pStrmInput);
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        /*
+         * Execute.
+         */
+        PVBCPPCOND pCond = pThis->pCondStack;
+        if (pCond)
+        {
+            pThis->pCondStack = pCond->pUp;
+            pThis->fIf0Mode   = pCond->pUp && pCond->pUp->enmStackResult == kVBCppEval_False;
+
+            /*
+             * Do pass thru.
+             */
+            if (   !pThis->fIf0Mode
+                && pCond->enmResult == kVBCppEval_Undecided)
+            {
+                ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sendif", pCond->iKeepLevel - 1, "");
+                if (cch > 0)
+                    rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 1);
+                else
+                    rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
+            }
+            else
+                pThis->fJustDroppedLine = true;
+        }
+        else
+            rcExit = vbcppError(pThis, "#endif without #if");
+    }
+    return rcExit;
+}
+
+
+
+
+
+/*
+ *
+ *
+ * Misc Directives
+ * Misc Directives
+ * Misc Directives
+ * Misc Directives
+ *
+ *
+ */
+
+
+/**
+ * Adds an include directory.
+ *
+ * @returns Program exit code, with error message on failure.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pszDir              The directory to add.
+ */
+static RTEXITCODE vbcppAddInclude(PVBCPP pThis, const char *pszDir)
+{
+    uint32_t cIncludes = pThis->cIncludes;
+    if (cIncludes >= _64K)
+        return vbcppError(pThis, "Too many include directories");
+
+    void *pv = RTMemRealloc(pThis->papszIncludes, (cIncludes + 1) * sizeof(char **));
+    if (!pv)
+        return vbcppError(pThis, "No memory for include directories");
+    pThis->papszIncludes = (char **)pv;
+
+    int rc = RTStrDupEx(&pThis->papszIncludes[cIncludes], pszDir);
+    if (RT_FAILURE(rc))
+        return vbcppError(pThis, "No string memory for include directories");
+
+    pThis->cIncludes = cIncludes + 1;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveInclude(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+
+    /*
+     * Parse it.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchFileSpec = 0;
+        const char *pchFileSpec = NULL;
+        size_t      cchFilename = 0;
+        const char *pchFilename = NULL;
+
+        unsigned ch = ScmStreamPeekCh(pStrmInput);
+        unsigned chType = ch;
+        if (ch == '"' || ch == '<')
+        {
+            ScmStreamGetCh(pStrmInput);
+            pchFileSpec = pchFilename = ScmStreamGetCur(pStrmInput);
+            unsigned chEnd  = chType == '<' ? '>' : '"';
+            while (   (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0
+                   &&  ch != chEnd)
+            {
+                if (ch == '\r' || ch == '\n')
+                {
+                    rcExit = vbcppError(pThis, "Multi-line include file specfications are not supported");
+                    break;
+                }
+            }
+
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                if (ch != ~(unsigned)0)
+                    cchFileSpec = cchFilename = ScmStreamGetCur(pStrmInput) - pchFilename - 1;
+                else
+                    rcExit = vbcppError(pThis, "Expected '%c'", chType);
+            }
+        }
+        else if (vbcppIsCIdentifierLeadChar(ch))
+        {
+            //pchFileSpec = ScmStreamCGetWord(pStrmInput, &cchFileSpec);
+            rcExit = vbcppError(pThis, "Including via a define is not implemented yet");
+        }
+        else
+            rcExit = vbcppError(pThis, "Malformed include directive");
+
+        /*
+         * Take down the location of the next non-white space, in case we need
+         * to pass thru the directive further down. Then skip to the end of the
+         * line.
+         */
+        size_t const offIncEnd = vbcppProcessSkipWhite(pStrmInput);
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
+
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            /*
+             * Execute it.
+             */
+            if (pThis->enmIncludeAction == kVBCppIncludeAction_Include)
+            {
+                /** @todo Search for the include file and push it onto the input stack.
+                 *  Not difficult, just unnecessary rigth now. */
+                rcExit = vbcppError(pThis, "Includes are fully implemented");
+            }
+            else if (pThis->enmIncludeAction == kVBCppIncludeAction_PassThru)
+            {
+                /* Pretty print the passthru. */
+                unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
+                ssize_t  cch;
+                if (chType == '<')
+                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude <%.*s>",
+                                          cchIndent, "", cchFileSpec, pchFileSpec);
+                else if (chType == '"')
+                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude \"%.*s\"",
+                                          cchIndent, "", cchFileSpec, pchFileSpec);
+                else
+                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude %.*s",
+                                          cchIndent, "", cchFileSpec, pchFileSpec);
+                if (cch > 0)
+                    rcExit = vbcppOutputComment(pThis, pStrmInput, offIncEnd, cch, 1);
+                else
+                    rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
+
+            }
+            else
+            {
+                Assert(pThis->enmIncludeAction == kVBCppIncludeAction_Drop);
+                pThis->fJustDroppedLine = true;
+            }
+        }
+    }
+    return rcExit;
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectivePragma(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+
+    /*
+     * Parse out the first word.
+     */
+    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        size_t      cchPragma;
+        const char *pchPragma = ScmStreamCGetWord(pStrmInput, &cchPragma);
+        if (pchPragma)
+        {
+            size_t const off2nd = vbcppProcessSkipWhite(pStrmInput);
+            size_t       offComment;
+            rcExit = vbcppInputSkipToEndOfDirectiveLine(pThis, pStrmInput, &offComment);
+            if (rcExit == RTEXITCODE_SUCCESS)
+            {
+                /*
+                 * What to do about this
+                 */
+                bool fPassThru = false;
+                if (   cchPragma  == 1
+                    && *pchPragma == 'D')
+                    fPassThru = pThis->fPassThruPragmaD;
+                else if (    cchPragma == 3
+                         &&  !strncmp(pchPragma, "STD", 3))
+                    fPassThru = pThis->fPassThruPragmaSTD;
+                else
+                    fPassThru = pThis->fPassThruPragmaOther;
+                if (fPassThru)
+                {
+                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
+                    ssize_t  cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*spragma %.*s",
+                                                   cchIndent, "", cchPragma, pchPragma);
+                    if (cch > 0)
+                        rcExit = vbcppOutputComment(pThis, pStrmInput, off2nd, cch, 1);
+                    else
+                        rcExit = vbcppError(pThis, "output error");
+                }
+                else
+                    pThis->fJustDroppedLine = true;
+            }
+        }
+        else
+            rcExit = vbcppError(pThis, "Malformed #pragma");
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Processes an error directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveError(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+    RT_NOREF_PV(pStrmInput);
+    return vbcppError(pThis, "Hit an #error");
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   offStart            The stream position where the directive
+ *                              started (for pass thru).
+ */
+static RTEXITCODE vbcppDirectiveLineNo(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
+{
+    RT_NOREF_PV(offStart);
+    RT_NOREF_PV(pStrmInput);
+    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
+}
+
+
+/**
+ * Processes a abbreviated line number directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppDirectiveLineNoShort(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    RT_NOREF_PV(pStrmInput);
+    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
+}
+
+
+/**
+ * Handles a preprocessor directive.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ */
+static RTEXITCODE vbcppProcessDirective(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    /*
+     * Get the directive and do a string switch on it.
+     */
+    RTEXITCODE  rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return rcExit;
+    size_t      cchDirective;
+    const char *pchDirective = ScmStreamCGetWord(pStrmInput, &cchDirective);
+    if (pchDirective)
+    {
+        size_t const offStart = ScmStreamTell(pStrmInput);
+#define IS_DIRECTIVE(a_sz) ( sizeof(a_sz) - 1 == cchDirective && strncmp(pchDirective, a_sz, sizeof(a_sz) - 1) == 0)
+        if (IS_DIRECTIVE("if"))
+            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_If);
+        else if (IS_DIRECTIVE("elif"))
+            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_ElIf);
+        else if (IS_DIRECTIVE("ifdef"))
+            rcExit = vbcppDirectiveIfDef(pThis, pStrmInput, offStart);
+        else if (IS_DIRECTIVE("ifndef"))
+            rcExit = vbcppDirectiveIfNDef(pThis, pStrmInput, offStart);
+        else if (IS_DIRECTIVE("else"))
+            rcExit = vbcppDirectiveElse(pThis, pStrmInput, offStart);
+        else if (IS_DIRECTIVE("endif"))
+            rcExit = vbcppDirectiveEndif(pThis, pStrmInput, offStart);
+        else if (!pThis->fIf0Mode)
+        {
+            if (IS_DIRECTIVE("include"))
+                rcExit = vbcppDirectiveInclude(pThis, pStrmInput, offStart);
+            else if (IS_DIRECTIVE("define"))
+                rcExit = vbcppDirectiveDefine(pThis, pStrmInput, offStart);
+            else if (IS_DIRECTIVE("undef"))
+                rcExit = vbcppDirectiveUndef(pThis, pStrmInput, offStart);
+            else if (IS_DIRECTIVE("pragma"))
+                rcExit = vbcppDirectivePragma(pThis, pStrmInput, offStart);
+            else if (IS_DIRECTIVE("error"))
+                rcExit = vbcppDirectiveError(pThis, pStrmInput, offStart);
+            else if (IS_DIRECTIVE("line"))
+                rcExit = vbcppDirectiveLineNo(pThis, pStrmInput, offStart);
+            else
+                rcExit = vbcppError(pThis, "Unknown preprocessor directive '#%.*s'", cchDirective, pchDirective);
+        }
+#undef IS_DIRECTIVE
+    }
+    else if (!pThis->fIf0Mode)
+    {
+        /* Could it be a # <num> "file" directive? */
+        unsigned ch = ScmStreamPeekCh(pStrmInput);
+        if (RT_C_IS_DIGIT(ch))
+            rcExit = vbcppDirectiveLineNoShort(pThis, pStrmInput);
+        else
+            rcExit = vbcppError(pThis, "Malformed preprocessor directive");
+    }
+    return rcExit;
+}
+
+
+/*
+ *
+ *
+ * M a i n   b o d y.
+ * M a i n   b o d y.
+ * M a i n   b o d y.
+ * M a i n   b o d y.
+ * M a i n   b o d y.
+ *
+ *
+ */
+
+
+/**
+ * Does the actually preprocessing of the input file.
+ *
+ * @returns Exit code.
+ * @param   pThis               The C preprocessor instance.
+ */
+static RTEXITCODE vbcppPreprocess(PVBCPP pThis)
+{
+    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
+
+    /*
+     * Parse.
+     */
+    while (pThis->pInputStack)
+    {
+        pThis->fMaybePreprocessorLine = true;
+
+        PSCMSTREAM  pStrmInput = &pThis->pInputStack->StrmInput;
+        unsigned    ch;
+        while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
+        {
+            if (ch == '/')
+            {
+                ch = ScmStreamPeekCh(pStrmInput);
+                if (ch == '*')
+                    rcExit = vbcppProcessMultiLineComment(pThis, pStrmInput);
+                else if (ch == '/')
+                    rcExit = vbcppProcessOneLineComment(pThis, pStrmInput);
+                else
+                {
+                    pThis->fMaybePreprocessorLine = false;
+                    if (!pThis->fIf0Mode)
+                        rcExit = vbcppOutputCh(pThis, '/');
+                }
+            }
+            else if (ch == '#' && pThis->fMaybePreprocessorLine)
+            {
+                rcExit = vbcppProcessDirective(pThis, pStrmInput);
+                pStrmInput = &pThis->pInputStack->StrmInput;
+            }
+            else if (ch == '\r' || ch == '\n')
+            {
+                if (   (   !pThis->fIf0Mode
+                        && !pThis->fJustDroppedLine)
+                    || !pThis->fRemoveDroppedLines
+                    || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
+                    rcExit = vbcppOutputCh(pThis, ch);
+                pThis->fJustDroppedLine       = false;
+                pThis->fMaybePreprocessorLine = true;
+            }
+            else if (RT_C_IS_SPACE(ch))
+            {
+                if (!pThis->fIf0Mode)
+                    rcExit = vbcppOutputCh(pThis, ch);
+            }
+            else
+            {
+                pThis->fMaybePreprocessorLine = false;
+                if (!pThis->fIf0Mode)
+                {
+                    if (ch == '"')
+                        rcExit = vbcppProcessStringLitteral(pThis, pStrmInput);
+                    else if (ch == '\'')
+                        rcExit = vbcppProcessCharacterConstant(pThis, pStrmInput);
+                    else if (vbcppIsCIdentifierLeadChar(ch))
+                        rcExit = vbcppProcessIdentifier(pThis, pStrmInput);
+                    else if (RT_C_IS_DIGIT(ch))
+                        rcExit = vbcppProcessNumber(pThis, pStrmInput, ch);
+                    else
+                        rcExit = vbcppOutputCh(pThis, ch);
+                }
+            }
+            if (rcExit != RTEXITCODE_SUCCESS)
+                break;
+        }
+
+        /*
+         * Check for errors.
+         */
+        if (rcExit != RTEXITCODE_SUCCESS)
+            break;
+
+        /*
+         * Pop the input stack.
+         */
+        PVBCPPINPUT pPopped = pThis->pInputStack;
+        pThis->pInputStack = pPopped->pUp;
+        RTMemFree(pPopped);
+    }
+
+    return rcExit;
+}
+
+
+/**
+ * Opens the input and output streams.
+ *
+ * @returns Exit code.
+ * @param   pThis               The C preprocessor instance.
+ */
+static RTEXITCODE vbcppOpenStreams(PVBCPP pThis)
+{
+    if (!pThis->pszInput)
+        return vbcppError(pThis, "Preprocessing the standard input stream is currently not supported");
+
+    size_t      cchName = strlen(pThis->pszInput);
+    PVBCPPINPUT pInput = (PVBCPPINPUT)RTMemAlloc(RT_UOFFSETOF_DYN(VBCPPINPUT, szName[cchName + 1]));
+    if (!pInput)
+        return vbcppError(pThis, "out of memory");
+    pInput->pUp          = pThis->pInputStack;
+    pInput->pszSpecified = pInput->szName;
+    memcpy(pInput->szName, pThis->pszInput, cchName + 1);
+    pThis->pInputStack   = pInput;
+    int rc = ScmStreamInitForReading(&pInput->StrmInput, pThis->pszInput);
+    if (RT_FAILURE(rc))
+        return vbcppError(pThis, "ScmStreamInitForReading returned %Rrc when opening input file (%s)",
+                          rc, pThis->pszInput);
+
+    rc = ScmStreamInitForWriting(&pThis->StrmOutput, &pInput->StrmInput);
+    if (RT_FAILURE(rc))
+        return vbcppError(pThis, "ScmStreamInitForWriting returned %Rrc", rc);
+
+    pThis->fStrmOutputValid = true;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Changes the preprocessing mode.
+ *
+ * @param   pThis               The C preprocessor instance.
+ * @param   enmMode             The new mode.
+ */
+static void vbcppSetMode(PVBCPP pThis, VBCPPMODE enmMode)
+{
+    switch (enmMode)
+    {
+        case kVBCppMode_Standard:
+            pThis->fKeepComments                    = false;
+            pThis->fRespectSourceDefines            = true;
+            pThis->fAllowRedefiningCmdLineDefines   = true;
+            pThis->fPassThruDefines                 = false;
+            pThis->fUndecidedConditionals           = false;
+            pThis->fPassThruPragmaD                 = false;
+            pThis->fPassThruPragmaSTD               = true;
+            pThis->fPassThruPragmaOther             = true;
+            pThis->fRemoveDroppedLines              = false;
+            pThis->fLineSplicing                    = true;
+            pThis->enmIncludeAction                 = kVBCppIncludeAction_Include;
+            break;
+
+        case kVBCppMode_Selective:
+            pThis->fKeepComments                    = true;
+            pThis->fRespectSourceDefines            = false;
+            pThis->fAllowRedefiningCmdLineDefines   = false;
+            pThis->fPassThruDefines                 = true;
+            pThis->fUndecidedConditionals           = true;
+            pThis->fPassThruPragmaD                 = true;
+            pThis->fPassThruPragmaSTD               = true;
+            pThis->fPassThruPragmaOther             = true;
+            pThis->fRemoveDroppedLines              = true;
+            pThis->fLineSplicing                    = false;
+            pThis->enmIncludeAction                 = kVBCppIncludeAction_PassThru;
+            break;
+
+        case kVBCppMode_SelectiveD:
+            pThis->fKeepComments                    = true;
+            pThis->fRespectSourceDefines            = true;
+            pThis->fAllowRedefiningCmdLineDefines   = false;
+            pThis->fPassThruDefines                 = false;
+            pThis->fUndecidedConditionals           = false;
+            pThis->fPassThruPragmaD                 = true;
+            pThis->fPassThruPragmaSTD               = false;
+            pThis->fPassThruPragmaOther             = false;
+            pThis->fRemoveDroppedLines              = true;
+            pThis->fLineSplicing                    = false;
+            pThis->enmIncludeAction                 = kVBCppIncludeAction_Drop;
+            break;
+
+        default:
+            AssertFailedReturnVoid();
+    }
+    pThis->enmMode = enmMode;
+}
+
+
+/**
+ * Parses the command line options.
+ *
+ * @returns Program exit code. Exit on non-success or if *pfExit is set.
+ * @param   pThis               The C preprocessor instance.
+ * @param   argc                The argument count.
+ * @param   argv                The argument vector.
+ * @param   pfExit              Pointer to the exit indicator.
+ */
+static RTEXITCODE vbcppParseOptions(PVBCPP pThis, int argc, char **argv, bool *pfExit)
+{
+    RTEXITCODE rcExit;
+
+    *pfExit = false;
+
+    /*
+     * Option config.
+     */
+    static RTGETOPTDEF const s_aOpts[] =
+    {
+        { "--define",                   'D',                    RTGETOPT_REQ_STRING },
+        { "--include-dir",              'I',                    RTGETOPT_REQ_STRING },
+        { "--undefine",                 'U',                    RTGETOPT_REQ_STRING },
+        { "--keep-comments",            'C',                    RTGETOPT_REQ_NOTHING },
+        { "--strip-comments",           'c',                    RTGETOPT_REQ_NOTHING },
+        { "--D-strip",                  'd',                    RTGETOPT_REQ_NOTHING },
+    };
+
+    RTGETOPTUNION   ValueUnion;
+    RTGETOPTSTATE   GetOptState;
+    int rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
+
+    /*
+     * Process the options.
+     */
+    while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
+    {
+        switch (rc)
+        {
+            case 'c':
+                pThis->fKeepComments = false;
+                break;
+
+            case 'C':
+                pThis->fKeepComments = false;
+                break;
+
+            case 'd':
+                vbcppSetMode(pThis, kVBCppMode_SelectiveD);
+                break;
+
+            case 'D':
+            {
+                const char *pszEqual = strchr(ValueUnion.psz, '=');
+                if (pszEqual)
+                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, pszEqual - ValueUnion.psz, pszEqual + 1, RTSTR_MAX, true);
+                else
+                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, RTSTR_MAX, "1", 1, true);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    return rcExit;
+                break;
+            }
+
+            case 'I':
+                rcExit = vbcppAddInclude(pThis, ValueUnion.psz);
+                if (rcExit != RTEXITCODE_SUCCESS)
+                    return rcExit;
+                break;
+
+            case 'U':
+                rcExit = vbcppMacroUndef(pThis, ValueUnion.psz, RTSTR_MAX, true);
+                break;
+
+            case 'h':
+                RTPrintf("No help yet, sorry\n");
+                *pfExit = true;
+                return RTEXITCODE_SUCCESS;
+
+            case 'V':
+            {
+                /* The following is assuming that svn does it's job here. */
+                static const char s_szRev[] = "$Revision: 155244 $";
+                const char *psz = RTStrStripL(strchr(s_szRev, ' '));
+                RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
+                *pfExit = true;
+                return RTEXITCODE_SUCCESS;
+            }
+
+            case VINF_GETOPT_NOT_OPTION:
+                if (!pThis->pszInput)
+                    pThis->pszInput = ValueUnion.psz;
+                else if (!pThis->pszOutput)
+                    pThis->pszOutput = ValueUnion.psz;
+                else
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "too many file arguments");
+                break;
+
+
+            /*
+             * Errors and bugs.
+             */
+            default:
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Terminates the preprocessor.
+ *
+ * This may return failure if an error was delayed.
+ *
+ * @returns Exit code.
+ * @param   pThis               The C preprocessor instance.
+ */
+static RTEXITCODE vbcppTerm(PVBCPP pThis)
+{
+    /*
+     * Flush the output first.
+     */
+    if (pThis->fStrmOutputValid)
+    {
+        if (pThis->pszOutput)
+        {
+            int rc = ScmStreamWriteToFile(&pThis->StrmOutput, "%s", pThis->pszOutput);
+            if (RT_FAILURE(rc))
+                vbcppError(pThis, "ScmStreamWriteToFile failed with %Rrc when writing '%s'", rc, pThis->pszOutput);
+        }
+        else
+        {
+            int rc = ScmStreamWriteToStdOut(&pThis->StrmOutput);
+            if (RT_FAILURE(rc))
+                vbcppError(pThis, "ScmStreamWriteToStdOut failed with %Rrc", rc);
+        }
+    }
+
+    /*
+     * Cleanup.
+     */
+    while (pThis->pInputStack)
+    {
+        ScmStreamDelete(&pThis->pInputStack->StrmInput);
+        void *pvFree = pThis->pInputStack;
+        pThis->pInputStack = pThis->pInputStack->pUp;
+        RTMemFree(pvFree);
+    }
+
+    ScmStreamDelete(&pThis->StrmOutput);
+
+    RTStrSpaceDestroy(&pThis->StrSpace, vbcppMacroFree, NULL);
+    pThis->StrSpace = NULL;
+
+    uint32_t i = pThis->cIncludes;
+    while (i-- > 0)
+        RTStrFree(pThis->papszIncludes[i]);
+    RTMemFree(pThis->papszIncludes);
+    pThis->papszIncludes = NULL;
+
+    return pThis->rcExit;
+}
+
+
+/**
+ * Initializes the C preprocessor instance data.
+ *
+ * @param   pThis               The C preprocessor instance data.
+ */
+static void vbcppInit(PVBCPP pThis)
+{
+    vbcppSetMode(pThis, kVBCppMode_Selective);
+    pThis->cIncludes        = 0;
+    pThis->papszIncludes    = NULL;
+    pThis->pszInput         = NULL;
+    pThis->pszOutput        = NULL;
+    pThis->StrSpace         = NULL;
+    pThis->UndefStrSpace    = NULL;
+    pThis->cCondStackDepth  = 0;
+    pThis->pCondStack       = NULL;
+    pThis->fIf0Mode         = false;
+    pThis->fJustDroppedLine = false;
+    pThis->fMaybePreprocessorLine = true;
+    VBCPP_BITMAP_EMPTY(pThis->bmDefined);
+    pThis->cCondStackDepth  = 0;
+    pThis->pInputStack      = NULL;
+    RT_ZERO(pThis->StrmOutput);
+    pThis->rcExit           = RTEXITCODE_SUCCESS;
+    pThis->fStrmOutputValid = false;
+}
+
+
+
+int main(int argc, char **argv)
+{
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_FAILURE(rc))
+        return RTMsgInitFailure(rc);
+
+    /*
+     * Do the job.  The code says it all.
+     */
+    VBCPP This;
+    vbcppInit(&This);
+    bool fExit;
+    RTEXITCODE rcExit = vbcppParseOptions(&This, argc, argv, &fExit);
+    if (!fExit && rcExit == RTEXITCODE_SUCCESS)
+    {
+        rcExit = vbcppOpenStreams(&This);
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = vbcppPreprocess(&This);
+    }
+
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = vbcppTerm(&This);
+    else
+        vbcppTerm(&This);
+    return rcExit;
+}
+
diff --git a/src/bldprogs/VBoxCheckImports.cpp b/src/bldprogs/VBoxCheckImports.cpp
new file mode 100644
index 00000000..42dd40c0
--- /dev/null
+++ b/src/bldprogs/VBoxCheckImports.cpp
@@ -0,0 +1,381 @@
+/* $Id: VBoxCheckImports.cpp $ */
+/** @file
+ * IPRT - Checks that a windows image only imports from a given set of DLLs.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/formats/mz.h>
+#include <iprt/formats/pecoff.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct
+{
+    const char *pszImage;
+    FILE       *pFile;
+    bool        f32Bit;
+    union
+    {
+        IMAGE_NT_HEADERS32 Nt32;
+        IMAGE_NT_HEADERS64 Nt64;
+    } Hdrs;
+
+    uint32_t                cSections;
+    PIMAGE_SECTION_HEADER   paSections;
+} MYIMAGE;
+
+
+static bool Failed(MYIMAGE *pThis, const char *pszFmt, ...)
+{
+    va_list va;
+    fprintf(stderr, "error '%s': ", pThis->pszImage);
+    va_start(va, pszFmt);
+    vfprintf(stderr, pszFmt, va);
+    va_end(va);
+    fprintf(stderr, "\n");
+    return false;
+}
+
+
+static bool ReadPeHeaders(MYIMAGE *pThis)
+{
+    /*
+     * MZ header.
+     */
+    IMAGE_DOS_HEADER MzHdr;
+    if (fread(&MzHdr, sizeof(MzHdr), 1, pThis->pFile) != 1)
+        return Failed(pThis, "Reading DOS header");
+
+    if (MzHdr.e_magic != IMAGE_DOS_SIGNATURE)
+        return Failed(pThis, "No MZ magic (found %#x)", MzHdr.e_magic);
+
+    if (fseek(pThis->pFile, MzHdr.e_lfanew, SEEK_SET) != 0)
+        return Failed(pThis, "Seeking to %#lx", (unsigned long)MzHdr.e_lfanew);
+
+    /*
+     * NT signature + file header.
+     */
+    if (fread(&pThis->Hdrs.Nt32, offsetof(IMAGE_NT_HEADERS32, OptionalHeader), 1, pThis->pFile) != 1)
+        return Failed(pThis, "Reading NT file header");
+
+    if (pThis->Hdrs.Nt32.Signature != IMAGE_NT_SIGNATURE)
+        return Failed(pThis, "No PE magic (found %#x)", pThis->Hdrs.Nt32.Signature);
+
+    if (pThis->Hdrs.Nt32.FileHeader.SizeOfOptionalHeader == sizeof(pThis->Hdrs.Nt32.OptionalHeader))
+        pThis->f32Bit = true;
+    else if (pThis->Hdrs.Nt32.FileHeader.SizeOfOptionalHeader == sizeof(pThis->Hdrs.Nt64.OptionalHeader))
+        pThis->f32Bit = false;
+    else
+        return Failed(pThis, "Unsupported SizeOfOptionalHeaders value: %#x",
+                      pThis->Hdrs.Nt32.FileHeader.SizeOfOptionalHeader);
+
+    /*
+     * NT optional header.
+     */
+    if (fread(&pThis->Hdrs.Nt32.OptionalHeader, pThis->Hdrs.Nt32.FileHeader.SizeOfOptionalHeader, 1, pThis->pFile) != 1)
+        return Failed(pThis, "Reading NT optional header");
+
+    if (   pThis->Hdrs.Nt32.OptionalHeader.Magic
+        != (pThis->f32Bit ? IMAGE_NT_OPTIONAL_HDR32_MAGIC : IMAGE_NT_OPTIONAL_HDR64_MAGIC) )
+        return Failed(pThis, "Bad optional header magic: %#x", pThis->Hdrs.Nt32.OptionalHeader.Magic);
+
+    uint32_t NumberOfRvaAndSizes = pThis->f32Bit
+                                 ? pThis->Hdrs.Nt32.OptionalHeader.NumberOfRvaAndSizes
+                                 : pThis->Hdrs.Nt64.OptionalHeader.NumberOfRvaAndSizes;
+    if (NumberOfRvaAndSizes != IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
+        return Failed(pThis, "Unsupported NumberOfRvaAndSizes value: %#x", NumberOfRvaAndSizes);
+
+    /*
+     * Read the section table.
+     */
+    pThis->cSections  = pThis->Hdrs.Nt32.FileHeader.NumberOfSections;
+    if (!pThis->cSections)
+        return Failed(pThis, "No sections in image!");
+    pThis->paSections = (PIMAGE_SECTION_HEADER)calloc(sizeof(pThis->paSections[0]), pThis->cSections);
+    if (!pThis->paSections)
+        return Failed(pThis, "Out of memory!");
+    if (fread(pThis->paSections, sizeof(pThis->paSections[0]), pThis->cSections, pThis->pFile) != pThis->cSections)
+        return Failed(pThis, "Reading NT section headers");
+
+
+    return true;
+}
+
+
+static bool ReadAtRva(MYIMAGE *pThis, uint32_t uRva, void *pvBuf, size_t cbToRead)
+{
+    unsigned const uRvaOrg     = uRva;
+    size_t   const cbToReadOrg = cbToRead;
+
+    /*
+     * Header section.
+     */
+    int      iSh        = -1;
+    uint32_t uSectRva   = 0;
+    uint32_t offSectRaw = 0;
+    uint32_t cbSectRaw  = pThis->f32Bit
+                        ? pThis->Hdrs.Nt32.OptionalHeader.SizeOfHeaders
+                        : pThis->Hdrs.Nt64.OptionalHeader.SizeOfHeaders;
+    uint32_t cbSectMax  = pThis->paSections[0].VirtualAddress;
+
+    for (;;)
+    {
+        /* Read if we've got a match. */
+        uint32_t off = uRva - uSectRva;
+        if (off < cbSectMax)
+        {
+            uint32_t cbThis = cbSectMax - off;
+            if (cbThis > cbToRead)
+                cbThis = (uint32_t)cbToRead;
+
+            memset(pvBuf, 0, cbThis);
+
+            if (off < cbSectRaw)
+            {
+                if (fseek(pThis->pFile, offSectRaw + off, SEEK_SET) != 0)
+                    return Failed(pThis, "Seeking to %#x", offSectRaw + off);
+                if (fread(pvBuf, RT_MIN(cbThis, cbSectRaw - off), 1, pThis->pFile) != 1)
+                    return Failed(pThis, "Reading %u bytes at %#x", RT_MIN(cbThis, cbSectRaw - off), offSectRaw + off);
+            }
+
+            cbToRead -= cbThis;
+            if (!cbToRead)
+                return true;
+            uRva += cbThis;
+            pvBuf = (uint8_t *)pvBuf + cbThis;
+        }
+
+        /* next section */
+        iSh++;
+        if ((unsigned)iSh >= pThis->cSections)
+            return Failed(pThis, "RVA %#x LB %u is outside the image", uRvaOrg, cbToReadOrg);
+        uSectRva   = pThis->paSections[iSh].VirtualAddress;
+        offSectRaw = pThis->paSections[iSh].PointerToRawData;
+        cbSectRaw  = pThis->paSections[iSh].SizeOfRawData;
+        if ((unsigned)iSh + 1 < pThis->cSections)
+            cbSectMax = pThis->paSections[iSh + 1].VirtualAddress - uSectRva;
+        else
+            cbSectMax = pThis->paSections[iSh].Misc.VirtualSize;
+    }
+}
+
+
+static bool ReadStringAtRva(MYIMAGE *pThis, uint32_t uRva, char *pszBuf, size_t cbMax)
+{
+    uint32_t const uRvaOrg = uRva;
+
+    /*
+     * Try read the whole string at once.
+     */
+    uint32_t cbImage = pThis->f32Bit
+                     ? pThis->Hdrs.Nt32.OptionalHeader.SizeOfImage
+                     : pThis->Hdrs.Nt64.OptionalHeader.SizeOfImage;
+    uint32_t cbThis = uRva < cbImage ? cbImage - uRva : 1;
+    if (cbThis > cbMax)
+        cbThis = (uint32_t)cbMax;
+    if (!ReadAtRva(pThis, uRva, pszBuf, cbThis))
+        return false;
+    if (memchr(pszBuf, 0, cbThis) != NULL)
+        return true;
+
+    /*
+     * Read more, byte-by-byte.
+     */
+    for (;;)
+    {
+        cbMax -= cbThis;
+        if (!cbMax)
+            return Failed(pThis, "String to long at %#x", uRvaOrg);
+        pszBuf += cbThis;
+        uRva   += cbThis;
+
+        cbThis = 1;
+        if (!ReadAtRva(pThis, uRva, pszBuf, cbThis))
+            return false;
+        if (!*pszBuf)
+            return true;
+    }
+}
+
+
+static void *ReadAtRvaAlloc(MYIMAGE *pThis, uint32_t uRva, size_t cbToRead)
+{
+    void *pvBuf = malloc(cbToRead);
+    if (pvBuf)
+    {
+        if (ReadAtRva(pThis, uRva, pvBuf, cbToRead))
+            return pvBuf;
+        free(pvBuf);
+    }
+    else
+        Failed(pThis, "Out of memory!");
+    return NULL;
+}
+
+
+static bool ParseAndCheckImports(MYIMAGE *pThis,  const char **papszAllowed, unsigned cAllowed)
+{
+    /*
+     * Do we have an import directory? If so, read it.
+     */
+    IMAGE_DATA_DIRECTORY ImpDir = pThis->f32Bit
+                                ? pThis->Hdrs.Nt32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
+                                : pThis->Hdrs.Nt64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
+    if (ImpDir.Size == 0)
+        return true;
+
+    uint32_t cImps = ImpDir.Size / sizeof(IMAGE_IMPORT_DESCRIPTOR);
+    if (cImps * sizeof(IMAGE_IMPORT_DESCRIPTOR) != ImpDir.Size)
+        return Failed(pThis, "Import directory size is not a multiple of IMAGE_IMPORT_DESCRIPTOR: %#x", ImpDir.Size);
+
+    PIMAGE_IMPORT_DESCRIPTOR paImps = (PIMAGE_IMPORT_DESCRIPTOR)ReadAtRvaAlloc(pThis, ImpDir.VirtualAddress, ImpDir.Size);
+    if (!paImps)
+        return false;
+
+    /* There is usually an empty entry at the end. */
+    if (   paImps[cImps - 1].Name       == 0
+        || paImps[cImps - 1].FirstThunk == 0)
+           cImps--;
+
+    /*
+     * Do the processing.
+     */
+    bool fRc = true;
+    for (uint32_t i = 0; i < cImps; i++)
+    {
+        /* Read the import name string. */
+        char szName[128];
+        if (!ReadStringAtRva(pThis, paImps[i].Name, szName, sizeof(szName)))
+        {
+            fRc = false;
+            break;
+        }
+
+        /* Check it against the list of allowed DLLs. */
+        bool fFound = false;
+        unsigned j = cAllowed;
+        while (j-- > 0)
+            if (stricmp(papszAllowed[j], szName) == 0)
+            {
+                fFound = true;
+                break;
+            }
+        if (!fFound)
+            fRc = Failed(pThis, "Illegal import: '%s'", szName);
+    }
+
+    free(paImps);
+    return fRc;
+}
+
+
+static int usage(const char *argv0)
+{
+    printf("usage: %s --image <image> [allowed-dll [..]]\n", argv0);
+    return RTEXITCODE_SUCCESS;
+}
+
+
+int main(int argc, char **argv)
+{
+    /*
+     * Parse arguments.
+     */
+    const char  *pszImage     = NULL;
+    const char **papszAllowed = (const char **)calloc(argc, sizeof(const char *));
+    unsigned     cAllowed     = 0;
+
+    for (int i = 1; i < argc; i++)
+    {
+        const char *psz = argv[i];
+        if (*psz == '-')
+        {
+            if (!strcmp(psz, "--image") || !strcmp(psz, "-i"))
+            {
+                if (++i >= argc)
+                {
+                    fprintf(stderr, "syntax error: File name expected after '%s'.\n", psz);
+                    return RTEXITCODE_SYNTAX;
+                }
+                pszImage = argv[i];
+            }
+            else if (   !strcmp(psz, "--help")
+                     || !strcmp(psz, "-help")
+                     || !strcmp(psz, "-h")
+                     || !strcmp(psz, "-?") )
+                return usage(argv[0]);
+            else if (   !strcmp(psz, "--version")
+                     || !strcmp(psz, "-V"))
+            {
+                printf("$Revision: 155244 $\n");
+                return RTEXITCODE_SUCCESS;
+            }
+            else
+            {
+                fprintf(stderr, "syntax error: Unknown option '%s'.\n", psz);
+                return RTEXITCODE_SYNTAX;
+            }
+        }
+        else
+            papszAllowed[cAllowed++] = argv[i];
+    }
+
+    if (!pszImage)
+    {
+        fprintf(stderr, "syntax error: No input file specified.\n");
+        return RTEXITCODE_SYNTAX;
+    }
+
+    /*
+     * Open the image and process headers.
+     */
+    RTEXITCODE  rcExit = RTEXITCODE_FAILURE;
+    MYIMAGE     MyImage;
+    memset(&MyImage, 0, sizeof(MyImage));
+    MyImage.pszImage = pszImage;
+    MyImage.pFile     = fopen(pszImage, "rb");
+    if (MyImage.pFile)
+    {
+        if (   ReadPeHeaders(&MyImage)
+            && ParseAndCheckImports(&MyImage, papszAllowed, cAllowed))
+               rcExit = RTEXITCODE_SUCCESS;
+
+        fclose(MyImage.pFile);
+        free(MyImage.paSections);
+    }
+    else
+        Failed(&MyImage, "Failed to open image for binary reading.");
+
+    return rcExit;
+}
+
diff --git a/src/bldprogs/VBoxCmp.cpp b/src/bldprogs/VBoxCmp.cpp
new file mode 100644
index 00000000..c4f08950
--- /dev/null
+++ b/src/bldprogs/VBoxCmp.cpp
@@ -0,0 +1,141 @@
+/* $Id: VBoxCmp.cpp $ */
+/** @file
+ * File Compare - Compares two files byte by byte.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <iprt/string.h>
+#include <iprt/stdarg.h>
+
+
+/**
+ * Writes an error message.
+ *
+ * @returns RTEXITCODE_FAILURE.
+ * @param   pcszFormat          Error message.
+ * @param   ...                 Format argument referenced in the message.
+ */
+static RTEXITCODE printErr(const char *pcszFormat, ...)
+{
+    va_list va;
+
+    fprintf(stderr, "VBoxCmp: ");
+    va_start(va, pcszFormat);
+    vfprintf(stderr, pcszFormat, va);
+    va_end(va);
+
+    return RTEXITCODE_FAILURE;
+}
+
+
+static FILE *openFile(const char *pszFile)
+{
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+    FILE *pFile = fopen(pszFile, "rb");
+#else
+    FILE *pFile = fopen(pszFile, "r");
+#endif
+    if (!pFile)
+        printErr("Failed to open '%s': %s\n", pszFile, strerror(errno));
+    return pFile;
+}
+
+
+static RTEXITCODE compareFiles(FILE *pFile1, FILE *pFile2)
+{
+    if (!pFile1 || !pFile2)
+        return RTEXITCODE_FAILURE;
+
+    uint32_t    cMismatches = 1;
+    RTEXITCODE  rcRet       = RTEXITCODE_SUCCESS;
+    uint64_t    off         = 0;
+    for (;;)
+    {
+        uint8_t b1;
+        size_t cb1 = fread(&b1, sizeof(b1), 1, pFile1);
+        uint8_t b2;
+        size_t cb2 = fread(&b2, sizeof(b2), 1, pFile2);
+        if (cb1 != 1 || cb2 != 1)
+            break;
+        if (b1 != b2)
+        {
+            printErr("0x%x%08x: %#04x (%3d) != %#04x (%3d)\n", (uint32_t)(off >> 32), (uint32_t)off, b1, b1, b2, b2);
+            rcRet = RTEXITCODE_FAILURE;
+            cMismatches++;
+            if (cMismatches > 128)
+            {
+                printErr("Too many mismatches, giving up\n");
+                return rcRet;
+            }
+        }
+        off++;
+    }
+
+    if (!feof(pFile1) || !feof(pFile2))
+    {
+        if (!feof(pFile1) && ferror(pFile1))
+            rcRet = printErr("Read error on file #1.\n");
+        else if (!feof(pFile2) && ferror(pFile2))
+            rcRet = printErr("Read error on file #2.\n");
+        else if (!feof(pFile2))
+            rcRet = printErr("0x%x%08x: file #1 ends before file #2\n", (uint32_t)(off >> 32), (uint32_t)off);
+        else
+            rcRet = printErr("0x%x%08x: file #2 ends before file #1\n", (uint32_t)(off >> 32), (uint32_t)off);
+    }
+
+    return rcRet;
+}
+
+
+int main(int argc, char *argv[])
+{
+    RTEXITCODE rcExit;
+
+    if (argc == 3)
+    {
+        const char *pszFile1 = argv[1];
+        const char *pszFile2 = argv[2];
+        FILE       *pFile1 = openFile(pszFile1);
+        FILE       *pFile2 = openFile(pszFile2);
+        rcExit = compareFiles(pFile1, pFile2);
+        if (pFile1)
+            fclose(pFile1);
+        if (pFile2)
+            fclose(pFile2);
+    }
+    else
+        rcExit = printErr("Syntax error: usage: VBoxCmp <file1> <file2>\n");
+    return rcExit;
+}
+
diff --git a/src/bldprogs/VBoxCompilerPlugIns.h b/src/bldprogs/VBoxCompilerPlugIns.h
new file mode 100644
index 00000000..9f521449
--- /dev/null
+++ b/src/bldprogs/VBoxCompilerPlugIns.h
@@ -0,0 +1,137 @@
+/* $Id: VBoxCompilerPlugIns.h $ */
+/** @file
+ * VBoxCompilerPlugIns - Types, Prototypes and Macros common to the VBox compiler plug-ins.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_bldprogs_VBoxCompilerPlugIns_h
+#define VBOX_INCLUDED_SRC_bldprogs_VBoxCompilerPlugIns_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/types.h>
+#include <stdio.h>
+
+
+/** @def dprintf
+ * Macro for debug printing using fprintf.  Only active when DEBUG is defined.
+ */
+#ifdef DEBUG
+# define dprintf(...) do { fprintf(stderr, __VA_ARGS__); } while (0)
+#else
+# define dprintf(...) do { } while (0)
+#endif
+
+
+/**
+ * Checker state.
+ */
+typedef struct VFMTCHKSTATE
+{
+    long            iFmt;
+    long            iArgs;
+    const char     *pszFmt;
+    bool            fMaybeNull;
+#if defined(__GNUC__) && !defined(VBOX_COMPILER_PLUG_IN_AGNOSTIC)
+# if RT_GNUC_PREREQ(6, 0)
+    gimple const   *hStmt;
+# else
+    gimple          hStmt;
+# endif
+    location_t      hFmtLoc;
+#endif
+} VFMTCHKSTATE;
+/** Pointer to my checker state. */
+typedef VFMTCHKSTATE *PVFMTCHKSTATE;
+
+#define MYSTATE_FMT_FILE(a_pState)      VFmtChkGetFmtLocFile(a_pState)
+#define MYSTATE_FMT_LINE(a_pState)      VFmtChkGetFmtLocLine(a_pState)
+#define MYSTATE_FMT_COLUMN(a_pState)    VFmtChkGetFmtLocColumn(a_pState)
+
+const char     *VFmtChkGetFmtLocFile(PVFMTCHKSTATE pState);
+
+unsigned int    VFmtChkGetFmtLocLine(PVFMTCHKSTATE pState);
+
+unsigned int    VFmtChkGetFmtLocColumn(PVFMTCHKSTATE pState);
+
+/**
+ * Implements checking format string replacement (%M).
+ *
+ * Caller will have checked all that can be checked.  This means that there is a
+ * string argument present, or it won't make the call.
+ *
+ * @param   pState              The format string checking state.
+ * @param   pszPctM             The position of the '%M'.
+ * @param   iArg                The next argument number.
+ */
+void            VFmtChkHandleReplacementFormatString(PVFMTCHKSTATE pState, const char *pszPctM, unsigned iArg);
+
+/**
+ * Warning.
+ *
+ * @returns
+ * @param   pState              .
+ * @param   pszLoc              .
+ * @param   pszFormat           .
+ * @param   ...                 .
+ */
+void            VFmtChkWarnFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...);
+
+/**
+ * Error.
+ *
+ * @returns
+ * @param   pState              .
+ * @param   pszLoc              .
+ * @param   pszFormat           .
+ * @param   ...                 .
+ */
+void            VFmtChkErrFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...);
+
+/**
+ * Checks that @a iFmtArg isn't present or a valid final dummy argument.
+ *
+ * Will issue warning/error if there are more arguments at @a iFmtArg.
+ *
+ * @param   pState              The format string checking state.
+ * @param   iArg                The index of the end of arguments, this is
+ *                              relative to VFMTCHKSTATE::iArgs.
+ */
+void            VFmtChkVerifyEndOfArgs(PVFMTCHKSTATE pState, unsigned iArg);
+
+bool            VFmtChkRequirePresentArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage);
+
+bool            VFmtChkRequireIntArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage);
+
+bool            VFmtChkRequireStringArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage);
+
+bool            VFmtChkRequireVaListPtrArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage);
+
+/* VBoxCompilerPlugInsCommon.cpp */
+void            MyCheckFormatCString(PVFMTCHKSTATE pState, const char *pszFmt);
+
+
+#endif /* !VBOX_INCLUDED_SRC_bldprogs_VBoxCompilerPlugIns_h */
+
diff --git a/src/bldprogs/VBoxCompilerPlugInsCommon.cpp b/src/bldprogs/VBoxCompilerPlugInsCommon.cpp
new file mode 100644
index 00000000..071e9951
--- /dev/null
+++ b/src/bldprogs/VBoxCompilerPlugInsCommon.cpp
@@ -0,0 +1,448 @@
+/* $Id: VBoxCompilerPlugInsCommon.cpp $ */
+/** @file
+ * VBoxCompilerPlugInsCommon - Code common to the compiler plug-ins.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define VBOX_COMPILER_PLUG_IN_AGNOSTIC
+#include "VBoxCompilerPlugIns.h"
+
+#include <iprt/string.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define MY_ISDIGIT(c) ((c) >= '0' && (c) <= '9')
+
+/** @name RTSTR_Z_XXX - Size modifiers
+ * @{ */
+#define RTSTR_Z_DEFAULT         UINT16_C(0x0001)
+#define RTSTR_Z_LONG            UINT16_C(0x0002) /**< l */
+#define RTSTR_Z_LONGLONG        UINT16_C(0x0004) /**< ll, L, q. */
+#define RTSTR_Z_HALF            UINT16_C(0x0008) /**< h */
+#define RTSTR_Z_HALFHALF        UINT16_C(0x0010) /**< hh (internally H) */
+#define RTSTR_Z_SIZE            UINT16_C(0x0020) /**< z */
+#define RTSTR_Z_PTRDIFF         UINT16_C(0x0040) /**< t */
+#define RTSTR_Z_INTMAX          UINT16_C(0x0080) /**< j */
+#define RTSTR_Z_MS_I32          UINT16_C(0x1000) /**< I32 */
+#define RTSTR_Z_MS_I64          UINT16_C(0x2000) /**< I64 */
+#define RTSTR_Z_ALL_INT         UINT16_C(0x30fe) /**< short hand for integers. */
+/** @} */
+
+
+/** @name VFMTCHKTYPE_F_XXX - Type flags.
+ * @{ */
+/** Pointers type. */
+#define VFMTCHKTYPE_F_PTR       UINT8_C(0x01)
+/** Both const and non-const pointer types. */
+#define VFMTCHKTYPE_F_CPTR      (UINT8_C(0x02) | VFMTCHKTYPE_F_PTR)
+/** @} */
+
+/** @name VFMTCHKTYPE_Z_XXX - Special type sizes
+ * @{ */
+#define VFMTCHKTYPE_Z_CHAR       UINT8_C(0xe0)
+#define VFMTCHKTYPE_Z_SHORT      UINT8_C(0xe1)
+#define VFMTCHKTYPE_Z_INT        UINT8_C(0xe2)
+#define VFMTCHKTYPE_Z_LONG       UINT8_C(0xe3)
+#define VFMTCHKTYPE_Z_LONGLONG   UINT8_C(0xe4)
+#define VFMTCHKTYPE_Z_PTR        UINT8_C(0xe5) /**< ASSUMED to be the same for 'void *', 'size_t' and 'ptrdiff_t'. */
+/** @} */
+
+/** @name VFMTCHKTYPE_NM_XXX - Standard C type names.
+ * @{ */
+#define VFMTCHKTYPE_NM_INT          "int"
+#define VFMTCHKTYPE_NM_UINT         "unsigned int"
+#define VFMTCHKTYPE_NM_LONG         "long"
+#define VFMTCHKTYPE_NM_ULONG        "unsigned long"
+#define VFMTCHKTYPE_NM_LONGLONG     "long long"
+#define VFMTCHKTYPE_NM_ULONGLONG    "unsigned long long"
+#define VFMTCHKTYPE_NM_SHORT        "short"
+#define VFMTCHKTYPE_NM_USHORT       "unsigned short"
+#define VFMTCHKTYPE_NM_CHAR         "char"
+#define VFMTCHKTYPE_NM_SCHAR        "signed char"
+#define VFMTCHKTYPE_NM_UCHAR        "unsigned char"
+/** @} */
+
+
+/** @name VFMTCHKDESC_F_XXX - Format descriptor flags.
+ * @{ */
+#define VFMTCHKDESC_F_NONE          UINT32_C(0)
+#define VFMTCHKDESC_F_SIGNED        RT_BIT_32(0)
+#define VFMTCHKDESC_F_UNSIGNED      RT_BIT_32(1)
+/** @} */
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Format check type entry.
+ */
+typedef struct VFMTCHKTYPE
+{
+    /** The format size flag(s). */
+    uint16_t        fSize;
+    /** The argument size. */
+    uint8_t         cbArg;
+    /** Argument flags (VFMTCHKTYPE_F_XXX). */
+    uint8_t         fFlags;
+    /** List of strings with acceptable types, if NULL only check the sizes. */
+    const char      *pszzTypeNames;
+} VFMTCHKTYPE;
+/** Pointer to a read only format check type entry. */
+typedef VFMTCHKTYPE const *PCVFMTCHKTYPE;
+
+/** For use as an initializer in VFMTCHKDESK where it indicates that
+ * everything is covered by VFMTCHKDESC::paMoreTypes.   Useful for repeating
+ * stuff. */
+#define VFMTCHKTYPE_USE_MORE_TYPES  { 0, 0, 0, NULL }
+
+/**
+ * Format type descriptor.
+ */
+typedef struct VFMTCHKDESC
+{
+    /** The format type. */
+    const char     *pszType;
+    /** Recognized format flags (RTSTR_F_XXX).  */
+    uint16_t        fFmtFlags;
+    /** Recognized format sizes (RTSTR_Z_XXX). */
+    uint16_t        fFmtSize;
+    /** Flags (VFMTCHKDESC_F_XXX).  */
+    uint32_t        fFlags;
+    /** Primary type. */
+    VFMTCHKTYPE     Type;
+    /** More recognized types (optional).   */
+    PCVFMTCHKTYPE   paMoreTypes;
+} VFMTCHKDESC;
+typedef VFMTCHKDESC const *PCVFMTCHKDESC;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Integer type specs for 'x', 'd', 'u', 'i', ++
+ *
+ * @todo RTUINT32U and friends...  The whole type matching thing.
+ */
+static VFMTCHKTYPE const g_aIntTypes[] =
+{
+    {   RTSTR_Z_DEFAULT,        VFMTCHKTYPE_Z_INT,      0, VFMTCHKTYPE_NM_INT "\0"      VFMTCHKTYPE_NM_UINT "\0" },
+    {   RTSTR_Z_LONG,           VFMTCHKTYPE_Z_LONG,     0, VFMTCHKTYPE_NM_LONG "\0"     VFMTCHKTYPE_NM_ULONG "\0" },
+    {   RTSTR_Z_LONGLONG,       VFMTCHKTYPE_Z_LONGLONG, 0, VFMTCHKTYPE_NM_LONGLONG "\0" VFMTCHKTYPE_NM_ULONGLONG "\0" },
+    {   RTSTR_Z_HALF,           VFMTCHKTYPE_Z_SHORT,    0, VFMTCHKTYPE_NM_SHORT "\0"    VFMTCHKTYPE_NM_USHORT "\0" },
+    {   RTSTR_Z_HALFHALF,       VFMTCHKTYPE_Z_CHAR,     0, VFMTCHKTYPE_NM_SCHAR "\0"    VFMTCHKTYPE_NM_UCHAR "\0" VFMTCHKTYPE_NM_CHAR "\0" },
+    {   RTSTR_Z_SIZE,           VFMTCHKTYPE_Z_PTR,      0, "size_t\0"    "RTUINTPTR\0"  "RTINTPTR\0" },
+    {   RTSTR_Z_PTRDIFF,        VFMTCHKTYPE_Z_PTR,      0, "ptrdiff_t\0" "RTUINTPTR\0"  "RTINTPTR\0" },
+    {   RTSTR_Z_INTMAX,         VFMTCHKTYPE_Z_PTR,      0, "uint64_t\0" "int64_t\0" "RTUINT64U\0" VFMTCHKTYPE_NM_LONGLONG "\0" VFMTCHKTYPE_NM_ULONGLONG "\0" },
+    {   RTSTR_Z_MS_I32,         sizeof(uint32_t),       0, "uint32_t\0" "int32_t\0" "RTUINT32U\0" },
+    {   RTSTR_Z_MS_I64,         sizeof(uint64_t),       0, "uint64_t\0" "int64_t\0" "RTUINT64U\0" },
+};
+
+/** String type specs for 's', 'ls' and 'Ls'.
+ */
+static VFMTCHKTYPE const g_aStringTypes[] =
+{
+    {   RTSTR_Z_DEFAULT,        VFMTCHKTYPE_Z_PTR,      VFMTCHKTYPE_F_CPTR, VFMTCHKTYPE_NM_CHAR "\0" },
+    {   RTSTR_Z_LONG,           VFMTCHKTYPE_Z_PTR,      VFMTCHKTYPE_F_CPTR, "RTUTF16\0" },
+    {   RTSTR_Z_LONGLONG,       VFMTCHKTYPE_Z_PTR,      VFMTCHKTYPE_F_CPTR, "RTUNICP\0" },
+};
+
+static VFMTCHKDESC const g_aFmtDescs[] =
+{
+    {   "s",
+        RTSTR_F_LEFT | RTSTR_F_WIDTH | RTSTR_F_PRECISION,
+        RTSTR_Z_DEFAULT | RTSTR_Z_LONG | RTSTR_Z_LONGLONG,
+        VFMTCHKDESC_F_UNSIGNED,
+        VFMTCHKTYPE_USE_MORE_TYPES,
+        g_aStringTypes
+    },
+    {   "x",
+        RTSTR_F_LEFT | RTSTR_F_ZEROPAD | RTSTR_F_SPECIAL | RTSTR_F_WIDTH | RTSTR_F_PRECISION,
+        RTSTR_Z_ALL_INT,
+        VFMTCHKDESC_F_UNSIGNED,
+        VFMTCHKTYPE_USE_MORE_TYPES,
+        g_aIntTypes
+    },
+    {   "RX32",
+        RTSTR_F_LEFT | RTSTR_F_ZEROPAD | RTSTR_F_SPECIAL | RTSTR_F_WIDTH | RTSTR_F_PRECISION,
+        RTSTR_Z_ALL_INT,
+        VFMTCHKDESC_F_UNSIGNED,
+        { RTSTR_Z_DEFAULT,      sizeof(uint32_t),       0, "uint32_t\0" "int32_t\0" },
+        NULL
+    },
+
+
+
+};
+
+
+/**
+ * Does the actual format string checking.
+ *
+ * @todo    Move this to different file common to both GCC and CLANG later.
+ *
+ * @param   pState              The format string checking state.
+ * @param   pszFmt              The format string.
+ */
+void MyCheckFormatCString(PVFMTCHKSTATE pState, const char *pszFmt)
+{
+    dprintf("checker2: \"%s\" at %s:%d col %d\n", pszFmt,
+            MYSTATE_FMT_FILE(pState), MYSTATE_FMT_LINE(pState), MYSTATE_FMT_COLUMN(pState));
+    pState->pszFmt = pszFmt;
+
+    unsigned iArg = 0;
+    for (;;)
+    {
+        /*
+         * Skip to the next argument.
+         * Quits the loop with the first char following the '%' in 'ch'.
+         */
+        char ch;
+        for (;;)
+        {
+            ch = *pszFmt++;
+            if (ch == '%')
+            {
+                ch = *pszFmt++;
+                if (ch != '%')
+                    break;
+            }
+            else if (ch == '\0')
+            {
+                VFmtChkVerifyEndOfArgs(pState, iArg);
+                return;
+            }
+        }
+        const char * const pszPct = pszFmt - 2;
+
+        /*
+         * Flags
+         */
+        uint32_t fFmtFlags = 0;
+        for (;;)
+        {
+            uint32_t fFlag;
+            switch (ch)
+            {
+                case '#':   fFlag = RTSTR_F_SPECIAL;      break;
+                case '-':   fFlag = RTSTR_F_LEFT;         break;
+                case '+':   fFlag = RTSTR_F_PLUS;         break;
+                case ' ':   fFlag = RTSTR_F_BLANK;        break;
+                case '0':   fFlag = RTSTR_F_ZEROPAD;      break;
+                case '\'':  fFlag = RTSTR_F_THOUSAND_SEP; break;
+                default:    fFlag = 0;                    break;
+            }
+            if (!fFlag)
+                break;
+            if (fFmtFlags & fFlag)
+                VFmtChkWarnFmt(pState, pszPct, "duplicate flag '%c'", ch);
+            fFmtFlags |= fFlag;
+            ch = *pszFmt++;
+        }
+
+        /*
+         * Width.
+         */
+        int cchWidth = -1;
+        if (MY_ISDIGIT(ch))
+        {
+            cchWidth = ch - '0';
+            while (   (ch = *pszFmt++) != '\0'
+                   && MY_ISDIGIT(ch))
+            {
+                cchWidth *= 10;
+                cchWidth += ch - '0';
+            }
+            fFmtFlags |= RTSTR_F_WIDTH;
+        }
+        else if (ch == '*')
+        {
+            VFmtChkRequireIntArg(pState, pszPct, iArg, "width should be an 'int' sized argument");
+            iArg++;
+            cchWidth = 0;
+            fFmtFlags |= RTSTR_F_WIDTH;
+            ch = *pszFmt++;
+        }
+
+        /*
+         * Precision
+         */
+        int cchPrecision = -1;
+        if (ch == '.')
+        {
+            ch = *pszFmt++;
+            if (MY_ISDIGIT(ch))
+            {
+                cchPrecision = ch - '0';
+                while (   (ch = *pszFmt++) != '\0'
+                       && MY_ISDIGIT(ch))
+                {
+                    cchPrecision *= 10;
+                    cchPrecision += ch - '0';
+                }
+            }
+            else if (ch == '*')
+            {
+                VFmtChkRequireIntArg(pState, pszPct, iArg, "precision should be an 'int' sized argument");
+                iArg++;
+                cchPrecision = 0;
+                ch = *pszFmt++;
+            }
+            else
+                VFmtChkErrFmt(pState, pszPct, "Missing precision value, only got the '.'");
+            if (cchPrecision < 0)
+            {
+                VFmtChkErrFmt(pState, pszPct, "Negative precision value: %d", cchPrecision);
+                cchPrecision = 0;
+            }
+            fFmtFlags |= RTSTR_F_PRECISION;
+        }
+
+        /*
+         * Argument size.
+         */
+        uint16_t fFmtSize = RTSTR_Z_DEFAULT;
+        switch (ch)
+        {
+            default:
+                fFmtSize = RTSTR_Z_DEFAULT;
+                break;
+
+            case 'z':
+                fFmtSize = RTSTR_Z_SIZE;
+                ch = *pszFmt++;
+                break;
+            case 'j':
+                fFmtSize = RTSTR_Z_INTMAX;
+                ch = *pszFmt++;
+                break;
+            case 't':
+                fFmtSize = RTSTR_Z_PTRDIFF;
+                ch = *pszFmt++;
+                break;
+
+            case 'l':
+                fFmtSize = RTSTR_Z_LONG;
+                ch = *pszFmt++;
+                if (ch == 'l')
+                {
+                    fFmtSize = RTSTR_Z_LONGLONG;
+                    ch = *pszFmt++;
+                }
+                break;
+
+            case 'q': /* Used on BSD platforms. */
+            case 'L':
+                fFmtSize = RTSTR_Z_LONGLONG;
+                ch = *pszFmt++;
+                break;
+
+            case 'h':
+                fFmtSize = RTSTR_Z_HALF;
+                ch = *pszFmt++;
+                if (ch == 'h')
+                {
+                    fFmtSize = RTSTR_Z_HALFHALF;
+                    ch = *pszFmt++;
+                }
+                break;
+
+            case 'I': /* Used by Win32/64 compilers. */
+                if (   pszFmt[0] == '6'
+                    && pszFmt[1] == '4')
+                {
+                    pszFmt += 2;
+                    fFmtSize = RTSTR_Z_MS_I64;
+                }
+                else if (   pszFmt[0] == '3'
+                         && pszFmt[1] == '2')
+                {
+                    pszFmt += 2;
+                    fFmtSize = RTSTR_Z_MS_I32;
+                }
+                else
+                {
+                    VFmtChkErrFmt(pState, pszFmt, "Unknow format type/size/flag 'I%c'", pszFmt[0]);
+                    fFmtSize = RTSTR_Z_INTMAX;
+                }
+                ch = *pszFmt++;
+                break;
+        }
+
+        /*
+         * The type.
+         */
+        switch (ch)
+        {
+            /*
+             * Nested extensions.
+             */
+            case 'M': /* replace the format string (not stacked yet). */
+            {
+                if (*pszFmt)
+                    VFmtChkErrFmt(pState, pszFmt, "Characters following '%%M' will be ignored");
+                if (fFmtSize != RTSTR_Z_DEFAULT)
+                    VFmtChkWarnFmt(pState, pszFmt, "'%%M' does not support any size flags (%#x)", fFmtSize);
+                if (fFmtFlags != 0)
+                    VFmtChkWarnFmt(pState, pszFmt, "'%%M' does not support any format flags (%#x)", fFmtFlags);
+                if (VFmtChkRequireStringArg(pState, pszPct, iArg, "'%M' expects a format string"))
+                    VFmtChkHandleReplacementFormatString(pState, pszPct, iArg);
+                return;
+            }
+
+            case 'N': /* real nesting. */
+            {
+                if (fFmtSize != RTSTR_Z_DEFAULT)
+                    VFmtChkWarnFmt(pState, pszFmt, "'%%N' does not support any size flags (%#x)", fFmtSize);
+                if (fFmtFlags != 0)
+                    VFmtChkWarnFmt(pState, pszFmt, "'%%N' does not support any format flags (%#x)", fFmtFlags);
+                VFmtChkRequireStringArg(pState, pszPct, iArg,        "'%N' expects a string followed by a va_list pointer");
+                VFmtChkRequireVaListPtrArg(pState, pszPct, iArg + 1, "'%N' expects a string followed by a va_list pointer");
+                iArg += 2;
+                break;
+            }
+
+            case 'R':
+                if (   pszFmt[0] == 'h'
+                    && pszFmt[1] == 'X')
+                {
+                    VFmtChkRequirePresentArg(pState, pszPct, iArg, "Expected argument");
+                    iArg++;
+                }
+                RT_FALL_THROUGH();
+
+            default:
+                VFmtChkRequirePresentArg(pState, pszPct, iArg, "Expected argument");
+                iArg++;
+                break;
+        }
+    }
+}
+
diff --git a/src/bldprogs/VBoxCompilerPlugInsGcc.cpp b/src/bldprogs/VBoxCompilerPlugInsGcc.cpp
new file mode 100644
index 00000000..04a0a133
--- /dev/null
+++ b/src/bldprogs/VBoxCompilerPlugInsGcc.cpp
@@ -0,0 +1,1012 @@
+/* $Id: VBoxCompilerPlugInsGcc.cpp $ */
+/** @file
+ * gccplugin - GCC plugin for checking IPRT format strings.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <stdio.h>
+#include <iprt/cdefs.h>
+#include <iprt/stdarg.h>
+
+#if RT_GNUC_PREREQ(5, 1)
+# include "gcc-plugin.h"
+# include "plugin-version.h"
+#endif
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
+# include "gmp.h"
+extern "C" {
+#endif
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
+# include "coretypes.h"
+#endif
+#include "plugin.h"
+#include "basic-block.h"
+#include "tree.h"
+#include "tree-pass.h"
+#if __GNUC__ == 5 && __GNUC_MINOR__ == 4
+# include "tree-ssa-alias.h"
+# include "gimple-expr.h"
+#endif
+#include "gimple.h"
+#if RT_GNUC_PREREQ(4, 9)
+# include "gimple-iterator.h"
+# include "context.h" /* for g */
+#endif
+#include "cp/cp-tree.h"
+#if RT_GNUC_PREREQ(10, 0)
+# include "stringpool.h"
+# include "attribs.h"
+#endif
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
+}
+#endif
+
+#include "VBoxCompilerPlugIns.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** License indicator. */
+int plugin_is_GPL_compatible;
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Convencience macro not present in earlier gcc versions. */
+#ifndef VAR_P
+# define VAR_P(a_hNode) (TREE_CODE(a_hNode) == VAR_DECL)
+#endif
+/** Replacement for the 4.9.0 get_tree_code_name function. */
+#if !RT_GNUC_PREREQ(4, 9)
+# define get_tree_code_name(a_enmTreeCode) (tree_code_name[a_enmTreeCode])
+#endif
+
+
+/** For use with messages.
+ * @todo needs some more work... Actually, seems we're a bit handicapped by
+ *       working on gimplified stuff. */
+#define MY_LOC(a_hPreferred, a_pState) EXPR_LOC_OR_LOC(a_hPreferred, (a_pState)->hFmtLoc)
+
+/** @name Compatibility glue
+ * @{ */
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
+# define linemap_location_from_macro_expansion_p(a, b) false
+#endif
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
+static tree gimple_call_fntype(gimple hStmt)
+{
+    tree hDecl = gimple_call_fndecl(hStmt);
+    if (hDecl)
+        return TREE_TYPE(hDecl);
+    hDecl = gimple_call_fn(hStmt);
+    if (TREE_CODE(hDecl) == OBJ_TYPE_REF)
+        hDecl = OBJ_TYPE_REF_EXPR(hDecl);
+    if (DECL_P(hDecl))
+    {
+        tree hType = TREE_TYPE(hDecl);
+        if (POINTER_TYPE_P(hType))
+            hType = TREE_TYPE(hType);
+        return hType;
+    }
+    return NULL_TREE; /* caller bitches about this*/
+}
+#endif
+
+///* Integer to HOST_WIDE_INT conversion fun. */
+//#if RT_GNUC_PREREQ(4, 6)
+//# define MY_INT_FITS_SHWI(hNode)    (hNode).fits_shwi()
+//# define MY_INT_TO_SHWI(hNode)      (hNode).to_shwi()
+//#else
+//# define MY_INT_FITS_SHWI(hNode)    double_int_fits_in_shwi_p(hNode)
+//# define MY_INT_TO_SHWI(hNode)      double_int_to_shwi(hNode)
+//#endif
+
+/* Integer to HOST_WIDE_INT conversion fun. */
+#if RT_GNUC_PREREQ(5, 1)
+# define MY_DOUBLE_INT_FITS_SHWI(hNode)     tree_fits_shwi_p(hNode)
+# define MY_DOUBLE_INT_TO_SHWI(hNode)       tree_to_shwi(hNode)
+#elif RT_GNUC_PREREQ(4, 6)
+# define MY_DOUBLE_INT_FITS_SHWI(hNode)     (TREE_INT_CST(hNode).fits_shwi())
+# define MY_DOUBLE_INT_TO_SHWI(hNode)       (TREE_INT_CST(hNode).to_shwi())
+#else
+# define MY_DOUBLE_INT_FITS_SHWI(hNode)     double_int_fits_in_shwi_p(TREE_INT_CST(hNode))
+# define MY_DOUBLE_INT_TO_SHWI(hNode)       double_int_to_shwi(TREE_INT_CST(hNode))
+#endif
+
+#ifndef EXPR_LOC_OR_LOC
+# define EXPR_LOC_OR_LOC(a,b) (b)
+#endif
+/** @} */
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static bool             MyPassGateCallback(void);
+static unsigned int     MyPassExecuteCallback(void);
+static unsigned int     MyPassExecuteCallbackWithFunction(struct function *pFun);
+static tree             AttributeHandler(tree *, tree, tree, int, bool *);
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Plug-in info. */
+static const struct plugin_info g_PlugInInfo =
+{
+    version: "0.0.0-ALPHA",
+    help   : "Implements the __iprt_format__ attribute for checking format strings and arguments."
+};
+
+#if RT_GNUC_PREREQ(4, 9)
+
+/** My pass. */
+static const pass_data g_MyPassData =
+{
+    type                    : GIMPLE_PASS,
+    name                    : "*iprt-format-checks", /* asterisk = no dump */
+# if RT_GNUC_PREREQ(10, 0)
+    optinfo_flags           : OPTGROUP_NONE,
+# else
+    optinfo_flags           : 0,
+# endif
+    tv_id                   : TV_NONE,
+    properties_required     : 0,
+    properties_provided     : 0,
+    properties_destroyed    : 0,
+    todo_flags_start        : 0,
+    todo_flags_finish       : 0,
+};
+
+class MyPass : public gimple_opt_pass
+{
+public:
+    MyPass(gcc::context *pCtx) : gimple_opt_pass(g_MyPassData, pCtx)
+    { }
+
+    virtual bool gate(function *pFun)
+    {
+        NOREF(pFun);
+        return MyPassGateCallback();
+    }
+
+    virtual unsigned int execute(function *pFun)
+    {
+        NOREF(pFun);
+        return MyPassExecuteCallbackWithFunction(pFun);
+    }
+};
+
+#else /* < 4.9.0 */
+
+/** My pass. */
+static struct gimple_opt_pass g_MyPass =
+{
+    pass:
+    {
+        type                    : GIMPLE_PASS,
+        name                    : "*iprt-format-checks", /* asterisk = no dump */
+# if RT_GNUC_PREREQ(4, 6)
+        optinfo_flags           : 0,
+# endif
+        gate                    : MyPassGateCallback,
+        execute                 : MyPassExecuteCallback,
+        sub                     : NULL,
+        next                    : NULL,
+        static_pass_number      : 0,
+        tv_id                   : TV_NONE,
+        properties_required     : 0,
+        properties_provided     : 0,
+        properties_destroyed    : 0,
+        todo_flags_start        : 0,
+        todo_flags_finish       : 0,
+    }
+};
+
+/** The registration info for my pass. */
+static const struct register_pass_info  g_MyPassInfo =
+{
+    pass                        : &g_MyPass.pass,
+    reference_pass_name         : "ssa",
+    ref_pass_instance_number    : 1,
+    pos_op                      : PASS_POS_INSERT_BEFORE,
+};
+
+#endif /* < 4.9.0 */
+
+
+/** Attribute specifications. */
+static const struct attribute_spec g_AttribSpecs[] =
+{
+    {
+        name                    : "iprt_format",
+        min_length              : 2,
+        max_length              : 2,
+        decl_required           : false,
+        type_required           : true,
+        function_type_required  : true,
+// gcc 7.3 at least moves this field to after "handler", and with 8.3 it is back
+#if RT_GNUC_PREREQ(4, 6) && !(RT_GNUC_PREREQ(7, 0) && !RT_GNUC_PREREQ(8, 0))
+        affects_type_identity   : false,
+#endif
+        handler                 : AttributeHandler,
+#if RT_GNUC_PREREQ(7, 0) && !RT_GNUC_PREREQ(8, 0)
+        affects_type_identity   : false,
+#endif
+#if RT_GNUC_PREREQ(8, 0)
+        exclude                 : NULL,
+#endif
+    },
+    {
+        name                    : "iprt_format_maybe_null",
+        min_length              : 2,
+        max_length              : 2,
+        decl_required           : false,
+        type_required           : true,
+        function_type_required  : true,
+#if RT_GNUC_PREREQ(4, 6) && !(RT_GNUC_PREREQ(7, 0) && !RT_GNUC_PREREQ(8, 0))
+        affects_type_identity   : false,
+#endif
+        handler                 : AttributeHandler,
+#if RT_GNUC_PREREQ(7, 0) && !RT_GNUC_PREREQ(8, 0)
+        affects_type_identity   : false,
+#endif
+#if RT_GNUC_PREREQ(8, 0)
+        exclude                 : NULL,
+#endif
+    }
+};
+
+
+#ifdef DEBUG
+
+/**
+ * Debug function for printing the scope of a decl.
+ * @param   hDecl               Declaration to print scope for.
+ */
+static void dprintScope(tree hDecl)
+{
+# if 0 /* later? */
+    tree hScope = CP_DECL_CONTEXT(hDecl);
+    if (hScope == global_namespace)
+        return;
+    if (TREE_CODE(hScope) == RECORD_TYPE)
+        hScope = TYPE_NAME(hScope);
+
+    /* recurse */
+    dprintScope(hScope);
+
+    /* name the scope. */
+    dprintf("::%s", DECL_NAME(hScope) ? IDENTIFIER_POINTER(DECL_NAME(hScope)) : "<noname>");
+# endif
+}
+
+
+/**
+ * Debug function for printing a declaration.
+ * @param   hDecl               The declaration to print.
+ */
+static void dprintDecl(tree hDecl)
+{
+    enum tree_code const    enmDeclCode = TREE_CODE(hDecl);
+    tree const              hType       = TREE_TYPE(hDecl);
+    enum tree_code const    enmTypeCode = hType ? TREE_CODE(hType) : (enum tree_code)-1;
+#if 0
+    if (   enmTypeCode == RECORD_TYPE
+        && enmDeclCode == TYPE_DECL
+        && DECL_ARTIFICIAL(hDecl))
+        dprint_class(hType);
+#endif
+
+    dprintf("%s ", get_tree_code_name(enmDeclCode));
+    dprintScope(hDecl);
+    dprintf("::%s", DECL_NAME(hDecl) ? IDENTIFIER_POINTER(DECL_NAME(hDecl)) : "<noname>");
+    if (hType)
+        dprintf(" type %s", get_tree_code_name(enmTypeCode));
+    dprintf(" @%s:%d", DECL_SOURCE_FILE(hDecl),  DECL_SOURCE_LINE(hDecl));
+}
+
+#endif /* DEBUG */
+
+
+static location_t MyGetLocationPlusColumnOffset(location_t hLoc, unsigned int offColumn)
+{
+    /*
+     * Skip NOOPs, reserved locations and macro expansion.
+     */
+    if (   offColumn != 0
+        && hLoc >= RESERVED_LOCATION_COUNT
+        && !linemap_location_from_macro_expansion_p(line_table, hLoc))
+    {
+#if __GNUC__ >= 5 /** @todo figure this... */
+        /*
+         * There is an API for doing this, nice.
+         */
+        location_t hNewLoc = linemap_position_for_loc_and_offset(line_table, hLoc, offColumn);
+        if (hNewLoc && hNewLoc != hLoc)
+        {
+            dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u\n", hNewLoc, hLoc, offColumn);
+            return hNewLoc;
+        }
+
+#elif __GNUC_MINOR__ > 5
+        /*
+         * Have to do the job ourselves, it seems.  This is a bit hairy...
+         */
+        line_map const *pMap = NULL;
+        location_t hLoc2 = linemap_resolve_location(line_table, hLoc, LRK_SPELLING_LOCATION, &pMap);
+        if (hLoc2)
+            hLoc = hLoc2;
+
+        /* Guard against wrap arounds and overlaps. */
+        if (   hLoc + offColumn > MAP_START_LOCATION(pMap) /** @todo Use MAX_SOURCE_LOCATION? */
+            && (   pMap == LINEMAPS_LAST_ORDINARY_MAP(line_table)
+                || hLoc + offColumn < MAP_START_LOCATION((pMap + 1))))
+        {
+            /* Calc new column and check that it's within the valid range. */
+            unsigned int uColumn = SOURCE_COLUMN(pMap, hLoc) + offColumn;
+            if (uColumn < RT_BIT_32(ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(pMap)))
+            {
+                /* Try add the position.  If we get a valid result, replace the location. */
+                source_location hNewLoc = linemap_position_for_line_and_column((line_map *)pMap, SOURCE_LINE(pMap, hLoc), uColumn);
+                if (   hNewLoc <= line_table->highest_location
+                    && linemap_lookup(line_table, hNewLoc) != NULL)
+                {
+                    dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u uColumn=%u\n",
+                            hNewLoc, hLoc, offColumn, uColumn);
+                    return hNewLoc;
+                }
+            }
+        }
+#endif
+    }
+    dprintf("MyGetLocationPlusColumnOffset: taking fallback\n");
+    return hLoc;
+}
+
+
+#if 0
+DECLINLINE(int) MyGetLineLength(const char *pszLine)
+{
+    if (pszLine)
+    {
+        const char *pszEol = strpbrk(pszLine, "\n\r");
+        if (!pszEol)
+            pszEol = strchr(pszLine, '\0');
+        return (int)(pszEol - pszLine);
+    }
+    return 0;
+}
+#endif
+
+static location_t MyGetFormatStringLocation(PVFMTCHKSTATE pState, const char *pszLoc)
+{
+    location_t hLoc = pState->hFmtLoc;
+#if RT_GNUC_PREREQ(4,6)
+    intptr_t   offString = pszLoc - pState->pszFmt;
+    if (   offString >= 0
+        && !linemap_location_from_macro_expansion_p(line_table, hLoc))
+    {
+        unsigned            uCol    = 1 + offString;
+# if 0 /* apparently not needed */
+        expanded_location   XLoc    = expand_location_to_spelling_point(hLoc);
+# if RT_GNUC_PREREQ(10,0)
+        char_span           Span    = location_get_source_line(XLoc.file, XLoc.line);
+        const char         *pszLine = Span.m_ptr; /** @todo if enabled */
+        int                 cchLine = (int)Span.m_n_elts;
+# elif RT_GNUC_PREREQ(6,0)
+        int                 cchLine = 0;
+        const char         *pszLine = location_get_source_line(XLoc.file, XLoc.line, &cchLine);
+# elif RT_GNUC_PREREQ(5,0)
+        int                 cchLine = 0;
+        const char         *pszLine = location_get_source_line(XLoc, &cchLine);
+# else
+        const char         *pszLine = location_get_source_line(XLoc);
+        int                 cchLine = MyGetLineLength(pszLine);
+# endif
+        if (pszLine)
+        {
+            /** @todo Adjust the position by parsing the source. */
+            pszLine += XLoc.column - 1;
+            cchLine -= XLoc.column - 1;
+        }
+# endif
+
+        hLoc = MyGetLocationPlusColumnOffset(hLoc, uCol);
+    }
+#endif
+    return hLoc;
+}
+
+
+/**
+ * Non-recursive worker for MyCheckFormatRecursive.
+ *
+ * This will attempt to result @a hFmtArg into a string literal which it then
+ * passes on to MyCheckFormatString for the actual analyzis.
+ *
+ * @param   pState              The format string checking state.
+ * @param   hFmtArg             The format string node.
+ */
+DECL_NO_INLINE(static, void) MyCheckFormatNonRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
+{
+    dprintf("checker: hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
+
+    /*
+     * Try resolve variables into constant strings.
+     */
+    if (VAR_P(hFmtArg))
+    {
+        hFmtArg = decl_constant_value(hFmtArg);
+        STRIP_NOPS(hFmtArg); /* Used as argument and assigned call result. */
+        dprintf("checker1: variable => hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
+    }
+
+    /*
+     * Fend off NULLs.
+     */
+    if (integer_zerop(hFmtArg))
+    {
+        if (pState->fMaybeNull)
+            VFmtChkVerifyEndOfArgs(pState, 0);
+        else
+            error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
+    }
+    /*
+     * Need address expression to get any further.
+     */
+    else if (TREE_CODE(hFmtArg) != ADDR_EXPR)
+        dprintf("checker1: Not address expression (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
+    else
+    {
+        pState->hFmtLoc = EXPR_LOC_OR_LOC(hFmtArg, pState->hFmtLoc);
+        hFmtArg = TREE_OPERAND(hFmtArg, 0);
+
+        /*
+         * Deal with fixed string indexing, if possible.
+         */
+        HOST_WIDE_INT off = 0;
+        if (   TREE_CODE(hFmtArg) == ARRAY_REF
+            && MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1))
+            && MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1)) )
+        {
+            off = MY_DOUBLE_INT_TO_SHWI(TREE_OPERAND(hFmtArg, 1));
+            if (off < 0)
+            {
+                dprintf("checker1: ARRAY_REF, off=%ld\n", off);
+                return;
+            }
+            hFmtArg = TREE_OPERAND(hFmtArg, 0);
+            dprintf("checker1: ARRAY_REF => hFmtArg=%p %s, off=%ld\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)), off);
+        }
+
+        /*
+         * Deal with static const char g_szFmt[] = "qwerty";  Take care as
+         * the actual string constant may not necessarily include the terminator.
+         */
+        tree hArraySize = NULL_TREE;
+        if (   VAR_P(hFmtArg)
+            && TREE_CODE(TREE_TYPE(hFmtArg)) == ARRAY_TYPE)
+        {
+            tree hArrayInitializer = decl_constant_value(hFmtArg);
+            if (   hArrayInitializer != hFmtArg
+                && TREE_CODE(hArrayInitializer) == STRING_CST)
+            {
+                hArraySize = DECL_SIZE_UNIT(hFmtArg);
+                hFmtArg = hArrayInitializer;
+            }
+        }
+
+        /*
+         * Are we dealing with a string literal now?
+         */
+        if (TREE_CODE(hFmtArg) != STRING_CST)
+            dprintf("checker1: Not string literal (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
+        else if (TYPE_MAIN_VARIANT(TREE_TYPE(TREE_TYPE(hFmtArg))) != char_type_node)
+            warning_at(pState->hFmtLoc, 0, "expected 'char' type string literal");
+        else
+        {
+            /*
+             * Yes we are, so get the pointer to the string and its length.
+             */
+            const char *pszFmt = TREE_STRING_POINTER(hFmtArg);
+            int         cchFmt = TREE_STRING_LENGTH(hFmtArg);
+
+            /* Adjust cchFmt to the initialized array size if appropriate. */
+            if (hArraySize != NULL_TREE)
+            {
+                if (TREE_CODE(hArraySize) != INTEGER_CST)
+                    warning_at(pState->hFmtLoc, 0, "Expected integer array size (not %s)", get_tree_code_name(TREE_CODE(hArraySize)));
+                else if (!MY_DOUBLE_INT_FITS_SHWI(hArraySize))
+                    warning_at(pState->hFmtLoc, 0, "Unexpected integer overflow in array size constant");
+                else
+                {
+                    HOST_WIDE_INT cbArray = MY_DOUBLE_INT_TO_SHWI(hArraySize);
+                    if (   cbArray <= 0
+                        || cbArray != (int)cbArray)
+                        warning_at(pState->hFmtLoc, 0, "Unexpected integer array size constant value: %ld", cbArray);
+                    else if (cchFmt > cbArray)
+                    {
+                        dprintf("checker1: cchFmt=%d => cchFmt=%ld (=cbArray)\n", cchFmt, cbArray);
+                        cchFmt = (int)cbArray;
+                    }
+                }
+            }
+
+            /* Apply the offset, if given. */
+            if (off)
+            {
+                if (off >= cchFmt)
+                {
+                    dprintf("checker1: off=%ld  >=  cchFmt=%d -> skipping\n", off, cchFmt);
+                    return;
+                }
+                pszFmt += off;
+                cchFmt -= (int)off;
+            }
+
+            /*
+             * Check for unterminated strings.
+             */
+            if (   cchFmt < 1
+                || pszFmt[cchFmt - 1] != '\0')
+                warning_at(pState->hFmtLoc, 0, "Unterminated format string (cchFmt=%d)", cchFmt);
+            /*
+             * Call worker to check the actual string.
+             */
+            else
+                MyCheckFormatCString(pState, pszFmt);
+        }
+    }
+}
+
+
+/**
+ * Deal recursively with special format string constructs.
+ *
+ * This will call MyCheckFormatNonRecursive to validate each format string.
+ *
+ * @param   pState              The format string checking state.
+ * @param   hFmtArg             The format string node.
+ */
+static void MyCheckFormatRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
+{
+    /*
+     * Catch wrong attribute use.
+     */
+    if (hFmtArg == NULL_TREE)
+        error_at(pState->hFmtLoc, "IPRT format attribute is probably used incorrectly (hFmtArg is NULL)");
+    /*
+     * NULL format strings may cause crashes.
+     */
+    else if (integer_zerop(hFmtArg))
+    {
+        if (pState->fMaybeNull)
+            VFmtChkVerifyEndOfArgs(pState, 0);
+        else
+            error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
+    }
+    /*
+     * Check both branches of a ternary operator.
+     */
+    else if (TREE_CODE(hFmtArg) == COND_EXPR)
+    {
+        MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 1));
+        MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 2));
+    }
+    /*
+     * Strip coercion.
+     */
+    else if (   CONVERT_EXPR_P(hFmtArg)
+             && TYPE_PRECISION(TREE_TYPE(hFmtArg)) == TYPE_PRECISION(TREE_TYPE(TREE_OPERAND(hFmtArg, 0))) )
+        MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 0));
+    /*
+     * We're good, hand it to the non-recursive worker.
+     */
+    else
+        MyCheckFormatNonRecursive(pState, hFmtArg);
+}
+
+
+#if !RT_GNUC_PREREQ(4, 9)
+/**
+ * Execute my pass.
+ * @returns Flags indicates stuff todo, we return 0.
+ */
+static unsigned int     MyPassExecuteCallback(void)
+{
+    return MyPassExecuteCallbackWithFunction(cfun);
+}
+#endif
+
+/**
+ * Execute my pass.
+ * @returns Flags indicates stuff todo, we return 0.
+ */
+static unsigned int     MyPassExecuteCallbackWithFunction(struct function *pFun)
+{
+    dprintf("MyPassExecuteCallback:\n");
+
+    /*
+     * Enumerate the basic blocks.
+     */
+    basic_block hBasicBlock;
+    FOR_EACH_BB_FN(hBasicBlock, pFun)
+    {
+        dprintf(" hBasicBlock=%p\n", hBasicBlock);
+
+        /*
+         * Enumerate the statements in the current basic block.
+         * We're interested in calls to functions with the __iprt_format__ attribute.
+         */
+        for (gimple_stmt_iterator hStmtItr = gsi_start_bb(hBasicBlock); !gsi_end_p(hStmtItr); gsi_next(&hStmtItr))
+        {
+#if RT_GNUC_PREREQ(6, 0)
+            const gimple * const    hStmt   = gsi_stmt(hStmtItr);
+#else
+            gimple const            hStmt   = gsi_stmt(hStmtItr);
+#endif
+
+            enum gimple_code const  enmCode = gimple_code(hStmt);
+#ifdef DEBUG
+            unsigned const          cOps    = gimple_num_ops(hStmt);
+            dprintf("   hStmt=%p %s (%d) ops=%d\n", hStmt, gimple_code_name[enmCode], enmCode, cOps);
+            for (unsigned iOp = 0; iOp < cOps; iOp++)
+            {
+                tree const hOp = gimple_op(hStmt, iOp);
+                if (hOp)
+                    dprintf("     %02d: %p, code %s(%d)\n", iOp, hOp, get_tree_code_name(TREE_CODE(hOp)), TREE_CODE(hOp));
+                else
+                    dprintf("     %02d: NULL_TREE\n", iOp);
+            }
+#endif
+            if (enmCode == GIMPLE_CALL)
+            {
+                /*
+                 * Check if the function type has the __iprt_format__ attribute.
+                 */
+                tree const hFn = gimple_call_fn(hStmt);
+                dprintf("     hFn    =%p %s(%d); args=%d\n",
+                        hFn, hFn ? get_tree_code_name(TREE_CODE(hFn)) : NULL, hFn ? TREE_CODE(hFn) : - 1,
+                        gimple_call_num_args(hStmt));
+#ifdef DEBUG
+                if (hFn && DECL_P(hFn))
+                    dprintf("     hFn is decl: %s %s:%d\n",
+                            DECL_NAME(hFn) ? IDENTIFIER_POINTER(DECL_NAME(hFn)) : "<unamed>",
+                            DECL_SOURCE_FILE(hFn), DECL_SOURCE_LINE(hFn));
+#endif
+                tree const hFnDecl = gimple_call_fndecl(hStmt);
+                if (hFnDecl)
+                    dprintf("     hFnDecl=%p %s(%d) %s type=%p %s:%d\n",
+                            hFnDecl, get_tree_code_name(TREE_CODE(hFnDecl)), TREE_CODE(hFnDecl),
+                            DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
+                            TREE_TYPE(hFnDecl), DECL_SOURCE_FILE(hFnDecl), DECL_SOURCE_LINE(hFnDecl));
+                tree const hFnType = gimple_call_fntype(hStmt);
+                if (hFnType == NULL_TREE)
+                {
+                    if (   hFnDecl == NULL_TREE
+                        && gimple_call_internal_p(hStmt) /* va_arg() kludge */)
+                        continue;
+                    error_at(gimple_location(hStmt), "Failed to resolve function type [fn=%s fndecl=%s]\n",
+                             hFn ? get_tree_code_name(TREE_CODE(hFn)) : "<null>",
+                             hFnDecl ? get_tree_code_name(TREE_CODE(hFnDecl)) : "<null>");
+                }
+                else if (POINTER_TYPE_P(hFnType))
+                    error_at(gimple_location(hStmt), "Got a POINTER_TYPE when expecting a function type [fn=%s]\n",
+                             get_tree_code_name(TREE_CODE(hFn)));
+                if (hFnType)
+                    dprintf("     hFnType=%p %s(%d) %s\n", hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType),
+                              TYPE_NAME(hFnType) && DECL_NAME(TYPE_NAME(hFnType))
+                            ? IDENTIFIER_POINTER(DECL_NAME(TYPE_NAME(hFnType))) : "<unamed>");
+
+                tree const hAttr        = hFnType ? lookup_attribute("iprt_format", TYPE_ATTRIBUTES(hFnType))            : NULL_TREE;
+                tree const hAttrMaybe0  = hFnType ? lookup_attribute("iprt_format_maybe_null", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
+                if (hAttr || hAttrMaybe0)
+                {
+                    /*
+                     * Yeah, it has the attribute!
+                     */
+                    tree const hAttrArgs = hAttr ? TREE_VALUE(hAttr) : TREE_VALUE(hAttrMaybe0);
+                    VFMTCHKSTATE State;
+                    State.iFmt          = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
+                    State.iArgs         = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
+                    State.pszFmt        = NULL;
+                    State.fMaybeNull    = hAttr == NULL_TREE;
+                    State.hStmt         = hStmt;
+                    State.hFmtLoc       = gimple_location(hStmt);
+                    dprintf("     %s() __iprt_format%s__(iFmt=%ld, iArgs=%ld)\n",
+                            hFnDecl && DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
+                            State.fMaybeNull ? "_maybe_null" : "", State.iFmt, State.iArgs);
+
+                    unsigned cCallArgs = gimple_call_num_args(hStmt);
+                    if (cCallArgs >= State.iFmt)
+                        MyCheckFormatRecursive(&State, gimple_call_arg(hStmt, State.iFmt - 1));
+                    else
+                        error_at(gimple_location(hStmt),
+                                 "Call has only %d arguments; %s() format string is argument #%lu (1-based), thus missing\n",
+                                 cCallArgs, DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>", State.iFmt);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+
+/**
+ * Gate callback for my pass that indicates whether it should execute or not.
+ * @returns true to execute.
+ */
+static bool             MyPassGateCallback(void)
+{
+    dprintf("MyPassGateCallback:\n");
+    return true;
+}
+
+
+/**
+ * Validate the use of an attribute.
+ *
+ * @returns ??
+ * @param   phOnNode        The node the attribute is being used on.
+ * @param   hAttrName       The attribute name.
+ * @param   hAttrArgs       The attribute arguments.
+ * @param   fFlags          Some kind of flags...
+ * @param   pfDontAddAttrib Whether to add the attribute to this node or not.
+ */
+static tree AttributeHandler(tree *phOnNode, tree hAttrName, tree hAttrArgs, int fFlags, bool *pfDontAddAttrib)
+{
+    dprintf("AttributeHandler: name=%s fFlags=%#x", IDENTIFIER_POINTER(hAttrName), fFlags);
+    long iFmt  = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
+    long iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
+    dprintf(" iFmt=%ld iArgs=%ld", iFmt, iArgs);
+
+    tree hType = *phOnNode;
+    dprintf(" hType=%p %s(%d)\n", hType, get_tree_code_name(TREE_CODE(hType)), TREE_CODE(hType));
+
+    if (pfDontAddAttrib)
+        *pfDontAddAttrib = false;
+    return NULL_TREE;
+}
+
+
+/**
+ * Called when we can register attributes.
+ *
+ * @param   pvEventData         Ignored.
+ * @param   pvUser              Ignored.
+ */
+static void RegisterAttributesEvent(void *pvEventData, void *pvUser)
+{
+    NOREF(pvEventData); NOREF(pvUser);
+    dprintf("RegisterAttributesEvent: pvEventData=%p\n", pvEventData);
+
+    register_attribute(&g_AttribSpecs[0]);
+    register_attribute(&g_AttribSpecs[1]);
+}
+
+
+/**
+ * The plug-in entry point.
+ *
+ * @returns 0 to indicate success?
+ * @param   pPlugInInfo         Plugin info structure.
+ * @param   pGccVer             GCC Version.
+ */
+int plugin_init(plugin_name_args *pPlugInInfo, plugin_gcc_version *pGccVer)
+{
+    dprintf("plugin_init: %s\n", pPlugInInfo->full_name);
+    dprintf("gcc version: basever=%s datestamp=%s devphase=%s revision=%s\n",
+            pGccVer->basever, pGccVer->datestamp, pGccVer->devphase, pGccVer->revision);
+
+    /* Ask for callback in which we may register the attribute. */
+    register_callback(pPlugInInfo->base_name, PLUGIN_ATTRIBUTES, RegisterAttributesEvent, NULL /*pvUser*/);
+
+    /* Register our pass. */
+#if RT_GNUC_PREREQ(4, 9)
+    /** The registration info for my pass. */
+    struct register_pass_info MyPassInfo;
+    MyPassInfo.pass                     = new MyPass(g);
+    MyPassInfo.reference_pass_name      = "ssa";
+    MyPassInfo.ref_pass_instance_number = 1;
+    MyPassInfo.pos_op                   = PASS_POS_INSERT_BEFORE;
+    register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &MyPassInfo);
+#else
+    register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, (void *)&g_MyPassInfo);
+#endif
+
+    /* Register plug-in info. */
+    register_callback(pPlugInInfo->base_name, PLUGIN_INFO, NULL, (void *)&g_PlugInInfo);
+
+    return 0;
+}
+
+
+
+
+/*
+ *
+ * Functions used by the common code.
+ * Functions used by the common code.
+ * Functions used by the common code.
+ *
+ */
+
+void VFmtChkWarnFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...)
+{
+    char szTmp[1024];
+    va_list va;
+    va_start(va, pszFormat);
+    vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
+    va_end(va);
+
+    /* display the warning. */
+    warning_at(MyGetFormatStringLocation(pState, pszLoc), 0, "%s", szTmp);
+}
+
+
+void VFmtChkErrFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...)
+{
+    char szTmp[1024];
+    va_list va;
+    va_start(va, pszFormat);
+    vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
+    va_end(va);
+
+    /* display the warning. */
+    error_at(MyGetFormatStringLocation(pState, pszLoc), "%s", szTmp);
+}
+
+
+
+void VFmtChkVerifyEndOfArgs(PVFMTCHKSTATE pState, unsigned iArg)
+{
+    dprintf("VFmtChkVerifyEndOfArgs: iArg=%u iArgs=%ld cArgs=%u\n", iArg, pState->iArgs, gimple_call_num_args(pState->hStmt));
+    if (pState->iArgs > 0)
+    {
+        iArg += pState->iArgs - 1;
+        unsigned cArgs = gimple_call_num_args(pState->hStmt);
+        if (iArg == cArgs)
+        { /* fine */ }
+        else if (iArg < cArgs)
+        {
+            tree hArg = gimple_call_arg(pState->hStmt, iArg);
+            if (cArgs - iArg > 1)
+                error_at(MY_LOC(hArg, pState), "%u extra arguments not consumed by format string", cArgs - iArg);
+            else if (   TREE_CODE(hArg) != INTEGER_CST
+                     || !MY_DOUBLE_INT_FITS_SHWI(hArg)
+                     || MY_DOUBLE_INT_TO_SHWI(hArg) != -99) /* ignore final dummy argument: ..., -99); */
+                error_at(MY_LOC(hArg, pState), "one extra argument not consumed by format string");
+        }
+        /* This should be handled elsewhere, but just in case. */
+        else if (iArg - 1 == cArgs)
+            error_at(pState->hFmtLoc, "one argument too few");
+        else
+            error_at(pState->hFmtLoc, "%u arguments too few", iArg - cArgs);
+    }
+}
+
+
+bool VFmtChkRequirePresentArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
+{
+    if (pState->iArgs > 0)
+    {
+        iArg += pState->iArgs - 1;
+        unsigned cArgs = gimple_call_num_args(pState->hStmt);
+        if (iArg >= cArgs)
+        {
+            VFmtChkErrFmt(pState, pszLoc, "Missing argument! %s", pszMessage);
+            return false;
+        }
+
+        tree hArg  = gimple_call_arg(pState->hStmt, iArg);
+        tree hType = TREE_TYPE(hArg);
+        dprintf("arg%u: hArg=%p [%s] hType=%p [%s] cls=%s\n", iArg, hArg, get_tree_code_name(TREE_CODE(hArg)),
+                hType, get_tree_code_name(TREE_CODE(hType)), tree_code_class_strings[TREE_CODE_CLASS(TREE_CODE(hType))]);
+        dprintf("      nm=%p\n", TYPE_NAME(hType));
+        dprintf("      cb=%p %s value=%ld\n", TYPE_SIZE(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE(hType))),
+                MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(hType)) );
+        dprintf("      unit=%p %s value=%ld\n", TYPE_SIZE_UNIT(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE_UNIT(hType))),
+                MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE_UNIT(hType)) );
+        tree hTypeNm = TYPE_NAME(hType);
+        if (hTypeNm)
+            dprintf("      typenm=%p %s '%s'\n", hTypeNm, get_tree_code_name(TREE_CODE(hTypeNm)),
+                    IDENTIFIER_POINTER(DECL_NAME(hTypeNm)));
+    }
+    return true;
+}
+
+
+bool VFmtChkRequireIntArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
+{
+    if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
+    {
+        /** @todo type check.  */
+        return true;
+    }
+    return false;
+}
+
+
+bool VFmtChkRequireStringArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
+{
+    if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
+    {
+        /** @todo type check.  */
+        return true;
+    }
+    return false;
+}
+
+
+bool VFmtChkRequireVaListPtrArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
+{
+    if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
+    {
+        /** @todo type check.  */
+        return true;
+    }
+    return false;
+}
+
+
+void VFmtChkHandleReplacementFormatString(PVFMTCHKSTATE pState, const char *pszPctM, unsigned iArg)
+{
+    if (pState->iArgs > 0)
+    {
+        pState->iFmt        = pState->iArgs + iArg;
+        pState->iArgs       = pState->iFmt  + 1;
+        pState->fMaybeNull  = false;
+        MyCheckFormatRecursive(pState, gimple_call_arg(pState->hStmt, pState->iFmt - 1));
+    }
+}
+
+
+const char  *VFmtChkGetFmtLocFile(PVFMTCHKSTATE pState)
+{
+    return LOCATION_FILE(pState->hFmtLoc);
+}
+
+
+unsigned int VFmtChkGetFmtLocLine(PVFMTCHKSTATE pState)
+{
+    return LOCATION_LINE(pState->hFmtLoc);
+}
+
+
+unsigned int VFmtChkGetFmtLocColumn(PVFMTCHKSTATE pState)
+{
+#ifdef LOCATION_COLUMN
+    return LOCATION_COLUMN(pState->hFmtLoc);
+#else
+    return 1;
+#endif
+}
+
diff --git a/src/bldprogs/VBoxDef2LazyLoad.cpp b/src/bldprogs/VBoxDef2LazyLoad.cpp
new file mode 100644
index 00000000..30321377
--- /dev/null
+++ b/src/bldprogs/VBoxDef2LazyLoad.cpp
@@ -0,0 +1,1624 @@
+/* $Id: VBoxDef2LazyLoad.cpp $ */
+/** @file
+ * VBoxDef2LazyLoad - Lazy Library Loader Generator.
+ *
+ * @note Only tested on win.amd64 & darwin.amd64.
+ */
+
+/*
+ * Copyright (C) 2013-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <iprt/types.h>
+#include <iprt/ldr.h> /* For RTLDRARCH. */
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct MYEXPORT
+{
+    struct MYEXPORT    *pNext;
+    /** Pointer to unmangled name for stdcall (after szName), NULL if not. */
+    char               *pszUnstdcallName;
+    /** Pointer to the exported name. */
+    char const         *pszExportedNm;
+    unsigned            uOrdinal;
+    bool                fNoName;
+    char                szName[1];
+} MYEXPORT;
+typedef MYEXPORT *PMYEXPORT;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** @name Options
+ * @{ */
+static const char  *g_pszOutput   = NULL;
+static const char  *g_pszLibrary  = NULL;
+static const char  *g_apszInputs[8] = { NULL, NULL, NULL, NULL,  NULL, NULL, NULL, NULL };
+static unsigned     g_cInputs = 0;
+static bool         g_fIgnoreData = true;
+static bool         g_fWithExplictLoadFunction = false;
+static bool         g_fSystemLibrary = false;
+#if   defined(RT_ARCH_AMD64)
+static RTLDRARCH    g_enmTarget = RTLDRARCH_AMD64;
+#elif defined(RT_ARCH_X86)
+static RTLDRARCH    g_enmTarget = RTLDRARCH_X86_32;
+#elif defined(RT_ARCH_ARM64)
+static RTLDRARCH    g_enmTarget = RTLDRARCH_ARM64;
+#else
+# error "Port me!"
+#endif
+/** @} */
+
+/** Pointer to the export name list head. */
+static PMYEXPORT    g_pExpHead  = NULL;
+/** Pointer to the next pointer for insertion. */
+static PMYEXPORT   *g_ppExpNext = &g_pExpHead;
+
+
+
+#if 0 /* unused */
+static const char *leftStrip(const char *psz)
+{
+    while (isspace(*psz))
+        psz++;
+    return psz;
+}
+#endif
+
+
+static char *leftStrip(char *psz)
+{
+    while (isspace(*psz))
+        psz++;
+    return psz;
+}
+
+
+static unsigned wordLength(const char *pszWord)
+{
+    unsigned off = 0;
+    char ch;
+    while (   (ch = pszWord[off]) != '\0'
+           && ch                  != '='
+           && ch                  != ','
+           && ch                  != ':'
+           && !isspace(ch) )
+        off++;
+    return off;
+}
+
+
+/**
+ * Parses the module definition file, collecting export information.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
+ *          details has been displayed.
+ * @param   pInput              The input stream.
+ */
+static RTEXITCODE parseInputInner(FILE *pInput, const char *pszInput)
+{
+    /*
+     * Process the file line-by-line.
+     */
+    bool        fInExports = false;
+    unsigned    iLine      = 0;
+    char        szLine[16384];
+    while (fgets(szLine, sizeof(szLine), pInput))
+    {
+        iLine++;
+
+        /*
+         * Strip leading and trailing spaces from the line as well as
+         * trailing comments.
+         */
+        char *psz = leftStrip(szLine);
+        if (*psz == ';')
+            continue; /* comment line. */
+
+        char *pszComment = strchr(psz, ';');
+        if (pszComment)
+            *pszComment = '\0';
+
+        unsigned cch = (unsigned)strlen(psz);
+        while (cch > 0 && (isspace(psz[cch - 1]) || psz[cch - 1] == '\r' || psz[cch - 1] == '\n'))
+            psz[--cch] = '\0';
+
+        if (!cch)
+            continue;
+
+        /*
+         * Check for known directives.
+         */
+        size_t cchWord0 = wordLength(psz);
+#define WORD_CMP(pszWord1, cchWord1, szWord2) \
+            ( (cchWord1) == sizeof(szWord2) - 1 && memcmp(pszWord1, szWord2, sizeof(szWord2) - 1) == 0 )
+        if (WORD_CMP(psz, cchWord0, "EXPORTS"))
+        {
+            fInExports = true;
+
+            /* In case there is an export on the same line. (Really allowed?) */
+            psz = leftStrip(psz + sizeof("EXPORTS") - 1);
+            if (!*psz)
+                continue;
+        }
+        /* Directives that we don't care about, but need to catch in order to
+           terminate the EXPORTS section in a timely manner. */
+        else if (   WORD_CMP(psz, cchWord0, "NAME")
+                 || WORD_CMP(psz, cchWord0, "LIBRARY")
+                 || WORD_CMP(psz, cchWord0, "DESCRIPTION")
+                 || WORD_CMP(psz, cchWord0, "STACKSIZE")
+                 || WORD_CMP(psz, cchWord0, "SECTIONS")
+                 || WORD_CMP(psz, cchWord0, "SEGMENTS")
+                 || WORD_CMP(psz, cchWord0, "VERSION")
+                )
+        {
+            fInExports = false;
+        }
+
+        /*
+         * Process exports:
+         *  entryname[=internalname] [@ordinal[ ][NONAME]] [DATA] [PRIVATE]
+         */
+        if (fInExports)
+        {
+            const char *pchName = psz;
+            unsigned    cchName = wordLength(psz);
+
+            psz = leftStrip(psz + cchName);
+            if (*psz == '=')
+            {
+                psz = leftStrip(psz + 1);
+                psz = leftStrip(psz + wordLength(psz));
+            }
+
+            bool     fNoName  = false;
+            unsigned uOrdinal = ~0U;
+            if (*psz == '@')
+            {
+                psz++;
+                if (!isdigit(*psz))
+                {
+                    fprintf(stderr, "%s:%u: error: Invalid ordinal spec.\n", pszInput, iLine);
+                    return RTEXITCODE_FAILURE;
+                }
+                uOrdinal = *psz++ - '0';
+                while (isdigit(*psz))
+                {
+                    uOrdinal *= 10;
+                    uOrdinal += *psz++ - '0';
+                }
+                psz = leftStrip(psz);
+                cch = wordLength(psz);
+                if (WORD_CMP(psz, cch, "NONAME"))
+                {
+                    fNoName = true;
+                    psz = leftStrip(psz + cch);
+                }
+            }
+
+            while (*psz)
+            {
+                cch = wordLength(psz);
+                if (WORD_CMP(psz, cch, "DATA"))
+                {
+                    if (!g_fIgnoreData)
+                    {
+                        fprintf(stderr, "%s:%u: error: Cannot wrap up DATA export '%.*s'.\n",
+                                pszInput, iLine, cchName, pchName);
+                        return RTEXITCODE_SUCCESS;
+                    }
+                }
+                else if (!WORD_CMP(psz, cch, "PRIVATE"))
+                {
+                    fprintf(stderr, "%s:%u: error: Cannot wrap up DATA export '%.*s'.\n",
+                            pszInput, iLine, cchName, pchName);
+                    return RTEXITCODE_SUCCESS;
+                }
+                psz = leftStrip(psz + cch);
+            }
+
+            /*
+             * Check for stdcall mangling.
+             */
+            size_t   cbExp = sizeof(MYEXPORT) + cchName;
+            unsigned cchStdcall = 0;
+            if (cchName > 3 && *pchName == '_' && isdigit(pchName[cchName - 1]))
+            {
+                if (cchName > 3 && pchName[cchName - 2] == '@')
+                    cchStdcall = 2;
+                else if (cchName > 4 && pchName[cchName - 3] == '@' && isdigit(pchName[cchName - 2]))
+                    cchStdcall = 3;
+                if (cchStdcall)
+                    cbExp += cchName - 1 - cchStdcall;
+            }
+
+            /*
+             * Add the export.
+             */
+
+            PMYEXPORT pExp = (PMYEXPORT)malloc(cbExp);
+            if (!pExp)
+            {
+                fprintf(stderr, "%s:%u: error: Out of memory.\n", pszInput, iLine);
+                return RTEXITCODE_SUCCESS;
+            }
+            memcpy(pExp->szName, pchName, cchName);
+            pExp->szName[cchName] = '\0';
+            if (!cchStdcall)
+            {
+                pExp->pszUnstdcallName = NULL;
+                pExp->pszExportedNm = pExp->szName;
+            }
+            else
+            {
+                pExp->pszUnstdcallName = &pExp->szName[cchName + 1];
+                memcpy(pExp->pszUnstdcallName, pchName + 1, cchName - 1 - cchStdcall);
+                pExp->pszUnstdcallName[cchName - 1 - cchStdcall] = '\0';
+                pExp->pszExportedNm = pExp->pszUnstdcallName;
+            }
+            pExp->uOrdinal   = uOrdinal;
+            pExp->fNoName    = fNoName;
+            pExp->pNext      = NULL;
+            *g_ppExpNext     = pExp;
+            g_ppExpNext      = &pExp->pNext;
+        }
+    }
+
+    /*
+     * Why did we quit the loop, EOF or error?
+     */
+    if (feof(pInput))
+        return RTEXITCODE_SUCCESS;
+    fprintf(stderr, "error: Read while reading '%s' (iLine=%u).\n", pszInput, iLine);
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Parses a_apszInputs, populating the list pointed to by g_pExpHead.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
+ *          details has been displayed.
+ */
+static RTEXITCODE  parseInputs(void)
+{
+    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
+    for (unsigned i = 0; i < g_cInputs; i++)
+    {
+        FILE *pInput = fopen(g_apszInputs[i], "r");
+        if (pInput)
+        {
+            RTEXITCODE rcExit2 = parseInputInner(pInput, g_apszInputs[i]);
+            fclose(pInput);
+            if (rcExit2 == RTEXITCODE_SUCCESS && !g_pExpHead)
+            {
+                fprintf(stderr, "error: Found no exports in '%s'.\n", g_apszInputs[i]);
+                rcExit2 = RTEXITCODE_FAILURE;
+            }
+            if (rcExit2 != RTEXITCODE_SUCCESS)
+                rcExit = rcExit2;
+        }
+        else
+        {
+            fprintf(stderr, "error: Failed to open '%s' for reading.\n", g_apszInputs[i]);
+            rcExit = RTEXITCODE_FAILURE;
+        }
+    }
+    return rcExit;
+}
+
+
+/**
+ * Generates the assembly source code for AMD64 and x86, writing it
+ * to @a pOutput.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
+ *          details has been displayed.
+ * @param   pOutput              The output stream (caller checks it for errors
+ *                               when closing).
+ */
+static RTEXITCODE generateOutputInnerX86AndAMD64(FILE *pOutput)
+{
+    fprintf(pOutput, ";;\n");
+    for (unsigned i = 0; i < g_cInputs; i++)
+        fprintf(pOutput, ";; Autogenerated from '%s'.\n", g_apszInputs[i]);
+
+    fprintf(pOutput,
+            ";; DO NOT EDIT!\n"
+            ";;\n"
+            "\n"
+            "\n"
+            "%%include \"iprt/asmdefs.mac\"\n"
+            "\n"
+            "\n");
+
+    /*
+     * Put the thunks first for alignment and other reasons. It's the hot part of the code.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Thunks.\n"
+            ";\n"
+            "BEGINCODE\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        if (!pExp->pszUnstdcallName)
+            fprintf(pOutput,
+                    "BEGINPROC %s\n"
+                    "    jmp   RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
+                    "ENDPROC   %s\n",
+                    pExp->szName, pExp->szName, pExp->szName);
+        else
+            fprintf(pOutput,
+                    "%%ifdef RT_ARCH_X86\n"
+                    "global    %s\n"
+                    "%s:\n"
+                    "    jmp   RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
+                    "%%else\n"
+                    "BEGINPROC %s\n"
+                    "    jmp   RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
+                    "ENDPROC   %s\n"
+                    "%%endif\n",
+                    pExp->szName, pExp->szName, pExp->pszUnstdcallName,
+                    pExp->pszUnstdcallName, pExp->pszUnstdcallName, pExp->pszUnstdcallName);
+
+    fprintf(pOutput,
+            "\n"
+            "\n");
+
+    /*
+     * Import pointers
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Import pointers. Initialized to point a lazy loading stubs.\n"
+            ";\n"
+            "BEGINDATA\n"
+            "g_apfnImports:\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        if (pExp->pszUnstdcallName)
+            fprintf(pOutput,
+                    "%%ifdef ASM_FORMAT_PE\n"
+                    " %%ifdef RT_ARCH_X86\n"
+                    "global __imp_%s\n"
+                    "__imp_%s:\n"
+                    " %%else\n"
+                    "global __imp_%s\n"
+                    "__imp_%s:\n"
+                    " %%endif\n"
+                    "%%endif\n"
+                    "g_pfn%s RTCCPTR_DEF ___LazyLoad___%s\n"
+                    "\n",
+                    pExp->szName,
+                    pExp->szName,
+                    pExp->pszUnstdcallName,
+                    pExp->pszUnstdcallName,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm);
+        else
+            fprintf(pOutput,
+                    "%%ifdef ASM_FORMAT_PE\n"
+                    "global __imp_%s\n"
+                    "__imp_%s:\n"
+                    "%%endif\n"
+                    "g_pfn%s RTCCPTR_DEF ___LazyLoad___%s\n"
+                    "\n",
+                    pExp->szName,
+                    pExp->szName,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm);
+    fprintf(pOutput,
+            "RTCCPTR_DEF 0 ; Terminator entry for traversal.\n"
+            "\n"
+            "\n");
+
+    /*
+     * Now for the less important stuff, starting with the names.
+     *
+     * We keep the names separate so we can traverse them in parallel to
+     * g_apfnImports in the load-everything routine further down.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Imported names.\n"
+            ";\n"
+            "BEGINCODE\n"
+            "g_szLibrary:        db '%s',0\n"
+            "\n"
+            "g_szzNames:\n",
+            g_pszLibrary);
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        if (!pExp->fNoName)
+            fprintf(pOutput, "  g_sz%s:\n    db '%s',0\n", pExp->pszExportedNm, pExp->pszExportedNm);
+        else
+            fprintf(pOutput, "  g_sz%s:\n    db '#%u',0\n", pExp->pszExportedNm, pExp->uOrdinal);
+    fprintf(pOutput,
+            "g_EndOfNames: db 0\n"
+            "\n"
+            "g_szFailLoadFmt:    db 'Lazy loader failed to load \"%%s\": %%Rrc', 10, 0\n"
+            "g_szFailResolveFmt: db 'Lazy loader failed to resolve symbol \"%%s\" in \"%%s\": %%Rrc', 10, 0\n"
+            "\n"
+            "\n");
+
+    /*
+     * The per import lazy load code.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Lazy load+resolve stubs.\n"
+            ";\n"
+            "BEGINCODE\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+    {
+        if (!pExp->fNoName)
+            fprintf(pOutput,
+                    "___LazyLoad___%s:\n"
+                    /* "int3\n" */
+                    "%%ifdef RT_ARCH_AMD64\n"
+                    "    lea     rax, [g_sz%s wrt rip]\n"
+                    "    lea     r10, [g_pfn%s wrt rip]\n"
+                    "    call    LazyLoadResolver\n"
+                    "%%elifdef RT_ARCH_X86\n"
+                    "    push    g_sz%s\n"
+                    "    push    g_pfn%s\n"
+                    "    call    LazyLoadResolver\n"
+                    "    add     esp, 8h\n"
+                    "%%else\n"
+                    " %%error \"Unsupported architecture\"\n"
+                    "%%endif\n"
+                    ,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm,
+                    pExp->pszExportedNm);
+        else
+            fprintf(pOutput,
+                    "___LazyLoad___%s:\n"
+                    /* "int3\n" */
+                    "%%ifdef RT_ARCH_AMD64\n"
+                    "    mov     eax, %u\n"
+                    "    lea     r10, [g_pfn%s wrt rip]\n"
+                    "    call    LazyLoadResolver\n"
+                    "%%elifdef RT_ARCH_X86\n"
+                    "    push    %u\n"
+                    "    push    g_pfn%s\n"
+                    "    call    LazyLoadResolver\n"
+                    "    add     esp, 8h\n"
+                    "%%else\n"
+                    " %%error \"Unsupported architecture\"\n"
+                    "%%endif\n"
+                    ,
+                    pExp->pszExportedNm,
+                    pExp->uOrdinal,
+                    pExp->pszExportedNm,
+                    pExp->uOrdinal,
+                    pExp->pszExportedNm);
+        if (!pExp->pszUnstdcallName)
+            fprintf(pOutput, "    jmp     NAME(%s)\n", pExp->szName);
+        else
+            fprintf(pOutput,
+                    "%%ifdef RT_ARCH_X86\n"
+                    "    jmp     %s\n"
+                    "%%else\n"
+                    "    jmp     NAME(%s)\n"
+                    "%%endif\n"
+                    ,
+                    pExp->szName, pExp->pszUnstdcallName);
+        fprintf(pOutput, "\n");
+    }
+    fprintf(pOutput,
+            "\n"
+            "\n"
+            "\n");
+
+    /*
+     * The code that does the loading and resolving.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; The module handle.\n"
+            ";\n"
+            "BEGINDATA\n"
+            "g_hMod RTCCPTR_DEF 0\n"
+            "\n"
+            "\n"
+            "\n");
+
+    /*
+     * How we load the module needs to be selectable later on.
+     *
+     * The LazyLoading routine returns the module handle in RCX/ECX, caller
+     * saved all necessary registers.
+     */
+    if (!g_fSystemLibrary)
+        fprintf(pOutput,
+                ";\n"
+                ";SUPR3DECL(int) SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod,\n"
+                ";                                           uint32_t fFlags, PRTERRINFO pErrInfo);\n"
+                ";\n"
+                "EXTERN_IMP2 SUPR3HardenedLdrLoadAppPriv\n"
+                "%%ifdef IN_RT_R3\n"
+                "extern NAME(RTAssertMsg2Weak)\n"
+                "%%else\n"
+                "EXTERN_IMP2 RTAssertMsg2Weak\n"
+                "%%endif\n"
+                "BEGINCODE\n"
+                "\n"
+                "LazyLoading:\n"
+                "    mov     xCX, [g_hMod xWrtRIP]\n"
+                "    or      xCX, xCX\n"
+                "    jnz     .return\n"
+                "\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    xor     rcx, rcx               ; pErrInfo\n"
+                "    xor     rdx, rdx               ; fFlags (local load)\n"
+                "    lea     rsi, [g_hMod wrt rip]  ; phLdrMod\n"
+                "    lea     rdi, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    sub     rsp, 08h\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "    add     rsp, 08h\n"
+                "\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    xor     r9, r9                 ; pErrInfo\n"
+                "    xor     r8, r8                 ; fFlags (local load)\n"
+                "    lea     rdx, [g_hMod wrt rip]  ; phLdrMod\n"
+                "    lea     rcx, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    sub     rsp, 28h\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "    add     rsp, 28h\n"
+                "\n"
+                "%%elifdef RT_ARCH_X86\n"
+                "    sub     xSP, 0ch\n"
+                "    push    0              ; pErrInfo\n"
+                "    push    0              ; fFlags (local load)\n"
+                "    push    g_hMod         ; phLdrMod\n"
+                "    push    g_szLibrary    ; pszFilename\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "    add     esp, 1ch\n"
+                "%%else\n"
+                " %%error \"Unsupported architecture\"\n"
+                "%%endif\n");
+    else
+        fprintf(pOutput,
+                ";\n"
+                "; RTDECL(int) RTLdrLoadSystem(const char *pszFilename, bool fNoUnload, PRTLDRMOD phLdrMod);\n"
+                ";\n"
+                "%%ifdef IN_RT_R3\n"
+                "extern NAME(RTLdrLoadSystem)\n"
+                "extern NAME(RTAssertMsg2Weak)\n"
+                "%%else\n"
+                "EXTERN_IMP2 RTLdrLoadSystem\n"
+                "EXTERN_IMP2 RTAssertMsg2Weak\n"
+                "%%endif\n"
+                "BEGINCODE\n"
+                "\n"
+                "LazyLoading:\n"
+                "    mov     xCX, [g_hMod xWrtRIP]\n"
+                "    or      xCX, xCX\n"
+                "    jnz     .return\n"
+                "\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    lea     rdx, [g_hMod wrt rip]  ; phLdrMod\n"
+                "    mov     esi, 1                 ; fNoUnload=true\n"
+                "    lea     rdi, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    sub     rsp, 08h\n"
+                " %%ifdef IN_RT_R3\n"
+                "    call    NAME(RTLdrLoadSystem)\n"
+                " %%else\n"
+                "    call    IMP2(RTLdrLoadSystem)\n"
+                " %%endif\n"
+                "    add     rsp, 08h\n"
+                "\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    lea     r8, [g_hMod wrt rip]   ; phLdrMod\n"
+                "    mov     edx, 1                 ; fNoUnload=true\n"
+                "    lea     rcx, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    sub     rsp, 28h\n"
+                " %%ifdef IN_RT_R3\n"
+                "    call    NAME(RTLdrLoadSystem)\n"
+                " %%else\n"
+                "    call    IMP2(RTLdrLoadSystem)\n"
+                " %%endif\n"
+                "    add     rsp, 28h\n"
+                "\n"
+                "%%elifdef RT_ARCH_X86\n"
+                "    push    g_hMod         ; phLdrMod\n"
+                "    push    1              ; fNoUnload=true\n"
+                "    push    g_szLibrary    ; pszFilename\n"
+                " %%ifdef IN_RT_R3\n"
+                "    call    NAME(RTLdrLoadSystem)\n"
+                " %%else\n"
+                "    call    IMP2(RTLdrLoadSystem)\n"
+                " %%endif\n"
+                "    add     esp, 0ch\n"
+                "%%else\n"
+                " %%error \"Unsupported architecture\"\n"
+                "%%endif\n");
+    fprintf(pOutput,
+            "    or      eax, eax\n"
+            "    jnz    .badload\n"
+            "    mov     xCX, [g_hMod xWrtRIP]\n"
+            ".return:\n"
+            "    ret\n"
+            "\n"
+            ".badload:\n"
+            "%%ifdef ASM_CALL64_GCC\n"
+            "    mov     edx, eax\n"
+            "    lea     rsi, [g_szLibrary wrt rip]\n"
+            "    lea     rdi, [g_szFailLoadFmt wrt rip]\n"
+            "    sub     rsp, 08h\n"
+            "%%elifdef ASM_CALL64_MSC\n"
+            "    mov     r8d, eax\n"
+            "    lea     rdx, [g_szLibrary wrt rip]\n"
+            "    lea     rcx, [g_szFailLoadFmt wrt rip]\n"
+            "    sub     rsp, 28h\n"
+            "%%elifdef RT_ARCH_X86\n"
+            "    push    eax\n"
+            "    push    g_szLibrary\n"
+            "    push    g_szFailLoadFmt\n"
+            "%%endif\n"
+            "%%ifdef IN_RT_R3\n"
+            "    call    NAME(RTAssertMsg2Weak)\n"
+            "%%else\n"
+            "    call    IMP2(RTAssertMsg2Weak)\n"
+            "%%endif\n"
+            ".badloadloop:\n"
+            "    int3\n"
+            "    jmp     .badloadloop\n"
+            "LazyLoading_End:\n"
+            "\n"
+            "\n");
+
+
+    fprintf(pOutput,
+            ";\n"
+            ";RTDECL(int) RTLdrGetSymbol(RTLDRMOD hLdrMod, const char *pszSymbol, void **ppvValue);\n"
+            ";\n"
+            "%%ifdef IN_RT_R3\n"
+            "extern NAME(RTLdrGetSymbol)\n"
+            "%%else\n"
+            "EXTERN_IMP2 RTLdrGetSymbol\n"
+            "%%endif\n"
+            "BEGINCODE\n"
+            "LazyLoadResolver:\n"
+            "%%ifdef RT_ARCH_AMD64\n"
+            "    push    rbp\n"
+            "    mov     rbp, rsp\n"
+            "    push    r15\n"
+            "    push    r14\n"
+            "    mov     r15, rax       ; name\n"
+            "    mov     r14, r10       ; ppfn\n"
+            "    push    r9\n"
+            "    push    r8\n"
+            "    push    rcx\n"
+            "    push    rdx\n"
+            "    push    r12\n"
+            " %%ifdef ASM_CALL64_GCC\n"
+            "    push    rsi\n"
+            "    push    rdi\n"
+            "    mov     r12, rsp\n"
+            " %%else\n"
+            "    mov     r12, rsp\n"
+            "    sub     rsp, 20h\n"
+            " %%endif\n"
+            "    and     rsp, 0fffffff0h ; Try make sure the stack is aligned\n"
+            "\n"
+            "    call    LazyLoading    ; returns handle in rcx\n"
+            " %%ifdef ASM_CALL64_GCC\n"
+            "    mov     rdi, rcx       ; hLdrMod\n"
+            "    mov     rsi, r15       ; pszSymbol\n"
+            "    mov     rdx, r14       ; ppvValue\n"
+            " %%else\n"
+            "    mov     rdx, r15       ; pszSymbol\n"
+            "    mov     r8, r14        ; ppvValue\n"
+            " %%endif\n"
+            " %%ifdef IN_RT_R3\n"
+            "    call    NAME(RTLdrGetSymbol)\n"
+            " %%else\n"
+            "    call    IMP2(RTLdrGetSymbol)\n"
+            " %%endif\n"
+            "    or      eax, eax\n"
+            "    jnz     .badsym\n"
+            "\n"
+            "    mov     rsp, r12\n"
+            " %%ifdef ASM_CALL64_GCC\n"
+            "    pop     rdi\n"
+            "    pop     rsi\n"
+            " %%endif\n"
+            "    pop     r12\n"
+            "    pop     rdx\n"
+            "    pop     rcx\n"
+            "    pop     r8\n"
+            "    pop     r9\n"
+            "    pop     r14\n"
+            "    pop     r15\n"
+            "    leave\n"
+            "\n"
+            "%%elifdef RT_ARCH_X86\n"
+            "    push    ebp\n"
+            "    mov     ebp, esp\n"
+            "    push    eax\n"
+            "    push    ecx\n"
+            "    push    edx\n"
+            "    and     esp, 0fffffff0h\n"
+            "\n"
+            ".loaded:\n"
+            "    call    LazyLoading      ; returns handle in ecx\n"
+            "    push    dword [ebp + 8]  ; value addr\n"
+            "    push    dword [ebp + 12] ; symbol name\n"
+            "    push    ecx\n"
+            " %%ifdef IN_RT_R3\n"
+            "    call    NAME(RTLdrGetSymbol)\n"
+            " %%else\n"
+            "    call    IMP2(RTLdrGetSymbol)\n"
+            " %%endif\n"
+            "    or      eax, eax\n"
+            "    jnz     .badsym\n"
+            "    lea     esp, [ebp - 0ch]\n"
+            "    pop     edx\n"
+            "    pop     ecx\n"
+            "    pop     eax\n"
+            "    leave\n"
+            "%%else\n"
+            " %%error \"Unsupported architecture\"\n"
+            "%%endif\n"
+            "    ret\n"
+            "\n"
+            ".badsym:\n"
+            "%%ifdef ASM_CALL64_GCC\n"
+            "    mov     ecx, eax\n"
+            "    lea     rdx, [g_szLibrary wrt rip]\n"
+            "    mov     rsi, r15\n"
+            "    lea     rdi, [g_szFailResolveFmt wrt rip]\n"
+            "    sub     rsp, 08h\n"
+            "%%elifdef ASM_CALL64_MSC\n"
+            "    mov     r9d, eax\n"
+            "    mov     r8, r15\n"
+            "    lea     rdx, [g_szLibrary wrt rip]\n"
+            "    lea     rcx, [g_szFailResolveFmt wrt rip]\n"
+            "    sub     rsp, 28h\n"
+            "%%elifdef RT_ARCH_X86\n"
+            "    push    eax\n"
+            "    push    dword [ebp + 12]\n"
+            "    push    g_szLibrary\n"
+            "    push    g_szFailResolveFmt\n"
+            "%%endif\n"
+            "%%ifdef IN_RT_R3\n"
+            "    call    NAME(RTAssertMsg2Weak)\n"
+            "%%else\n"
+            "    call    IMP2(RTAssertMsg2Weak)\n"
+            "%%endif\n"
+            ".badsymloop:\n"
+            "    int3\n"
+            "    jmp     .badsymloop\n"
+            "\n"
+            "LazyLoadResolver_End:\n"
+            "\n"
+            "\n"
+            );
+
+
+
+    /*
+     * C callable method for explicitly loading the library and optionally
+     * resolving all the imports.
+     */
+    if (g_fWithExplictLoadFunction)
+    {
+        if (g_fSystemLibrary) /* Lazy bird. */
+        {
+            fprintf(stderr, "error: cannot use --system with --explicit-load-function, sorry\n");
+            return RTEXITCODE_FAILURE;
+        }
+
+        int cchLibBaseName = (int)(strchr(g_pszLibrary, '.') ? strchr(g_pszLibrary, '.') - g_pszLibrary : strlen(g_pszLibrary));
+        fprintf(pOutput,
+                ";;\n"
+                "; ExplicitlyLoad%.*s(bool fResolveAllImports, pErrInfo);\n"
+                ";\n"
+                "EXTERN_IMP2 RTErrInfoSet\n"
+                "BEGINCODE\n"
+                "BEGINPROC ExplicitlyLoad%.*s\n"
+                "    push    xBP\n"
+                "    mov     xBP, xSP\n"
+                "    push    xBX\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                " %%define pszCurStr r14\n"
+                "    push    r14\n"
+                "%%else\n"
+                " %%define pszCurStr xDI\n"
+                "    push    xDI\n"
+                "%%endif\n"
+                "    sub     xSP, 40h\n"
+                "\n"
+                "    ;\n"
+                "    ; Save parameters on stack (64-bit only).\n"
+                "    ;\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    mov     [xBP - xCB * 3], rdi ; fResolveAllImports\n"
+                "    mov     [xBP - xCB * 4], rsi ; pErrInfo\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    mov     [xBP - xCB * 3], rcx ; fResolveAllImports\n"
+                "    mov     [xBP - xCB * 4], rdx ; pErrInfo\n"
+                "%%endif\n"
+                "\n"
+                "    ;\n"
+                "    ; Is the module already loaded?\n"
+                "    ;\n"
+                "    cmp     RTCCPTR_PRE [g_hMod xWrtRIP], 0\n"
+                "    jnz     .loaded\n"
+                "\n"
+                "    ;\n"
+                "    ; Load the module.\n"
+                "    ;\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    mov     rcx, [xBP - xCB * 4]       ; pErrInfo\n"
+                "    xor     rdx, rdx                   ; fFlags (local load)\n"
+                "    lea     rsi, [g_hMod wrt rip]      ; phLdrMod\n"
+                "    lea     rdi, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    mov     r9, [xBP - xCB * 4]        ; pErrInfo\n"
+                "    xor     r8, r8                     ; fFlags (local load)\n"
+                "    lea     rdx, [g_hMod wrt rip]      ; phLdrMod\n"
+                "    lea     rcx, [g_szLibrary wrt rip] ; pszFilename\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "\n"
+                "%%elifdef RT_ARCH_X86\n"
+                "    sub     xSP, 0ch\n"
+                "    push    dword [xBP + 12]           ; pErrInfo\n"
+                "    push    0                          ; fFlags (local load)\n"
+                "    push    g_hMod                     ; phLdrMod\n"
+                "    push    g_szLibrary                ; pszFilename\n"
+                "    call    IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
+                "    add     esp, 1ch\n"
+                "%%else\n"
+                " %%error \"Unsupported architecture\"\n"
+                "%%endif\n"
+                "    or      eax, eax\n"
+                "    jnz     .return\n"
+                "\n"
+                "    ;\n"
+                "    ; Resolve the imports too if requested to do so.\n"
+                "    ;\n"
+                ".loaded:\n"
+                "%%ifdef ASM_ARCH_X86\n"
+                "    cmp     byte [xBP + 8], 0\n"
+                "%%else\n"
+                "    cmp     byte [xBP - xCB * 3], 0\n"
+                "%%endif\n"
+                "    je      .return\n"
+                "\n"
+                "    lea     pszCurStr, [g_szzNames xWrtRIP]\n"
+                "    lea     xBX, [g_apfnImports xWrtRIP]\n"
+                ".next_import:\n"
+                "    cmp     RTCCPTR_PRE [xBX], 0\n"
+                "    je      .return\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    mov     rdx, xBX                  ; ppvValue\n"
+                "    mov     rsi, pszCurStr            ; pszSymbol\n"
+                "    mov     rdi, [g_hMod wrt rip]     ; hLdrMod\n"
+                "    call    IMP2(RTLdrGetSymbol)\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    mov     r8, xBX                   ; ppvValue\n"
+                "    mov     rdx, pszCurStr            ; pszSymbol\n"
+                "    mov     rcx, [g_hMod wrt rip]     ; pszSymbol\n"
+                "    call    IMP2(RTLdrGetSymbol)\n"
+                "%%else\n"
+                "    push    xBX                       ; ppvValue\n"
+                "    push    pszCurStr                 ; pszSymbol\n"
+                "    push    RTCCPTR_PRE [g_hMod]      ; hLdrMod\n"
+                "    call    IMP2(RTLdrGetSymbol)\n"
+                "    add     xSP, 0ch\n"
+                "%%endif\n"
+                "    or      eax, eax\n"
+                "    jnz     .symbol_error\n"
+                "\n"
+                "    ; Advance.\n"
+                "    add     xBX, RTCCPTR_CB\n"
+                "    xor     eax, eax\n"
+                "    mov     xCX, 0ffffffffh\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    mov     xDI, pszCurStr\n"
+                "    repne scasb\n"
+                "    mov     pszCurStr, xDI\n"
+                "%%else\n"
+                "    repne scasb\n"
+                "%%endif\n"
+                "    jmp     .next_import\n"
+                "\n"
+                "    ;\n"
+                "    ; Error loading a symbol. Call RTErrInfoSet on pErrInfo (preserves eax).\n"
+                "    ;\n"
+                ".symbol_error:\n"
+                "%%ifdef ASM_CALL64_GCC\n"
+                "    mov     rdx, pszCurStr            ; pszMsg\n"
+                "    mov     esi, eax                  ; rc\n"
+                "    mov     rdi, [xBP - xCB * 4]      ; pErrInfo\n"
+                "    call    IMP2(RTErrInfoSet)\n"
+                "%%elifdef ASM_CALL64_MSC\n"
+                "    mov     r8, pszCurStr             ; pszMsg\n"
+                "    mov     edx, eax                  ; rc\n"
+                "    mov     rcx, [xBP - xCB * 4]      ; pErrInfo\n"
+                "    call    IMP2(RTErrInfoSet)\n"
+                "%%else\n"
+                "    push    pszCurStr                 ; pszMsg\n"
+                "    push    eax                       ; pszSymbol\n"
+                "    push    dword [xBP + 0ch]         ; pErrInfo\n"
+                "    call    IMP2(RTErrInfoSet)\n"
+                "    add     xSP, 0ch\n"
+                "%%endif\n"
+                "    "
+                "\n"
+                ".return:\n"
+                "    mov    pszCurStr, [xBP - xCB * 2]\n"
+                "    mov    xBX,       [xBP - xCB * 1]\n"
+                "    leave\n"
+                "    ret\n"
+                "ENDPROC   ExplicitlyLoad%.*s\n"
+                "\n"
+                "\n"
+                ,
+                cchLibBaseName, g_pszLibrary,
+                cchLibBaseName, g_pszLibrary,
+                cchLibBaseName, g_pszLibrary
+                );
+    }
+
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Generates the assembly source code for ARM64, writing it
+ * to @a pOutput.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
+ *          details has been displayed.
+ * @param   pOutput              The output stream (caller checks it for errors
+ *                               when closing).
+ */
+static RTEXITCODE generateOutputInnerArm64(FILE *pOutput)
+{
+//    bool fMachO  = true;
+//    bool fDarwin = true;
+    const char *pszNmPfx = "_";
+
+    fprintf(pOutput, ";;\n");
+    for (unsigned i = 0; i < g_cInputs; i++)
+        fprintf(pOutput, ";; Autogenerated from '%s'.\n", g_apszInputs[i]);
+
+    fprintf(pOutput,
+            ";; DO NOT EDIT!\n"
+            ";;\n"
+            "\n"
+            "\n"
+            /*"%%include \"iprt/asmdefs.mac\"\n"*/
+            "\n"
+            "\n");
+
+    /*
+     * Put the thunks first for alignment and other reasons. It's the hot part of the code.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Thunks.\n"
+            ";\n"
+            ".section __TEXT,__text,regular,pure_instructions\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        fprintf(pOutput,
+                ".p2align 3\n"
+                ".globl %s%s\n"
+                "%s%s:\n"
+                "    adrp    x9, %sg_pfn%s@PAGE\n"
+                "    ldr     x9, [x9, %sg_pfn%s@PAGEOFF]\n"
+                "    br      x9\n",
+                pszNmPfx, pExp->szName, pszNmPfx, pExp->szName, pszNmPfx, pExp->szName, pszNmPfx, pExp->szName);
+    fprintf(pOutput,
+            "\n"
+            "\n");
+
+    /*
+     * Import pointers
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Import pointers. Initialized to point a lazy loading stubs.\n"
+            ";\n"
+            ".section __DATA,__data\n"
+            ".p2align 3\n"
+            "g_apfnImports:\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        fprintf(pOutput,
+                ".globl __imp_%s\n"
+                "__imp_%s:\n"
+                ".globl %sg_pfn%s\n"
+                "%sg_pfn%s:\n"
+                "    .quad ___LazyLoad___%s\n"
+                "\n",
+                pExp->szName, pExp->szName,
+                pszNmPfx, pExp->szName, pszNmPfx, pExp->szName,
+                pExp->pszExportedNm);
+    fprintf(pOutput,
+            "    .quad 0 ; Terminator entry for traversal.\n"
+            "\n"
+            "\n");
+
+    /*
+     * Now for the less important stuff, starting with the names.
+     *
+     * We keep the names separate so we can traverse them in parallel to
+     * g_apfnImports in the load-everything routine further down.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Imported names.\n"
+            ";\n"
+            ".section __TEXT,__cstring,cstring_literals\n"
+            "g_szLibrary:\n"
+            "    .asciz \"%s\"\n"
+            "\n"
+            "g_szzNames:\n",
+            g_pszLibrary);
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+        if (!pExp->fNoName)
+            fprintf(pOutput, "  g_sz%s:\n    .asciz \"%s\"\n", pExp->pszExportedNm, pExp->pszExportedNm);
+        else
+            fprintf(pOutput, "  g_sz%s:\n    .asciz \"#%u\"\n", pExp->pszExportedNm, pExp->uOrdinal);
+    fprintf(pOutput,
+            "g_EndOfNames: .byte 0\n"
+            "\n"
+            "g_szFailLoadFmt:    .asciz \"Lazy loader failed to load \\\"%%s\\\": %%Rrc\\n\"\n"
+            "g_szFailResolveFmt: .asciz \"Lazy loader failed to resolve symbol \\\"%%s\\\" in \\\"%%s\\\": %%Rrc\\n\"\n"
+            "\n"
+            "\n");
+
+    /*
+     * The per import lazy load code.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; Lazy load+resolve stubs.\n"
+            ";\n"
+            ".section __TEXT,__text,regular,pure_instructions\n"
+            ".p2align 3\n");
+    for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
+    {
+        if (!pExp->fNoName)
+            fprintf(pOutput,
+                    "___LazyLoad___%s:\n"
+                    "    adrp    x9, g_sz%s@PAGE\n"
+                    "    add     x9, x9, g_sz%s@PAGEOFF\n"
+                    "    adrp    x10, %sg_pfn%s@PAGE\n"
+                    "    add     x10, x10, %sg_pfn%s@PAGEOFF\n"
+                    "    bl      LazyLoadResolver\n"
+                    , pExp->pszExportedNm,
+                    pExp->pszExportedNm, pExp->pszExportedNm,
+                    pszNmPfx, pExp->pszExportedNm, pszNmPfx, pExp->pszExportedNm);
+        else
+            fprintf(pOutput,
+                    "___LazyLoad___%s:\n"
+                    "    movk    w9, #%u\n"
+                    "    adrp    x10, %sg_pfn%s@PAGE\n"
+                    "    add     x10, x10, %sg_pfn%s@PAGEOFF\n"
+                    , pExp->pszExportedNm,
+                    pExp->uOrdinal,
+                    pszNmPfx, pExp->pszExportedNm, pszNmPfx, pExp->pszExportedNm);
+        fprintf(pOutput, "    b       %s%s\n", pszNmPfx, pExp->szName);
+        fprintf(pOutput, "\n");
+    }
+    fprintf(pOutput,
+            "\n"
+            "\n"
+            "\n");
+
+    /*
+     * The code that does the loading and resolving.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; The module handle.\n"
+            ";\n"
+            ".section __DATA,__data\n"
+            "g_hMod:\n"
+            "    .quad 0\n"
+            "\n"
+            "\n"
+            "\n");
+
+    /*
+     * Common lazy loader and resolved.
+     */
+    fprintf(pOutput,
+            ";\n"
+            "; The resolver code.\n"
+            ";\n"
+            ".section __TEXT,__text,regular,pure_instructions\n"
+            ".p2align 3\n"
+            "LazyLoadResolver:\n"
+            "    .cfi_startproc\n"
+            "    ; Create frame.\n"
+            "    sub     sp, sp, #(16 + 192)\n"
+            "    stp     x29, x30, [sp, #192]\n"
+            "    add     x29, sp, #192\n"
+            "    .cfi_def_cfa x29, 16\n"
+            "    .cfi_offset x30, -8\n"
+            "    .cfi_offset x29, -16\n"
+            "    ; Save all argument registers and a handful of preserved ones.\n"
+            "    stp     x0,   x1, [sp, #(192 - 16)]\n"
+            "    .cfi_offset  x0, -32\n"
+            "    .cfi_offset  x1, -24\n"
+            "    stp     x2,   x3, [sp, #(192 - 32)]\n"
+            "    .cfi_offset  x3, -40\n"
+            "    .cfi_offset  x2, -48\n"
+            "    stp     x4,   x5, [sp, #(192 - 48)]\n"
+            "    .cfi_offset  x6, -56\n"
+            "    .cfi_offset  x5, -64\n"
+            "    stp     x6,   x7, [sp, #(192 - 64)]\n"
+            "    .cfi_offset  x7, -72\n"
+            "    .cfi_offset  x6, -80\n"
+            "    stp     x16, x17, [sp, #(192 - 80)]\n"
+            "    .cfi_offset x17, -88\n"
+            "    .cfi_offset x16, -96\n"
+            "    stp     x18, x19, [sp, #(192 - 96)]\n"
+            "    .cfi_offset x19, -104\n"
+            "    .cfi_offset x18, -112\n"
+            "    stp     x20, x21, [sp, #(192 - 112)]\n"
+            "    .cfi_offset x21, -120\n"
+            "    .cfi_offset x20, -128\n"
+            "    stp     x22, x23, [sp, #(192 - 128)]\n"
+            "    .cfi_offset x23, -136\n"
+            "    .cfi_offset x22, -144\n"
+            "    str     x8,       [sp, #(192 - 144)]\n"
+            "\n"
+            "    ; Shift the symbol name to x19 and g_pfnXXXX pointer to x20 as these are preserved registers\n"
+            "    ; (in case we need to call LazyLoadModule/RTLdrLoad)\n"
+            "    mov     x19, x9\n"
+            "    mov     x20, x10\n"
+            "\n"
+            "    ; Get the module handle and call RTLdrGetSymbol(RTLDRMOD hLdrMod, const char *pszSymbol, void **ppvValue)\n"
+            "    adrp    x0, g_hMod@PAGE\n"
+            "    ldr     x0, [x0, g_hMod@PAGEOFF]\n"
+            "    cmp     x0, #0\n"
+            "    b.eq    LazyLoading\n"
+            "    mov     x1, x19\n"
+            "    mov     x2, x20\n"
+            "    bl      %sRTLdrGetSymbol\n"
+            "\n"
+            "    cmp     w0, #0\n"
+            "    b.eq    Lreturn\n"
+            "\n"
+            "Lbadsym: ; Call sRTAssertMsg2Weak. Variadic (...) arguments are passed on the stack it seems.\n"
+            "    mov     x3, x0\n"
+            "    adrp    x2, g_szLibrary@PAGE\n"
+            "    add     x2, x2, g_szLibrary@PAGEOFF\n"
+            "    mov     x1, x19\n"
+            "    adrp    x0, g_szFailLoadFmt@PAGE\n"
+            "    add     x0, x0, g_szFailLoadFmt@PAGEOFF\n"
+            "    stp     x1, x2, [sp]\n"
+            "    str     x3,     [sp, #16]\n"
+            "    bl      %sRTAssertMsg2Weak\n"
+            "Lbadsymloop:\n"
+            "    brk     #0x1\n"
+            "    b       Lbadsymloop\n"
+
+            "Lreturn:\n"
+            "    ; Restore saved register\n"
+            "    ldr     x8,       [sp, #(192 - 144)]\n"
+            "    .cfi_restore x8\n"
+            "    ldp     x22, x23, [sp, #(192 - 128)]\n"
+            "    .cfi_restore x23\n"
+            "    .cfi_restore x22\n"
+            "    ldp     x20, x21, [sp, #(192 - 112)]\n"
+            "    .cfi_restore x21\n"
+            "    .cfi_restore x20\n"
+            "    ldp     x18, x19, [sp, #(192 - 96)]\n"
+            "    .cfi_restore x19\n"
+            "    .cfi_restore x18\n"
+            "    ldp     x16, x17, [sp, #(192 - 80)]\n"
+            "    .cfi_restore x17\n"
+            "    .cfi_restore x18\n"
+            "    ldp     x6,   x7, [sp, #(192 - 64)]\n"
+            "    .cfi_restore x7\n"
+            "    .cfi_restore x6\n"
+            "    ldp     x4,   x5, [sp, #(192 - 48)]\n"
+            "    .cfi_restore x5\n"
+            "    .cfi_restore x4\n"
+            "    ldp     x2,   x3, [sp, #(192 - 32)]\n"
+            "    .cfi_restore x3\n"
+            "    .cfi_restore x2\n"
+            "    ldp     x0,   x1, [sp, #(192 - 16)]\n"
+            "    .cfi_restore x1\n"
+            "    .cfi_restore x0\n"
+            "\n"
+            "    ldp     x29, x30, [sp, #192]\n"
+            "    .cfi_restore x29\n"
+            "    .cfi_restore x30\n"
+            "    add     sp, sp, #(16 + 192)\n"
+            "    ret\n"
+            "    .cfi_endproc\n"
+            "\n"
+            "\n"
+            , pszNmPfx, pszNmPfx);
+
+    fprintf(pOutput,
+            ";\n"
+            "; Loads the module.\n"
+            "; ASSUMES called from LazyLoadResolver where all relevant registers are already saved.\n"
+            ";\n"
+            "LazyLoading:\n"
+            "    .cfi_startproc\n"
+            "    ; Create frame.\n"
+            "    sub     sp, sp, #(16 + 48)\n"
+            "    stp     x29, x30, [sp, #48]\n"
+            "    add     x29, sp, #48\n"
+            "    .cfi_def_cfa x29, 16\n"
+            "    .cfi_offset x30, -8\n"
+            "    .cfi_offset x29, -16\n"
+            "\n");
+
+    if (!g_fSystemLibrary)
+        fprintf(pOutput,
+                "    ; Call SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);\n"
+                "    mov     x3, #0\n"
+                "    mov     x2, #0\n"
+                "    adrp    x1, g_hMod@PAGE\n"
+                "    add     x1, x1, g_hMod@PAGEOFF\n"
+                "    adrp    x0, g_szLibrary@PAGE\n"
+                "    add     x0, x0, g_szLibrary@PAGEOFF\n"
+                "    bl      %sSUPR3HardenedLdrLoadAppPriv\n"
+                , pszNmPfx);
+    else
+        fprintf(pOutput,
+                "    ; Call RTLdrLoadSystem(const char *pszFilename, bool fNoUnload, PRTLDRMOD phLdrMod);\n"
+                "    adrp    x2, g_hMod@PAGE\n"
+                "    add     x2, x2, g_hMod@PAGEOFF\n"
+                "    mov     x1, #1\n"
+                "    adrp    x0, g_szLibrary@PAGE\n"
+                "    add     x0, x0, g_szLibrary@PAGEOFF\n"
+                "    bl      %sRTLdrLoadSystem\n"
+                , pszNmPfx);
+
+    fprintf(pOutput,
+            "    cmp     w0, #0\n"
+            "    b.eq    Lload_return\n"
+            "\n"
+            "Lbadload: ; Call sRTAssertMsg2Weak. Variadic (...) arguments are passed on the stack it seems.\n"
+            "    mov     x2, x0\n"
+            "    adrp    x1, g_szLibrary@PAGE\n"
+            "    add     x1, x1, g_szLibrary@PAGEOFF\n"
+            "    adrp    x0, g_szFailResolveFmt@PAGE\n"
+            "    add     x0, x0, g_szFailResolveFmt@PAGEOFF\n"
+            "    stp     x1, x2, [sp]\n"
+            "    bl      %sRTAssertMsg2Weak\n"
+            "Lbadloadloop:\n"
+            "    brk     #0x1\n"
+            "    b       Lbadloadloop\n"
+            "Lload_return:\n"
+            "    adrp    x0, g_hMod@PAGE\n"
+            "    ldr     x0, [x0, g_hMod@PAGEOFF]\n"
+            "    ldp     x29, x30, [sp, #48]\n"
+            "    .cfi_restore x29\n"
+            "    .cfi_restore x30\n"
+            "    add     sp, sp, #(16 + 48)\n"
+            "    ret\n"
+            "    .cfi_endproc\n"
+            "\n"
+            "\n"
+            , pszNmPfx);
+
+    /*
+     * C callable method for explicitly loading the library and optionally
+     * resolving all the imports.
+     */
+    if (g_fWithExplictLoadFunction)
+    {
+        if (g_fSystemLibrary) /* Lazy bird. */
+        {
+            fprintf(stderr, "error: cannot use --system with --explicit-load-function, sorry\n");
+            return RTEXITCODE_FAILURE;
+        }
+
+        int cchLibBaseName = (int)(strchr(g_pszLibrary, '.') ? strchr(g_pszLibrary, '.') - g_pszLibrary : strlen(g_pszLibrary));
+        fprintf(pOutput,
+                ";;\n"
+                "; ExplicitlyLoad%.*s(bool fResolveAllImports, pErrInfo);\n"
+                ";\n"
+                ".section __TEXT,__text,regular,pure_instructions\n"
+                ".p2align 3\n"
+                ".globl %sExplicitlyLoad%.*s\n"
+                "%sExplicitlyLoad%.*s:\n"
+                "    .cfi_startproc\n"
+                "    ; Create frame.\n"
+                "    sub     sp, sp, #(16 + 96)\n"
+                "    stp     x29, x30, [sp, #96]\n"
+                "    add     x29, sp, #96\n"
+                "    .cfi_def_cfa x29, 16\n"
+                "    .cfi_offset x30, -8\n"
+                "    .cfi_offset x29, -16\n"
+                "\n"
+                "    stp     x20, x21, [sp, #(96 - 16)]\n"
+                "    .cfi_offset x21, -24\n"
+                "    .cfi_offset x20, -32\n"
+                "    stp     x22, x23, [sp, #(96 - 32)]\n"
+                "    .cfi_offset x23, -40\n"
+                "    .cfi_offset x22, -48\n"
+
+                "    ; Save the input parameters.\n"
+                "    mov     x20, x0\n"
+                "    mov     x21, x1\n"
+                "\n"
+                "    ;\n"
+                "    ; Is the module already loaded?\n"
+                "    ;\n"
+                "    adrp    x0, g_hMod@PAGE\n"
+                "    ldr     x0, [x0, g_hMod@PAGEOFF]\n"
+                "    cmp     x0, #0\n"
+                "    b.ne    Lexplicit_loaded_module\n"
+                "\n"
+                ,
+                cchLibBaseName, g_pszLibrary,
+                pszNmPfx, cchLibBaseName, g_pszLibrary,
+                pszNmPfx, cchLibBaseName, g_pszLibrary);
+        fprintf(pOutput,
+                "Lexplicit_load_module:\n"
+                "    ; Call SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);\n"
+                "    mov     x3, #0\n"
+                "    mov     x2, #0\n"
+                "    adrp    x1, g_hMod@PAGE\n"
+                "    add     x1, x1, g_hMod@PAGEOFF\n"
+                "    adrp    x0, g_szLibrary@PAGE\n"
+                "    add     x0, x0, g_szLibrary@PAGEOFF\n"
+                "    bl      %sSUPR3HardenedLdrLoadAppPriv\n"
+                "    cmp     x0, #0\n"
+                "    b.ne    Lexplicit_load_return\n"
+                "\n"
+                , pszNmPfx);
+
+        fprintf(pOutput,
+                "    ;\n"
+                "    ; Resolve the imports too if requested to do so.\n"
+                "    ;\n"
+                "Lexplicit_loaded_module:\n"
+                "    cmp     w20, #0\n"
+                "    b.eq    Lexplicit_load_return\n"
+                "\n"
+                "    adrp     x22, g_szzNames@PAGE\n"
+                "    add      x22, x22, g_szzNames@PAGEOFF\n"
+                "    adrp     x23, g_apfnImports@PAGE\n"
+                "    add      x23, x23, g_apfnImports@PAGEOFF\n"
+                "Lexplicit_load_next_import:\n"
+                "    ldr     x0, [x23]\n"
+                "    cmp     x0, #0\n"
+                "    b.eq    Lexplicit_load_return\n"
+                "\n"
+                "    ; Get the module handle and call RTLdrGetSymbol(RTLDRMOD hLdrMod, const char *pszSymbol, void **ppvValue)\n"
+                "    adrp    x0, g_hMod@PAGE\n"
+                "    ldr     x0, [x0, g_hMod@PAGEOFF]\n"
+                "    mov     x1, x22\n"
+                "    mov     x2, x23\n"
+                "    bl      %sRTLdrGetSymbol\n"
+                "    cmp     x0, #0\n"
+                "    b.ne    Lexplicit_load_symbol_error\n"
+                "\n"
+                "    ; Advance.\n"
+                "    add     x23, x23, #8\n"
+                "Lexplict_load_advance_string:\n"
+                "    ldrb    w0, [x22]\n"
+                "    add     x22, x22, #1\n"
+                "    cmp     w0, #0\n"
+                "    b.ne    Lexplict_load_advance_string\n"
+                "    b       Lexplicit_load_next_import\n"
+                "\n"
+                "    ;\n"
+                "    ; Error loading a symbol. Call RTErrInfoSet(PRTERRINFO pErrInfo, int rc, const char *pszMsg) on pErrInfo (preserves x0).\n"
+                "    ;\n"
+                "Lexplicit_load_symbol_error:\n"
+                "    mov     x2, x22\n"
+                "    mov     x1, x0\n"
+                "    mov     x0, x21\n"
+                "    bl      %sRTErrInfoSet\n"
+                "    b       Lexplicit_load_return"
+                "    "
+                "\n"
+                "Lexplicit_load_return:\n"
+                "    ldp     x22,   x23, [sp, #(96 - 32)]\n"
+                "    .cfi_restore x23\n"
+                "    .cfi_restore x22\n"
+                "    ldp     x20,   x21, [sp, #(96 - 16)]\n"
+                "    .cfi_restore x21\n"
+                "    .cfi_restore x20\n"
+                "\n"
+                "    ldp     x29, x30, [sp, #96]\n"
+                "    .cfi_restore x29\n"
+                "    .cfi_restore x30\n"
+                "    add     sp, sp, #(16 + 96)\n"
+                "    ret\n"
+                "    .cfi_endproc\n"
+                "\n"
+                "\n"
+                , pszNmPfx, pszNmPfx);
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Generates the assembly source code, writing it to g_pszOutput.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
+ *          details has been displayed.
+ */
+static RTEXITCODE generateOutput(void)
+{
+    RTEXITCODE rcExit = RTEXITCODE_FAILURE;
+    FILE *pOutput = fopen(g_pszOutput, "w");
+    if (pOutput)
+    {
+        switch (g_enmTarget)
+        {
+            case RTLDRARCH_AMD64:
+            case RTLDRARCH_X86_32:
+                rcExit = generateOutputInnerX86AndAMD64(pOutput);
+                break;
+            case RTLDRARCH_ARM64:
+                rcExit = generateOutputInnerArm64(pOutput);
+                break;
+            default:
+                rcExit = RTEXITCODE_FAILURE;
+                break;
+        }
+        if (fclose(pOutput))
+        {
+            fprintf(stderr, "error: Error closing '%s'.\n", g_pszOutput);
+            rcExit = RTEXITCODE_FAILURE;
+        }
+    }
+    else
+        fprintf(stderr, "error: Failed to open '%s' for writing.\n", g_pszOutput);
+    return rcExit;
+}
+
+
+/**
+ * Displays usage information.
+ *
+ * @returns RTEXITCODE_SUCCESS.
+ * @param   pszArgv0            The argv[0] string.
+ */
+static int usage(const char *pszArgv0)
+{
+    printf("usage: %s [options] --libary <loadname> --output <lazyload.asm> <input.def>\n"
+           "\n"
+           "Options:\n"
+           "  --explicit-load-function, --no-explicit-load-function\n"
+           "    Whether to include the explicit load function, default is not to.\n"
+           "\n"
+           "Copyright (C) 2013-2016 Oracle Corporation\n"
+           , pszArgv0);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+int main(int argc, char **argv)
+{
+    /*
+     * Parse options.
+     */
+    for (int i = 1; i < argc; i++)
+    {
+        const char *psz = argv[i];
+        if (*psz == '-')
+        {
+            if (!strcmp(psz, "--output") || !strcmp(psz, "-o"))
+            {
+                if (++i >= argc)
+                {
+                    fprintf(stderr, "syntax error: File name expected after '%s'.\n", psz);
+                    return RTEXITCODE_SYNTAX;
+                }
+                g_pszOutput = argv[i];
+            }
+            else if (!strcmp(psz, "--library") || !strcmp(psz, "-l"))
+            {
+                if (++i >= argc)
+                {
+                    fprintf(stderr, "syntax error: Library name expected after '%s'.\n", psz);
+                    return RTEXITCODE_SYNTAX;
+                }
+                g_pszLibrary = argv[i];
+            }
+            else if (!strcmp(psz, "--explicit-load-function"))
+                g_fWithExplictLoadFunction = true;
+            else if (!strcmp(psz, "--no-explicit-load-function"))
+                g_fWithExplictLoadFunction = false;
+            else if (!strcmp(psz, "--system"))
+                g_fSystemLibrary = true;
+            /** @todo Support different load methods so this can be used on system libs and
+             *        such if we like. */
+            else if (   !strcmp(psz, "--help")
+                     || !strcmp(psz, "-help")
+                     || !strcmp(psz, "-h")
+                     || !strcmp(psz, "-?") )
+                return usage(argv[0]);
+            else if (   !strcmp(psz, "--version")
+                     || !strcmp(psz, "-V"))
+            {
+                printf("$Revision: 155244 $\n");
+                return RTEXITCODE_SUCCESS;
+            }
+            else
+            {
+                fprintf(stderr, "syntax error: Unknown option '%s'.\n", psz);
+                return RTEXITCODE_SYNTAX;
+            }
+        }
+        else
+        {
+            if (g_cInputs >= RT_ELEMENTS(g_apszInputs))
+            {
+                fprintf(stderr, "syntax error: Too many input files, max is %d.\n", (int)RT_ELEMENTS(g_apszInputs));
+                return RTEXITCODE_SYNTAX;
+            }
+            g_apszInputs[g_cInputs++] = argv[i];
+        }
+    }
+    if (g_cInputs == 0)
+    {
+        fprintf(stderr, "syntax error: No input file specified.\n");
+        return RTEXITCODE_SYNTAX;
+    }
+    if (!g_pszOutput)
+    {
+        fprintf(stderr, "syntax error: No output file specified.\n");
+        return RTEXITCODE_SYNTAX;
+    }
+    if (!g_pszLibrary)
+    {
+        fprintf(stderr, "syntax error: No library name specified.\n");
+        return RTEXITCODE_SYNTAX;
+    }
+
+    /*
+     * Do the job.
+     */
+    RTEXITCODE rcExit = parseInputs();
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = generateOutput();
+    return rcExit;
+}
+
diff --git a/src/bldprogs/VBoxEditCoffLib.cpp b/src/bldprogs/VBoxEditCoffLib.cpp
new file mode 100644
index 00000000..42bd5494
--- /dev/null
+++ b/src/bldprogs/VBoxEditCoffLib.cpp
@@ -0,0 +1,476 @@
+/* $Id: VBoxEditCoffLib.cpp $ */
+/** @file
+ * VBoxEditCoffLib - Simple COFF editor for library files.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <iprt/assertcompile.h>
+#include <iprt/types.h>
+#include <iprt/ctype.h>
+#include <iprt/formats/pecoff.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct ARHDR
+{
+    char    achName[16];
+    char    achDate[12];
+    char    achUid[6];
+    char    achGid[6];
+    char    achMode[8];
+    char    achSize[10];
+    char    achMagic[2];
+} ARHDR;
+AssertCompileSize(ARHDR, 16+12+6+6+8+10+2);
+
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Verbosity level. */
+static int      g_cVerbosity = 0;
+
+/** The binary size. */
+static unsigned g_cbBinary   = 0;
+/** The binary data we're editing.   */
+static uint8_t *g_pbBinary   = NULL;
+
+/** Size of the currently selected member. */
+static unsigned g_cbMember   = 0;
+/** Pointer to the data for the currently selected member. */
+static uint8_t *g_pbMember   = NULL;
+
+
+/**
+ * File size.
+ *
+ * @returns file size in bytes.
+ * @returns 0 on failure.
+ * @param   pFile   File to size.
+ */
+static unsigned fsize(FILE *pFile)
+{
+    long    cbFile;
+    off_t   Pos = ftell(pFile);
+    if (    Pos >= 0
+        &&  !fseek(pFile, 0, SEEK_END))
+    {
+        cbFile = ftell(pFile);
+        if (    cbFile >= 0
+            &&  !fseek(pFile, 0, SEEK_SET))
+            return cbFile;
+    }
+    return 0;
+}
+
+
+/**
+ * Reports a problem.
+ *
+ * @returns RTEXITCODE_FAILURE
+ */
+static int error(const char *pszFormat, ...)
+{
+    fprintf(stderr, "error: ");
+    va_list va;
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Reports a syntax problem.
+ *
+ * @returns RTEXITCODE_SYNTAX
+ */
+static int syntax(const char *pszFormat, ...)
+{
+    fprintf(stderr, "syntax error: ");
+    va_list va;
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Display usage
+ *
+ * @returns success if stdout, syntax error if stderr.
+ */
+static int usage(FILE *pOut, const char *argv0)
+{
+    fprintf(pOut,
+            "usage: %s --input <in.lib> --output <out.lib> [options and operations]\n"
+            "\n"
+            "Operations and Options (processed in place):\n"
+            "  --verbose   Noisier.\n"
+            "  --quiet     Quiet execution.\n"
+            "  --select <member>\n"
+            "      Selects archive member which name ends in the given string.\n"
+            "  --redefine-sym <old>=<new>\n"
+            "      Redefine the symbol <old> to <new>.\n"
+            "      Note! the length must be the same!\n"
+            , argv0);
+    return pOut == stdout ? RTEXITCODE_SUCCESS : RTEXITCODE_SYNTAX;
+}
+
+
+/**
+ * Helper for SelectMember.
+ */
+static bool AreAllDigits(const char *pch, size_t cch, size_t *puValue)
+{
+    *puValue = 0;
+    do
+    {
+        if (!RT_C_IS_DIGIT(*pch))
+            return false;
+        *puValue = *puValue * 10 + *pch - '0';
+        pch++;
+        cch--;
+    } while (cch > 0);
+    return true;
+}
+
+
+/**
+ * Selects archive member ending with the given name.
+ *
+ * Updates g_cbMember and g_pbMember.
+ */
+static int SelectMember(const char *pszEndsWith)
+{
+    size_t const cchEndsWith = strlen(pszEndsWith);
+
+    /*
+     * Check the header.
+     */
+    if (memcmp(g_pbBinary, RT_STR_TUPLE("!<arch>\n")))
+        return error("Not an AR library!\n");
+
+    /*
+     * Work the members.
+     */
+    const char *pszStringTab = NULL;
+    size_t      cbStringTab  = 0;
+    for (size_t off = sizeof("!<arch>\n") - 1; off < g_cbBinary;)
+    {
+        ARHDR      *pHdr = (ARHDR *)&g_pbBinary[off];
+        char        szTmp[16 + 8];
+        size_t      uValue;
+        char       *pszIgn;
+#define COPY_AND_TRIM(a_pchSrc, a_cbSrc) do { \
+            memcpy(szTmp, (a_pchSrc), (a_cbSrc)); \
+            size_t offCopy = (a_cbSrc); \
+            while (offCopy > 0 && (szTmp[offCopy - 1] == ' ' || szTmp[offCopy - 1] == '\0')) \
+                offCopy--; \
+            szTmp[offCopy] = '\0'; \
+        } while (0)
+
+        /*
+         * Parse the header.
+         */
+
+        /* The size: */
+        COPY_AND_TRIM(pHdr->achSize, sizeof(pHdr->achSize));
+        size_t cbFile = strtol(szTmp, &pszIgn, 10);
+
+        /* The name: */
+        size_t      cbExtra = 0;
+        size_t      cchName = sizeof(pHdr->achName);
+        const char *pchName = pHdr->achName;
+        if (   pchName[0] == '#'
+            && pchName[1] == '1'
+            && pchName[2] == '/')
+        {
+            COPY_AND_TRIM(&pchName[3], cchName - 3);
+            cchName = cbExtra = strtol(szTmp, &pszIgn, 10);
+            pchName = (char *)(pHdr + 1);
+        }
+        else
+        {
+            while (cchName > 0 && (pchName[cchName - 1] == ' ' || pchName[cchName - 1] == '\0'))
+                cchName--;
+
+            /* Long filename string table? */
+            if (   (cchName == 2 && pchName[0] == '/' && pchName[1] == '/')
+                || (cchName == sizeof("ARFILENAMES/") - 1 && memcmp(pchName, RT_STR_TUPLE("ARFILENAMES/")) == 0))
+            {
+                pszStringTab = (char *)(pHdr + 1);
+                cbStringTab  = cbFile;
+            }
+            /* Long filename string table reference? */
+            else if (   cchName >= 2
+                     && (   pchName[0] == '/' /* System V */
+                         || pchName[0] == ' ' /* Other */)
+                     && AreAllDigits(&pchName[1], cchName - 1, &uValue) && uValue < cbStringTab)
+            {
+                pchName = &pszStringTab[uValue];
+                cchName = strlen(pchName); /** @todo unsafe! */
+            }
+            /* Drop trailing slash in case of System V filename: */
+            else if (cchName > 1 && pchName[cchName - 1] == '/')
+                cchName -= 1;
+        }
+
+        if (g_cVerbosity > 2)
+            fprintf(stderr, "debug: %#08x: %#010x %*.*s\n",
+                    (unsigned)off, (unsigned)(cbFile - cbExtra), (int)cchName, (int)cchName, pchName);
+
+        /*
+         * Do matching.
+         */
+        if (   cchName >= cchEndsWith
+            && strncmp(&pchName[cchName - cchEndsWith], pszEndsWith, cchEndsWith) == 0)
+        {
+            g_pbMember = (uint8_t *)(pHdr + 1) + cbExtra;
+            g_cbMember = (unsigned)(cbFile - cbExtra);
+            if (g_cVerbosity > 1)
+                fprintf(stderr, "debug: selected '%*.*s': %#x LB %#x\n",
+                        (int)cchName, (int)cchName, pchName, (unsigned)(off + sizeof(*pHdr) + cbExtra), g_cbMember);
+            return 0;
+        }
+
+        /*
+         * Advance.
+         */
+        off += sizeof(ARHDR) + cbFile + (cbFile & 1);
+    }
+
+    return error("No member ending with '%s' was found!\n", pszEndsWith);
+}
+
+
+/**
+ * @note Borrowed from VBoxBs3objConverter.cpp
+ */
+static const char *coffGetSymbolName(PCIMAGE_SYMBOL pSym, const char *pchStrTab, uint32_t cbStrTab, char pszShortName[16])
+{
+    if (pSym->N.Name.Short != 0)
+    {
+        memcpy(pszShortName, pSym->N.ShortName, 8);
+        pszShortName[8] = '\0';
+        return pszShortName;
+    }
+    if (pSym->N.Name.Long < cbStrTab)
+    {
+        uint32_t const cbLeft = cbStrTab - pSym->N.Name.Long;
+        const char    *pszRet = pchStrTab + pSym->N.Name.Long;
+        if (memchr(pszRet, '\0', cbLeft) != NULL)
+            return pszRet;
+    }
+    error("Invalid string table index %#x!\n", pSym->N.Name.Long);
+    return "Invalid Symbol Table Entry";
+}
+
+
+/**
+ * Redefine a symbol with a different name.
+ */
+static int RedefineSymbol(const char *pszOldEqualNew)
+{
+    /*
+     * Check state and split up the input.
+     */
+    if (!g_pbMember)
+        return error("No selected archive member!\n");
+
+    const char *pszNew = strchr(pszOldEqualNew, '=');
+    if (!pszNew || pszNew[1] == '\0')
+        return error("Malformed 'old=new' argument: %s\n", pszOldEqualNew);
+    const char  *pszOld = pszOldEqualNew;
+    size_t const cchOld = pszNew - pszOldEqualNew;
+    pszNew += 1;
+    size_t const cchNew = strlen(pszNew);
+    if (cchNew > cchOld)
+        return error("The new symbol must not be longer than the old symbol: %#x vs %#x (%s)\n", cchNew, cchOld, pszOldEqualNew);
+
+    if (g_cVerbosity > 2)
+        fprintf(stderr, "debug: redefining symbol '%*.*s' to '%*.*s'...\n",
+                (int)cchOld, (int)cchOld, pszOld, (int)cchNew, (int)cchNew, pszNew);
+
+    /*
+     * Parse COFF header.
+     */
+    const IMAGE_FILE_HEADER *pHdr = (const IMAGE_FILE_HEADER *)g_pbMember;
+    if (sizeof(*pHdr) >= g_cbMember)
+        return error("member too small for COFF\n");
+    if (   pHdr->Machine != IMAGE_FILE_MACHINE_AMD64
+        && pHdr->Machine != IMAGE_FILE_MACHINE_I386)
+        return error("Unsupported COFF machine: %#x\n", pHdr->Machine);
+    if (   pHdr->PointerToSymbolTable >= g_cbMember
+        || pHdr->PointerToSymbolTable < sizeof(*pHdr))
+        return error("PointerToSymbolTable is out of bounds: %#x, max %#x\n", pHdr->PointerToSymbolTable, g_cbMember);
+    unsigned const cSymbols = pHdr->NumberOfSymbols;
+    if (   cSymbols >= g_cbMember - pHdr->PointerToSymbolTable
+        || cSymbols * sizeof(IMAGE_SYMBOL) > g_cbMember - pHdr->PointerToSymbolTable)
+        return error("PointerToSymbolTable + NumberOfSymbols is out of bounds: %#x + %#x * %#x (%#x), max %#x\n",
+                     pHdr->PointerToSymbolTable, cSymbols, sizeof(IMAGE_SYMBOL),
+                     pHdr->PointerToSymbolTable + cSymbols * sizeof(IMAGE_SYMBOL), g_cbMember);
+
+    /*
+     * Work the symbol table.
+     */
+    unsigned            cRenames  = 0;
+    PIMAGE_SYMBOL const paSymTab  = (PIMAGE_SYMBOL)&g_pbMember[pHdr->PointerToSymbolTable];
+    const char * const  pchStrTab = (const char *)&paSymTab[pHdr->NumberOfSymbols];
+    uint32_t const      cbStrTab  = (uint32_t)((uintptr_t)&g_pbMember[g_cbMember] - (uintptr_t)pchStrTab);
+    for (unsigned iSym = 0; iSym < cSymbols; iSym++)
+    {
+        char        szShort[16];
+        const char *pszSymName = coffGetSymbolName(&paSymTab[iSym], pchStrTab, cbStrTab, szShort);
+        size_t      cchSymName = strlen(pszSymName);
+        if (g_cVerbosity > 3 && cchSymName > 0)
+            fprintf(stderr, "debug: symbol %u: %s\n", iSym, pszSymName);
+        if (   cchSymName == cchOld
+            && memcmp(pszSymName, pszOld, cchSymName) == 0)
+        {
+            size_t const offStrTab = (size_t)(pszSymName - pchStrTab);
+            if (offStrTab < cbStrTab)
+            {
+                if (g_cVerbosity > 1)
+                    fprintf(stderr, "debug: Found symbol '%s' in at string table offset %#x, renaming to '%s'.\n",
+                            pszSymName, (uint32_t)offStrTab, pszNew);
+                if (offStrTab > 0 && pchStrTab[offStrTab - 1] != '\0')
+                    return error("Cannot rename sub-string!\n");
+                memset((char *)pszSymName, 0, cchOld);
+                memcpy((char *)pszSymName, pszNew, cchNew);
+            }
+            else
+            {
+                if (g_cVerbosity > 1)
+                    fprintf(stderr, "debug: Found symbol '%s' in symbol table, renaming to '%s'.\n", pszSymName, pszNew);
+                memset(paSymTab[iSym].N.ShortName, 0, sizeof(paSymTab[iSym].N.ShortName));
+                memcpy(paSymTab[iSym].N.ShortName, pszNew, cchNew);
+            }
+            cRenames++;
+        }
+
+        /* Skip AUX symbols. */
+        uint8_t cAuxSyms = paSymTab[iSym].NumberOfAuxSymbols;
+        while (cAuxSyms-- > 0)
+            iSym++;
+    }
+
+    if (cRenames > 0)
+        return RTEXITCODE_SUCCESS;
+    return error("Symbol '%*.*s' was not found!\n", cchOld, cchOld, pszOld);
+}
+
+
+int main(int argc, char **argv)
+{
+    /*
+     * Parse arguments.
+     */
+    const char *pszIn  = NULL;
+    const char *pszOut = NULL;
+    for (int i = 1; i < argc; i++)
+    {
+        const char *pszArg = argv[i];
+
+        /* Options without values first: */
+        if (   strcmp(pszArg, "--verbose") == 0
+            || strcmp(pszArg, "-v") == 0)
+            g_cVerbosity += 1;
+        else if (   strcmp(pszArg, "--quiet") == 0
+                 || strcmp(pszArg, "--q") == 0)
+            g_cVerbosity  = 0;
+        else if (   strcmp(pszArg, "--help") == 0
+                 || strcmp(pszArg, "-h") == 0
+                 || strcmp(pszArg, "-?") == 0)
+            return usage(stdout, argv[0]);
+        else if (i + 1 >= argc)
+            return syntax("Missing argument value or unknown option '%s'!\n", pszArg);
+        else
+        {
+            i++;
+            const char *pszValue = argv[i];
+            int         rc = 0;
+            if (strcmp(pszArg, "--input") == 0)
+            {
+                if (pszIn)
+                    return syntax("--input can only be specified once!\n");
+                pszIn = pszValue;
+
+                /* Load it into memory: */
+                FILE *pIn = fopen(pszIn, "rb");
+                if (!pIn)
+                    return error("Failed to open '%s' for reading!\n", pszIn);
+                g_cbBinary = fsize(pIn);
+                if (!g_cbBinary)
+                    return error("Failed to determin the size of '%s'!\n", pszIn);
+                if (g_cbBinary > _128M)
+                    return error("'%s' is too large: %x, max %x\n", g_cbBinary, (size_t)_128M);
+                g_pbBinary = (uint8_t *)calloc(1, g_cbBinary + 4096);
+                if (!g_pbBinary)
+                    return error("Out of memory!\n");
+                if (fread(g_pbBinary, g_cbBinary, 1, pIn) != 1)
+                    return error("Failed to read '%s' into memory!\n", pszIn);
+                fclose(pIn);
+            }
+            else if (strcmp(pszArg, "--output") == 0)
+                pszOut = pszValue;
+            else if (strcmp(pszArg, "--select") == 0)
+                rc = SelectMember(pszValue);
+            else if (strcmp(pszArg, "--redefine-sym") == 0)
+                rc = RedefineSymbol(pszValue);
+            else
+                return syntax("Unknown option: %s\n", pszArg);
+            if (rc != RTEXITCODE_SUCCESS)
+                return rc;
+        }
+    }
+
+    if (!pszIn || !pszOut)
+        return syntax("No %s specified!\n", pszIn ? "output file" : "intput library file");
+
+    /*
+     * Write out the result.
+     */
+    FILE *pOut = fopen(pszOut, "wb");
+    if (!pOut)
+        return error("Failed to open '%s' for writing!\n", pszOut);
+    if (fwrite(g_pbBinary, g_cbBinary, 1, pOut) != 1)
+        return error("Error writing %#x bytes to '%s'!\n", g_cbBinary, pszOut);
+    if (fclose(pOut) != 0)
+        return error("Error closing '%s'!\n", pszOut);
+    return RTEXITCODE_SUCCESS;
+}
+
diff --git a/src/bldprogs/VBoxPeSetVersion.cpp b/src/bldprogs/VBoxPeSetVersion.cpp
new file mode 100644
index 00000000..0c17c971
--- /dev/null
+++ b/src/bldprogs/VBoxPeSetVersion.cpp
@@ -0,0 +1,404 @@
+/* $Id: VBoxPeSetVersion.cpp $ */
+/** @file
+ * IPRT - Change the OS and SubSystem version to value suitable for NT v3.1.
+ *
+ * Also make sure the IAT is writable, since NT v3.1 expects this.  These are
+ * tricks necessary to make binaries created by newer Visual C++ linkers work
+ * on ancient NT version like W2K, NT4 and NT 3.x.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/formats/mz.h>
+#include <iprt/formats/pecoff.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define MK_VER(a_uHi, a_uLo)  ( ((a_uHi) << 8) | (a_uLo))
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static const char *g_pszFilename;
+static unsigned    g_cVerbosity = 0;
+
+
+static int Error(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    char szTmp[1024];
+    _vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
+    va_end(va);
+    fprintf(stderr, "VBoxPeSetVersion: %s: error: %s\n", g_pszFilename, szTmp);
+    return RTEXITCODE_FAILURE;
+}
+
+
+static void Info(unsigned iLevel, const char *pszFormat, ...)
+{
+    if (iLevel <= g_cVerbosity)
+    {
+        va_list va;
+        va_start(va, pszFormat);
+        char szTmp[1024];
+        _vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
+        va_end(va);
+        fprintf(stderr, "VBoxPeSetVersion: %s: info: %s\n", g_pszFilename, szTmp);
+    }
+}
+
+
+static int UpdateFile(FILE *pFile, unsigned uNtVersion, PIMAGE_SECTION_HEADER *ppaShdr)
+{
+    /*
+     * Locate and read the PE header.
+     *
+     * Note! We'll be reading the 64-bit size even for 32-bit since the difference
+     *       is 16 bytes, which is less than a section header, so it won't be a problem.
+     */
+    unsigned long offNtHdrs;
+    {
+        IMAGE_DOS_HEADER MzHdr;
+        if (fread(&MzHdr, sizeof(MzHdr), 1, pFile) != 1)
+            return Error("Failed to read MZ header: %s", strerror(errno));
+        if (MzHdr.e_magic != IMAGE_DOS_SIGNATURE)
+            return Error("Invalid MZ magic: %#x", MzHdr.e_magic);
+        offNtHdrs = MzHdr.e_lfanew;
+    }
+
+    if (fseek(pFile, offNtHdrs, SEEK_SET) != 0)
+        return Error("Failed to seek to PE header at %#lx: %s", offNtHdrs, strerror(errno));
+    union
+    {
+        IMAGE_NT_HEADERS32 x32;
+        IMAGE_NT_HEADERS64 x64;
+    }   NtHdrs,
+        NtHdrsNew;
+    if (fread(&NtHdrs, sizeof(NtHdrs), 1, pFile) != 1)
+        return Error("Failed to read PE header at %#lx: %s", offNtHdrs, strerror(errno));
+
+    /*
+     * Validate it a little bit.
+     */
+    if (NtHdrs.x32.Signature != IMAGE_NT_SIGNATURE)
+        return Error("Invalid PE signature: %#x", NtHdrs.x32.Signature);
+    uint32_t cbNewHdrs;
+    if (NtHdrs.x32.FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
+    {
+        if (NtHdrs.x64.FileHeader.SizeOfOptionalHeader != sizeof(NtHdrs.x64.OptionalHeader))
+            return Error("Invalid optional header size: %#x", NtHdrs.x64.FileHeader.SizeOfOptionalHeader);
+        if (NtHdrs.x64.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC)
+            return Error("Invalid optional header magic: %#x", NtHdrs.x64.OptionalHeader.Magic);
+        if (!uNtVersion)
+            uNtVersion = MK_VER(5, 2);
+        else if (uNtVersion < MK_VER(5, 2))
+            return Error("Selected version is too old for AMD64: %u.%u", uNtVersion >> 8, uNtVersion & 0xff);
+        cbNewHdrs = sizeof(NtHdrsNew.x64);
+    }
+    else if (NtHdrs.x32.FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
+        return Error("Not I386 or AMD64 machine: %#x", NtHdrs.x32.FileHeader.Machine);
+    else
+    {
+        if (NtHdrs.x32.FileHeader.SizeOfOptionalHeader != sizeof(NtHdrs.x32.OptionalHeader))
+            return Error("Invalid optional header size: %#x", NtHdrs.x32.FileHeader.SizeOfOptionalHeader);
+        if (NtHdrs.x32.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
+            return Error("Invalid optional header magic: %#x", NtHdrs.x32.OptionalHeader.Magic);
+        if (!uNtVersion)
+            uNtVersion = MK_VER(3, 10);
+        cbNewHdrs = sizeof(NtHdrsNew.x32);
+    }
+
+    /*
+     * Do the header modifications.
+     */
+    memcpy(&NtHdrsNew, &NtHdrs, sizeof(NtHdrsNew));
+    NtHdrsNew.x32.OptionalHeader.MajorOperatingSystemVersion = uNtVersion >> 8;
+    NtHdrsNew.x32.OptionalHeader.MinorOperatingSystemVersion = uNtVersion & 0xff;
+    NtHdrsNew.x32.OptionalHeader.MajorSubsystemVersion       = uNtVersion >> 8;
+    NtHdrsNew.x32.OptionalHeader.MinorSubsystemVersion       = uNtVersion & 0xff;
+    AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MajorOperatingSystemVersion,  IMAGE_NT_HEADERS64, OptionalHeader.MajorOperatingSystemVersion);
+    AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MinorOperatingSystemVersion,  IMAGE_NT_HEADERS64, OptionalHeader.MinorOperatingSystemVersion);
+    AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MajorSubsystemVersion,        IMAGE_NT_HEADERS64, OptionalHeader.MajorSubsystemVersion);
+    AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MinorSubsystemVersion,        IMAGE_NT_HEADERS64, OptionalHeader.MinorSubsystemVersion);
+
+    if (uNtVersion <= MK_VER(3, 50))
+    {
+        NtHdrsNew.x32.OptionalHeader.MajorOperatingSystemVersion = 1;
+        NtHdrsNew.x32.OptionalHeader.MinorOperatingSystemVersion = 0;
+        AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MajorOperatingSystemVersion, IMAGE_NT_HEADERS64, OptionalHeader.MajorOperatingSystemVersion);
+        AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MinorOperatingSystemVersion, IMAGE_NT_HEADERS64, OptionalHeader.MinorOperatingSystemVersion);
+    }
+
+    if (memcmp(&NtHdrsNew, &NtHdrs, sizeof(NtHdrs)))
+    {
+        /** @todo calc checksum. */
+        NtHdrsNew.x32.OptionalHeader.CheckSum = 0;
+        AssertCompileMembersAtSameOffset(IMAGE_NT_HEADERS32, OptionalHeader.MinorOperatingSystemVersion, IMAGE_NT_HEADERS64, OptionalHeader.MinorOperatingSystemVersion);
+
+        if (   NtHdrsNew.x32.OptionalHeader.MajorOperatingSystemVersion != NtHdrs.x32.OptionalHeader.MajorOperatingSystemVersion
+            || NtHdrsNew.x32.OptionalHeader.MinorOperatingSystemVersion != NtHdrs.x32.OptionalHeader.MinorOperatingSystemVersion)
+            Info(1,"OperatingSystemVersion %u.%u -> %u.%u",
+                 NtHdrs.x32.OptionalHeader.MajorOperatingSystemVersion, NtHdrs.x32.OptionalHeader.MinorOperatingSystemVersion,
+                 NtHdrsNew.x32.OptionalHeader.MajorOperatingSystemVersion, NtHdrsNew.x32.OptionalHeader.MinorOperatingSystemVersion);
+        if (   NtHdrsNew.x32.OptionalHeader.MajorSubsystemVersion != NtHdrs.x32.OptionalHeader.MajorSubsystemVersion
+            || NtHdrsNew.x32.OptionalHeader.MinorSubsystemVersion != NtHdrs.x32.OptionalHeader.MinorSubsystemVersion)
+            Info(1,"SubsystemVersion %u.%u -> %u.%u",
+                 NtHdrs.x32.OptionalHeader.MajorSubsystemVersion, NtHdrs.x32.OptionalHeader.MinorSubsystemVersion,
+                 NtHdrsNew.x32.OptionalHeader.MajorSubsystemVersion, NtHdrsNew.x32.OptionalHeader.MinorSubsystemVersion);
+
+        if (fseek(pFile, offNtHdrs, SEEK_SET) != 0)
+            return Error("Failed to seek to PE header at %#lx: %s", offNtHdrs, strerror(errno));
+        if (fwrite(&NtHdrsNew, cbNewHdrs, 1, pFile) != 1)
+            return Error("Failed to write PE header at %#lx: %s", offNtHdrs, strerror(errno));
+    }
+
+    /*
+     * Make the IAT writable for NT 3.1 and drop the non-cachable flag from .bss.
+     *
+     * The latter is a trick we use to prevent the linker from merging .data and .bss,
+     * because NT 3.1 does not honor Misc.VirtualSize and won't zero padd the .bss part
+     * if it's not zero padded in the file.  This seemed simpler than adding zero padding.
+     */
+    if (   uNtVersion <= MK_VER(3, 10)
+        && NtHdrsNew.x32.FileHeader.NumberOfSections > 0)
+    {
+        uint32_t              cbShdrs = sizeof(IMAGE_SECTION_HEADER) * NtHdrsNew.x32.FileHeader.NumberOfSections;
+        PIMAGE_SECTION_HEADER paShdrs = (PIMAGE_SECTION_HEADER)calloc(1, cbShdrs);
+        if (!paShdrs)
+            return Error("Out of memory");
+        *ppaShdr = paShdrs;
+
+        unsigned long offShdrs = offNtHdrs
+                               + RT_UOFFSETOF_DYN(IMAGE_NT_HEADERS32,
+                                                  OptionalHeader.DataDirectory[NtHdrsNew.x32.OptionalHeader.NumberOfRvaAndSizes]);
+        if (fseek(pFile, offShdrs, SEEK_SET) != 0)
+            return Error("Failed to seek to section headers at %#lx: %s", offShdrs, strerror(errno));
+        if (fread(paShdrs, cbShdrs, 1, pFile) != 1)
+            return Error("Failed to read section headers at %#lx: %s", offShdrs, strerror(errno));
+
+        bool     fFoundBss = false;
+        uint32_t uRvaEnd   = NtHdrsNew.x32.OptionalHeader.SizeOfImage;
+        uint32_t uRvaIat   = NtHdrsNew.x32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size > 0
+                           ? NtHdrsNew.x32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress : UINT32_MAX;
+        uint32_t i         = NtHdrsNew.x32.FileHeader.NumberOfSections;
+        while (i-- > 0)
+            if (!(paShdrs[i].Characteristics & IMAGE_SCN_TYPE_NOLOAD))
+            {
+                bool     fModified = false;
+                if (uRvaIat >= paShdrs[i].VirtualAddress && uRvaIat < uRvaEnd)
+                {
+                    if (!(paShdrs[i].Characteristics & IMAGE_SCN_MEM_WRITE))
+                    {
+                        paShdrs[i].Characteristics |= IMAGE_SCN_MEM_WRITE;
+                        fModified = true;
+                    }
+                    uRvaIat = UINT32_MAX;
+                }
+
+                if (   !fFoundBss
+                    && strcmp((const char *)paShdrs[i].Name, ".bss") == 0)
+                {
+                    if (paShdrs[i].Characteristics & IMAGE_SCN_MEM_NOT_CACHED)
+                    {
+                        paShdrs[i].Characteristics &= ~IMAGE_SCN_MEM_NOT_CACHED;
+                        fModified = true;
+                    }
+                    fFoundBss = true;
+                }
+
+                if (fModified)
+                {
+                    unsigned long offShdr = offShdrs + i * sizeof(IMAGE_SECTION_HEADER);
+                    if (fseek(pFile, offShdr, SEEK_SET) != 0)
+                        return Error("Failed to seek to section header #%u at %#lx: %s", i, offShdr, strerror(errno));
+                    if (fwrite(&paShdrs[i], sizeof(IMAGE_SECTION_HEADER), 1, pFile) != 1)
+                        return Error("Failed to write %8.8s section header header at %#lx: %s",
+                                     paShdrs[i].Name, offShdr, strerror(errno));
+                    if (uRvaIat == UINT32_MAX && fFoundBss)
+                        break;
+                }
+
+                /* Advance */
+                uRvaEnd = paShdrs[i].VirtualAddress;
+            }
+
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static int Usage(FILE *pOutput)
+{
+    fprintf(pOutput,
+            "Usage: VBoxPeSetVersion [options] <PE-image>\n"
+            "Options:\n"
+            "  -v, --verbose\n"
+            "    Increases verbosity.\n"
+            "  -q, --quiet\n"
+            "    Quiet operation (default).\n"
+            "  --nt31, --nt350, --nt351, --nt4, --w2k, --xp, --w2k3, --vista,\n"
+            "  --w7, --w8, --w81, --w10\n"
+            "    Which version to set.  Default: --nt31\n"
+            );
+    return RTEXITCODE_SYNTAX;
+}
+
+
+/** @todo Rewrite this so it can take options and print out error messages. */
+int main(int argc, char **argv)
+{
+    /*
+     * Parse arguments.
+     * This stucks
+     */
+    unsigned    uNtVersion     = 0;
+    const char *pszFilename    = NULL;
+    bool        fAcceptOptions = true;
+    for (int i = 1; i < argc; i++)
+    {
+        const char *psz = argv[i];
+        if (fAcceptOptions && *psz == '-')
+        {
+            char ch = psz[1];
+            psz += 2;
+            if (ch == '-')
+            {
+                if (!*psz)
+                {
+                    fAcceptOptions = false;
+                    continue;
+                }
+
+                if (strcmp(psz, "verbose") == 0)
+                    ch = 'v';
+                else if (strcmp(psz, "quiet") == 0)
+                    ch = 'q';
+                else if (strcmp(psz, "help") == 0)
+                    ch = 'h';
+                else if (strcmp(psz, "version") == 0)
+                    ch = 'V';
+                else
+                {
+                    if (strcmp(psz, "nt31") == 0)
+                        uNtVersion = MK_VER(3,10);
+                    else if (strcmp(psz, "nt350") == 0)
+                        uNtVersion = MK_VER(3,50);
+                    else if (strcmp(psz, "nt351") == 0)
+                        uNtVersion = MK_VER(3,51);
+                    else if (strcmp(psz, "nt4") == 0)
+                        uNtVersion = MK_VER(4,0);
+                    else if (strcmp(psz, "w2k") == 0)
+                        uNtVersion = MK_VER(5,0);
+                    else if (strcmp(psz, "xp") == 0)
+                        uNtVersion = MK_VER(5,1);
+                    else if (strcmp(psz, "w2k3") == 0)
+                        uNtVersion = MK_VER(5,2);
+                    else if (strcmp(psz, "vista") == 0)
+                        uNtVersion = MK_VER(6,0);
+                    else if (strcmp(psz, "w7") == 0)
+                        uNtVersion = MK_VER(6,1);
+                    else if (strcmp(psz, "w8") == 0)
+                        uNtVersion = MK_VER(6,2);
+                    else if (strcmp(psz, "w81") == 0)
+                        uNtVersion = MK_VER(6,3);
+                    else if (strcmp(psz, "w10") == 0)
+                        uNtVersion = MK_VER(10,0);
+                    else
+                    {
+                        fprintf(stderr, "VBoxPeSetVersion: syntax error: Unknown option: --%s\n", psz);
+                        return RTEXITCODE_SYNTAX;
+                    }
+                    continue;
+                }
+                psz = " ";
+            }
+            do
+            {
+                switch (ch)
+                {
+                    case 'q':
+                        g_cVerbosity = 0;
+                        break;
+                    case 'v':
+                        g_cVerbosity++;
+                        break;
+                    case 'V':
+                        printf("2.0\n");
+                        return RTEXITCODE_SUCCESS;
+                    case 'h':
+                        Usage(stdout);
+                        return RTEXITCODE_SUCCESS;
+                    default:
+                        fprintf(stderr, "VBoxPeSetVersion: syntax error: Unknown option: -%c\n", ch ? ch : ' ');
+                        return RTEXITCODE_SYNTAX;
+                }
+            } while ((ch = *psz++) != '\0');
+
+        }
+        else if (!pszFilename)
+            pszFilename = psz;
+        else
+        {
+            fprintf(stderr, "VBoxPeSetVersion: syntax error: More than one PE-image specified!\n");
+            return RTEXITCODE_SYNTAX;
+        }
+    }
+
+    if (!pszFilename)
+    {
+        fprintf(stderr, "VBoxPeSetVersion: syntax error: No PE-image specified!\n");
+        return RTEXITCODE_SYNTAX;
+    }
+    g_pszFilename = pszFilename;
+
+    /*
+     * Process the file.
+     */
+    int rcExit;
+    FILE *pFile = fopen(pszFilename, "r+b");
+    if (pFile)
+    {
+        PIMAGE_SECTION_HEADER paShdrs = NULL;
+        rcExit = UpdateFile(pFile, uNtVersion, &paShdrs);
+        if (paShdrs)
+            free(paShdrs);
+        if (fclose(pFile) != 0)
+            rcExit = Error("fclose failed on '%s': %s", pszFilename, strerror(errno));
+    }
+    else
+        rcExit = Error("Failed to open '%s' for updating: %s", pszFilename, strerror(errno));
+    return rcExit;
+}
+
diff --git a/src/bldprogs/VBoxTpG.cpp b/src/bldprogs/VBoxTpG.cpp
new file mode 100644
index 00000000..516b749e
--- /dev/null
+++ b/src/bldprogs/VBoxTpG.cpp
@@ -0,0 +1,2665 @@
+/* $Id: VBoxTpG.cpp $ */
+/** @file
+ * VBox Build Tool - VBox Tracepoint Generator.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <VBox/VBoxTpG.h>
+
+#include <iprt/alloca.h>
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/env.h>
+#include <iprt/errcore.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/list.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+#include <iprt/uuid.h>
+
+#include "scmstream.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct VTGPROBE *PVTGPROBE;
+
+typedef struct VTGATTRS
+{
+    kVTGStability   enmCode;
+    kVTGStability   enmData;
+    kVTGClass       enmDataDep;
+} VTGATTRS;
+typedef VTGATTRS *PVTGATTRS;
+
+
+typedef struct VTGARG
+{
+    RTLISTNODE      ListEntry;
+    /** The argument name. (heap) */
+    char           *pszName;
+    /** The type presented to the tracer (in string table). */
+    const char     *pszTracerType;
+    /** The argument type used in the probe method in that context. (heap) */
+    char           *pszCtxType;
+    /** Argument passing format string.  First and only argument is the name.
+     *  (const string) */
+    const char     *pszArgPassingFmt;
+    /** The type flags. */
+    uint32_t        fType;
+    /** The argument number (0-based) for complaining/whatever. */
+    uint16_t        iArgNo;
+    /** The probe the argument belongs to (for complaining/whatever). */
+    PVTGPROBE       pProbe;
+    /** The absolute source position. */
+    size_t          offSrc;
+} VTGARG;
+typedef VTGARG *PVTGARG;
+
+typedef struct VTGPROBE
+{
+    RTLISTNODE      ListEntry;
+    char           *pszMangledName;
+    const char     *pszUnmangledName;
+    RTLISTANCHOR    ArgHead;
+    uint32_t        cArgs;
+    bool            fHaveLargeArgs;
+    uint32_t        offArgList;
+    uint32_t        iProbe;
+    size_t          iLine;
+} VTGPROBE;
+
+typedef struct VTGPROVIDER
+{
+    RTLISTNODE      ListEntry;
+    const char     *pszName;
+
+    uint16_t        iFirstProbe;
+    uint16_t        cProbes;
+
+    VTGATTRS        AttrSelf;
+    VTGATTRS        AttrModules;
+    VTGATTRS        AttrFunctions;
+    VTGATTRS        AttrName;
+    VTGATTRS        AttrArguments;
+
+    RTLISTANCHOR    ProbeHead;
+} VTGPROVIDER;
+typedef VTGPROVIDER *PVTGPROVIDER;
+
+/**
+ * A string table string.
+ */
+typedef struct VTGSTRING
+{
+    /** The string space core. */
+    RTSTRSPACECORE  Core;
+    /** The string table offset. */
+    uint32_t        offStrTab;
+    /** The actual string. */
+    char            szString[1];
+} VTGSTRING;
+typedef VTGSTRING *PVTGSTRING;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The string space organizing the string table strings. Each node is a VTGSTRING. */
+static RTSTRSPACE       g_StrSpace = NULL;
+/** Used by the string table enumerator to set VTGSTRING::offStrTab. */
+static uint32_t         g_offStrTab;
+/** List of providers created by the parser. */
+static RTLISTANCHOR     g_ProviderHead;
+/** The number of type errors. */
+static uint32_t         g_cTypeErrors = 0;
+
+
+/** @name Options
+ * @{ */
+static enum
+{
+    kVBoxTpGAction_Nothing,
+    kVBoxTpGAction_GenerateHeader,
+    kVBoxTpGAction_GenerateWrapperHeader,
+    kVBoxTpGAction_GenerateObject
+}                           g_enmAction                 = kVBoxTpGAction_Nothing;
+static uint32_t             g_cBits                     = HC_ARCH_BITS;
+static uint32_t             g_cHostBits                 = HC_ARCH_BITS;
+static uint32_t             g_fTypeContext              = VTG_TYPE_CTX_R0;
+static const char          *g_pszContextDefine          = "IN_RING0";
+static const char          *g_pszContextDefine2         = NULL;
+static bool                 g_fApplyCpp                 = false;
+static uint32_t             g_cVerbosity                = 0;
+static const char          *g_pszOutput                 = NULL;
+static const char          *g_pszScript                 = NULL;
+static const char          *g_pszTempAsm                = NULL;
+#ifdef RT_OS_DARWIN
+static const char          *g_pszAssembler              = "yasm";
+static const char          *g_pszAssemblerFmtOpt        = "-f";
+static const char           g_szAssemblerFmtVal32[]     = "macho32";
+static const char           g_szAssemblerFmtVal64[]     = "macho64";
+static const char           g_szAssemblerOsDef[]        = "RT_OS_DARWIN";
+#elif defined(RT_OS_OS2)
+static const char          *g_pszAssembler              = "nasm.exe";
+static const char          *g_pszAssemblerFmtOpt        = "-f";
+static const char           g_szAssemblerFmtVal32[]     = "obj";
+static const char           g_szAssemblerFmtVal64[]     = "elf64";
+static const char           g_szAssemblerOsDef[]        = "RT_OS_OS2";
+#elif defined(RT_OS_WINDOWS)
+static const char          *g_pszAssembler              = "yasm.exe";
+static const char          *g_pszAssemblerFmtOpt        = "-f";
+static const char           g_szAssemblerFmtVal32[]     = "win32";
+static const char           g_szAssemblerFmtVal64[]     = "win64";
+static const char           g_szAssemblerOsDef[]        = "RT_OS_WINDOWS";
+#else
+static const char          *g_pszAssembler              = "yasm";
+static const char          *g_pszAssemblerFmtOpt        = "-f";
+static const char           g_szAssemblerFmtVal32[]     = "elf32";
+static const char           g_szAssemblerFmtVal64[]     = "elf64";
+# ifdef RT_OS_FREEBSD
+static const char           g_szAssemblerOsDef[]        = "RT_OS_FREEBSD";
+# elif  defined(RT_OS_NETBSD)
+static const char           g_szAssemblerOsDef[]        = "RT_OS_NETBSD";
+# elif  defined(RT_OS_OPENBSD)
+static const char           g_szAssemblerOsDef[]        = "RT_OS_OPENBSD";
+# elif  defined(RT_OS_LINUX)
+static const char           g_szAssemblerOsDef[]        = "RT_OS_LINUX";
+# elif  defined(RT_OS_SOLARIS)
+static const char           g_szAssemblerOsDef[]        = "RT_OS_SOLARIS";
+# else
+#  error "Port me!"
+# endif
+#endif
+static const char          *g_pszAssemblerFmtVal        = RT_CONCAT(g_szAssemblerFmtVal, HC_ARCH_BITS);
+static const char          *g_pszAssemblerDefOpt        = "-D";
+static const char          *g_pszAssemblerIncOpt        = "-I";
+static char                 g_szAssemblerIncVal[RTPATH_MAX];
+static const char          *g_pszAssemblerIncVal        = __FILE__ "/../../../include/";
+static const char          *g_pszAssemblerOutputOpt     = "-o";
+static unsigned             g_cAssemblerOptions         = 0;
+static const char          *g_apszAssemblerOptions[32];
+static const char          *g_pszProbeFnName            = "SUPR0TracerFireProbe";
+static bool                 g_fProbeFnImported          = true;
+static bool                 g_fPic                      = false;
+/** @} */
+
+
+
+
+/**
+ * Inserts a string into the string table, reusing any matching existing string
+ * if possible.
+ *
+ * @returns Read only string.
+ * @param   pch                 The string to insert (need not be terminated).
+ * @param   cch                 The length of the string.
+ */
+static const char *strtabInsertN(const char *pch, size_t cch)
+{
+    PVTGSTRING pStr = (PVTGSTRING)RTStrSpaceGetN(&g_StrSpace, pch, cch);
+    if (pStr)
+        return pStr->szString;
+
+    /*
+     * Create a new entry.
+     */
+    pStr = (PVTGSTRING)RTMemAlloc(RT_UOFFSETOF_DYN(VTGSTRING, szString[cch + 1]));
+    if (!pStr)
+        return NULL;
+
+    pStr->Core.pszString = pStr->szString;
+    memcpy(pStr->szString, pch, cch);
+    pStr->szString[cch]  = '\0';
+    pStr->offStrTab      = UINT32_MAX;
+
+    bool fRc = RTStrSpaceInsert(&g_StrSpace, &pStr->Core);
+    Assert(fRc); NOREF(fRc);
+    return pStr->szString;
+}
+
+
+/**
+ * Retrieves the string table offset of the given string table string.
+ *
+ * @returns String table offset.
+ * @param   pszStrTabString     The string table string.
+ */
+static uint32_t strtabGetOff(const char *pszStrTabString)
+{
+    PVTGSTRING pStr = RT_FROM_MEMBER(pszStrTabString, VTGSTRING, szString[0]);
+    Assert(pStr->Core.pszString == pszStrTabString);
+    return pStr->offStrTab;
+}
+
+
+/**
+ * Invokes the assembler.
+ *
+ * @returns Exit code.
+ * @param   pszOutput           The output file.
+ * @param   pszTempAsm          The source file.
+ */
+static RTEXITCODE generateInvokeAssembler(const char *pszOutput, const char *pszTempAsm)
+{
+    const char     *apszArgs[64];
+    unsigned        iArg = 0;
+
+    apszArgs[iArg++] = g_pszAssembler;
+    apszArgs[iArg++] = g_pszAssemblerFmtOpt;
+    apszArgs[iArg++] = g_pszAssemblerFmtVal;
+    apszArgs[iArg++] = g_pszAssemblerDefOpt;
+    if (!strcmp(g_pszAssemblerFmtVal, "macho32") || !strcmp(g_pszAssemblerFmtVal, "macho64"))
+        apszArgs[iArg++] = "ASM_FORMAT_MACHO";
+    else if (!strcmp(g_pszAssemblerFmtVal, "obj") || !strcmp(g_pszAssemblerFmtVal, "omf"))
+        apszArgs[iArg++] = "ASM_FORMAT_OMF";
+    else if (   !strcmp(g_pszAssemblerFmtVal, "win32")
+             || !strcmp(g_pszAssemblerFmtVal, "win64")
+             || !strcmp(g_pszAssemblerFmtVal, "pe32")
+             || !strcmp(g_pszAssemblerFmtVal, "pe64")
+             || !strcmp(g_pszAssemblerFmtVal, "pe") )
+        apszArgs[iArg++] = "ASM_FORMAT_PE";
+    else if (   !strcmp(g_pszAssemblerFmtVal, "elf32")
+             || !strcmp(g_pszAssemblerFmtVal, "elf64")
+             || !strcmp(g_pszAssemblerFmtVal, "elf"))
+        apszArgs[iArg++] = "ASM_FORMAT_ELF";
+    else
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unknown assembler format '%s'", g_pszAssemblerFmtVal);
+    apszArgs[iArg++] = g_pszAssemblerDefOpt;
+    if (g_cBits == 32)
+        apszArgs[iArg++] = "ARCH_BITS=32";
+    else
+        apszArgs[iArg++] = "ARCH_BITS=64";
+    apszArgs[iArg++] = g_pszAssemblerDefOpt;
+    if (g_cHostBits == 32)
+        apszArgs[iArg++] = "HC_ARCH_BITS=32";
+    else
+        apszArgs[iArg++] = "HC_ARCH_BITS=64";
+    apszArgs[iArg++] = g_pszAssemblerDefOpt;
+    if (g_cBits == 32)
+        apszArgs[iArg++] = "RT_ARCH_X86";
+    else
+        apszArgs[iArg++] = "RT_ARCH_AMD64";
+    apszArgs[iArg++] = g_pszAssemblerDefOpt;
+    apszArgs[iArg++] = g_pszContextDefine;
+    if (g_pszContextDefine2)
+    {
+        apszArgs[iArg++] = g_pszAssemblerDefOpt;
+        apszArgs[iArg++] = g_pszContextDefine2;
+    }
+    if (g_szAssemblerOsDef[0])
+    {
+        apszArgs[iArg++] = g_pszAssemblerDefOpt;
+        apszArgs[iArg++] = g_szAssemblerOsDef;
+    }
+    apszArgs[iArg++] = g_pszAssemblerIncOpt;
+    apszArgs[iArg++] = g_pszAssemblerIncVal;
+    apszArgs[iArg++] = g_pszAssemblerOutputOpt;
+    apszArgs[iArg++] = pszOutput;
+    for (unsigned i = 0; i < g_cAssemblerOptions; i++)
+        apszArgs[iArg++] = g_apszAssemblerOptions[i];
+    apszArgs[iArg++] = pszTempAsm;
+    apszArgs[iArg]   = NULL;
+    Assert(iArg <= RT_ELEMENTS(apszArgs));
+
+    if (g_cVerbosity > 1)
+    {
+        RTMsgInfo("Starting assmbler '%s' with arguments:\n",  g_pszAssembler);
+        for (unsigned i = 0; i < iArg; i++)
+            RTMsgInfo("  #%02u: '%s'\n",  i, apszArgs[i]);
+    }
+
+    RTPROCESS hProc;
+    int rc = RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, RTPROC_FLAGS_SEARCH_PATH, &hProc);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to start '%s' (assembler): %Rrc", apszArgs[0], rc);
+
+    RTPROCSTATUS Status;
+    rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &Status);
+    if (RT_FAILURE(rc))
+    {
+        RTProcTerminate(hProc);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTProcWait failed: %Rrc", rc);
+    }
+    if (Status.enmReason == RTPROCEXITREASON_SIGNAL)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: signal %d", Status.iStatus);
+    if (Status.enmReason != RTPROCEXITREASON_NORMAL)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: abend");
+    if (Status.iStatus != 0)
+        return RTMsgErrorExit((RTEXITCODE)Status.iStatus, "The assembler failed: exit code %d", Status.iStatus);
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Worker that does the boring bits when generating a file.
+ *
+ * @returns Exit code.
+ * @param   pszOutput           The name of the output file.
+ * @param   pszWhat             What kind of file it is.
+ * @param   pfnGenerator        The callback function that provides the contents
+ *                              of the file.
+ */
+static RTEXITCODE generateFile(const char *pszOutput, const char *pszWhat,
+                               RTEXITCODE (*pfnGenerator)(PSCMSTREAM))
+{
+    SCMSTREAM Strm;
+    int rc = ScmStreamInitForWriting(&Strm, NULL);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamInitForWriting returned %Rrc when generating the %s file",
+                              rc, pszWhat);
+
+    RTEXITCODE rcExit = pfnGenerator(&Strm);
+    if (RT_FAILURE(ScmStreamGetStatus(&Strm)))
+        rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Stream error %Rrc generating the %s file",
+                                ScmStreamGetStatus(&Strm), pszWhat);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        rc = ScmStreamWriteToFile(&Strm, "%s", pszOutput);
+        if (RT_FAILURE(rc))
+            rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamWriteToFile returned %Rrc when writing '%s' (%s)",
+                                    rc, pszOutput, pszWhat);
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            if (g_cVerbosity > 0)
+                RTMsgInfo("Successfully generated '%s'.", pszOutput);
+            if (g_cVerbosity > 1)
+            {
+                RTMsgInfo("================ %s - start ================", pszWhat);
+                ScmStreamRewindForReading(&Strm);
+                const char *pszLine;
+                size_t      cchLine;
+                SCMEOL      enmEol;
+                while ((pszLine = ScmStreamGetLine(&Strm, &cchLine, &enmEol)) != NULL)
+                    RTPrintf("%.*s\n", cchLine, pszLine);
+                RTMsgInfo("================ %s - end   ================", pszWhat);
+            }
+        }
+    }
+    ScmStreamDelete(&Strm);
+    return rcExit;
+}
+
+
+/**
+ * @callback_method_impl{FNRTSTRSPACECALLBACK, Writes the string table strings.}
+ */
+static DECLCALLBACK(int) generateAssemblyStrTabCallback(PRTSTRSPACECORE pStr, void *pvUser)
+{
+    PVTGSTRING pVtgStr = (PVTGSTRING)pStr;
+    PSCMSTREAM pStrm   = (PSCMSTREAM)pvUser;
+
+    pVtgStr->offStrTab = g_offStrTab;
+    g_offStrTab += (uint32_t)pVtgStr->Core.cchString + 1;
+
+    ScmStreamPrintf(pStrm,
+                    "    db '%s', 0 ; off=%u len=%zu\n",
+                    pVtgStr->szString, pVtgStr->offStrTab, pVtgStr->Core.cchString);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Generate assembly source that can be turned into an object file.
+ *
+ * (This is a generateFile callback.)
+ *
+ * @returns Exit code.
+ * @param   pStrm               The output stream.
+ */
+static RTEXITCODE generateAssembly(PSCMSTREAM pStrm)
+{
+    PVTGPROVIDER    pProvider;
+    PVTGPROBE       pProbe;
+    PVTGARG         pArg;
+
+
+    if (g_cVerbosity > 0)
+        RTMsgInfo("Generating assembly code...");
+
+    /*
+     * Write the file header.
+     */
+    ScmStreamPrintf(pStrm,
+                    "; $Id: VBoxTpG.cpp $ \n"
+                    ";; @file\n"
+                    "; Automatically generated from %s. Do NOT edit!\n"
+                    ";\n"
+                    "\n"
+                    "%%include \"iprt/asmdefs.mac\"\n"
+                    "\n"
+                    "\n"
+                    ";"
+                    "; We put all the data in a dedicated section / segment.\n"
+                    ";\n"
+                    "; In order to find the probe location specifiers, we do the necessary\n"
+                    "; trickery here, ASSUMING that this object comes in first in the link\n"
+                    "; editing process.\n"
+                    ";\n"
+                    "%%ifdef ASM_FORMAT_OMF\n"
+                    " %%macro VTG_GLOBAL 2\n"
+                    "  global NAME(%%1)\n"
+                    "  NAME(%%1):\n"
+                    " %%endmacro\n"
+                    " segment VTG.Obj public CLASS=VTG align=4096 use32\n"
+                    "\n"
+                    "%%elifdef ASM_FORMAT_MACHO\n"
+                    " %%macro VTG_GLOBAL 2\n"
+                    "  global NAME(%%1)\n"
+                    "  NAME(%%1):\n"
+                    " %%endmacro\n"
+                    "  %%ifdef IN_RING3\n"
+                    "   %%define VTG_NEW_MACHO_LINKER\n"
+                    "  %%elif ARCH_BITS == 64\n"
+                    "   %%define VTG_NEW_MACHO_LINKER\n"
+                    "  %%elifdef IN_RING0_AGNOSTIC\n"
+                    "   %%define VTG_NEW_MACHO_LINKER\n"
+                    "  %%endif\n"
+                    " %%ifdef VTG_NEW_MACHO_LINKER\n"
+                    "  ; Section order hack!\n"
+                    "  ; With the ld64-97.17 linker there was a problem with it determining the section\n"
+                    "  ; order based on symbol references. The references to the start and end of the\n"
+                    "  ; __VTGPrLc section forced it in front of __VTGObj, we want __VTGObj first.\n"
+                    "  extern section$start$__VTG$__VTGObj\n"
+                    "  extern section$end$__VTG$__VTGObj\n"
+                    " %%else\n"
+                    "  ; Creating 32-bit kext of the type MH_OBJECT. No fancy section end/start symbols handy.\n"
+                    "  [section __VTG __VTGObj        align=16]\n"
+                    "VTG_GLOBAL g_aVTGObj_LinkerPleaseNoticeMe, data\n"
+                    "  [section __VTG __VTGPrLc.Begin align=16]\n"
+                    "  dq 0, 0 ; Paranoia, related to the fudge below.\n"
+                    "VTG_GLOBAL g_aVTGPrLc, data\n"
+                    "  [section __VTG __VTGPrLc align=16]\n"
+                    "VTG_GLOBAL g_aVTGPrLc_LinkerPleaseNoticeMe, data\n"
+                    "  [section __VTG __VTGPrLc.End   align=16]\n"
+                    "VTG_GLOBAL g_aVTGPrLc_End, data\n"
+                    "  dq 0, 0 ; Fudge to work around unidentified linker where it would otherwise generate\n"
+                    "          ; a fix up of the first dword in __VTGPrLc.Begin despite the fact that it were\n"
+                    "          ; an empty section with nothing whatsoever to fix up.\n"
+                    " %%endif\n"
+                    " [section __VTG __VTGObj]\n"
+                    "\n"
+                    "%%elifdef ASM_FORMAT_PE\n"
+                    " %%macro VTG_GLOBAL 2\n"
+                    "  global NAME(%%1)\n"
+                    "  NAME(%%1):\n"
+                    " %%endmacro\n"
+                    " [section VTGPrLc.Begin data align=64]\n"
+                    /*"   times 16 db 0xcc\n"*/
+                    "VTG_GLOBAL g_aVTGPrLc, data\n"
+                    " [section VTGPrLc.Data  data align=4]\n"
+                    " [section VTGPrLc.End   data align=4]\n"
+                    "VTG_GLOBAL g_aVTGPrLc_End, data\n"
+                    /*"   times 16 db 0xcc\n"*/
+                    " [section VTGObj   data align=32]\n"
+                    "\n"
+                    "%%elifdef ASM_FORMAT_ELF\n"
+                    " %%macro VTG_GLOBAL 2\n"
+                    "  global NAME(%%1):%%2 hidden\n"
+                    "  NAME(%%1):\n"
+                    " %%endmacro\n"
+                    " [section .VTGData progbits alloc noexec write align=4096]\n"
+                    " [section .VTGPrLc.Begin progbits alloc noexec write align=32]\n"
+                    " dd 0,0,0,0, 0,0,0,0\n"
+                    "VTG_GLOBAL g_aVTGPrLc, data\n"
+                    " [section .VTGPrLc       progbits alloc noexec write align=1]\n"
+                    " [section .VTGPrLc.End   progbits alloc noexec write align=1]\n"
+                    "VTG_GLOBAL g_aVTGPrLc_End, data\n"
+                    " dd 0,0,0,0, 0,0,0,0\n"
+                    " [section .VTGData]\n"
+                    "\n"
+                    "%%else\n"
+                    " %%error \"ASM_FORMAT_XXX is not defined\"\n"
+                    "%%endif\n"
+                    "\n"
+                    "\n"
+                    "VTG_GLOBAL g_VTGObjHeader, data\n"
+                    "                ;0         1         2         3\n"
+                    "                ;012345678901234567890123456789012\n"
+                    "    db          'VTG Object Header v1.7', 0, 0\n"
+                    "    dd          %u\n"
+                    "    dd          NAME(g_acVTGProbeEnabled_End) - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_achVTGStringTable)     - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_achVTGStringTable_End) - NAME(g_achVTGStringTable)\n"
+                    "    dd          NAME(g_aVTGArgLists)          - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_aVTGArgLists_End)      - NAME(g_aVTGArgLists)\n"
+                    "    dd          NAME(g_aVTGProbes)            - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_aVTGProbes_End)        - NAME(g_aVTGProbes)\n"
+                    "    dd          NAME(g_aVTGProviders)         - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_aVTGProviders_End)     - NAME(g_aVTGProviders)\n"
+                    "    dd          NAME(g_acVTGProbeEnabled)     - NAME(g_VTGObjHeader)\n"
+                    "    dd          NAME(g_acVTGProbeEnabled_End) - NAME(g_acVTGProbeEnabled)\n"
+                    "    dd          0\n"
+                    "    dd          0\n"
+                    "%%ifdef VTG_NEW_MACHO_LINKER\n"
+                    " extern section$start$__VTG$__VTGPrLc\n"
+                    "    RTCCPTR_DEF section$start$__VTG$__VTGPrLc\n"
+                    " %%if ARCH_BITS == 32\n"
+                    "    dd          0\n"
+                    " %%endif\n"
+                    " extern section$end$__VTG$__VTGPrLc\n"
+                    "    RTCCPTR_DEF section$end$__VTG$__VTGPrLc\n"
+                    " %%if ARCH_BITS == 32\n"
+                    "    dd          0\n"
+                    " %%endif\n"
+                    "%%else\n"
+                    "    RTCCPTR_DEF NAME(g_aVTGPrLc)\n"
+                    " %%if ARCH_BITS == 32\n"
+                    "    dd          0\n"
+                    " %%endif\n"
+                    "    RTCCPTR_DEF NAME(g_aVTGPrLc_End)\n"
+                    " %%if ARCH_BITS == 32\n"
+                    "    dd          0\n"
+                    " %%endif\n"
+                    "%%endif\n"
+                    ,
+                    g_pszScript, g_cBits);
+    RTUUID Uuid;
+    int rc = RTUuidCreate(&Uuid);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTUuidCreate failed: %Rrc", rc);
+    ScmStreamPrintf(pStrm,
+                    "    dd 0%08xh, 0%08xh, 0%08xh, 0%08xh\n"
+                    "%%ifdef VTG_NEW_MACHO_LINKER\n"
+                    "    RTCCPTR_DEF section$start$__VTG$__VTGObj\n"
+                    " %%if ARCH_BITS == 32\n"
+                    "    dd          0\n"
+                    " %%endif\n"
+                    "%%else\n"
+                    "    dd 0, 0\n"
+                    "%%endif\n"
+                    "    dd 0, 0\n"
+                    , Uuid.au32[0], Uuid.au32[1], Uuid.au32[2], Uuid.au32[3]);
+
+    /*
+     * Dump the string table before we start using the strings.
+     */
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    ";\n"
+                    "; The string table.\n"
+                    ";\n"
+                    "VTG_GLOBAL g_achVTGStringTable, data\n");
+    g_offStrTab = 0;
+    RTStrSpaceEnumerate(&g_StrSpace, generateAssemblyStrTabCallback, pStrm);
+    ScmStreamPrintf(pStrm,
+                    "VTG_GLOBAL g_achVTGStringTable_End, data\n");
+
+    /*
+     * Write out the argument lists before we use them.
+     */
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    ";\n"
+                    "; The argument lists.\n"
+                    ";\n"
+                    "ALIGNDATA(16)\n"
+                    "VTG_GLOBAL g_aVTGArgLists, data\n");
+    uint32_t off = 0;
+    RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
+    {
+        RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            if (pProbe->offArgList != UINT32_MAX)
+                continue;
+
+            /* Write it. */
+            pProbe->offArgList = off;
+            ScmStreamPrintf(pStrm,
+                            "    ; off=%u\n"
+                            "    db        %2u  ; Argument count\n"
+                            "    db         %u  ; fHaveLargeArgs\n"
+                            "    db      0, 0  ; Reserved\n"
+                            , off, pProbe->cArgs, (int)pProbe->fHaveLargeArgs);
+            off += 4;
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                ScmStreamPrintf(pStrm,
+                                "    dd  %8u  ; type '%s' (name '%s')\n"
+                                "    dd 0%08xh ; type flags\n",
+                                strtabGetOff(pArg->pszTracerType), pArg->pszTracerType, pArg->pszName,
+                                pArg->fType);
+                off += 8;
+            }
+
+            /* Look for matching argument lists (lazy bird walks the whole list). */
+            PVTGPROVIDER pProv2;
+            RTListForEach(&g_ProviderHead, pProv2, VTGPROVIDER, ListEntry)
+            {
+                PVTGPROBE pProbe2;
+                RTListForEach(&pProvider->ProbeHead, pProbe2, VTGPROBE, ListEntry)
+                {
+                    if (pProbe2->offArgList != UINT32_MAX)
+                        continue;
+                    if (pProbe2->cArgs != pProbe->cArgs)
+                        continue;
+
+                    PVTGARG pArg2;
+                    pArg  = RTListNodeGetNext(&pProbe->ArgHead, VTGARG, ListEntry);
+                    pArg2 = RTListNodeGetNext(&pProbe2->ArgHead, VTGARG, ListEntry);
+                    int32_t cArgs = pProbe->cArgs;
+                    while (   cArgs-- > 0
+                           && pArg2->pszTracerType == pArg->pszTracerType
+                           && pArg2->fType         == pArg->fType)
+                    {
+                        pArg  = RTListNodeGetNext(&pArg->ListEntry, VTGARG, ListEntry);
+                        pArg2 = RTListNodeGetNext(&pArg2->ListEntry, VTGARG, ListEntry);
+                    }
+                    if (cArgs >= 0)
+                        continue;
+                    pProbe2->offArgList = pProbe->offArgList;
+                }
+            }
+        }
+    }
+    ScmStreamPrintf(pStrm,
+                    "VTG_GLOBAL g_aVTGArgLists_End, data\n");
+
+
+    /*
+     * Probe definitions.
+     */
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    ";\n"
+                    "; Prob definitions.\n"
+                    ";\n"
+                    "ALIGNDATA(16)\n"
+                    "VTG_GLOBAL g_aVTGProbes, data\n"
+                    "\n");
+    uint32_t iProvider = 0;
+    uint32_t iProbe = 0;
+    RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
+    {
+        pProvider->iFirstProbe = iProbe;
+        RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            ScmStreamPrintf(pStrm,
+                            "VTG_GLOBAL g_VTGProbeData_%s_%s, data ; idx=#%4u\n"
+                            "    dd %6u  ; offName\n"
+                            "    dd %6u  ; offArgList\n"
+                            "    dw (NAME(g_cVTGProbeEnabled_%s_%s) - NAME(g_acVTGProbeEnabled)) / 4 ; idxEnabled\n"
+                            "    dw %6u  ; idxProvider\n"
+                            "    dd NAME(g_VTGObjHeader) - NAME(g_VTGProbeData_%s_%s) ; offObjHdr\n"
+                            ,
+                            pProvider->pszName, pProbe->pszMangledName, iProbe,
+                            strtabGetOff(pProbe->pszUnmangledName),
+                            pProbe->offArgList,
+                            pProvider->pszName, pProbe->pszMangledName,
+                            iProvider,
+                            pProvider->pszName, pProbe->pszMangledName
+                            );
+            pProbe->iProbe = iProbe;
+            iProbe++;
+        }
+        pProvider->cProbes = iProbe - pProvider->iFirstProbe;
+        iProvider++;
+    }
+    ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProbes_End, data\n");
+
+    /*
+     * The provider data.
+     */
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    ";\n"
+                    "; Provider data.\n"
+                    ";\n"
+                    "ALIGNDATA(16)\n"
+                    "VTG_GLOBAL g_aVTGProviders, data\n");
+    iProvider = 0;
+    RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
+    {
+        ScmStreamPrintf(pStrm,
+                        "    ; idx=#%4u - %s\n"
+                        "    dd %6u  ; name\n"
+                        "    dw %6u  ; index of first probe\n"
+                        "    dw %6u  ; count of probes\n"
+                        "    db %d, %d, %d ; AttrSelf\n"
+                        "    db %d, %d, %d ; AttrModules\n"
+                        "    db %d, %d, %d ; AttrFunctions\n"
+                        "    db %d, %d, %d ; AttrName\n"
+                        "    db %d, %d, %d ; AttrArguments\n"
+                        "    db 0       ; reserved\n"
+                        "VTG_GLOBAL g_cVTGProviderProbesEnabled_%s, data\n"
+                        "    dd 0\n"
+                        "VTG_GLOBAL g_cVTGProviderSettingsSeqNo_%s, data\n"
+                        "    dd 0\n"
+                        ,
+                        iProvider, pProvider->pszName,
+                        strtabGetOff(pProvider->pszName),
+                        pProvider->iFirstProbe,
+                        pProvider->cProbes,
+                        pProvider->AttrSelf.enmCode,        pProvider->AttrSelf.enmData,        pProvider->AttrSelf.enmDataDep,
+                        pProvider->AttrModules.enmCode,     pProvider->AttrModules.enmData,     pProvider->AttrModules.enmDataDep,
+                        pProvider->AttrFunctions.enmCode,   pProvider->AttrFunctions.enmData,   pProvider->AttrFunctions.enmDataDep,
+                        pProvider->AttrName.enmCode,        pProvider->AttrName.enmData,        pProvider->AttrName.enmDataDep,
+                        pProvider->AttrArguments.enmCode,   pProvider->AttrArguments.enmData,   pProvider->AttrArguments.enmDataDep,
+                        pProvider->pszName,
+                        pProvider->pszName);
+        iProvider++;
+    }
+    ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProviders_End, data\n");
+
+    /*
+     * Declare the probe enable flags.
+     *
+     * These must be placed at the end so they'll end up adjacent to the probe
+     * locations.  This is important for reducing the amount of memory we need
+     * to lock down for user mode modules.
+     */
+    ScmStreamPrintf(pStrm,
+                    ";\n"
+                    "; Probe enabled flags.\n"
+                    ";\n"
+                    "ALIGNDATA(16)\n"
+                    "VTG_GLOBAL g_acVTGProbeEnabled, data\n"
+                    );
+    uint32_t        cProbes = 0;
+    RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
+    {
+        RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            ScmStreamPrintf(pStrm,
+                            "VTG_GLOBAL g_cVTGProbeEnabled_%s_%s, data\n"
+                            "    dd 0\n",
+                            pProvider->pszName, pProbe->pszMangledName);
+            cProbes++;
+        }
+    }
+    ScmStreamPrintf(pStrm, "VTG_GLOBAL g_acVTGProbeEnabled_End, data\n");
+    if (cProbes >= _32K)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Too many probes: %u (max %u)", cProbes, _32K - 1);
+
+
+    /*
+     * Emit code for the stub functions.
+     */
+    bool const fWin64   = g_cBits == 64 && (!strcmp(g_pszAssemblerFmtVal, "win64") || !strcmp(g_pszAssemblerFmtVal, "pe64"));
+    bool const fElf     = !strcmp(g_pszAssemblerFmtVal, "elf32") || !strcmp(g_pszAssemblerFmtVal, "elf64");
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    ";\n"
+                    "; Prob stubs.\n"
+                    ";\n"
+                    "BEGINCODE\n"
+                    );
+    if (g_fProbeFnImported)
+        ScmStreamPrintf(pStrm,
+                        "EXTERN_IMP2 %s\n"
+                        "BEGINCODE ; EXTERN_IMP2 changes section\n",
+                        g_pszProbeFnName);
+    else
+        ScmStreamPrintf(pStrm, "extern NAME(%s)\n", g_pszProbeFnName);
+
+    RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
+    {
+        RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            ScmStreamPrintf(pStrm,
+                            "\n"
+                            "VTG_GLOBAL VTGProbeStub_%s_%s, function; (VBOXTPGPROBELOC pVTGProbeLoc",
+                            pProvider->pszName, pProbe->pszMangledName);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                ScmStreamPrintf(pStrm, ", %s %s", pArg->pszTracerType, pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            ");\n");
+
+            /*
+             * Check if the probe in question is enabled.
+             */
+            if (g_cBits == 32)
+                ScmStreamPrintf(pStrm,
+                                "        mov     eax, [esp + 4]\n"
+                                "        test    byte [eax+3], 0x80 ; fEnabled == true?\n"
+                                "        jz      .return            ; jump on false\n");
+            else if (fWin64)
+                ScmStreamPrintf(pStrm,
+                                "        test    byte [rcx+3], 0x80 ; fEnabled == true?\n"
+                                "        jz      .return            ; jump on false\n");
+            else
+                ScmStreamPrintf(pStrm,
+                                "        test    byte [rdi+3], 0x80 ; fEnabled == true?\n"
+                                "        jz      .return            ; jump on false\n");
+
+            /*
+             * Jump to the fire-probe function.
+             */
+            if (g_cBits == 32)
+                ScmStreamPrintf(pStrm, g_fPic && fElf ?
+                                "        jmp     %s wrt ..plt\n"
+                                : g_fProbeFnImported ?
+                                "        mov     ecx, IMP2(%s)\n"
+                                "        jmp     ecx\n"
+                                :
+                                "        jmp     NAME(%s)\n"
+                                , g_pszProbeFnName);
+            else
+                ScmStreamPrintf(pStrm, g_fPic && fElf ?
+                                "        jmp     [rel %s wrt ..got]\n"
+                                : g_fProbeFnImported ?
+                                "        jmp     IMP2(%s)\n"
+                                :
+                                "        jmp     NAME(%s)\n"
+                                , g_pszProbeFnName);
+
+            ScmStreamPrintf(pStrm,
+                            ".return:\n"
+                            "        ret                        ; The probe was disabled, return\n"
+                            "\n");
+        }
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE generateObject(const char *pszOutput, const char *pszTempAsm)
+{
+    if (!pszTempAsm)
+    {
+        size_t cch = strlen(pszOutput);
+        char  *psz = (char *)alloca(cch + sizeof(".asm"));
+        memcpy(psz, pszOutput, cch);
+        memcpy(psz + cch, ".asm", sizeof(".asm"));
+        pszTempAsm = psz;
+    }
+
+    RTEXITCODE rcExit = generateFile(pszTempAsm, "assembly", generateAssembly);
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = generateInvokeAssembler(pszOutput, pszTempAsm);
+    RTFileDelete(pszTempAsm);
+    return rcExit;
+}
+
+
+static RTEXITCODE generateProbeDefineName(char *pszBuf, size_t cbBuf, const char *pszProvider, const char *pszProbe)
+{
+    size_t cbMax = strlen(pszProvider) + 1 + strlen(pszProbe) + 1;
+    if (cbMax > cbBuf || cbMax > 80)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Probe '%s' in provider '%s' ends up with a too long defined\n", pszProbe, pszProvider);
+
+    while (*pszProvider)
+        *pszBuf++ = RT_C_TO_UPPER(*pszProvider++);
+
+    *pszBuf++ = '_';
+
+    while (*pszProbe)
+    {
+        if (pszProbe[0] == '_' && pszProbe[1] == '_')
+            pszProbe++;
+        *pszBuf++ = RT_C_TO_UPPER(*pszProbe++);
+    }
+
+    *pszBuf = '\0';
+    return RTEXITCODE_SUCCESS;
+}
+
+
+static RTEXITCODE generateProviderDefineName(char *pszBuf, size_t cbBuf, const char *pszProvider)
+{
+    size_t cbMax = strlen(pszProvider) + 1;
+    if (cbMax > cbBuf || cbMax > 80)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Provider '%s' ends up with a too long defined\n", pszProvider);
+
+    while (*pszProvider)
+        *pszBuf++ = RT_C_TO_UPPER(*pszProvider++);
+
+    *pszBuf = '\0';
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Called via generateFile to generate the header file.
+ *
+ * @returns Exit code status.
+ * @param   pStrm               The output stream.
+ */
+static RTEXITCODE generateHeader(PSCMSTREAM pStrm)
+{
+    /*
+     * Calc the double inclusion blocker define and then write the file header.
+     */
+    char szTmp[4096];
+    const char *pszName = RTPathFilename(g_pszScript);
+    size_t      cchName = strlen(pszName);
+    if (cchName >= sizeof(szTmp) - 64)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "File name is too long '%s'", pszName);
+    szTmp[0] = '_';
+    szTmp[1] = '_';
+    szTmp[2] = '_';
+    memcpy(&szTmp[3], pszName, cchName);
+    szTmp[3 + cchName + 0] = '_';
+    szTmp[3 + cchName + 1] = '_';
+    szTmp[3 + cchName + 2] = '_';
+    szTmp[3 + cchName + 3] = '\0';
+    char *psz = &szTmp[3];
+    while (*psz)
+    {
+        if (!RT_C_IS_ALNUM(*psz) && *psz != '_')
+            *psz = '_';
+        psz++;
+    }
+
+    ScmStreamPrintf(pStrm,
+                    "/* $Id: VBoxTpG.cpp $ */\n"
+                    "/** @file\n"
+                    " * Automatically generated from %s.  Do NOT edit!\n"
+                    " */\n"
+                    "\n"
+                    "#ifndef %s\n"
+                    "#define %s\n"
+                    "#ifndef RT_WITHOUT_PRAGMA_ONCE\n"
+                    "# pragma once\n"
+                    "#endif\n"
+                    "\n"
+                    "#include <VBox/VBoxTpG.h>\n"
+                    "\n"
+                    "#ifndef %s\n"
+                    "# error \"Expected '%s' to be defined\"\n"
+                    "#endif\n"
+                    "\n"
+                    "RT_C_DECLS_BEGIN\n"
+                    "\n"
+                    "#ifdef VBOX_WITH_DTRACE\n"
+                    "\n"
+                    "# ifdef _MSC_VER\n"
+                    "#  pragma data_seg(VTG_LOC_SECT)\n"
+                    "#  pragma data_seg()\n"
+                    "# endif\n"
+                    "\n"
+                    ,
+                    g_pszScript,
+                    szTmp,
+                    szTmp,
+                    g_pszContextDefine,
+                    g_pszContextDefine);
+
+    /*
+     * Declare data, code and macros for each probe.
+     */
+    PVTGPROVIDER pProv;
+    PVTGPROBE    pProbe;
+    PVTGARG      pArg;
+    RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
+    {
+        /* This macro is not available in ring-3 because we don't have
+           anything similar available for native dtrace. */
+        ScmStreamPrintf(pStrm, "\n\n");
+        if (g_fTypeContext != VTG_TYPE_CTX_R3)
+        {
+            generateProviderDefineName(szTmp, sizeof(szTmp), pProv->pszName);
+            ScmStreamPrintf(pStrm,
+                            "extern uint32_t const volatile g_cVTGProviderProbesEnabled_%s;\n"
+                            "# define %s_ANY_PROBES_ENABLED() \\\n"
+                            "    (RT_UNLIKELY(g_cVTGProviderProbesEnabled_%s != 0))\n"
+                            "extern uint32_t const volatile g_cVTGProviderSettingsSeqNo_%s;\n"
+                            "# define %s_GET_SETTINGS_SEQ_NO() (g_cVTGProviderSettingsSeqNo_%s)\n"
+                            "\n",
+                            pProv->pszName,
+                            szTmp, pProv->pszName,
+                            pProv->pszName,
+                            szTmp, pProv->pszName);
+        }
+
+        RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            ScmStreamPrintf(pStrm,
+                            "extern uint32_t const volatile g_cVTGProbeEnabled_%s_%s;\n"
+                            "extern VTGDESCPROBE            g_VTGProbeData_%s_%s;\n"
+                            "DECLASM(void)                  VTGProbeStub_%s_%s(PVTGPROBELOC",
+                            pProv->pszName, pProbe->pszMangledName,
+                            pProv->pszName, pProbe->pszMangledName,
+                            pProv->pszName, pProbe->pszMangledName);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                ScmStreamPrintf(pStrm, ", %s", pArg->pszCtxType);
+            }
+            generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
+            ScmStreamPrintf(pStrm,
+                            ");\n"
+                            "# define %s_ENABLED() (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s != 0))\n"
+                            "# define %s_ENABLED_RAW() (g_cVTGProbeEnabled_%s_%s)\n"
+                            "# define %s("
+                            ,
+                            szTmp, pProv->pszName, pProbe->pszMangledName,
+                            szTmp, pProv->pszName, pProbe->pszMangledName,
+                            szTmp);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                    ScmStreamPrintf(pStrm, "%s", pArg->pszName);
+                else
+                    ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            ") \\\n"
+                            "    do { \\\n"
+                            "        if (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s)) \\\n"
+                            "        { \\\n"
+                            "            VTG_DECL_VTGPROBELOC(s_VTGProbeLoc) = \\\n"
+                            "            { __LINE__, 0, 0, __FUNCTION__, &g_VTGProbeData_%s_%s }; \\\n"
+                            "            VTGProbeStub_%s_%s(&s_VTGProbeLoc",
+                            pProv->pszName, pProbe->pszMangledName,
+                            pProv->pszName, pProbe->pszMangledName,
+                            pProv->pszName, pProbe->pszMangledName);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt, pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            "); \\\n"
+                            "        } \\\n"
+                            "        { \\\n" );
+            uint32_t iArg = 0;
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                if ((pArg->fType & (VTG_TYPE_FIXED_SIZED | VTG_TYPE_AUTO_CONV_PTR)) == VTG_TYPE_FIXED_SIZED)
+                    ScmStreamPrintf(pStrm,
+                                    "        AssertCompile(sizeof(%s) == %u); \\\n"
+                                    "        AssertCompile(sizeof(%s) <= %u); \\\n",
+                                    pArg->pszTracerType, pArg->fType & VTG_TYPE_SIZE_MASK,
+                                    pArg->pszName, pArg->fType & VTG_TYPE_SIZE_MASK);
+                else if (pArg->fType & (VTG_TYPE_POINTER | VTG_TYPE_HC_ARCH_SIZED))
+                    ScmStreamPrintf(pStrm,
+                                    "        AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n"
+                                    "        AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n",
+                                    pArg->pszName,
+                                    pArg->pszTracerType);
+                iArg++;
+            }
+            ScmStreamPrintf(pStrm,
+                            "        } \\\n"
+                            "    } while (0)\n"
+                            "\n");
+        }
+    }
+
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    "#else\n"
+                    "\n");
+    RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
+    {
+        if (g_fTypeContext != VTG_TYPE_CTX_R3)
+        {
+            generateProviderDefineName(szTmp, sizeof(szTmp), pProv->pszName);
+            ScmStreamPrintf(pStrm,
+                            "# define %s_ANY_PROBES_ENABLED() (false)\n"
+                            "# define %s_GET_SETTINGS_SEQ_NO() UINT32_C(0)\n"
+                            "\n",
+                            szTmp, szTmp);
+        }
+
+        RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
+            ScmStreamPrintf(pStrm,
+                            "# define %s_ENABLED() (false)\n"
+                            "# define %s_ENABLED_RAW() UINT32_C(0)\n"
+                            "# define %s("
+                            , szTmp, szTmp, szTmp);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                    ScmStreamPrintf(pStrm, "%s", pArg->pszName);
+                else
+                    ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            ") do { } while (0)\n");
+        }
+    }
+
+    ScmStreamWrite(pStrm, RT_STR_TUPLE("\n"
+                                       "#endif\n"
+                                       "\n"
+                                       "RT_C_DECLS_END\n"
+                                       "#endif\n"));
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Called via generateFile to generate the wrapper header file.
+ *
+ * @returns Exit code status.
+ * @param   pStrm               The output stream.
+ */
+static RTEXITCODE generateWrapperHeader(PSCMSTREAM pStrm)
+{
+    /*
+     * Calc the double inclusion blocker define and then write the file header.
+     */
+    char szTmp[4096];
+    const char *pszName = RTPathFilename(g_pszScript);
+    size_t      cchName = strlen(pszName);
+    if (cchName >= sizeof(szTmp) - 64)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "File name is too long '%s'", pszName);
+    szTmp[0] = '_';
+    szTmp[1] = '_';
+    szTmp[2] = '_';
+    memcpy(&szTmp[3], pszName, cchName);
+    strcpy(&szTmp[3 + cchName ], "___WRAPPER___");
+    char *psz = &szTmp[3];
+    while (*psz)
+    {
+        if (!RT_C_IS_ALNUM(*psz) && *psz != '_')
+            *psz = '_';
+        psz++;
+    }
+
+    ScmStreamPrintf(pStrm,
+                    "/* $Id: VBoxTpG.cpp $ */\n"
+                    "/** @file\n"
+                    " * Automatically generated from %s.  Do NOT edit!\n"
+                    " */\n"
+                    "\n"
+                    "#ifndef %s\n"
+                    "#define %s\n"
+                    "\n"
+                    "#include <VBox/VBoxTpG.h>\n"
+                    "\n"
+                    "#ifndef %s\n"
+                    "# error \"Expected '%s' to be defined\"\n"
+                    "#endif\n"
+                    "\n"
+                    "#ifdef VBOX_WITH_DTRACE\n"
+                    "\n"
+                    ,
+                    g_pszScript,
+                    szTmp,
+                    szTmp,
+                    g_pszContextDefine,
+                    g_pszContextDefine);
+
+    /*
+     * Declare macros for each probe.
+     */
+    PVTGPROVIDER pProv;
+    PVTGPROBE    pProbe;
+    PVTGARG      pArg;
+    RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
+    {
+        RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
+            ScmStreamPrintf(pStrm,
+                            "# define %s("
+                            , szTmp);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                    ScmStreamPrintf(pStrm, "%s", pArg->pszName);
+                else
+                    ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            ") \\\n"
+                            "    do { \\\n"
+                            "        if (RT_UNLIKELY(%s_ENABLED())) \\\n"
+                            "        { \\\n"
+                            "            %s_ORIGINAL("
+                            , szTmp, szTmp);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                const char *pszFmt = pArg->pszArgPassingFmt;
+                if (pArg->fType & VTG_TYPE_AUTO_CONV_PTR)
+                {
+                    /* Casting is required.  ASSUMES sizeof(RTR0PTR) == sizeof(RTR3PTR) - safe! */
+                    pszFmt += sizeof(", ") - 1;
+                    if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                        ScmStreamPrintf(pStrm, "(%s)%M", pArg->pszTracerType, pszFmt, pArg->pszName);
+                    else
+                        ScmStreamPrintf(pStrm, ", (%s)%M", pArg->pszTracerType, pszFmt, pArg->pszName);
+                }
+                else if (pArg->fType & VTG_TYPE_CONST_CHAR_PTR)
+                {
+                    /* Casting from 'const char *' (probe) to 'char *' (dtrace) is required to shut up warnings. */
+                    pszFmt += sizeof(", ") - 1;
+                    if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                        ScmStreamPrintf(pStrm, "(char *)%M", pszFmt, pArg->pszName);
+                    else
+                        ScmStreamPrintf(pStrm, ", (char *)%M", pszFmt, pArg->pszName);
+                }
+                else
+                {
+                    if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                        ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt + sizeof(", ") - 1, pArg->pszName);
+                    else
+                        ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt, pArg->pszName);
+                }
+            }
+            ScmStreamPrintf(pStrm,
+                            "); \\\n"
+                            "        } \\\n"
+                            "    } while (0)\n"
+                            "\n");
+        }
+    }
+
+    ScmStreamPrintf(pStrm,
+                    "\n"
+                    "#else\n"
+                    "\n");
+    RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
+    {
+        RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
+        {
+            generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
+            ScmStreamPrintf(pStrm,
+                            "# define %s("
+                            , szTmp);
+            RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
+            {
+                if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
+                    ScmStreamPrintf(pStrm, "%s", pArg->pszName);
+                else
+                    ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
+            }
+            ScmStreamPrintf(pStrm,
+                            ") do { } while (0)\n");
+        }
+    }
+
+    ScmStreamWrite(pStrm, RT_STR_TUPLE("\n"
+                                       "#endif\n"
+                                       "\n"
+                                       "#endif\n"));
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Parser error with line and position.
+ *
+ * @returns RTEXITCODE_FAILURE.
+ * @param   pStrm       The stream.
+ * @param   fAbs        Absolute or relative offset.
+ * @param   offSeek     When @a fAbs is @c false, the offset from the current
+ *                      position to the point of failure.  When @a fAbs is @c
+ *                      true, it's the absolute position.
+ * @param   pszFormat   The message format string.
+ * @param   va          Format arguments.
+ */
+static RTEXITCODE parseErrorExV(PSCMSTREAM pStrm, bool fAbs, size_t offSeek, const char *pszFormat, va_list va)
+{
+    if (fAbs)
+        ScmStreamSeekAbsolute(pStrm, offSeek);
+    else if (offSeek != 0)
+        ScmStreamSeekRelative(pStrm, -(ssize_t)offSeek);
+    size_t const off     = ScmStreamTell(pStrm);
+    size_t const iLine   = ScmStreamTellLine(pStrm);
+    ScmStreamSeekByLine(pStrm, iLine);
+    size_t const offLine = ScmStreamTell(pStrm);
+
+    va_list va2;
+    va_copy(va2, va);
+    RTPrintf("%s:%d:%zd: error: %N.\n", g_pszScript, iLine + 1, off - offLine + 1, pszFormat, &va2);
+    va_end(va2);
+
+    size_t cchLine;
+    SCMEOL enmEof;
+    const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
+    if (pszLine)
+        RTPrintf("  %.*s\n"
+                 "  %*s^\n",
+                 cchLine, pszLine, off - offLine, "");
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Parser error with line and position.
+ *
+ * @returns RTEXITCODE_FAILURE.
+ * @param   pStrm       The stream.
+ * @param   off         The offset from the current position to the point of
+ *                      failure.
+ * @param   pszFormat   The message format string.
+ * @param   ...         Format arguments.
+ */
+static RTEXITCODE parseError(PSCMSTREAM pStrm, size_t off, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTEXITCODE rcExit = parseErrorExV(pStrm, false, off, pszFormat, va);
+    va_end(va);
+    return rcExit;
+}
+
+
+/**
+ * Parser error with line and position, absolute version.
+ *
+ * @returns RTEXITCODE_FAILURE.
+ * @param   pStrm       The stream.
+ * @param   off         The offset from the current position to the point of
+ *                      failure.
+ * @param   pszFormat   The message format string.
+ * @param   ...         Format arguments.
+ */
+static RTEXITCODE parseErrorAbs(PSCMSTREAM pStrm, size_t off, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    RTEXITCODE rcExit = parseErrorExV(pStrm, true /*fAbs*/, off, pszFormat, va);
+    va_end(va);
+    return rcExit;
+}
+
+
+/**
+ * Parser warning with line and position.
+ *
+ * @param   pStrm       The stream.
+ * @param   fAbs        Absolute or relative offset.
+ * @param   offSeek     When @a fAbs is @c false, the offset from the current
+ *                      position to the point of failure.  When @a fAbs is @c
+ *                      true, it's the absolute position.
+ * @param   pszFormat   The message format string.
+ * @param   va          Format arguments.
+ */
+static void parseWarnExV(PSCMSTREAM pStrm, bool fAbs, size_t offSeek, const char *pszFormat, va_list va)
+{
+    /* Save the stream position. */
+    size_t const offOrg = ScmStreamTell(pStrm);
+
+    if (fAbs)
+        ScmStreamSeekAbsolute(pStrm, offSeek);
+    else if (offSeek != 0)
+        ScmStreamSeekRelative(pStrm, -(ssize_t)offSeek);
+    size_t const off     = ScmStreamTell(pStrm);
+    size_t const iLine   = ScmStreamTellLine(pStrm);
+    ScmStreamSeekByLine(pStrm, iLine);
+    size_t const offLine = ScmStreamTell(pStrm);
+
+    va_list va2;
+    va_copy(va2, va);
+    RTPrintf("%s:%d:%zd: warning: %N.\n", g_pszScript, iLine + 1, off - offLine + 1, pszFormat, &va2);
+    va_end(va2);
+
+    size_t cchLine;
+    SCMEOL enmEof;
+    const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
+    if (pszLine)
+        RTPrintf("  %.*s\n"
+                 "  %*s^\n",
+                 cchLine, pszLine, off - offLine, "");
+
+    /* restore the position. */
+    int rc = ScmStreamSeekAbsolute(pStrm, offOrg);
+    AssertRC(rc);
+}
+
+#if 0 /* unused */
+/**
+ * Parser warning with line and position.
+ *
+ * @param   pStrm       The stream.
+ * @param   off         The offset from the current position to the point of
+ *                      failure.
+ * @param   pszFormat   The message format string.
+ * @param   ...         Format arguments.
+ */
+static void parseWarn(PSCMSTREAM pStrm, size_t off, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    parseWarnExV(pStrm, false, off, pszFormat, va);
+    va_end(va);
+}
+#endif /* unused */
+
+/**
+ * Parser warning with line and position, absolute version.
+ *
+ * @param   pStrm       The stream.
+ * @param   off         The offset from the current position to the point of
+ *                      failure.
+ * @param   pszFormat   The message format string.
+ * @param   ...         Format arguments.
+ */
+static void parseWarnAbs(PSCMSTREAM pStrm, size_t off, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    parseWarnExV(pStrm, true /*fAbs*/, off, pszFormat, va);
+    va_end(va);
+}
+
+
+/**
+ * Handles a C++ one line comment.
+ *
+ * @returns Exit code.
+ * @param   pStrm               The stream.
+ */
+static RTEXITCODE parseOneLineComment(PSCMSTREAM pStrm)
+{
+    ScmStreamSeekByLine(pStrm, ScmStreamTellLine(pStrm) + 1);
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Handles a multi-line C/C++ comment.
+ *
+ * @returns Exit code.
+ * @param   pStrm               The stream.
+ */
+static RTEXITCODE parseMultiLineComment(PSCMSTREAM pStrm)
+{
+    unsigned ch;
+    while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
+    {
+        if (ch == '*')
+        {
+            do
+                ch = ScmStreamGetCh(pStrm);
+            while (ch == '*');
+            if (ch == '/')
+                return RTEXITCODE_SUCCESS;
+        }
+    }
+
+    parseError(pStrm, 1, "Expected end of comment, got end of file");
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Skips spaces and comments.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE.
+ * @param   pStrm               The stream..
+ */
+static RTEXITCODE parseSkipSpacesAndComments(PSCMSTREAM pStrm)
+{
+    unsigned ch;
+    while ((ch = ScmStreamPeekCh(pStrm)) != ~(unsigned)0)
+    {
+        if (!RT_C_IS_SPACE(ch) && ch != '/')
+            return RTEXITCODE_SUCCESS;
+        unsigned ch2 = ScmStreamGetCh(pStrm); AssertBreak(ch == ch2); NOREF(ch2);
+        if (ch == '/')
+        {
+            ch = ScmStreamGetCh(pStrm);
+            RTEXITCODE rcExit;
+            if (ch == '*')
+                rcExit = parseMultiLineComment(pStrm);
+            else if (ch == '/')
+                rcExit = parseOneLineComment(pStrm);
+            else
+                rcExit = parseError(pStrm, 2, "Unexpected character");
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return rcExit;
+        }
+    }
+
+    return parseError(pStrm, 0, "Unexpected end of file");
+}
+
+
+/**
+ * Skips spaces and comments, returning the next character.
+ *
+ * @returns Next non-space-non-comment character. ~(unsigned)0 on EOF or
+ *          failure.
+ * @param   pStrm               The stream.
+ */
+static unsigned parseGetNextNonSpaceNonCommentCh(PSCMSTREAM pStrm)
+{
+    unsigned ch;
+    while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
+    {
+        if (!RT_C_IS_SPACE(ch) && ch != '/')
+            return ch;
+        if (ch == '/')
+        {
+            ch = ScmStreamGetCh(pStrm);
+            RTEXITCODE rcExit;
+            if (ch == '*')
+                rcExit = parseMultiLineComment(pStrm);
+            else if (ch == '/')
+                rcExit = parseOneLineComment(pStrm);
+            else
+                rcExit = parseError(pStrm, 2, "Unexpected character");
+            if (rcExit != RTEXITCODE_SUCCESS)
+                return ~(unsigned)0;
+        }
+    }
+
+    parseError(pStrm, 0, "Unexpected end of file");
+    return ~(unsigned)0;
+}
+
+
+/**
+ * Get the next non-space-non-comment character on a preprocessor line.
+ *
+ * @returns The next character. On error message and ~(unsigned)0.
+ * @param   pStrm               The stream.
+ */
+static unsigned parseGetNextNonSpaceNonCommentChOnPpLine(PSCMSTREAM pStrm)
+{
+    size_t   off = ScmStreamTell(pStrm) - 1;
+    unsigned ch;
+    while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
+    {
+        if (RT_C_IS_SPACE(ch))
+        {
+            if (ch == '\n' || ch == '\r')
+            {
+                parseErrorAbs(pStrm, off, "Invalid preprocessor statement");
+                break;
+            }
+        }
+        else if (ch == '\\')
+        {
+            size_t off2 = ScmStreamTell(pStrm) - 1;
+            ch = ScmStreamGetCh(pStrm);
+            if (ch == '\r')
+                ch = ScmStreamGetCh(pStrm);
+            if (ch != '\n')
+            {
+                parseErrorAbs(pStrm, off2, "Expected new line");
+                break;
+            }
+        }
+        else
+            return ch;
+    }
+    return ~(unsigned)0;
+}
+
+
+
+/**
+ * Skips spaces and comments.
+ *
+ * @returns Same as ScmStreamCGetWord
+ * @param   pStrm               The stream..
+ * @param   pcchWord            Where to return the length.
+ */
+static const char *parseGetNextCWord(PSCMSTREAM pStrm, size_t *pcchWord)
+{
+    if (parseSkipSpacesAndComments(pStrm) != RTEXITCODE_SUCCESS)
+        return NULL;
+    return ScmStreamCGetWord(pStrm, pcchWord);
+}
+
+
+
+/**
+ * Parses interface stability.
+ *
+ * @returns Interface stability if parsed correctly, otherwise error message and
+ *          kVTGStability_Invalid.
+ * @param   pStrm               The stream.
+ * @param   ch                  The first character in the stability spec.
+ */
+static kVTGStability parseStability(PSCMSTREAM pStrm, unsigned ch)
+{
+    switch (ch)
+    {
+        case 'E':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("External")))
+                return kVTGStability_External;
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Evolving")))
+                return kVTGStability_Evolving;
+            break;
+        case 'I':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Internal")))
+                return kVTGStability_Internal;
+            break;
+        case 'O':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Obsolete")))
+                return kVTGStability_Obsolete;
+            break;
+        case 'P':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Private")))
+                return kVTGStability_Private;
+            break;
+        case 'S':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Stable")))
+                return kVTGStability_Stable;
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Standard")))
+                return kVTGStability_Standard;
+            break;
+        case 'U':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unstable")))
+                return kVTGStability_Unstable;
+            break;
+    }
+    parseError(pStrm, 1, "Unknown stability specifier");
+    return kVTGStability_Invalid;
+}
+
+
+/**
+ * Parses data depndency class.
+ *
+ * @returns Data dependency class if parsed correctly, otherwise error message
+ *          and kVTGClass_Invalid.
+ * @param   pStrm               The stream.
+ * @param   ch                  The first character in the stability spec.
+ */
+static kVTGClass parseDataDepClass(PSCMSTREAM pStrm, unsigned ch)
+{
+    switch (ch)
+    {
+        case 'C':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Common")))
+                return kVTGClass_Common;
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Cpu")))
+                return kVTGClass_Cpu;
+            break;
+        case 'G':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Group")))
+                return kVTGClass_Group;
+            break;
+        case 'I':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Isa")))
+                return kVTGClass_Isa;
+            break;
+        case 'P':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Platform")))
+                return kVTGClass_Platform;
+            break;
+        case 'U':
+            if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unknown")))
+                return kVTGClass_Unknown;
+            break;
+    }
+    parseError(pStrm, 1, "Unknown data dependency class specifier");
+    return kVTGClass_Invalid;
+}
+
+/**
+ * Parses a pragma D attributes statement.
+ *
+ * @returns Suitable exit code, errors message already written on failure.
+ * @param   pStrm               The stream.
+ */
+static RTEXITCODE parsePragmaDAttributes(PSCMSTREAM pStrm)
+{
+    /*
+     * "CodeStability/DataStability/DataDepClass" - no spaces allowed.
+     */
+    unsigned ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
+    if (ch == ~(unsigned)0)
+        return RTEXITCODE_FAILURE;
+
+    kVTGStability enmCode = parseStability(pStrm, ch);
+    if (enmCode == kVTGStability_Invalid)
+        return RTEXITCODE_FAILURE;
+    ch = ScmStreamGetCh(pStrm);
+    if (ch != '/')
+        return parseError(pStrm, 1, "Expected '/' following the code stability specifier");
+
+    kVTGStability enmData = parseStability(pStrm, ScmStreamGetCh(pStrm));
+    if (enmData == kVTGStability_Invalid)
+        return RTEXITCODE_FAILURE;
+    ch = ScmStreamGetCh(pStrm);
+    if (ch != '/')
+        return parseError(pStrm, 1, "Expected '/' following the data stability specifier");
+
+    kVTGClass enmDataDep =  parseDataDepClass(pStrm, ScmStreamGetCh(pStrm));
+    if (enmDataDep == kVTGClass_Invalid)
+        return RTEXITCODE_FAILURE;
+
+    /*
+     * Expecting 'provider' followed by the name of an provider defined earlier.
+     */
+    ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
+    if (ch == ~(unsigned)0)
+        return RTEXITCODE_FAILURE;
+    if (ch != 'p' || !ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("provider")))
+        return parseError(pStrm, 1, "Expected 'provider'");
+
+    size_t      cchName;
+    const char *pszName = parseGetNextCWord(pStrm, &cchName);
+    if (!pszName)
+        return parseError(pStrm, 1, "Expected provider name");
+
+    PVTGPROVIDER pProv;
+    RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
+    {
+        if (   !strncmp(pProv->pszName, pszName, cchName)
+            && pProv->pszName[cchName] == '\0')
+            break;
+    }
+    if (RTListNodeIsDummy(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry))
+        return parseError(pStrm, cchName, "Provider not found");
+
+    /*
+     * Which aspect of the provider?
+     */
+    size_t      cchAspect;
+    const char *pszAspect = parseGetNextCWord(pStrm, &cchAspect);
+    if (!pszAspect)
+        return parseError(pStrm, 1, "Expected provider aspect");
+
+    PVTGATTRS pAttrs;
+    if (cchAspect == 8 && !memcmp(pszAspect, "provider", 8))
+        pAttrs = &pProv->AttrSelf;
+    else if (cchAspect == 8 && !memcmp(pszAspect, "function", 8))
+        pAttrs = &pProv->AttrFunctions;
+    else if (cchAspect == 6 && !memcmp(pszAspect, "module", 6))
+        pAttrs = &pProv->AttrModules;
+    else if (cchAspect == 4 && !memcmp(pszAspect, "name", 4))
+        pAttrs = &pProv->AttrName;
+    else if (cchAspect == 4 && !memcmp(pszAspect, "args", 4))
+        pAttrs = &pProv->AttrArguments;
+    else
+        return parseError(pStrm, cchAspect, "Unknown aspect");
+
+    if (pAttrs->enmCode != kVTGStability_Invalid)
+        return parseError(pStrm, cchAspect, "You have already specified these attributes");
+
+    pAttrs->enmCode     = enmCode;
+    pAttrs->enmData     = enmData;
+    pAttrs->enmDataDep  = enmDataDep;
+    return RTEXITCODE_SUCCESS;
+}
+
+/**
+ * Parses a D pragma statement.
+ *
+ * @returns Suitable exit code, errors message already written on failure.
+ * @param   pStrm               The stream.
+ */
+static RTEXITCODE parsePragma(PSCMSTREAM pStrm)
+{
+    RTEXITCODE rcExit;
+    unsigned   ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
+    if (ch == ~(unsigned)0)
+        rcExit = RTEXITCODE_FAILURE;
+    else if (ch == 'D' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("D")))
+    {
+        ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
+        if (ch == ~(unsigned)0)
+            rcExit = RTEXITCODE_FAILURE;
+        else if (ch == 'a' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("attributes")))
+            rcExit = parsePragmaDAttributes(pStrm);
+        else
+            rcExit = parseError(pStrm, 1, "Unknown pragma D");
+    }
+    else
+        rcExit = parseError(pStrm, 1, "Unknown pragma");
+    return rcExit;
+}
+
+
+/**
+ * Classifies the given type expression.
+ *
+ * @return  Type flags.
+ * @param   pszType         The type expression.
+ * @param   pStrm           The input stream (for errors + warnings).
+ * @param   offSrc          The absolute source position of this expression (for
+ *                          warnings).
+ */
+static uint32_t parseTypeExpression(const char *pszType, PSCMSTREAM pStrm, size_t offSrc)
+{
+    size_t cchType = strlen(pszType);
+#define MY_STRMATCH(a_sz)  (cchType == sizeof(a_sz) - 1 && !memcmp(a_sz, pszType, sizeof(a_sz) - 1))
+
+    /*
+     * Try detect pointers.
+     */
+    if (pszType[cchType - 1] == '*')
+    {
+        if (MY_STRMATCH("const char *")) return VTG_TYPE_POINTER | VTG_TYPE_CONST_CHAR_PTR;
+        return VTG_TYPE_POINTER;
+    }
+    if (pszType[cchType - 1] == '&')
+    {
+        parseWarnAbs(pStrm, offSrc, "Please avoid using references like '%s' for probe arguments!", pszType);
+        return VTG_TYPE_POINTER;
+    }
+
+    /*
+     * Standard integer types and IPRT variants.
+     * It's important that we catch all types larger than 32-bit here or we'll
+     * screw up the probe argument handling.
+     */
+    if (MY_STRMATCH("int"))             return VTG_TYPE_FIXED_SIZED | sizeof(int)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("uintptr_t"))       return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("intptr_t"))        return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_SIGNED;
+
+    //if (MY_STRMATCH("uint128_t"))       return VTG_TYPE_FIXED_SIZED | sizeof(uint128_t) | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("uint64_t"))        return VTG_TYPE_FIXED_SIZED | sizeof(uint64_t)  | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("uint32_t"))        return VTG_TYPE_FIXED_SIZED | sizeof(uint32_t)  | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("uint16_t"))        return VTG_TYPE_FIXED_SIZED | sizeof(uint16_t)  | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("uint8_t"))         return VTG_TYPE_FIXED_SIZED | sizeof(uint8_t)   | VTG_TYPE_UNSIGNED;
+
+    //if (MY_STRMATCH("int128_t"))        return VTG_TYPE_FIXED_SIZED | sizeof(int128_t)  | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("int64_t"))         return VTG_TYPE_FIXED_SIZED | sizeof(int64_t)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("int32_t"))         return VTG_TYPE_FIXED_SIZED | sizeof(int32_t)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("int16_t"))         return VTG_TYPE_FIXED_SIZED | sizeof(int16_t)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("int8_t"))          return VTG_TYPE_FIXED_SIZED | sizeof(int8_t)    | VTG_TYPE_SIGNED;
+
+    if (MY_STRMATCH("RTUINT64U"))       return VTG_TYPE_FIXED_SIZED | sizeof(uint64_t)  | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTUINT32U"))       return VTG_TYPE_FIXED_SIZED | sizeof(uint32_t)  | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTUINT16U"))       return VTG_TYPE_FIXED_SIZED | sizeof(uint16_t)  | VTG_TYPE_UNSIGNED;
+
+    if (MY_STRMATCH("RTMSINTERVAL"))    return VTG_TYPE_FIXED_SIZED | sizeof(RTMSINTERVAL) | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTTIMESPEC"))      return VTG_TYPE_FIXED_SIZED | sizeof(RTTIMESPEC)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("RTPROCESS"))       return VTG_TYPE_FIXED_SIZED | sizeof(RTPROCESS)    | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTHCPHYS"))        return VTG_TYPE_FIXED_SIZED | sizeof(RTHCPHYS)     | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS;
+
+    if (MY_STRMATCH("RTR3PTR"))         return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3;
+    if (MY_STRMATCH("RTR0PTR"))         return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0;
+    if (MY_STRMATCH("RTRCPTR"))         return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC;
+    if (MY_STRMATCH("RTHCPTR"))         return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0;
+
+    if (MY_STRMATCH("RTR3UINTPTR"))     return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTR0UINTPTR"))     return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTRCUINTPTR"))     return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTHCUINTPTR"))     return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;
+
+    if (MY_STRMATCH("RTR3INTPTR"))      return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("RTR0INTPTR"))      return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0 | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("RTRCINTPTR"))      return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("RTHCINTPTR"))      return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_SIGNED;
+
+    if (MY_STRMATCH("RTUINTPTR"))       return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_CTX_RC | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTINTPTR"))        return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_CTX_RC | VTG_TYPE_SIGNED;
+
+    if (MY_STRMATCH("RTHCUINTREG"))     return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTR3UINTREG"))     return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("RTR0UINTREG"))     return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;
+
+    if (MY_STRMATCH("RTGCUINTREG"))     return VTG_TYPE_FIXED_SIZED | sizeof(RTGCUINTREG) | VTG_TYPE_UNSIGNED | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPTR"))         return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR)     | VTG_TYPE_UNSIGNED | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCINTPTR"))      return VTG_TYPE_FIXED_SIZED | sizeof(RTGCUINTPTR) | VTG_TYPE_SIGNED   | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPTR32"))       return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR32)   | VTG_TYPE_SIGNED   | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPTR64"))       return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR64)   | VTG_TYPE_SIGNED   | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPHYS"))        return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS)    | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPHYS32"))      return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS32)  | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;
+    if (MY_STRMATCH("RTGCPHYS64"))      return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS64)  | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;
+
+    /*
+     * The special VBox types.
+     */
+    if (MY_STRMATCH("PVM"))             return VTG_TYPE_POINTER;
+    if (MY_STRMATCH("PVMCPU"))          return VTG_TYPE_POINTER;
+    if (MY_STRMATCH("PCPUMCTX"))        return VTG_TYPE_POINTER;
+
+    /*
+     * Preaching time.
+     */
+    if (   MY_STRMATCH("unsigned long")
+        || MY_STRMATCH("unsigned long long")
+        || MY_STRMATCH("signed long")
+        || MY_STRMATCH("signed long long")
+        || MY_STRMATCH("long")
+        || MY_STRMATCH("long long")
+        || MY_STRMATCH("char")
+        || MY_STRMATCH("signed char")
+        || MY_STRMATCH("unsigned char")
+        || MY_STRMATCH("double")
+        || MY_STRMATCH("long double")
+        || MY_STRMATCH("float")
+       )
+    {
+        RTMsgError("Please do NOT use the type '%s' for probe arguments!", pszType);
+        g_cTypeErrors++;
+        return 0;
+    }
+
+    if (   MY_STRMATCH("unsigned")
+        || MY_STRMATCH("signed")
+        || MY_STRMATCH("signed int")
+        || MY_STRMATCH("unsigned int")
+        || MY_STRMATCH("short")
+        || MY_STRMATCH("signed short")
+        || MY_STRMATCH("unsigned short")
+       )
+        parseWarnAbs(pStrm, offSrc, "Please avoid using the type '%s' for probe arguments!", pszType);
+    if (MY_STRMATCH("unsigned"))        return VTG_TYPE_FIXED_SIZED | sizeof(int)   | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("unsigned int"))    return VTG_TYPE_FIXED_SIZED | sizeof(int)   | VTG_TYPE_UNSIGNED;
+    if (MY_STRMATCH("signed"))          return VTG_TYPE_FIXED_SIZED | sizeof(int)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("signed int"))      return VTG_TYPE_FIXED_SIZED | sizeof(int)   | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("short"))           return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("signed short"))    return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_SIGNED;
+    if (MY_STRMATCH("unsigned short"))  return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_UNSIGNED;
+
+    /*
+     * What we haven't caught by now is either unknown to us or wrong.
+     */
+    if (pszType[0] == 'P')
+    {
+        RTMsgError("Type '%s' looks like a pointer typedef, please do NOT use those "
+                   "but rather the non-pointer typedef or struct with '*'",
+                   pszType);
+        g_cTypeErrors++;
+        return VTG_TYPE_POINTER;
+    }
+
+    RTMsgError("Don't know '%s' - please change or fix VBoxTpG", pszType);
+    g_cTypeErrors++;
+
+#undef MY_STRCMP
+    return 0;
+}
+
+
+/**
+ * Initializes the members of an argument.
+ *
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pProbe              The probe.
+ * @param   pArg                The argument.
+ * @param   pStrm               The input stream (for errors + warnings).
+ * @param   pchType             The type.
+ * @param   cchType             The type length.
+ * @param   pchName             The name.
+ * @param   cchName             The name length.
+ */
+static RTEXITCODE parseInitArgument(PVTGPROBE pProbe, PVTGARG pArg, PSCMSTREAM pStrm,
+                                    char *pchType, size_t cchType, char *pchName, size_t cchName)
+{
+    Assert(!pArg->pszName); Assert(!pArg->pszTracerType); Assert(!pArg->pszCtxType); Assert(!pArg->fType);
+
+    pArg->pszArgPassingFmt  = ", %s";
+    pArg->pszName           = RTStrDupN(pchName, cchName);
+    pArg->pszTracerType     = strtabInsertN(pchType, cchType);
+    if (!pArg->pszTracerType || !pArg->pszName)
+        return parseError(pStrm, 1, "Out of memory");
+    pArg->fType             = parseTypeExpression(pArg->pszTracerType, pStrm, pArg->offSrc);
+
+    if (   (pArg->fType & VTG_TYPE_POINTER)
+        && !(g_fTypeContext & VTG_TYPE_CTX_R0) )
+    {
+        pArg->fType &= ~VTG_TYPE_POINTER;
+        if (   !strcmp(pArg->pszTracerType, "struct VM *")          || !strcmp(pArg->pszTracerType, "PVM")
+            || !strcmp(pArg->pszTracerType, "struct VMCPU *")       || !strcmp(pArg->pszTracerType, "PVMCPU")
+            || !strcmp(pArg->pszTracerType, "struct CPUMCTX *")     || !strcmp(pArg->pszTracerType, "PCPUMCTX")
+            )
+        {
+            pArg->fType |= VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0
+                         | VTG_TYPE_FIXED_SIZED | (g_cHostBits / 8)
+                         | VTG_TYPE_AUTO_CONV_PTR;
+            pArg->pszCtxType = RTStrDup("RTR0PTR");
+
+            if (!strcmp(pArg->pszTracerType, "struct VM *")         || !strcmp(pArg->pszTracerType, "PVM"))
+                pArg->pszArgPassingFmt = ", VTG_VM_TO_R0(%s)";
+            else if (!strcmp(pArg->pszTracerType, "struct VMCPU *") || !strcmp(pArg->pszTracerType, "PVMCPU"))
+                pArg->pszArgPassingFmt = ", VTG_VMCPU_TO_R0(%s)";
+            else
+            {
+                PVTGARG pFirstArg = RTListGetFirst(&pProbe->ArgHead, VTGARG, ListEntry);
+                if (   !pFirstArg
+                    || pFirstArg == pArg
+                    || strcmp(pFirstArg->pszName, "a_pVCpu")
+                    || (   strcmp(pFirstArg->pszTracerType, "struct VMCPU *")
+                        && strcmp(pFirstArg->pszTracerType, "PVMCPU *")) )
+                    return parseError(pStrm, 1, "The automatic ring-0 pointer conversion requires 'a_pVCpu' with type 'struct VMCPU *' as the first argument");
+
+                if (!strcmp(pArg->pszTracerType, "struct CPUMCTX *")|| !strcmp(pArg->pszTracerType, "PCPUMCTX"))
+                    pArg->pszArgPassingFmt = ", VTG_CPUMCTX_TO_R0(a_pVCpu, %s)";
+                else
+                    pArg->pszArgPassingFmt = ", VBoxTpG-Is-Buggy!!";
+            }
+        }
+        else
+        {
+            pArg->fType |= VTG_TYPE_CTX_POINTER | g_fTypeContext | VTG_TYPE_FIXED_SIZED | (g_cBits / 8);
+            pArg->pszCtxType = RTStrDupN(pchType, cchType);
+        }
+    }
+    else
+        pArg->pszCtxType = RTStrDupN(pchType, cchType);
+    if (!pArg->pszCtxType)
+        return parseError(pStrm, 1, "Out of memory");
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * Unmangles the probe name.
+ *
+ * This involves translating double underscore to dash.
+ *
+ * @returns Pointer to the unmangled name in the string table.
+ * @param   pszMangled          The mangled name.
+ */
+static const char *parseUnmangleProbeName(const char *pszMangled)
+{
+    size_t      cchMangled = strlen(pszMangled);
+    char       *pszTmp     = (char *)alloca(cchMangled + 2);
+    const char *pszSrc     = pszMangled;
+    char       *pszDst     = pszTmp;
+
+    while (*pszSrc)
+    {
+        if (pszSrc[0] == '_' && pszSrc[1] == '_' && pszSrc[2] != '_')
+        {
+            *pszDst++ = '-';
+            pszSrc   += 2;
+        }
+        else
+            *pszDst++ = *pszSrc++;
+    }
+    *pszDst = '\0';
+
+    return strtabInsertN(pszTmp, pszDst - pszTmp);
+}
+
+
+/**
+ * Parses a D probe statement.
+ *
+ * @returns Suitable exit code, errors message already written on failure.
+ * @param   pStrm               The stream.
+ * @param   pProv               The provider being parsed.
+ */
+static RTEXITCODE parseProbe(PSCMSTREAM pStrm, PVTGPROVIDER pProv)
+{
+    size_t const iProbeLine = ScmStreamTellLine(pStrm);
+
+    /*
+     * Next up is a name followed by an opening parenthesis.
+     */
+    size_t      cchProbe;
+    const char *pszProbe = parseGetNextCWord(pStrm, &cchProbe);
+    if (!pszProbe)
+        return parseError(pStrm, 1, "Expected a probe name starting with an alphabetical character");
+    unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+    if (ch != '(')
+        return parseError(pStrm, 1, "Expected '(' after the probe name");
+
+    /*
+     * Create a probe instance.
+     */
+    PVTGPROBE pProbe = (PVTGPROBE)RTMemAllocZ(sizeof(*pProbe));
+    if (!pProbe)
+        return parseError(pStrm, 0, "Out of memory");
+    RTListInit(&pProbe->ArgHead);
+    RTListAppend(&pProv->ProbeHead, &pProbe->ListEntry);
+    pProbe->offArgList     = UINT32_MAX;
+    pProbe->iLine          = iProbeLine;
+    pProbe->pszMangledName = RTStrDupN(pszProbe, cchProbe);
+    if (!pProbe->pszMangledName)
+        return parseError(pStrm, 0, "Out of memory");
+    pProbe->pszUnmangledName = parseUnmangleProbeName(pProbe->pszMangledName);
+    if (!pProbe->pszUnmangledName)
+        return parseError(pStrm, 0, "Out of memory");
+
+    /*
+     * Parse loop for the argument.
+     */
+    PVTGARG pArg    = NULL;
+    size_t  cchName = 0;
+    size_t  cchArg  = 0;
+    char    szArg[4096];
+    for (;;)
+    {
+        ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+        switch (ch)
+        {
+            case ')':
+            case ',':
+            {
+                /* commit the argument */
+                if (pArg)
+                {
+                    if (!cchName)
+                        return parseError(pStrm, 1, "Argument has no name");
+                    if (cchArg - cchName - 1 >= 128)
+                        return parseError(pStrm, 1, "Argument type too long");
+                    RTEXITCODE rcExit = parseInitArgument(pProbe, pArg, pStrm,
+                                                          szArg, cchArg - cchName - 1,
+                                                          &szArg[cchArg - cchName], cchName);
+                    if (rcExit != RTEXITCODE_SUCCESS)
+                        return rcExit;
+                    if (VTG_TYPE_IS_LARGE(pArg->fType))
+                        pProbe->fHaveLargeArgs = true;
+                    pArg = NULL;
+                    cchName = cchArg = 0;
+                }
+                if (ch == ')')
+                {
+                    size_t off = ScmStreamTell(pStrm);
+                    ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+                    if (ch != ';')
+                        return parseErrorAbs(pStrm, off, "Expected ';'");
+                    return RTEXITCODE_SUCCESS;
+                }
+                break;
+            }
+
+            default:
+            {
+                size_t      cchWord;
+                const char *pszWord = ScmStreamCGetWordM1(pStrm, &cchWord);
+                if (!pszWord)
+                    return parseError(pStrm, 0, "Expected argument");
+                if (!pArg)
+                {
+                    pArg = (PVTGARG)RTMemAllocZ(sizeof(*pArg));
+                    if (!pArg)
+                        return parseError(pStrm, 1, "Out of memory");
+                    RTListAppend(&pProbe->ArgHead, &pArg->ListEntry);
+                    pArg->iArgNo = pProbe->cArgs++;
+                    pArg->pProbe = pProbe;
+                    pArg->offSrc = ScmStreamTell(pStrm) - cchWord;
+
+                    if (cchWord + 1 > sizeof(szArg))
+                        return parseError(pStrm, 1, "Too long parameter declaration");
+                    memcpy(szArg, pszWord, cchWord);
+                    szArg[cchWord] = '\0';
+                    cchArg  = cchWord;
+                    cchName = 0;
+                }
+                else
+                {
+                    if (cchArg + 1 + cchWord + 1 > sizeof(szArg))
+                        return parseError(pStrm, 1, "Too long parameter declaration");
+
+                    szArg[cchArg++] = ' ';
+                    memcpy(&szArg[cchArg], pszWord, cchWord);
+                    cchArg += cchWord;
+                    szArg[cchArg] = '\0';
+                    cchName = cchWord;
+                }
+                break;
+            }
+
+            case '*':
+            {
+                if (!pArg)
+                    return parseError(pStrm, 1, "A parameter type does not start with an asterix");
+                if (cchArg + sizeof(" *") >= sizeof(szArg))
+                    return parseError(pStrm, 1, "Too long parameter declaration");
+                szArg[cchArg++] = ' ';
+                szArg[cchArg++] = '*';
+                szArg[cchArg  ] = '\0';
+                cchName = 0;
+                break;
+            }
+
+            case ~(unsigned)0:
+                return parseError(pStrm, 0, "Missing closing ')' on probe");
+        }
+    }
+}
+
+/**
+ * Parses a D provider statement.
+ *
+ * @returns Suitable exit code, errors message already written on failure.
+ * @param   pStrm               The stream.
+ */
+static RTEXITCODE parseProvider(PSCMSTREAM pStrm)
+{
+    /*
+     * Next up is a name followed by a curly bracket. Ignore comments.
+     */
+    RTEXITCODE rcExit = parseSkipSpacesAndComments(pStrm);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return parseError(pStrm, 1, "Expected a provider name starting with an alphabetical character");
+    size_t      cchName;
+    const char *pszName = ScmStreamCGetWord(pStrm, &cchName);
+    if (!pszName)
+        return parseError(pStrm, 0, "Bad provider name");
+    if (RT_C_IS_DIGIT(pszName[cchName - 1]))
+        return parseError(pStrm, 1, "A provider name cannot end with digit");
+
+    unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+    if (ch != '{')
+        return parseError(pStrm, 1, "Expected '{' after the provider name");
+
+    /*
+     * Create a provider instance.
+     */
+    PVTGPROVIDER pProv = (PVTGPROVIDER)RTMemAllocZ(sizeof(*pProv));
+    if (!pProv)
+        return parseError(pStrm, 0, "Out of memory");
+    RTListInit(&pProv->ProbeHead);
+    RTListAppend(&g_ProviderHead, &pProv->ListEntry);
+    pProv->pszName = strtabInsertN(pszName, cchName);
+    if (!pProv->pszName)
+        return parseError(pStrm, 0, "Out of memory");
+
+    /*
+     * Parse loop.
+     */
+    for (;;)
+    {
+        ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+        switch (ch)
+        {
+            case 'p':
+                if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("probe")))
+                    rcExit = parseProbe(pStrm, pProv);
+                else
+                    rcExit = parseError(pStrm, 1, "Unexpected character");
+                break;
+
+            case '}':
+            {
+                size_t off = ScmStreamTell(pStrm);
+                ch = parseGetNextNonSpaceNonCommentCh(pStrm);
+                if (ch == ';')
+                    return RTEXITCODE_SUCCESS;
+                rcExit = parseErrorAbs(pStrm, off, "Expected ';'");
+                break;
+            }
+
+            case ~(unsigned)0:
+                rcExit = parseError(pStrm, 0, "Missing closing '}' on provider");
+                break;
+
+            default:
+                rcExit = parseError(pStrm, 1, "Unexpected character");
+                break;
+        }
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+    }
+}
+
+
+static RTEXITCODE parseScript(const char *pszScript)
+{
+    SCMSTREAM Strm;
+    int rc = ScmStreamInitForReading(&Strm, pszScript);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open & read '%s' into memory: %Rrc", pszScript, rc);
+    if (g_cVerbosity > 0)
+        RTMsgInfo("Parsing '%s'...", pszScript);
+
+    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
+    unsigned    ch;
+    while ((ch = ScmStreamGetCh(&Strm)) != ~(unsigned)0)
+    {
+        if (RT_C_IS_SPACE(ch))
+            continue;
+        switch (ch)
+        {
+            case '/':
+                ch = ScmStreamGetCh(&Strm);
+                if (ch == '*')
+                    rcExit = parseMultiLineComment(&Strm);
+                else if (ch == '/')
+                    rcExit = parseOneLineComment(&Strm);
+                else
+                    rcExit = parseError(&Strm, 2, "Unexpected character");
+                break;
+
+            case 'p':
+                if (ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("provider")))
+                    rcExit = parseProvider(&Strm);
+                else
+                    rcExit = parseError(&Strm, 1, "Unexpected character");
+                break;
+
+            case '#':
+            {
+                ch = parseGetNextNonSpaceNonCommentChOnPpLine(&Strm);
+                if (ch == ~(unsigned)0)
+                    rcExit = RTEXITCODE_FAILURE;
+                else if (ch == 'p' && ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("pragma")))
+                    rcExit = parsePragma(&Strm);
+                else
+                    rcExit = parseError(&Strm, 1, "Unsupported preprocessor directive");
+                break;
+            }
+
+            default:
+                rcExit = parseError(&Strm, 1, "Unexpected character");
+                break;
+        }
+        if (rcExit != RTEXITCODE_SUCCESS)
+            return rcExit;
+    }
+
+    ScmStreamDelete(&Strm);
+    if (g_cVerbosity > 0 && rcExit == RTEXITCODE_SUCCESS)
+        RTMsgInfo("Successfully parsed '%s'.", pszScript);
+    return rcExit;
+}
+
+
+/**
+ * Parses the arguments.
+ */
+static RTEXITCODE parseArguments(int argc,  char **argv)
+{
+    /*
+     * Set / Adjust defaults.
+     */
+    int rc = RTPathAbs(g_pszAssemblerIncVal, g_szAssemblerIncVal, sizeof(g_szAssemblerIncVal) - 1);
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed: %Rrc", rc);
+    strcat(g_szAssemblerIncVal, "/");
+    g_pszAssemblerIncVal = g_szAssemblerIncVal;
+
+    /*
+     * Option config.
+     */
+    enum
+    {
+        kVBoxTpGOpt_32Bit = 1000,
+        kVBoxTpGOpt_64Bit,
+        kVBoxTpGOpt_GenerateWrapperHeader,
+        kVBoxTpGOpt_Assembler,
+        kVBoxTpGOpt_AssemblerFmtOpt,
+        kVBoxTpGOpt_AssemblerFmtVal,
+        kVBoxTpGOpt_AssemblerOutputOpt,
+        kVBoxTpGOpt_AssemblerOption,
+        kVBoxTpGOpt_Pic,
+        kVBoxTpGOpt_ProbeFnName,
+        kVBoxTpGOpt_ProbeFnImported,
+        kVBoxTpGOpt_ProbeFnNotImported,
+        kVBoxTpGOpt_Host32Bit,
+        kVBoxTpGOpt_Host64Bit,
+        kVBoxTpGOpt_RawModeContext,
+        kVBoxTpGOpt_Ring0Context,
+        kVBoxTpGOpt_Ring0ContextAgnostic,
+        kVBoxTpGOpt_Ring3Context,
+        kVBoxTpGOpt_End
+    };
+
+    static RTGETOPTDEF const s_aOpts[] =
+    {
+        /* dtrace w/ long options */
+        { "-32",                                kVBoxTpGOpt_32Bit,                      RTGETOPT_REQ_NOTHING },
+        { "-64",                                kVBoxTpGOpt_64Bit,                      RTGETOPT_REQ_NOTHING },
+        { "--apply-cpp",                        'C',                                    RTGETOPT_REQ_NOTHING },
+        { "--generate-obj",                     'G',                                    RTGETOPT_REQ_NOTHING },
+        { "--generate-header",                  'h',                                    RTGETOPT_REQ_NOTHING },
+        { "--output",                           'o',                                    RTGETOPT_REQ_STRING  },
+        { "--script",                           's',                                    RTGETOPT_REQ_STRING  },
+        { "--verbose",                          'v',                                    RTGETOPT_REQ_NOTHING },
+        /* our stuff */
+        { "--generate-wrapper-header",          kVBoxTpGOpt_GenerateWrapperHeader,      RTGETOPT_REQ_NOTHING },
+        { "--assembler",                        kVBoxTpGOpt_Assembler,                  RTGETOPT_REQ_STRING  },
+        { "--assembler-fmt-opt",                kVBoxTpGOpt_AssemblerFmtOpt,            RTGETOPT_REQ_STRING  },
+        { "--assembler-fmt-val",                kVBoxTpGOpt_AssemblerFmtVal,            RTGETOPT_REQ_STRING  },
+        { "--assembler-output-opt",             kVBoxTpGOpt_AssemblerOutputOpt,         RTGETOPT_REQ_STRING  },
+        { "--assembler-option",                 kVBoxTpGOpt_AssemblerOption,            RTGETOPT_REQ_STRING  },
+        { "--pic",                              kVBoxTpGOpt_Pic,                        RTGETOPT_REQ_NOTHING },
+        { "--probe-fn-name",                    kVBoxTpGOpt_ProbeFnName,                RTGETOPT_REQ_STRING  },
+        { "--probe-fn-imported",                kVBoxTpGOpt_ProbeFnImported,            RTGETOPT_REQ_NOTHING },
+        { "--probe-fn-not-imported",            kVBoxTpGOpt_ProbeFnNotImported,         RTGETOPT_REQ_NOTHING },
+        { "--host-32-bit",                      kVBoxTpGOpt_Host32Bit,                  RTGETOPT_REQ_NOTHING },
+        { "--host-64-bit",                      kVBoxTpGOpt_Host64Bit,                  RTGETOPT_REQ_NOTHING },
+        { "--raw-mode-context",                 kVBoxTpGOpt_RawModeContext,             RTGETOPT_REQ_NOTHING },
+        { "--ring-0-context",                   kVBoxTpGOpt_Ring0Context,               RTGETOPT_REQ_NOTHING },
+        { "--ring-0-context-agnostic",          kVBoxTpGOpt_Ring0ContextAgnostic,       RTGETOPT_REQ_NOTHING },
+        { "--ring-3-context",                   kVBoxTpGOpt_Ring3Context,               RTGETOPT_REQ_NOTHING },
+        /** @todo We're missing a bunch of assembler options! */
+    };
+
+    RTGETOPTUNION   ValueUnion;
+    RTGETOPTSTATE   GetOptState;
+    rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
+
+    /*
+     * Process the options.
+     */
+    while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
+    {
+        switch (rc)
+        {
+            /*
+             * DTrace compatible options.
+             */
+            case kVBoxTpGOpt_32Bit:
+                g_cHostBits = g_cBits = 32;
+                g_pszAssemblerFmtVal = g_szAssemblerFmtVal32;
+                break;
+
+            case kVBoxTpGOpt_64Bit:
+                g_cHostBits = g_cBits = 64;
+                g_pszAssemblerFmtVal = g_szAssemblerFmtVal64;
+                break;
+
+            case 'C':
+                g_fApplyCpp = true;
+                RTMsgWarning("Ignoring the -C option - no preprocessing of the D script will be performed");
+                break;
+
+            case 'G':
+                if (   g_enmAction != kVBoxTpGAction_Nothing
+                    && g_enmAction != kVBoxTpGAction_GenerateObject)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-G does not mix with -h or --generate-wrapper-header");
+                g_enmAction = kVBoxTpGAction_GenerateObject;
+                break;
+
+            case 'h':
+                if (!strcmp(GetOptState.pDef->pszLong, "--generate-header"))
+                {
+                    if (   g_enmAction != kVBoxTpGAction_Nothing
+                        && g_enmAction != kVBoxTpGAction_GenerateHeader)
+                        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-h does not mix with -G or --generate-wrapper-header");
+                    g_enmAction = kVBoxTpGAction_GenerateHeader;
+                }
+                else
+                {
+                    /* --help or similar */
+                    RTPrintf("VirtualBox Tracepoint Generator\n"
+                             "\n"
+                             "Usage: %s [options]\n"
+                             "\n"
+                             "Options:\n", RTProcShortName());
+                    for (size_t i = 0; i < RT_ELEMENTS(s_aOpts); i++)
+                        if ((unsigned)s_aOpts[i].iShort < 128)
+                            RTPrintf("   -%c,%s\n", s_aOpts[i].iShort, s_aOpts[i].pszLong);
+                        else
+                            RTPrintf("   %s\n", s_aOpts[i].pszLong);
+                    return RTEXITCODE_SUCCESS;
+                }
+                break;
+
+            case 'o':
+                if (g_pszOutput)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Output file is already set to '%s'", g_pszOutput);
+                g_pszOutput = ValueUnion.psz;
+                break;
+
+            case 's':
+                if (g_pszScript)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Script file is already set to '%s'", g_pszScript);
+                g_pszScript = ValueUnion.psz;
+                break;
+
+            case 'v':
+                g_cVerbosity++;
+                break;
+
+            case 'V':
+            {
+                /* The following is assuming that svn does it's job here. */
+                static const char s_szRev[] = "$Revision: 155244 $";
+                const char *psz = RTStrStripL(strchr(s_szRev, ' '));
+                RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
+                return RTEXITCODE_SUCCESS;
+            }
+
+            case VINF_GETOPT_NOT_OPTION:
+                if (g_enmAction == kVBoxTpGAction_GenerateObject)
+                    break; /* object files, ignore them. */
+                return RTGetOptPrintError(rc, &ValueUnion);
+
+
+            /*
+             * Our options.
+             */
+            case kVBoxTpGOpt_GenerateWrapperHeader:
+                if (   g_enmAction != kVBoxTpGAction_Nothing
+                    && g_enmAction != kVBoxTpGAction_GenerateWrapperHeader)
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--generate-wrapper-header does not mix with -h or -G");
+                g_enmAction = kVBoxTpGAction_GenerateWrapperHeader;
+                break;
+
+            case kVBoxTpGOpt_Assembler:
+                g_pszAssembler = ValueUnion.psz;
+                break;
+
+            case kVBoxTpGOpt_AssemblerFmtOpt:
+                g_pszAssemblerFmtOpt = ValueUnion.psz;
+                break;
+
+            case kVBoxTpGOpt_AssemblerFmtVal:
+                g_pszAssemblerFmtVal = ValueUnion.psz;
+                break;
+
+            case kVBoxTpGOpt_AssemblerOutputOpt:
+                g_pszAssemblerOutputOpt = ValueUnion.psz;
+                break;
+
+            case kVBoxTpGOpt_AssemblerOption:
+                if (g_cAssemblerOptions >= RT_ELEMENTS(g_apszAssemblerOptions))
+                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Too many assembly options (max %u)", RT_ELEMENTS(g_apszAssemblerOptions));
+                g_apszAssemblerOptions[g_cAssemblerOptions] = ValueUnion.psz;
+                g_cAssemblerOptions++;
+                break;
+
+            case kVBoxTpGOpt_Pic:
+                g_fPic = true;
+                break;
+
+            case kVBoxTpGOpt_ProbeFnName:
+                g_pszProbeFnName = ValueUnion.psz;
+                break;
+
+            case kVBoxTpGOpt_ProbeFnImported:
+                g_fProbeFnImported = true;
+                break;
+
+            case kVBoxTpGOpt_ProbeFnNotImported:
+                g_fProbeFnImported = false;
+                break;
+
+            case kVBoxTpGOpt_Host32Bit:
+                g_cHostBits = 32;
+                break;
+
+            case kVBoxTpGOpt_Host64Bit:
+                g_cHostBits = 64;
+                break;
+
+            case kVBoxTpGOpt_RawModeContext:
+                g_fTypeContext = VTG_TYPE_CTX_RC;
+                g_pszContextDefine = "IN_RC";
+                g_pszContextDefine2 = NULL;
+                break;
+
+            case kVBoxTpGOpt_Ring0Context:
+                g_fTypeContext = VTG_TYPE_CTX_R0;
+                g_pszContextDefine = "IN_RING0";
+                g_pszContextDefine2 = NULL;
+                break;
+
+            case kVBoxTpGOpt_Ring0ContextAgnostic:
+                g_fTypeContext = VTG_TYPE_CTX_R0;
+                g_pszContextDefine = "IN_RING0_AGNOSTIC";
+                g_pszContextDefine2 = "IN_RING0";
+                break;
+
+            case kVBoxTpGOpt_Ring3Context:
+                g_fTypeContext = VTG_TYPE_CTX_R3;
+                g_pszContextDefine = "IN_RING3";
+                g_pszContextDefine2 = NULL;
+                break;
+
+
+            /*
+             * Errors and bugs.
+             */
+            default:
+                return RTGetOptPrintError(rc, &ValueUnion);
+        }
+    }
+
+    /*
+     * Check that we've got all we need.
+     */
+    if (g_enmAction == kVBoxTpGAction_Nothing)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No action specified (-h, -G or --generate-wrapper-header)");
+    if (!g_pszScript)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No script file specified (-s)");
+    if (!g_pszOutput)
+        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No output file specified (-o)");
+
+    return RTEXITCODE_SUCCESS;
+}
+
+
+int main(int argc, char **argv)
+{
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_FAILURE(rc))
+        return 1;
+
+    RTEXITCODE rcExit = parseArguments(argc, argv);
+    if (rcExit == RTEXITCODE_SUCCESS)
+    {
+        /*
+         * Parse the script.
+         */
+        RTListInit(&g_ProviderHead);
+        rcExit = parseScript(g_pszScript);
+        if (rcExit == RTEXITCODE_SUCCESS)
+        {
+            /*
+             * Take action.
+             */
+            if (g_enmAction == kVBoxTpGAction_GenerateHeader)
+                rcExit = generateFile(g_pszOutput, "header", generateHeader);
+            else if (g_enmAction == kVBoxTpGAction_GenerateWrapperHeader)
+                rcExit = generateFile(g_pszOutput, "wrapper header", generateWrapperHeader);
+            else
+                rcExit = generateObject(g_pszOutput, g_pszTempAsm);
+        }
+    }
+
+    if (rcExit == RTEXITCODE_SUCCESS && g_cTypeErrors > 0)
+        rcExit = RTEXITCODE_FAILURE;
+    return rcExit;
+}
+
diff --git a/src/bldprogs/bin2c.c b/src/bldprogs/bin2c.c
new file mode 100644
index 00000000..5e7c2f19
--- /dev/null
+++ b/src/bldprogs/bin2c.c
@@ -0,0 +1,274 @@
+/* $Id: bin2c.c $ */
+/** @file
+ * bin2c - Binary 2 C Structure Converter.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+
+/**
+ * File size.
+ *
+ * @returns file size in bytes.
+ * @returns 0 on failure.
+ * @param   pFile   File to size.
+ */
+static size_t fsize(FILE *pFile)
+{
+    long    cbFile;
+    off_t   Pos = ftell(pFile);
+    if (    Pos >= 0
+        &&  !fseek(pFile, 0, SEEK_END))
+    {
+        cbFile = ftell(pFile);
+        if (    cbFile >= 0
+            &&  !fseek(pFile, 0, SEEK_SET))
+            return cbFile;
+    }
+    return 0;
+}
+
+static int usage(const char *argv0)
+{
+    fprintf(stderr,
+            "Syntax: %s [options] <arrayname> <binaryfile> <outname>\n"
+            "  --min <n>    check if <binaryfile> is not smaller than <n>KB\n"
+            "  --max <n>    check if <binaryfile> is not bigger than <n>KB\n"
+            "  --mask <n>   check if size of binaryfile is <n>-aligned\n"
+            "  --width <n>  number of bytes per line (default: 16)\n"
+            "  --break <n>  break every <n> lines    (default: -1)\n"
+            , argv0);
+    fprintf(stderr,
+            "  --ascii      show ASCII representation of binary as comment\n"
+            "  --export     emit DECLEXPORT\n"
+            "  --append     append to the output file (default: truncate)\n"
+            "  --no-size    Skip the size.\n"
+            "  --static     Static data scope.\n");
+
+    return 1;
+}
+
+int main(int argc, char *argv[])
+{
+    FILE          *pFileIn;
+    FILE          *pFileOut;
+    int           iArg;
+    size_t        cbMin = 0;
+    size_t        cbMax = ~0U;
+    size_t        uMask = 0;
+    int           fAscii = 0;
+    int           fAppend = 0;
+    int           fExport = 0;
+    int           fNoSize = 0;
+    int           fStatic = 0;
+    long          iBreakEvery = -1;
+    unsigned char abLine[32];
+    size_t        cbLine = 16;
+    size_t        off;
+    size_t        cbRead;
+    size_t        cbBin;
+    int           rc = 1;               /* assume the worst... */
+
+    if (argc < 2)
+        return usage(argv[0]);
+
+    for (iArg = 1; iArg < argc; iArg++)
+    {
+        if (!strcmp(argv[iArg], "--min") || !strcmp(argv[iArg], "-min"))
+        {
+            if (++iArg >= argc)
+                return usage(argv[0]);
+            cbMin = 1024 * strtoul(argv[iArg], NULL, 0);
+        }
+        else if (!strcmp(argv[iArg], "--max") || !strcmp(argv[iArg], "-max"))
+        {
+            if (++iArg >= argc)
+                return usage(argv[0]);
+            cbMax = 1024 * strtoul(argv[iArg], NULL, 0);
+        }
+        else if (!strcmp(argv[iArg], "--mask") || !strcmp(argv[iArg], "-mask"))
+        {
+            if (++iArg >= argc)
+                return usage(argv[0]);
+            uMask = strtoul(argv[iArg], NULL, 0);
+        }
+        else if (!strcmp(argv[iArg], "--ascii") || !strcmp(argv[iArg], "-ascii"))
+            fAscii = 1;
+        else if (!strcmp(argv[iArg], "--append"))
+            fAppend = 1;
+        else if (!strcmp(argv[iArg], "--export") || !strcmp(argv[iArg], "-export"))
+            fExport = 1;
+        else if (!strcmp(argv[iArg], "--no-size"))
+            fNoSize = 1;
+        else if (!strcmp(argv[iArg], "--static"))
+            fStatic = 1;
+        else if (!strcmp(argv[iArg], "--width") || !strcmp(argv[iArg], "-width"))
+        {
+            if (++iArg >= argc)
+                return usage(argv[0]);
+            cbLine = strtoul(argv[iArg], NULL, 0);
+            if (cbLine == 0 || cbLine > sizeof(abLine))
+            {
+                fprintf(stderr, "%s: '%s' is too wide, max %u\n",
+                        argv[0], argv[iArg], (unsigned)sizeof(abLine));
+                return 1;
+            }
+        }
+        else if (!strcmp(argv[iArg], "--break") || !strcmp(argv[iArg], "-break"))
+        {
+            if (++iArg >= argc)
+                return usage(argv[0]);
+            iBreakEvery = strtol(argv[iArg], NULL, 0);
+            if (iBreakEvery <= 0 && iBreakEvery != -1)
+            {
+                fprintf(stderr, "%s: -break value '%s' is not >= 1 or -1.\n",
+                        argv[0], argv[iArg]);
+                return 1;
+            }
+        }
+        else if (iArg == argc - 3)
+            break;
+        else
+        {
+            fprintf(stderr, "%s: syntax error: Unknown argument '%s'\n",
+                    argv[0], argv[iArg]);
+            return usage(argv[0]);
+        }
+    }
+
+    pFileIn = fopen(argv[iArg+1], "rb");
+    if (!pFileIn)
+    {
+        fprintf(stderr, "Error: failed to open input file '%s'!\n", argv[iArg+1]);
+        return 1;
+    }
+
+    pFileOut = fopen(argv[iArg+2], fAppend ? "a" : "w"); /* no b! */
+    if (!pFileOut)
+    {
+        fprintf(stderr, "Error: failed to open output file '%s'!\n", argv[iArg+2]);
+        fclose(pFileIn);
+        return 1;
+    }
+
+    cbBin = fsize(pFileIn);
+
+    fprintf(pFileOut,
+           "/*\n"
+           " * This file was automatically generated\n"
+           " * from %s\n"
+           " * by %s.\n"
+           " */\n"
+           "\n"
+           "#include <iprt/cdefs.h>\n"
+           "\n"
+           "%sconst unsigned char%s g_ab%s[] =\n"
+           "{\n",
+           argv[iArg+1], argv[0], fStatic ? "static " : fExport ? "DECLEXPORT(" : "", !fStatic && fExport ? ")" : "", argv[iArg]);
+
+    /* check size restrictions */
+    if (uMask && (cbBin & uMask))
+        fprintf(stderr, "%s: size=%ld - Not aligned!\n", argv[0], (long)cbBin);
+    else if (cbBin < cbMin || cbBin > cbMax)
+        fprintf(stderr, "%s: size=%ld - Not %ld-%ldb in size!\n",
+                argv[0], (long)cbBin, (long)cbMin, (long)cbMax);
+    else
+    {
+        /* the binary data */
+        off = 0;
+        while ((cbRead = fread(&abLine[0], 1, cbLine, pFileIn)) > 0)
+        {
+            size_t j;
+
+            if (    iBreakEvery > 0
+                &&  off
+                && (off / cbLine) % iBreakEvery == 0)
+                fprintf(pFileOut, "\n");
+
+            fprintf(pFileOut, "   ");
+            for (j = 0; j < cbRead; j++)
+                fprintf(pFileOut, " 0x%02x,", abLine[j]);
+            for (; j < cbLine; j++)
+                fprintf(pFileOut, "      ");
+            if (fAscii)
+            {
+                fprintf(pFileOut, " /* 0x%08lx: ", (long)off);
+                for (j = 0; j < cbRead; j++)
+                    /* be careful with '/' prefixed/followed by a '*'! */
+                    fprintf(pFileOut, "%c",
+                            isprint(abLine[j]) && abLine[j] != '/' ? abLine[j] : '.');
+                for (; j < cbLine; j++)
+                    fprintf(pFileOut, " ");
+                fprintf(pFileOut, " */");
+            }
+            fprintf(pFileOut, "\n");
+
+            off += cbRead;
+        }
+
+        /* check for errors */
+        if (ferror(pFileIn) && !feof(pFileIn))
+            fprintf(stderr, "%s: read error\n", argv[0]);
+        else if (off != cbBin)
+            fprintf(stderr, "%s: read error off=%ld cbBin=%ld\n", argv[0], (long)off, (long)cbBin);
+        else
+        {
+            /* no errors, finish the structure. */
+            fprintf(pFileOut,
+                    "};\n");
+
+            if (!fNoSize)
+                fprintf(pFileOut,
+                        "\n"
+                        "%sconst unsigned%s g_cb%s = sizeof(g_ab%s);\n",
+                        fExport ? "DECLEXPORT(" : "", fExport ? ")" : "", argv[iArg], argv[iArg]);
+
+            fprintf(pFileOut, "/* end of file */\n");
+
+            /* flush output and check for error. */
+            fflush(pFileOut);
+            if (ferror(pFileOut))
+                fprintf(stderr, "%s: write error\n", argv[0]);
+            else
+                rc = 0; /* success! */
+        }
+    }
+
+    /* cleanup, delete the output file on failure. */
+    fclose(pFileOut);
+    fclose(pFileIn);
+    if (rc)
+        remove(argv[iArg+2]);
+
+    return rc;
+}
diff --git a/src/bldprogs/biossums.c b/src/bldprogs/biossums.c
new file mode 100644
index 00000000..37dbc8fb
--- /dev/null
+++ b/src/bldprogs/biossums.c
@@ -0,0 +1,255 @@
+/* $Id: biossums.c $ */
+/** @file
+ * Tool for modifying a BIOS image to write the BIOS checksum.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#ifndef RT_OS_WINDOWS
+# include <unistd.h> /* unlink */
+#endif
+
+typedef unsigned char uint8_t;
+
+static uint8_t abBios[64*1024];
+static FILE *g_pIn = NULL;
+static FILE *g_pOut = NULL;
+static const char *g_pszOutFile = NULL;
+static const char *g_argv0;
+
+/**
+ * Find where the filename starts in the given path.
+ */
+static const char *name(const char *pszPath)
+{
+    const char *psz = strrchr(pszPath, '/');
+#if defined(_MSC_VER) || defined(__OS2__)
+    const char *psz2 = strrchr(pszPath, '\\');
+    if (!psz2)
+        psz2 = strrchr(pszPath, ':');
+    if (psz2 && (!psz || psz2 > psz))
+        psz = psz2;
+#endif
+    return psz ? psz + 1 : pszPath;
+}
+
+/**
+ * Report an error.
+ */
+static int fatal(const char *pszFormat, ...)
+{
+    va_list va;
+
+    fprintf(stderr, "%s: ", name(g_argv0));
+
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+
+    /* clean up */
+    if (g_pIn)
+        fclose(g_pIn);
+    if (g_pOut)
+        fclose(g_pOut);
+    if (g_pszOutFile)
+        unlink(g_pszOutFile);
+
+    return 1;
+}
+
+/**
+ * Calculate the checksum.
+ */
+static uint8_t calculateChecksum(uint8_t *pb, size_t cb, size_t iChecksum)
+{
+    uint8_t u8Sum = 0;
+    size_t  i;
+
+    for (i = 0; i < cb; i++)
+        if (i != iChecksum)
+            u8Sum += pb[i];
+
+    return -u8Sum;
+}
+
+/**
+ * Find a header in the binary.
+ *
+ * @param   pb        Where to search for the signature
+ * @param   cb        Size of the search area
+ * @param   pbHeader  Pointer to the start of the signature
+ * @returns           0 if signature was not found, 1 if found or
+ *                    2 if more than one signature was found */
+static int searchHeader(uint8_t *pb, size_t cb, const char *pszHeader, uint8_t **pbHeader)
+{
+    int          fFound = 0;
+    unsigned int i;
+    size_t       cbSignature = strlen(pszHeader);
+
+    for (i = 0; i < cb; i += 16)
+        if (!memcmp(pb + i, pszHeader, cbSignature))
+        {
+            if (fFound++)
+                return 2;
+            *pbHeader = pb + i;
+        }
+
+    return fFound;
+}
+
+int main(int argc, char **argv)
+{
+    FILE    *pIn, *pOut;
+    size_t  cbIn, cbOut;
+    int     fAdapterBios = 0;
+
+    g_argv0 = argv[0];
+
+    if (argc != 3)
+        return fatal("Input file name and output file name required.\n");
+
+    pIn = g_pIn = fopen(argv[1], "rb");
+    if (!pIn)
+        return fatal("Error opening '%s' for reading (%s).\n", argv[1], strerror(errno));
+
+    pOut = g_pOut = fopen(argv[2], "wb");
+    if (!pOut)
+        return fatal("Error opening '%s' for writing (%s).\n", argv[2], strerror(errno));
+    g_pszOutFile = argv[2];
+
+    /* safety precaution (aka. complete paranoia :-) */
+    memset(abBios, 0, sizeof(abBios));
+
+    cbIn = fread(abBios, 1, sizeof(abBios), pIn);
+    if (ferror(pIn))
+        return fatal("Error reading from '%s' (%s).\n", argv[1], strerror(errno));
+    g_pIn = NULL;
+    fclose(pIn);
+
+    fAdapterBios = abBios[0] == 0x55 && abBios[1] == 0xaa;
+
+    /* align size to page size */
+    if ((cbIn % 4096) != 0)
+        cbIn = (cbIn + 4095) & ~4095;
+
+    if (!fAdapterBios && cbIn != 64*1024)
+        return fatal("Size of system BIOS is not 64KB!\n");
+
+    if (fAdapterBios)
+    {
+        /* adapter BIOS */
+
+        /* set the length indicator */
+        abBios[2] = (uint8_t)(cbIn / 512);
+    }
+    else
+    {
+        /* system BIOS */
+        size_t  cbChecksum;
+        uint8_t u8Checksum;
+        uint8_t *pbHeader;
+
+        /* Set the BIOS32 header checksum. */
+        switch (searchHeader(abBios, cbIn, "_32_", &pbHeader))
+        {
+            case 0:
+                return fatal("No BIOS32 header not found!\n");
+            case 2:
+                return fatal("More than one BIOS32 header found!\n");
+            case 1:
+                cbChecksum = (size_t)pbHeader[9] * 16;
+                u8Checksum = calculateChecksum(pbHeader, cbChecksum, 10);
+                pbHeader[10] = u8Checksum;
+                break;
+        }
+
+        /* Set the PIR header checksum according to PCI IRQ Routing table
+         * specification version 1.0, Microsoft Corporation, 1996 */
+        switch (searchHeader(abBios, cbIn, "$PIR", &pbHeader))
+        {
+            case 0:
+                return fatal("No PCI IRQ routing table found!\n");
+            case 2:
+                return fatal("More than one PCI IRQ routing table found!\n");
+            case 1:
+                cbChecksum = (size_t)pbHeader[6] + (size_t)pbHeader[7] * 256;
+                u8Checksum = calculateChecksum(pbHeader, cbChecksum, 31);
+                pbHeader[31] = u8Checksum;
+                break;
+        }
+
+        /* Set the SMBIOS header checksum according to System Management BIOS
+         * Reference Specification Version 2.5, DSP0134. */
+        switch (searchHeader(abBios, cbIn, "_SM_", &pbHeader))
+        {
+            case 0:
+                return fatal("No SMBIOS header found!\n");
+            case 2:
+                return fatal("More than one SMBIOS header found!\n");
+            case 1:
+                /* at first fix the DMI header starting at SMBIOS header offset 16 */
+                u8Checksum = calculateChecksum(pbHeader+16, 15, 5);
+                pbHeader[21] = u8Checksum;
+
+                /* now fix the checksum of the whole SMBIOS header */
+                cbChecksum = (size_t)pbHeader[5];
+                u8Checksum = calculateChecksum(pbHeader, cbChecksum, 4);
+                pbHeader[4] = u8Checksum;
+                break;
+        }
+
+        /* If there is a VPD table, adjust its checksum. */
+        switch (searchHeader(abBios, cbIn, "\xAA\x55VPD", &pbHeader))
+        {
+            case 0:
+                break;  /* VPD is optional */
+            case 2:
+                return fatal("More than one VPD header found!\n");
+            case 1:
+                cbChecksum = (size_t)pbHeader[5];
+                if (cbChecksum < 0x30)
+                    return fatal("VPD size too small!\n");
+                u8Checksum = calculateChecksum(pbHeader, cbChecksum, cbChecksum - 1);
+                pbHeader[cbChecksum - 1] = u8Checksum;
+                break;
+        }
+    }
+
+    /* set the BIOS checksum */
+    abBios[cbIn-1] = calculateChecksum(abBios, cbIn, cbIn - 1);
+
+    cbOut = fwrite(abBios, 1, cbIn, pOut);
+    if (ferror(pOut))
+        return fatal("Error writing to '%s' (%s).\n", g_pszOutFile, strerror(errno));
+    g_pOut = NULL;
+    if (fclose(pOut))
+        return fatal("Error closing '%s' (%s).\n", g_pszOutFile, strerror(errno));
+
+    return 0;
+}
+
diff --git a/src/bldprogs/checkUndefined.sh b/src/bldprogs/checkUndefined.sh
new file mode 100755
index 00000000..cb5165f5
--- /dev/null
+++ b/src/bldprogs/checkUndefined.sh
@@ -0,0 +1,102 @@
+#!/bin/sh
+
+#
+# Copyright (C) 2006-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# 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, in version 3 of the
+# License.
+#
+# 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 <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+#
+# Compare undefined symbols in a shared or static object against a new-line
+# separated list of grep patterns in a set of text files and complain if
+# symbols are found which aren't in the files.
+#
+# Usage: /bin/sh <script name> <object> [--static] <undefined symbol file...>
+#
+# Currently only works for native objects on Linux (and Solaris?) platforms.
+#
+
+echoerr()
+{
+  echo $* 1>&2
+}
+
+hostos="${1}"
+target="${2}"
+shift 2
+if test "${1}" = "--static"; then
+    static="${1}"
+    shift
+fi
+
+if test $# -lt 1; then
+    echoerr "${0}: Wrong number of arguments"
+    args_ok="no"
+fi
+if test ! -r "${target}"; then
+    echoerr "${0}: '${target}' not readable"
+    args_ok="no"
+fi
+for i in "${@}"; do
+    if test ! -r "${i}"; then
+        echoerr "${0}: '${i}' not readable"
+        args_ok="no"
+    fi
+done
+
+if test "$args_ok" = "no"; then
+  echoerr "Usage: $0 <object> [--static] <undefined symbol file...>"
+  exit 1
+fi
+
+if test "$hostos" = "solaris"; then
+    objdumpbin=/usr/sfw/bin/gobjdump
+    grepbin=/usr/sfw/bin/ggrep
+elif test "$hostos" = "linux"; then
+    objdumpbin=`which objdump`
+    grepbin=`which grep`
+else
+    echoerr "$0: '$hostos' not a valid hostos string. supported 'linux' 'solaris'"
+    exit 1
+fi
+
+command="-T"
+if test "$static" = "--static"; then
+  command="-t"
+fi
+
+if test ! -x "${objdumpbin}"; then
+    echoerr "${0}: '${objdumpbin}' not found or not executable."
+    exit 1
+fi
+
+undefined=`"${objdumpbin}" ${command} "${target}" | kmk_sed -n 's/.*\*UND\*.*\s\([:graph:]*\)/\1/p'`
+for i in "${@}"; do
+    undefined=`echo "${undefined}" | "${grepbin}" -w -v -f "${i}"`
+done
+num_undef=`echo $undefined | wc -w`
+
+if test $num_undef -ne 0; then
+  echoerr "${0}: following symbols not defined in the files ${@}:"
+  echoerr "${undefined}"
+  exit 1
+fi
+# Return code
+exit 0
+
diff --git a/src/bldprogs/deftoimp.sed b/src/bldprogs/deftoimp.sed
new file mode 100644
index 00000000..c4d0793b
--- /dev/null
+++ b/src/bldprogs/deftoimp.sed
@@ -0,0 +1,66 @@
+# $Id: deftoimp.sed $
+## @file
+# SED script for generating a dummy .c from a windows .def file.
+#
+
+#
+# Copyright (C) 2006-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# 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, in version 3 of the
+# License.
+#
+# 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 <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+#
+# Remove comments and space. Skip empty lines.
+#
+s/;.*$//g
+s/^[[:space:]][[:space:]]*//g
+s/[[:space:]][[:space:]]*$//g
+/^$/d
+
+# Handle text after EXPORTS
+/EXPORTS/,//{
+s/^EXPORTS$//
+/^$/b end
+
+
+/[[:space:]]DATA$/b data
+
+#
+# Function export
+#
+:code
+s/^\(.*\)$/EXPORT\nvoid \1(void);\nvoid \1(void){}/
+b end
+
+
+#
+# Data export
+#
+:data
+s/^\(.*\)[[:space:]]*DATA$/EXPORT_DATA void *\1 = (void *)0;/
+b end
+
+}
+d
+b end
+
+
+# next expression
+:end
+
diff --git a/src/bldprogs/filesplitter.cpp b/src/bldprogs/filesplitter.cpp
new file mode 100644
index 00000000..90c7dbe7
--- /dev/null
+++ b/src/bldprogs/filesplitter.cpp
@@ -0,0 +1,388 @@
+/* $Id: filesplitter.cpp $ */
+/** @file
+ * File splitter - Splits a text file according to ###### markers in it.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <iprt/string.h>
+#include <iprt/stdarg.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#ifndef S_ISDIR
+# define S_ISDIR(a_fMode)       ( (S_IFMT & (a_fMode)) == S_IFDIR )
+#endif
+
+
+/**
+ * Calculates the line number for a file position.
+ *
+ * @returns Line number.
+ * @param   pcszContent         The file content.
+ * @param   pcszPos             The current position.
+ */
+static unsigned long lineNumber(const char *pcszContent, const char *pcszPos)
+{
+    unsigned long cLine = 0;
+    while (   *pcszContent
+           && (uintptr_t)pcszContent < (uintptr_t)pcszPos)
+    {
+        pcszContent = strchr(pcszContent, '\n');
+        if (!pcszContent)
+            break;
+        ++cLine;
+        ++pcszContent;
+    }
+
+    return cLine;
+}
+
+
+/**
+ * Writes an error message.
+ *
+ * @returns RTEXITCODE_FAILURE.
+ * @param   pcszFormat          Error message.
+ * @param   ...                 Format argument referenced in the message.
+ */
+static int printErr(const char *pcszFormat, ...)
+{
+    va_list va;
+
+    fprintf(stderr, "filesplitter: ");
+    va_start(va, pcszFormat);
+    vfprintf(stderr, pcszFormat, va);
+    va_end(va);
+
+    return RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * Opens the makefile list for writing.
+ *
+ * @returns Exit code.
+ * @param   pcszPath            The path to the file.
+ * @param   pcszVariableName    The make variable name.
+ * @param   ppFile              Where to return the file stream.
+ */
+static int openMakefileList(const char *pcszPath, const char *pcszVariableName, FILE **ppFile)
+{
+    *ppFile = NULL;
+
+    FILE *pFile= fopen(pcszPath, "w");
+    if (!pFile)
+#ifdef _MSC_VER
+        return printErr("Failed to open \"%s\" for writing the file list: %s (win32: %d)\n",
+                        pcszPath, strerror(errno), _doserrno);
+#else
+        return printErr("Failed to open \"%s\" for writing the file list: %s\n", pcszPath, strerror(errno));
+#endif
+
+    if (fprintf(pFile, "%s := \\\n", pcszVariableName) <= 0)
+    {
+        fclose(pFile);
+        return printErr("Error writing to the makefile list.\n");
+    }
+
+    *ppFile = pFile;
+    return 0;
+}
+
+
+/**
+ * Adds the given file to the makefile list.
+ *
+ * @returns Exit code.
+ * @param   pFile               The file stream of the makefile list.
+ * @param   pszFilename         The file name to add.
+ */
+static int addFileToMakefileList(FILE *pFile, char *pszFilename)
+{
+    if (pFile)
+    {
+        char *pszSlash = pszFilename;
+        while ((pszSlash = strchr(pszSlash, '\\')) != NULL)
+            *pszSlash++ = '/';
+
+        if (fprintf(pFile, "\t%s \\\n", pszFilename) <= 0)
+            return printErr("Error adding file to makefile list.\n");
+    }
+    return 0;
+}
+
+
+/**
+ * Closes the makefile list.
+ *
+ * @returns Exit code derived from @a rc.
+ * @param   pFile               The file stream of the makefile list.
+ * @param   rc                  The current exit code.
+ */
+static int closeMakefileList(FILE *pFile, int rc)
+{
+    fprintf(pFile, "\n\n");
+    if (fclose(pFile))
+        return printErr("Error closing the file list file: %s\n", strerror(errno));
+    return rc;
+}
+
+
+/**
+ * Reads in a file.
+ *
+ * @returns Exit code.
+ * @param   pcszFile            The path to the file.
+ * @param   ppszFile            Where to return the buffer.
+ * @param   pcchFile            Where to return the file size.
+ */
+static int readFile(const char *pcszFile, char **ppszFile, size_t *pcchFile)
+{
+    FILE          *pFile;
+    struct stat    FileStat;
+    int            rc;
+
+    if (stat(pcszFile, &FileStat))
+        return printErr("Failed to stat \"%s\": %s\n", pcszFile, strerror(errno));
+
+    pFile = fopen(pcszFile, "r");
+    if (!pFile)
+        return printErr("Failed to open \"%s\": %s\n", pcszFile, strerror(errno));
+
+    *ppszFile = (char *)malloc(FileStat.st_size + 1);
+    if (*ppszFile)
+    {
+        errno = 0;
+        size_t cbRead = fread(*ppszFile, 1, FileStat.st_size, pFile);
+        if (   cbRead <= (size_t)FileStat.st_size
+            && (cbRead > 0 || !ferror(pFile)) )
+        {
+            if (ftell(pFile) == FileStat.st_size) /* (\r\n vs \n in the DOS world) */
+            {
+                (*ppszFile)[cbRead] = '\0';
+                if (pcchFile)
+                    *pcchFile = (size_t)cbRead;
+
+                fclose(pFile);
+                return 0;
+            }
+        }
+
+        rc = printErr("Error reading \"%s\": %s\n", pcszFile, strerror(errno));
+        free(*ppszFile);
+        *ppszFile = NULL;
+    }
+    else
+        rc = printErr("Failed to allocate %lu bytes\n", (unsigned long)(FileStat.st_size + 1));
+    fclose(pFile);
+    return rc;
+}
+
+
+/**
+ * Checks whether the sub-file already exists and has the exact
+ * same content.
+ *
+ * @returns @c true if the existing file matches exactly, otherwise @c false.
+ * @param   pcszFilename    The path to the file.
+ * @param   pcszSubContent  The content to write.
+ * @param   cchSubContent   The length of the content.
+ */
+static bool compareSubFile(const char *pcszFilename, const char *pcszSubContent, size_t cchSubContent)
+{
+    struct stat     FileStat;
+    if (stat(pcszFilename, &FileStat))
+        return false;
+    if ((size_t)FileStat.st_size < cchSubContent)
+        return false;
+
+    size_t cchExisting;
+    char  *pszExisting;
+    int rc = readFile(pcszFilename, &pszExisting, &cchExisting);
+    if (rc)
+        return false;
+
+    bool fRc = cchExisting == cchSubContent
+            && !memcmp(pcszSubContent, pszExisting, cchSubContent);
+    free(pszExisting);
+
+    return fRc;
+}
+
+
+/**
+ * Writes out a sub-file.
+ *
+ * @returns exit code.
+ * @param   pcszFilename    The path to the sub-file.
+ * @param   pcszSubContent  The content of the file.
+ * @param   cchSubContent   The size of the content.
+ */
+static int writeSubFile(const char *pcszFilename, const char *pcszSubContent, size_t cchSubContent)
+{
+    FILE   *pFile = fopen(pcszFilename, "w");
+    if (!pFile)
+#ifdef _MSC_VER
+        return printErr("Failed to open \"%s\" for writing: %s (win32: %d)\n", pcszFilename, strerror(errno), _doserrno);
+#else
+        return printErr("Failed to open \"%s\" for writing: %s\n", pcszFilename, strerror(errno));
+#endif
+
+    errno = 0;
+    int rc = 0;
+    if (fwrite(pcszSubContent, cchSubContent, 1, pFile) != 1)
+        rc = printErr("Error writing \"%s\": %s\n", pcszFilename, strerror(errno));
+
+    errno = 0;
+    int rc2 = fclose(pFile);
+    if (rc2 == EOF)
+        rc = printErr("Error closing \"%s\": %s\n", pcszFilename, strerror(errno));
+    return rc;
+}
+
+
+/**
+ * Does the actual file splitting.
+ *
+ * @returns exit code.
+ * @param   pcszOutDir      Path to the output directory.
+ * @param   pcszContent     The content to split up.
+ * @param   pFileList       The file stream of the makefile list.  Can be NULL.
+ */
+static int splitFile(const char *pcszOutDir, const char *pcszContent, FILE *pFileList)
+{
+    static char const   s_szBeginMarker[] = "\n// ##### BEGINFILE \"";
+    static char const   s_szEndMarker[]   = "\n// ##### ENDFILE";
+    const size_t        cchBeginMarker    = sizeof(s_szBeginMarker) - 1;
+    const char         *pcszSearch        = pcszContent;
+    size_t const        cchOutDir         = strlen(pcszOutDir);
+    unsigned long       cFilesWritten     = 0;
+    unsigned long       cFilesUnchanged   = 0;
+    int                 rc                = 0;
+
+    do
+    {
+        /* find begin marker */
+        const char *pcszBegin = strstr(pcszSearch, s_szBeginMarker);
+        if (!pcszBegin)
+            break;
+
+        /* find line after begin marker */
+        const char *pcszLineAfterBegin = strchr(pcszBegin + cchBeginMarker, '\n');
+        if (!pcszLineAfterBegin)
+            return printErr("No newline after begin-file marker found.\n");
+        ++pcszLineAfterBegin;
+
+        /* find filename end quote in begin marker line */
+        const char *pcszStartFilename = pcszBegin + cchBeginMarker;
+        const char *pcszEndQuote = (const char *)memchr(pcszStartFilename, '\"', pcszLineAfterBegin - pcszStartFilename);
+        if (!pcszEndQuote)
+            return printErr("Can't parse filename after begin-file marker (line %lu).\n",
+                            lineNumber(pcszContent, s_szBeginMarker));
+
+        /* find end marker */
+        const char *pcszEnd = strstr(pcszLineAfterBegin, s_szEndMarker);
+        if (!pcszEnd)
+            return printErr("No matching end-line marker for begin-file marker found (line %lu).\n",
+                            lineNumber(pcszContent, s_szBeginMarker));
+
+        /* construct output filename */
+        size_t cchFilename = pcszEndQuote - pcszStartFilename;
+        char  *pszFilename = (char *)malloc(cchOutDir + 1 + cchFilename + 1);
+        if (!pszFilename)
+            return printErr("Can't allocate memory for filename.\n");
+
+        memcpy(pszFilename, pcszOutDir, cchOutDir);
+        pszFilename[cchOutDir] = '/';
+        memcpy(pszFilename + cchOutDir + 1, pcszStartFilename, cchFilename);
+        pszFilename[cchFilename + 1 + cchOutDir] = '\0';
+
+        /* Write the file only if necessary. */
+        if (compareSubFile(pszFilename, pcszLineAfterBegin, pcszEnd - pcszLineAfterBegin))
+            cFilesUnchanged++;
+        else
+        {
+            rc = writeSubFile(pszFilename, pcszLineAfterBegin, pcszEnd - pcszLineAfterBegin);
+            cFilesWritten++;
+        }
+
+        if (!rc)
+            rc = addFileToMakefileList(pFileList, pszFilename);
+
+        free(pszFilename);
+
+        pcszSearch = pcszEnd;
+    } while (rc == 0 && pcszSearch);
+
+    printf("filesplitter: Out of %lu files: %lu rewritten, %lu unchanged. (%s)\n",
+           cFilesWritten + cFilesUnchanged, cFilesWritten, cFilesUnchanged, pcszOutDir);
+    return rc;
+}
+
+
+int main(int argc, char *argv[])
+{
+    int rc = 0;
+
+    if (argc == 3 || argc == 5)
+    {
+        struct stat DirStat;
+        if (   stat(argv[2], &DirStat) == 0
+            && S_ISDIR(DirStat.st_mode))
+        {
+            char   *pszContent;
+            rc = readFile(argv[1], &pszContent, NULL);
+            if (!rc)
+            {
+                FILE *pFileList = NULL;
+                if (argc == 5)
+                    rc = openMakefileList(argv[3], argv[4], &pFileList);
+
+                if (argc < 4 || pFileList)
+                    rc = splitFile(argv[2], pszContent, pFileList);
+
+                if (pFileList)
+                    rc = closeMakefileList(pFileList, rc);
+                free(pszContent);
+            }
+        }
+        else
+            rc = printErr("Given argument \"%s\" is not a valid directory.\n", argv[2]);
+    }
+    else
+        rc = printErr("Syntax error: usage: filesplitter <infile> <outdir> [<list.kmk> <kmkvar>]\n");
+    return rc;
+}
diff --git a/src/bldprogs/genalias.cpp b/src/bldprogs/genalias.cpp
new file mode 100644
index 00000000..073f169f
--- /dev/null
+++ b/src/bldprogs/genalias.cpp
@@ -0,0 +1,500 @@
+/* $Id: genalias.cpp $ */
+/** @file
+ * genalias - generate a number of alias objects.
+ *
+ * @note The code has its origin with kLIBC and was added to VBox by the author.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <stdarg.h>
+#include <stdio.h>
+#include <iprt/stdint.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#if defined(RT_OS_DARWIN) || (defined(RT_ARCH_X86) && (defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)))
+# define GENALIAS_UNDERSCORED 1
+#else
+# define GENALIAS_UNDERSCORED 0
+#endif
+
+
+
+static int Error(const char *pszFormat, ...)
+{
+    va_list va;
+    fprintf(stderr, "genalias: error: ");
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+    return 1;
+}
+
+static int SyntaxError(const char *pszFormat, ...)
+{
+    va_list va;
+    fprintf(stderr, "genalias: syntax error: ");
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+    return 1;
+}
+
+static int WriteAliasObjectAOUT(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+#pragma pack(1)
+    /* ASSUMES 32-bit target. */
+    struct AoutHdr
+    {
+        uint32_t a_info;
+        uint32_t a_text;
+        uint32_t a_data;
+        uint32_t a_bss;
+        uint32_t a_syms;
+        uint32_t a_entry;
+        uint32_t a_trsize;
+        uint32_t a_drsize;
+    } Hdr;
+#define OMAGIC 0407
+    struct AoutSym
+    {
+        uint32_t n_strx;
+        uint8_t n_type;
+        int8_t n_other;
+        uint16_t n_desc;
+        uint32_t n_value;
+    } Sym;
+#define N_EXT 1
+#define N_INDR 10
+#pragma pack()
+    const uint32_t cchAlias = (uint32_t)strlen(pszAlias);
+    const uint32_t cchReal  = (uint32_t)strlen(pszReal);
+    uint32_t     u32;
+
+    /* write the header. */
+    memset(&Hdr, 0, sizeof(Hdr));
+    Hdr.a_info = OMAGIC;
+    Hdr.a_syms = 2 * sizeof(Sym);
+    if (fwrite(&Hdr, sizeof(Hdr), 1, pOutput) != 1)
+        return -2;
+
+    /* The alias symbol. */
+    Sym.n_strx = 4 + cchReal + 1 + GENALIAS_UNDERSCORED;
+    Sym.n_type = N_INDR | N_EXT;
+    Sym.n_other = 0;
+    Sym.n_desc = 0;
+    Sym.n_value = 0;
+    if (fwrite(&Sym, sizeof(Sym), 1, pOutput) != 1)
+        return -2;
+
+    /* The real symbol. */
+    Sym.n_strx = 4;
+    Sym.n_type = N_EXT;
+    Sym.n_other = 0;
+    Sym.n_desc = 0;
+    Sym.n_value = 0;
+    if (fwrite(&Sym, sizeof(Sym), 1, pOutput) != 1)
+        return -2;
+
+    /* the string table. */
+    u32 = 4 + cchReal + 1 + cchAlias + 1 + GENALIAS_UNDERSCORED * 2;
+    if (fwrite(&u32, 4, 1, pOutput) != 1)
+        return -2;
+#if GENALIAS_UNDERSCORED
+    if (fputc('_', pOutput) == EOF)
+        return -2;
+#endif
+    if (fwrite(pszReal, cchReal + 1, 1, pOutput) != 1)
+        return -2;
+#if GENALIAS_UNDERSCORED
+    if (fputc('_', pOutput) == EOF)
+        return -2;
+#endif
+    if (fwrite(pszAlias, cchAlias + 1, 1, pOutput) != 1)
+        return -2;
+    return 0;
+}
+
+static int WriteAliasObjectCOFF(FILE *pOutput, const char *pszAlias, const char *pszReal, bool fUnderscored)
+{
+#pragma pack(1)
+    struct CoffHdr
+    {
+        uint16_t Machine;
+        uint16_t NumberOfSections;
+        uint32_t TimeDateStamp;
+        uint32_t PointerToSymbolTable;
+        uint32_t NumberOfSymbols;
+        uint16_t SizeOfOptionalHeader;
+        uint16_t Characteristics;
+    } Hdr;
+    struct CoffShdr
+    {
+        char        Name[8];
+        uint32_t    VirtualSize;
+        uint32_t    VirtualAddress;
+        uint32_t    SizeOfRawData;
+        uint32_t    PointerToRawData;
+        uint32_t    PointerToRelocations;
+        uint32_t    PointerToLinenumbers;
+        uint16_t    NumberOfRelocations;
+        uint16_t    NumberOfLinenumbers;
+        uint32_t    Characteristics;
+    } Shdr;
+#define IMAGE_SCN_LNK_INFO   0x200
+#define IMAGE_SCN_LNK_REMOVE 0x800
+    struct CoffSym
+    {
+        union
+        {
+            char ShortName[8];
+            struct
+            {
+                uint32_t Zeros;
+                uint32_t Offset;
+            } s;
+        } u;
+        uint32_t    Value;
+        uint16_t    SectionNumber;
+        uint16_t    Type;
+        uint8_t     StorageClass;
+        uint8_t     NumberOfAuxSymbols;
+    } Sym;
+#define IMAGE_SYM_UNDEFINED 0
+#define IMAGE_SYM_TYPE_NULL 0
+#define IMAGE_SYM_CLASS_EXTERNAL 2
+#define IMAGE_SYM_CLASS_WEAK_EXTERNAL 105
+    struct CoffAuxWeakExt
+    {
+        uint32_t    TagIndex;
+        uint32_t    Characteristics;
+        uint8_t     padding[10];
+    } Aux;
+#define IMAGE_WEAK_EXTERN_SEARCH_ALIAS 3
+    assert(sizeof(Hdr) == 20); assert(sizeof(Sym) == 18); assert(sizeof(Aux) == sizeof(Sym));
+#pragma pack()
+    const uint32_t cchAlias = (uint32_t)strlen(pszAlias);
+    const uint32_t cchReal  = (uint32_t)strlen(pszReal);
+    uint32_t       u32;
+
+    /* write the header. */
+    Hdr.Machine = 0 /*unknown*/; //0x14c /* i386 */;
+    Hdr.NumberOfSections = 1;
+    Hdr.TimeDateStamp = time(NULL);
+    Hdr.PointerToSymbolTable = sizeof(Hdr) + sizeof(Shdr);
+    Hdr.NumberOfSymbols = 3;
+    Hdr.SizeOfOptionalHeader = 0;
+    Hdr.Characteristics = 0;
+    if (fwrite(&Hdr, sizeof(Hdr), 1, pOutput) != 1)
+        return -2;
+
+    /* The directive section. */
+    if (Hdr.NumberOfSections == 1)
+    {
+        memset(&Shdr, 0, sizeof(Shdr));
+        memcpy(Shdr.Name, ".drectve", 8);
+        Shdr.Characteristics = IMAGE_SCN_LNK_REMOVE | IMAGE_SCN_LNK_INFO;
+        if (fwrite(&Shdr, sizeof(Shdr), 1, pOutput) != 1)
+            return -2;
+    }
+
+    /* The real symbol. */
+    memset(&Sym, 0, sizeof(Sym));
+    Sym.u.s.Offset = 4;
+    Sym.SectionNumber = IMAGE_SYM_UNDEFINED;
+    Sym.Type = IMAGE_SYM_TYPE_NULL;
+    Sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL;
+    if (fwrite(&Sym, sizeof(Sym), 1, pOutput) != 1)
+        return -2;
+
+    /* The alias symbol. */
+    memset(&Sym, 0, sizeof(Sym));
+    Sym.u.s.Offset = fUnderscored + cchReal + 1 + 4;
+    Sym.SectionNumber = IMAGE_SYM_UNDEFINED;
+    Sym.Type = IMAGE_SYM_TYPE_NULL;
+    Sym.StorageClass = IMAGE_SYM_CLASS_WEAK_EXTERNAL;
+    Sym.NumberOfAuxSymbols = 1;
+    if (fwrite(&Sym, sizeof(Sym), 1, pOutput) != 1)
+        return -2;
+
+    /* aux entry for that. */
+    memset(&Aux, 0, sizeof(Aux));
+    Aux.TagIndex = 0;
+    Aux.Characteristics = IMAGE_WEAK_EXTERN_SEARCH_ALIAS;
+    if (fwrite(&Aux, sizeof(Aux), 1, pOutput) != 1)
+        return -2;
+
+    /* the string table. */
+    u32 = 4 + cchReal + 1 + cchAlias + 1 + fUnderscored * 2;
+    if (fwrite(&u32, 4, 1, pOutput) != 1)
+        return -2;
+    if (fUnderscored)
+        if (fputc('_', pOutput) == EOF)
+            return -2;
+    if (fwrite(pszReal, cchReal + 1, 1, pOutput) != 1)
+        return -2;
+    if (fUnderscored)
+        if (fputc('_', pOutput) == EOF)
+            return -2;
+    if (fwrite(pszAlias, cchAlias + 1, 1, pOutput) != 1)
+        return -2;
+    return 0;
+}
+
+static int WriteAliasObjectTargetCOFF(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    return WriteAliasObjectCOFF(pOutput, pszAlias, pszReal, GENALIAS_UNDERSCORED);
+}
+
+static int WriteAliasObjectX86COFF(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    return WriteAliasObjectCOFF(pOutput, pszAlias, pszReal, true  /*fUnderscored*/);
+}
+
+static int WriteAliasObjectAmd64COFF(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    return WriteAliasObjectCOFF(pOutput, pszAlias, pszReal, false /*fUnderscored*/);
+}
+
+
+static int WriteAliasObjectELF(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    RT_NOREF(pOutput, pszAlias, pszReal);
+    fprintf(stderr, "ELF does not support proper aliasing, only option seems to be adding weak symbols with the strong one.\n");
+    return -1;
+}
+
+static int WriteAliasObjectOMF(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    const uint32_t cchAlias = (uint32_t)strlen(pszAlias);
+    const uint32_t cchReal  = (uint32_t)strlen(pszReal);
+    //const uint32_t cchName  = cchAlias > 250 ? 250 : cchAlias;
+    uint32_t       cch;
+
+    if (cchReal >= 250)
+        return Error("Symbol '%s' is too long!\n", pszReal);
+    if (cchAlias >= 250)
+        return Error("Symbol '%s' is too long!\n", pszAlias);
+
+    /* THEADR */
+    fputc(0x80, pOutput);
+    cch = cchAlias + 2;
+    fputc(cch & 0xff, pOutput);
+    fputc(cch >> 8, pOutput);
+    fputc(cchAlias, pOutput);
+    fwrite(pszAlias, cchAlias, 1, pOutput);
+    fputc(0, pOutput);                  /* CRC */
+
+    /* ALIAS */
+    fputc(0xc6, pOutput);
+    cch = cchAlias + 1 + cchReal + 1 + GENALIAS_UNDERSCORED * 2 + 1;
+    fputc(cch & 0xff, pOutput);
+    fputc(cch >> 8, pOutput);
+    fputc(cchAlias + GENALIAS_UNDERSCORED, pOutput);
+    if (GENALIAS_UNDERSCORED)
+        fputc('_', pOutput);
+    fwrite(pszAlias, cchAlias, 1, pOutput);
+    fputc(cchReal + GENALIAS_UNDERSCORED, pOutput);
+    if (GENALIAS_UNDERSCORED)
+        fputc('_', pOutput);
+    fwrite(pszReal, cchReal, 1, pOutput);
+    fputc(0, pOutput);                  /* CRC */
+
+    /* MODEND32 */
+    fputc(0x8b, pOutput);
+    fputc(2, pOutput);
+    fputc(0, pOutput);
+    fputc(0, pOutput);
+    if (fputc(0, pOutput) == EOF)       /* CRC */
+        return -2;
+    return 0;
+}
+
+static int WriteAliasObjectMACHO(FILE *pOutput, const char *pszAlias, const char *pszReal)
+{
+    RT_NOREF(pOutput, pszAlias, pszReal);
+    fprintf(stderr, "Mach-O support not implemented yet\n");
+    return -1;
+}
+
+static int CreateAlias(char *pszBuf, size_t cchInput, char *pszFileBuf, char *pszFilename,
+                       int (*pfnWriter)(FILE *, const char *, const char *))
+{
+    char *pszAlias = pszBuf;
+    char *pszReal;
+    char *pszFile;
+    FILE *pOutput;
+    int   rc;
+    RT_NOREF(cchInput);
+
+    /*
+     * Parse input.
+     */
+    pszReal = strchr(pszBuf, '=');
+    if (!pszReal)
+        return Error("Malformed request: '%s'\n", pszBuf);
+    *pszReal++ = '\0';
+
+    pszFile = strchr(pszReal, '=');
+    if (pszFile)
+    {
+        *pszFile++ = '\0';
+        strcpy(pszFilename, pszFile);
+    }
+    else
+        strcat(strcpy(pszFilename, pszAlias), ".o");
+
+    /*
+     * Open the output file.
+     */
+    pOutput = fopen(pszFileBuf, "wb");
+    if (!pOutput)
+        return Error("Failed to open '%s' for writing!\n", pszFileBuf);
+    rc = pfnWriter(pOutput, pszAlias, pszReal);
+    if (rc == -2)
+        rc = Error("Write error writing '%s'!\n", pszFileBuf);
+    fclose(pOutput);
+    return rc;
+}
+
+
+static int Syntax(void)
+{
+    printf("syntax: genalias -f <format> -D <output-dir> alias=real[=file] [alias2=real2[=file2] [..]]\n"
+           "    OR\n"
+           "        genalias -f <format> -D <output-dir> -r <response-file>\n"
+           "\n"
+           "Format can be: aout, coff or omf\n"
+           "The responsefile is a single argument per line.\n");
+    return 1;
+}
+
+
+int main(int argc, char **argv)
+{
+    static char s_szBuf[4096];
+    static char s_szFile[1024 + sizeof(s_szBuf)];
+    int (*pfnWriter)(FILE *pOutput, const char *pszAlias, const char *pszReal);
+    char *pszFilename;
+    int i;
+    int rc;
+
+    /*
+     * Parse arguments.
+     */
+    if (argc <= 5)
+        return Syntax();
+    if (strcmp(argv[1], "-f"))
+        return SyntaxError("Expected -f as the 1st argument.\n");
+    if (!strcmp(argv[2], "aout"))
+        pfnWriter = WriteAliasObjectAOUT;
+    else if (!strcmp(argv[2], "coff"))
+        pfnWriter = WriteAliasObjectTargetCOFF;
+    else if (!strcmp(argv[2], "coff.x86"))
+        pfnWriter = WriteAliasObjectX86COFF;
+    else if (!strcmp(argv[2], "coff.amd64"))
+        pfnWriter = WriteAliasObjectAmd64COFF;
+    else if (!strcmp(argv[2], "elf"))
+        pfnWriter = WriteAliasObjectELF;
+    else if (!strcmp(argv[2], "omf"))
+        pfnWriter = WriteAliasObjectOMF;
+    else if (!strcmp(argv[2], "macho"))
+        pfnWriter = WriteAliasObjectMACHO;
+    else
+        return SyntaxError("Unknown format '%s'.\n", argv[2]);
+    if (strcmp(argv[3], "-D"))
+        return SyntaxError("Expected -D as the 3rd argument\n");
+    if (!*argv[4])
+        return SyntaxError("The output directory name is empty.\n");
+    size_t cchFile = strlen(argv[4]);
+    if (cchFile > sizeof(s_szFile) - sizeof(s_szBuf))
+        return SyntaxError("The output directory name is too long.\n");
+    memcpy(s_szFile, argv[4], cchFile);
+    s_szFile[cchFile++] = '/';
+    pszFilename = &s_szFile[cchFile];
+
+    /* anything to do? */
+    if (argc == 5)
+        return 0;
+
+    rc = 0;
+    if (!strcmp(argv[5], "-r"))
+    {
+        /*
+         * Responsefile.
+         */
+        FILE *pResp;
+        if (argc <= 6)
+            return SyntaxError("Missing response file name\n");
+        pResp = fopen(argv[6], "rt");
+        if (!pResp)
+            return Error("Failed to open '%s' for reading.\n", argv[6]);
+
+        i = 0;
+        while (fgets(s_szBuf, sizeof(s_szBuf), pResp))
+        {
+            size_t  cch = strlen(s_szBuf);
+            i++;
+            if (cch == sizeof(s_szBuf) && s_szBuf[cch - 1] != '\n')
+            {
+                rc = Error("Line %d is too long!\n", i);
+                break;
+            }
+            if (cch && s_szBuf[cch - 1] == '\n')
+                s_szBuf[--cch] = '\0';
+            rc = CreateAlias(s_szBuf, cch, s_szFile, pszFilename, pfnWriter);
+            if (rc)
+                break;
+        }
+
+        fclose(pResp);
+    }
+    else
+    {
+        /*
+         * Alias descriptors.
+         */
+        for (i = 5; i < argc; i++)
+        {
+            size_t  cch = strlen(argv[i]);
+            if (cch >= sizeof(s_szBuf))
+                return SyntaxError("Argument %d is too long\n", i);
+            memcpy(s_szBuf, argv[i], cch + 1);
+            rc = CreateAlias(s_szBuf, cch, s_szFile, pszFilename, pfnWriter);
+            if (rc)
+                break;
+        }
+    }
+    return rc;
+}
+
diff --git a/src/bldprogs/preload.cpp b/src/bldprogs/preload.cpp
new file mode 100644
index 00000000..5285047c
--- /dev/null
+++ b/src/bldprogs/preload.cpp
@@ -0,0 +1,222 @@
+/* $Id: preload.cpp $ */
+/** @file
+ * bin2c - Binary 2 C Structure Converter.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#ifdef RT_OS_WINDOWS
+# include <Windows.h>
+#else
+# include <sys/mman.h>
+# include <sys/stat.h>
+# include <fcntl.h>
+# include <unistd.h>
+# include <errno.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+
+
+static int load(const char *pszImage)
+{
+#ifdef RT_OS_WINDOWS
+    HANDLE hFile = CreateFile(pszImage,
+                              GENERIC_READ,
+                              FILE_SHARE_READ,
+                              NULL /*pSecurityAttributes*/,
+                              OPEN_EXISTING,
+                              FILE_ATTRIBUTE_NORMAL,
+                              NULL /*hTemplateFile*/);
+    if (hFile == INVALID_HANDLE_VALUE)
+    {
+        printf("error: CreateFile('%s',): %d\n", pszImage, GetLastError());
+        return 1;
+    }
+
+    DWORD cbHigh  = 0;
+    DWORD cbLow   = GetFileSize(hFile, &cbHigh);
+    size_t cbFile = cbLow != INVALID_FILE_SIZE
+                  ? cbHigh == 0
+                  ? cbLow
+                  : ~(DWORD)0 / 4
+                  : 64;
+
+    HANDLE hMap = CreateFileMapping(hFile,
+                                    NULL /*pAttributes*/,
+                                    PAGE_READONLY | SEC_COMMIT,
+                                    0 /*dwMaximumSizeHigh -> file size*/,
+                                    0 /*dwMaximumSizeLow  -> file size*/,
+                                    NULL /*pName*/);
+    if (hMap == INVALID_HANDLE_VALUE)
+        printf("error: CreateFile('%s',): %d\n", pszImage, GetLastError());
+        CloseHandle(hFile);
+    if (hMap == INVALID_HANDLE_VALUE)
+        return 1;
+
+    void *pvWhere = MapViewOfFile(hMap,
+                                  FILE_MAP_READ,
+                                  0 /*dwFileOffsetHigh*/,
+                                  0 /*dwFileOffsetLow*/,
+                                  0 /*dwNumberOfBytesToMap - file size */);
+    if (!pvWhere)
+    {
+        printf("error: MapViewOfView('%s',): %d\n", pszImage, GetLastError());
+        CloseHandle(hMap);
+        return 1;
+    }
+
+#else
+    int fd = open(pszImage, O_RDONLY, 0);
+    if (fd < 0)
+    {
+        printf("error: open('%s',): %d\n", pszImage, errno);
+        return 1;
+    }
+
+    struct stat st;
+    memset(&st, 0, sizeof(st));
+    if (fstat(fd, &st))
+        st.st_size = 64;
+    size_t cbFile = st.st_size < ~(size_t)0
+                  ? (size_t)st.st_size
+                  : ~(size_t)0 / 4;
+
+    void *pvWhere = mmap(NULL /*addr*/, cbFile, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0 /*offset*/);
+    if (pvWhere == MAP_FAILED)
+        printf("error: mmap(,%lu,)/'%s': %d\n", (unsigned long)cbFile, pszImage, errno);
+    close(fd);
+    if (pvWhere == MAP_FAILED)
+        return 1;
+
+#endif
+
+    /* Touch the whole image... do a dummy crc to keep the optimizer from begin
+       smart with us. */
+    unsigned char  *puchFile = (unsigned char *)pvWhere;
+    size_t          off      = 0;
+    unsigned int    uCrc     = 0;
+    while (off < cbFile)
+        uCrc += puchFile[off++];
+    printf("info: %p/%#lx/%#x - %s\n", pvWhere, (unsigned long)cbFile, (unsigned char)uCrc, pszImage);
+
+    return 0;
+}
+
+static int usage(const char *argv0)
+{
+    printf("Generic executable image preloader.\n"
+           "Usage: %s [dll|exe|file []]\n", argv0);
+    return 1;
+}
+
+int main(int argc, char **argv)
+{
+    /*
+     * Check for options.
+     */
+    for (int i = 1; i < argc; i++)
+    {
+        if (argv[i][0] == '-')
+        {
+            if (   argv[i][1] == '-'
+                && argv[i][2] == '\0')
+                break;
+            if (   !strcmp(argv[i], "--help")
+                || !strcmp(argv[i], "-help")
+                || !strcmp(argv[i], "-h")
+                || !strcmp(argv[i], "-?"))
+            {
+                usage(argv[0]);
+                return 1;
+            }
+            if (   !strcmp(argv[i], "--version")
+                || !strcmp(argv[i], "-V"))
+            {
+                printf("$Revision: 155244 $\n");
+                return 0;
+            }
+            fprintf(stderr, "syntax error: unknown option '%s'\n", argv[i]);
+            return 1;
+        }
+    }
+    if (argc <= 1)
+        return usage(argv[0]);
+
+    /*
+     * Do the loading.
+     */
+    for (int i = 1; i < argc; i++)
+    {
+        if (!strcmp(argv[i], "--"))
+            continue;
+        if (argv[i][0] == '@')
+        {
+            FILE *pFile = fopen(&argv[i][1], "r");
+            if (pFile)
+            {
+                char szLine[4096];
+                while (fgets(szLine, sizeof(szLine), pFile))
+                {
+                    char *psz = szLine;
+                    while (*psz == ' ' || *psz == '\t')
+                        psz++;
+                    size_t off = strlen(psz);
+                    while (     off > 0
+                           &&   (   psz[off - 1] == ' '
+                                 || psz[off - 1] == '\t'
+                                 || psz[off - 1] == '\n'
+                                 || psz[off - 1] == '\r')
+                          )
+                        psz[--off] = '\0';
+
+                    if (*psz && *psz != '#')
+                        load(psz);
+                }
+                fclose(pFile);
+            }
+            else
+                fprintf(stderr, "error: fopen('%s','r'): %d\n", &argv[i][1], errno);
+        }
+        else
+            load(argv[i]);
+    }
+
+    /*
+     * Sleep for ever.
+     */
+    for (;;)
+    {
+#ifdef RT_OS_WINDOWS
+        Sleep(3600*1000);
+#else
+        sleep(3600);
+#endif
+    }
+
+    return 0;
+}
diff --git a/src/bldprogs/scm.cpp b/src/bldprogs/scm.cpp
new file mode 100644
index 00000000..0b093255
--- /dev/null
+++ b/src/bldprogs/scm.cpp
@@ -0,0 +1,3269 @@
+/* $Id: scm.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scm.h"
+#include "scmdiff.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** The name of the settings files. */
+#define SCM_SETTINGS_FILENAME           ".scm-settings"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+/**
+ * Option identifiers.
+ *
+ * @note    The first chunk, down to SCMOPT_TAB_SIZE, are alternately set &
+ *          clear.  So, the option setting a flag (boolean) will have an even
+ *          number and the one clearing it will have an odd number.
+ * @note    Down to SCMOPT_LAST_SETTINGS corresponds exactly to SCMSETTINGSBASE.
+ */
+typedef enum SCMOPT
+{
+    SCMOPT_CONVERT_EOL = 10000,
+    SCMOPT_NO_CONVERT_EOL,
+    SCMOPT_CONVERT_TABS,
+    SCMOPT_NO_CONVERT_TABS,
+    SCMOPT_FORCE_FINAL_EOL,
+    SCMOPT_NO_FORCE_FINAL_EOL,
+    SCMOPT_FORCE_TRAILING_LINE,
+    SCMOPT_NO_FORCE_TRAILING_LINE,
+    SCMOPT_STRIP_TRAILING_BLANKS,
+    SCMOPT_NO_STRIP_TRAILING_BLANKS,
+    SCMOPT_STRIP_TRAILING_LINES,
+    SCMOPT_NO_STRIP_TRAILING_LINES,
+    SCMOPT_FIX_FLOWER_BOX_MARKERS,
+    SCMOPT_NO_FIX_FLOWER_BOX_MARKERS,
+    SCMOPT_FIX_HEADER_GUARDS,
+    SCMOPT_NO_FIX_HEADER_GUARDS,
+    SCMOPT_PRAGMA_ONCE,
+    SCMOPT_NO_PRAGMA_ONCE,
+    SCMOPT_FIX_HEADER_GUARD_ENDIF,
+    SCMOPT_NO_FIX_HEADER_GUARD_ENDIF,
+    SCMOPT_ENDIF_GUARD_COMMENT,
+    SCMOPT_NO_ENDIF_GUARD_COMMENT,
+    SCMOPT_GUARD_PREFIX,
+    SCMOPT_GUARD_RELATIVE_TO_DIR,
+    SCMOPT_FIX_TODOS,
+    SCMOPT_NO_FIX_TODOS,
+    SCMOPT_FIX_ERR_H,
+    SCMOPT_NO_FIX_ERR_H,
+    SCMOPT_ONLY_GUEST_HOST_PAGE,
+    SCMOPT_NO_ASM_MEM_PAGE_USE,
+    SCMOPT_UNRESTRICTED_ASM_MEM_PAGE_USE,
+    SCMOPT_NO_PAGE_RESTRICTIONS,
+    SCMOPT_NO_RC_USE,
+    SCMOPT_UNRESTRICTED_RC_USE,
+    SCMOPT_STANDARIZE_KMK,
+    SCMOPT_NO_STANDARIZE_KMK,
+    SCMOPT_UPDATE_COPYRIGHT_YEAR,
+    SCMOPT_NO_UPDATE_COPYRIGHT_YEAR,
+    SCMOPT_EXTERNAL_COPYRIGHT,
+    SCMOPT_NO_EXTERNAL_COPYRIGHT,
+    SCMOPT_NO_UPDATE_LICENSE,
+    SCMOPT_LICENSE_OSE_GPL,
+    SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL,
+    SCMOPT_LICENSE_OSE_CDDL,
+    SCMOPT_LICENSE_LGPL,
+    SCMOPT_LICENSE_MIT,
+    SCMOPT_LICENSE_BASED_ON_MIT,
+    SCMOPT_LGPL_DISCLAIMER,
+    SCMOPT_NO_LGPL_DISCLAIMER,
+    SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS,
+    SCMOPT_ONLY_SVN_DIRS,
+    SCMOPT_NOT_ONLY_SVN_DIRS,
+    SCMOPT_ONLY_SVN_FILES,
+    SCMOPT_NOT_ONLY_SVN_FILES,
+    SCMOPT_SET_SVN_EOL,
+    SCMOPT_DONT_SET_SVN_EOL,
+    SCMOPT_SET_SVN_EXECUTABLE,
+    SCMOPT_DONT_SET_SVN_EXECUTABLE,
+    SCMOPT_SET_SVN_KEYWORDS,
+    SCMOPT_DONT_SET_SVN_KEYWORDS,
+    SCMOPT_SKIP_SVN_SYNC_PROCESS,
+    SCMOPT_DONT_SKIP_SVN_SYNC_PROCESS,
+    SCMOPT_SKIP_UNICODE_CHECKS,
+    SCMOPT_DONT_SKIP_UNICODE_CHECKS,
+    SCMOPT_TAB_SIZE,
+    SCMOPT_WIDTH,
+    SCMOPT_FILTER_OUT_DIRS,
+    SCMOPT_FILTER_FILES,
+    SCMOPT_FILTER_OUT_FILES,
+    SCMOPT_TREAT_AS,
+    SCMOPT_ADD_ACTION,
+    SCMOPT_DEL_ACTION,
+    SCMOPT_LAST_SETTINGS = SCMOPT_DEL_ACTION,
+    //
+    SCMOPT_CHECK_RUN,
+    SCMOPT_DIFF_IGNORE_EOL,
+    SCMOPT_DIFF_NO_IGNORE_EOL,
+    SCMOPT_DIFF_IGNORE_SPACE,
+    SCMOPT_DIFF_NO_IGNORE_SPACE,
+    SCMOPT_DIFF_IGNORE_LEADING_SPACE,
+    SCMOPT_DIFF_NO_IGNORE_LEADING_SPACE,
+    SCMOPT_DIFF_IGNORE_TRAILING_SPACE,
+    SCMOPT_DIFF_NO_IGNORE_TRAILING_SPACE,
+    SCMOPT_DIFF_SPECIAL_CHARS,
+    SCMOPT_DIFF_NO_SPECIAL_CHARS,
+    SCMOPT_HELP_CONFIG,
+    SCMOPT_HELP_ACTIONS,
+    SCMOPT_END
+} SCMOPT;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+const char          g_szTabSpaces[16+1]     = "                ";
+const char          g_szAsterisks[255+1]    =
+"****************************************************************************************************"
+"****************************************************************************************************"
+"*******************************************************";
+const char          g_szSpaces[255+1]       =
+"                                                                                                    "
+"                                                                                                    "
+"                                                       ";
+static const char   g_szProgName[]          = "scm";
+static const char  *g_pszChangedSuff        = "";
+static bool         g_fDryRun               = true;
+static bool         g_fDiffSpecialChars     = true;
+static bool         g_fDiffIgnoreEol        = false;
+static bool         g_fDiffIgnoreLeadingWS  = false;
+static bool         g_fDiffIgnoreTrailingWS = false;
+static int          g_iVerbosity            = 2;//99; //0;
+uint32_t            g_uYear                 = 0; /**< The current year. */
+/** @name Statistics
+ * @{ */
+static uint32_t     g_cDirsProcessed        = 0;
+static uint32_t     g_cFilesProcessed       = 0;
+static uint32_t     g_cFilesModified        = 0;
+static uint32_t     g_cFilesSkipped         = 0;
+static uint32_t     g_cFilesNotInSvn        = 0;
+static uint32_t     g_cFilesNoRewriters     = 0;
+static uint32_t     g_cFilesBinaries        = 0;
+static uint32_t     g_cFilesRequiringManualFixing = 0;
+/** @} */
+
+/** The global settings. */
+static SCMSETTINGSBASE const g_Defaults =
+{
+    /* .fConvertEol = */                            true,
+    /* .fConvertTabs = */                           true,
+    /* .fForceFinalEol = */                         true,
+    /* .fForceTrailingLine = */                     false,
+    /* .fStripTrailingBlanks = */                   true,
+    /* .fStripTrailingLines = */                    true,
+    /* .fFixFlowerBoxMarkers = */                   true,
+    /* .cMinBlankLinesBeforeFlowerBoxMakers = */    2,
+    /* .fFixHeaderGuards = */                       true,
+    /* .fPragmaOnce = */                            true,
+    /* .fFixHeaderGuardEndif = */                   true,
+    /* .fEndifGuardComment = */                     true,
+    /* .pszGuardPrefix = */                         (char *)"VBOX_INCLUDED_SRC_",
+    /* .pszGuardRelativeToDir = */                  (char *)"{parent}",
+    /* .fFixTodos = */                              true,
+    /* .fFixErrH = */                               true,
+    /* .fOnlyGuestHostPage = */                     false,
+    /* .fNoASMMemPageUse = */                       false,
+    /* .fOnlyHrcVrcInsteadOfRc */                   false,
+    /* .fStandarizeKmk */                           true,
+    /* .fUpdateCopyrightYear = */                   false,
+    /* .fExternalCopyright = */                     false,
+    /* .fLgplDisclaimer = */                        false,
+    /* .enmUpdateLicense = */                       kScmLicense_OseGpl,
+    /* .fOnlySvnFiles = */                          false,
+    /* .fOnlySvnDirs = */                           false,
+    /* .fSetSvnEol = */                             false,
+    /* .fSetSvnExecutable = */                      false,
+    /* .fSetSvnKeywords = */                        false,
+    /* .fSkipSvnSyncProcess = */                    false,
+    /* .fSkipUnicodeChecks = */                     false,
+    /* .cchTab = */                                 8,
+    /* .cchWidth = */                               130,
+    /* .fFreeTreatAs = */                           false,
+    /* .pTreatAs = */                               NULL,
+    /* .pszFilterFiles = */                         (char *)"",
+    /* .pszFilterOutFiles = */                      (char *)"*.exe|*.com|20*-*-*.log",
+    /* .pszFilterOutDirs = */                       (char *)".svn|.hg|.git|CVS",
+};
+
+/** Option definitions for the base settings. */
+static RTGETOPTDEF  g_aScmOpts[] =
+{
+    /* rewriters */
+    { "--convert-eol",                      SCMOPT_CONVERT_EOL,                     RTGETOPT_REQ_NOTHING },
+    { "--no-convert-eol",                   SCMOPT_NO_CONVERT_EOL,                  RTGETOPT_REQ_NOTHING },
+    { "--convert-tabs",                     SCMOPT_CONVERT_TABS,                    RTGETOPT_REQ_NOTHING },
+    { "--no-convert-tabs",                  SCMOPT_NO_CONVERT_TABS,                 RTGETOPT_REQ_NOTHING },
+    { "--force-final-eol",                  SCMOPT_FORCE_FINAL_EOL,                 RTGETOPT_REQ_NOTHING },
+    { "--no-force-final-eol",               SCMOPT_NO_FORCE_FINAL_EOL,              RTGETOPT_REQ_NOTHING },
+    { "--force-trailing-line",              SCMOPT_FORCE_TRAILING_LINE,             RTGETOPT_REQ_NOTHING },
+    { "--no-force-trailing-line",           SCMOPT_NO_FORCE_TRAILING_LINE,          RTGETOPT_REQ_NOTHING },
+    { "--strip-trailing-blanks",            SCMOPT_STRIP_TRAILING_BLANKS,           RTGETOPT_REQ_NOTHING },
+    { "--no-strip-trailing-blanks",         SCMOPT_NO_STRIP_TRAILING_BLANKS,        RTGETOPT_REQ_NOTHING },
+    { "--strip-trailing-lines",             SCMOPT_STRIP_TRAILING_LINES,            RTGETOPT_REQ_NOTHING },
+    { "--strip-no-trailing-lines",          SCMOPT_NO_STRIP_TRAILING_LINES,         RTGETOPT_REQ_NOTHING },
+    { "--min-blank-lines-before-flower-box-makers", SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS,  RTGETOPT_REQ_UINT8 },
+    { "--fix-flower-box-markers",           SCMOPT_FIX_FLOWER_BOX_MARKERS,          RTGETOPT_REQ_NOTHING },
+    { "--no-fix-flower-box-markers",        SCMOPT_NO_FIX_FLOWER_BOX_MARKERS,       RTGETOPT_REQ_NOTHING },
+    { "--fix-header-guards",                SCMOPT_FIX_HEADER_GUARDS,               RTGETOPT_REQ_NOTHING },
+    { "--no-fix-header-guards",             SCMOPT_NO_FIX_HEADER_GUARDS,            RTGETOPT_REQ_NOTHING },
+    { "--pragma-once",                      SCMOPT_PRAGMA_ONCE,                     RTGETOPT_REQ_NOTHING },
+    { "--no-pragma-once",                   SCMOPT_NO_PRAGMA_ONCE,                  RTGETOPT_REQ_NOTHING },
+    { "--fix-header-guard-endif",           SCMOPT_FIX_HEADER_GUARD_ENDIF,          RTGETOPT_REQ_NOTHING },
+    { "--no-fix-header-guard-endif",        SCMOPT_NO_FIX_HEADER_GUARD_ENDIF,       RTGETOPT_REQ_NOTHING },
+    { "--endif-guard-comment",              SCMOPT_ENDIF_GUARD_COMMENT,             RTGETOPT_REQ_NOTHING },
+    { "--no-endif-guard-comment",           SCMOPT_NO_ENDIF_GUARD_COMMENT,          RTGETOPT_REQ_NOTHING },
+    { "--guard-prefix",                     SCMOPT_GUARD_PREFIX,                    RTGETOPT_REQ_STRING },
+    { "--guard-relative-to-dir",            SCMOPT_GUARD_RELATIVE_TO_DIR,           RTGETOPT_REQ_STRING },
+    { "--fix-todos",                        SCMOPT_FIX_TODOS,                       RTGETOPT_REQ_NOTHING },
+    { "--no-fix-todos",                     SCMOPT_NO_FIX_TODOS,                    RTGETOPT_REQ_NOTHING },
+    { "--fix-err-h",                        SCMOPT_FIX_ERR_H,                       RTGETOPT_REQ_NOTHING },
+    { "--no-fix-err-h",                     SCMOPT_NO_FIX_ERR_H,                    RTGETOPT_REQ_NOTHING },
+    { "--only-guest-host-page",             SCMOPT_ONLY_GUEST_HOST_PAGE,            RTGETOPT_REQ_NOTHING },
+    { "--no-page-restrictions",             SCMOPT_NO_PAGE_RESTRICTIONS,            RTGETOPT_REQ_NOTHING },
+    { "--no-ASMMemPage-use",                SCMOPT_NO_ASM_MEM_PAGE_USE,             RTGETOPT_REQ_NOTHING },
+    { "--unrestricted-ASMMemPage-use",      SCMOPT_UNRESTRICTED_ASM_MEM_PAGE_USE,   RTGETOPT_REQ_NOTHING },
+    { "--no-rc-use",                        SCMOPT_NO_RC_USE,                       RTGETOPT_REQ_NOTHING },
+    { "--unrestricted-rc-use",              SCMOPT_UNRESTRICTED_RC_USE,             RTGETOPT_REQ_NOTHING },
+    { "--standarize-kmk",                   SCMOPT_STANDARIZE_KMK,                  RTGETOPT_REQ_NOTHING },
+    { "--no-standarize-kmk",                SCMOPT_NO_STANDARIZE_KMK,               RTGETOPT_REQ_NOTHING },
+    { "--update-copyright-year",            SCMOPT_UPDATE_COPYRIGHT_YEAR,           RTGETOPT_REQ_NOTHING },
+    { "--no-update-copyright-year",         SCMOPT_NO_UPDATE_COPYRIGHT_YEAR,        RTGETOPT_REQ_NOTHING },
+    { "--external-copyright",               SCMOPT_EXTERNAL_COPYRIGHT,              RTGETOPT_REQ_NOTHING },
+    { "--no-external-copyright",            SCMOPT_NO_EXTERNAL_COPYRIGHT,           RTGETOPT_REQ_NOTHING },
+    { "--no-update-license",                SCMOPT_NO_UPDATE_LICENSE,               RTGETOPT_REQ_NOTHING },
+    { "--license-ose-gpl",                  SCMOPT_LICENSE_OSE_GPL,                 RTGETOPT_REQ_NOTHING },
+    { "--license-ose-dual",                 SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL,       RTGETOPT_REQ_NOTHING },
+    { "--license-ose-cddl",                 SCMOPT_LICENSE_OSE_CDDL,                RTGETOPT_REQ_NOTHING },
+    { "--license-lgpl",                     SCMOPT_LICENSE_LGPL,                    RTGETOPT_REQ_NOTHING },
+    { "--license-mit",                      SCMOPT_LICENSE_MIT,                     RTGETOPT_REQ_NOTHING },
+    { "--license-based-on-mit",             SCMOPT_LICENSE_BASED_ON_MIT,            RTGETOPT_REQ_NOTHING },
+    { "--lgpl-disclaimer",                  SCMOPT_LGPL_DISCLAIMER,                 RTGETOPT_REQ_NOTHING },
+    { "--no-lgpl-disclaimer",               SCMOPT_NO_LGPL_DISCLAIMER,              RTGETOPT_REQ_NOTHING },
+    { "--set-svn-eol",                      SCMOPT_SET_SVN_EOL,                     RTGETOPT_REQ_NOTHING },
+    { "--dont-set-svn-eol",                 SCMOPT_DONT_SET_SVN_EOL,                RTGETOPT_REQ_NOTHING },
+    { "--set-svn-executable",               SCMOPT_SET_SVN_EXECUTABLE,              RTGETOPT_REQ_NOTHING },
+    { "--dont-set-svn-executable",          SCMOPT_DONT_SET_SVN_EXECUTABLE,         RTGETOPT_REQ_NOTHING },
+    { "--set-svn-keywords",                 SCMOPT_SET_SVN_KEYWORDS,                RTGETOPT_REQ_NOTHING },
+    { "--dont-set-svn-keywords",            SCMOPT_DONT_SET_SVN_KEYWORDS,           RTGETOPT_REQ_NOTHING },
+    { "--skip-svn-sync-process",            SCMOPT_SKIP_SVN_SYNC_PROCESS,           RTGETOPT_REQ_NOTHING },
+    { "--dont-skip-svn-sync-process",       SCMOPT_DONT_SKIP_SVN_SYNC_PROCESS,      RTGETOPT_REQ_NOTHING },
+    { "--skip-unicode-checks",              SCMOPT_SKIP_UNICODE_CHECKS,             RTGETOPT_REQ_NOTHING },
+    { "--dont-skip-unicode-checks",         SCMOPT_DONT_SKIP_UNICODE_CHECKS,        RTGETOPT_REQ_NOTHING },
+    { "--tab-size",                         SCMOPT_TAB_SIZE,                        RTGETOPT_REQ_UINT8   },
+    { "--width",                            SCMOPT_WIDTH,                           RTGETOPT_REQ_UINT8   },
+
+    /* input selection */
+    { "--only-svn-dirs",                    SCMOPT_ONLY_SVN_DIRS,                   RTGETOPT_REQ_NOTHING },
+    { "--not-only-svn-dirs",                SCMOPT_NOT_ONLY_SVN_DIRS,               RTGETOPT_REQ_NOTHING },
+    { "--only-svn-files",                   SCMOPT_ONLY_SVN_FILES,                  RTGETOPT_REQ_NOTHING },
+    { "--not-only-svn-files",               SCMOPT_NOT_ONLY_SVN_FILES,              RTGETOPT_REQ_NOTHING },
+    { "--filter-out-dirs",                  SCMOPT_FILTER_OUT_DIRS,                 RTGETOPT_REQ_STRING  },
+    { "--filter-files",                     SCMOPT_FILTER_FILES,                    RTGETOPT_REQ_STRING  },
+    { "--filter-out-files",                 SCMOPT_FILTER_OUT_FILES,                RTGETOPT_REQ_STRING  },
+
+    /* rewriter selection */
+    { "--treat-as",                         SCMOPT_TREAT_AS,                        RTGETOPT_REQ_STRING  },
+    { "--add-action",                       SCMOPT_ADD_ACTION,                      RTGETOPT_REQ_STRING  },
+    { "--del-action",                       SCMOPT_DEL_ACTION,                      RTGETOPT_REQ_STRING  },
+
+    /* Additional help */
+    { "--help-config",                      SCMOPT_HELP_CONFIG,                     RTGETOPT_REQ_NOTHING },
+    { "--help-actions",                     SCMOPT_HELP_ACTIONS,                    RTGETOPT_REQ_NOTHING },
+};
+
+/** Consider files matching the following patterns (base names only). */
+static const char  *g_pszFileFilter         = NULL;
+
+/* The rewriter configuration. */
+#define SCM_REWRITER_CFG(a_Global, a_szName, fnRewriter) static const SCMREWRITERCFG a_Global = { &fnRewriter, a_szName }
+SCM_REWRITER_CFG(g_StripTrailingBlanks,             "strip-trailing-blanks",        rewrite_StripTrailingBlanks);
+SCM_REWRITER_CFG(g_ExpandTabs,                      "expand-tabs",                  rewrite_ExpandTabs);
+SCM_REWRITER_CFG(g_ForceNativeEol,                  "force-native-eol",             rewrite_ForceNativeEol);
+SCM_REWRITER_CFG(g_ForceLF,                         "force-lf",                     rewrite_ForceLF);
+SCM_REWRITER_CFG(g_ForceCRLF,                       "force-crlf",                   rewrite_ForceCRLF);
+SCM_REWRITER_CFG(g_AdjustTrailingLines,             "adjust-trailing-lines",        rewrite_AdjustTrailingLines);
+SCM_REWRITER_CFG(g_SvnNoExecutable,                 "svn-no-executable",            rewrite_SvnNoExecutable);
+SCM_REWRITER_CFG(g_SvnNoKeywords,                   "svn-no-keywords",              rewrite_SvnNoKeywords);
+SCM_REWRITER_CFG(g_SvnNoEolStyle,                   "svn-no-eol-style",             rewrite_SvnNoEolStyle);
+SCM_REWRITER_CFG(g_SvnBinary,                       "svn-binary",                   rewrite_SvnBinary);
+SCM_REWRITER_CFG(g_SvnKeywords,                     "svn-keywords",                 rewrite_SvnKeywords);
+SCM_REWRITER_CFG(g_SvnSyncProcess,                  "svn-sync-process",             rewrite_SvnSyncProcess);
+SCM_REWRITER_CFG(g_UnicodeChecks,                   "unicode-checks",               rewrite_UnicodeChecks);
+SCM_REWRITER_CFG(g_PageChecks,                      "page-checks",                  rewrite_PageChecks);
+SCM_REWRITER_CFG(g_ForceHrcVrcInsteadOfRc,          "force-hrc-vrc-no-rc",          rewrite_ForceHrcVrcInsteadOfRc);
+SCM_REWRITER_CFG(g_Copyright_CstyleComment,         "copyright-c-style",            rewrite_Copyright_CstyleComment);
+SCM_REWRITER_CFG(g_Copyright_HashComment,           "copyright-hash-style",         rewrite_Copyright_HashComment);
+SCM_REWRITER_CFG(g_Copyright_PythonComment,         "copyright-python-style",       rewrite_Copyright_PythonComment);
+SCM_REWRITER_CFG(g_Copyright_RemComment,            "copyright-rem-style",          rewrite_Copyright_RemComment);
+SCM_REWRITER_CFG(g_Copyright_SemicolonComment,      "copyright-semicolon-style",    rewrite_Copyright_SemicolonComment);
+SCM_REWRITER_CFG(g_Copyright_SqlComment,            "copyright-sql-style",          rewrite_Copyright_SqlComment);
+SCM_REWRITER_CFG(g_Copyright_TickComment,           "copyright-tick-style",         rewrite_Copyright_TickComment);
+SCM_REWRITER_CFG(g_Copyright_XmlComment,            "copyright-xml-style",          rewrite_Copyright_XmlComment);
+SCM_REWRITER_CFG(g_Makefile_kup,                    "makefile-kup",                 rewrite_Makefile_kup);
+SCM_REWRITER_CFG(g_Makefile_kmk,                    "makefile-kmk",                 rewrite_Makefile_kmk);
+SCM_REWRITER_CFG(g_FixFlowerBoxMarkers,             "fix-flower-boxes",             rewrite_FixFlowerBoxMarkers);
+SCM_REWRITER_CFG(g_FixHeaderGuards,                 "fix-header-guard",             rewrite_FixHeaderGuards);
+SCM_REWRITER_CFG(g_Fix_C_and_CPP_Todos,             "fix-c-todos",                  rewrite_Fix_C_and_CPP_Todos);
+SCM_REWRITER_CFG(g_Fix_Err_H,                       "fix-err-h",                    rewrite_Fix_Err_H);
+SCM_REWRITER_CFG(g_C_and_CPP,                       "c-and-cpp",                    rewrite_C_and_CPP);
+
+/** The rewriter actions. */
+static PCSCMREWRITERCFG const g_papRewriterActions[] =
+{
+    &g_StripTrailingBlanks,
+    &g_ExpandTabs,
+    &g_ForceNativeEol,
+    &g_ForceLF,
+    &g_ForceCRLF,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnNoKeywords,
+    &g_SvnNoEolStyle,
+    &g_SvnBinary,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_Copyright_CstyleComment,
+    &g_Copyright_HashComment,
+    &g_Copyright_PythonComment,
+    &g_Copyright_RemComment,
+    &g_Copyright_SemicolonComment,
+    &g_Copyright_SqlComment,
+    &g_Copyright_TickComment,
+    &g_Makefile_kup,
+    &g_Makefile_kmk,
+    &g_FixFlowerBoxMarkers,
+    &g_FixHeaderGuards,
+    &g_Fix_C_and_CPP_Todos,
+    &g_Fix_Err_H,
+    &g_UnicodeChecks,
+    &g_PageChecks,
+    &g_ForceHrcVrcInsteadOfRc,
+    &g_C_and_CPP,
+};
+
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Makefile_kup[] =
+{
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Makefile_kup
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Makefile_kmk[] =
+{
+    &g_ForceNativeEol,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+    &g_Makefile_kmk
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_OtherMakefiles[] =
+{
+    &g_ForceNativeEol,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_C_and_CPP[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_PageChecks,
+    &g_ForceHrcVrcInsteadOfRc,
+    &g_Copyright_CstyleComment,
+    &g_FixFlowerBoxMarkers,
+    &g_Fix_C_and_CPP_Todos,
+    &g_Fix_Err_H,
+    &g_C_and_CPP,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_H_and_HPP[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_PageChecks,
+    &g_ForceHrcVrcInsteadOfRc,
+    &g_Copyright_CstyleComment,
+    /// @todo &g_FixFlowerBoxMarkers,
+    &g_FixHeaderGuards,
+    &g_C_and_CPP
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_RC[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_CstyleComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_DTrace[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_CstyleComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_DSL[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_CstyleComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_ASM[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SemicolonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_DEF[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SemicolonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_ShellScripts[] =
+{
+    &g_ForceLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_BatchFiles[] =
+{
+    &g_ForceCRLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_RemComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_BasicScripts[] =
+{
+    &g_ForceCRLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_TickComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_SedScripts[] =
+{
+    &g_ForceLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Python[] =
+{
+    /** @todo &g_ForceLFIfExecutable */
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_PythonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Perl[] =
+{
+    /** @todo &g_ForceLFIfExecutable */
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_DriverInfFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SemicolonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_NsisFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SemicolonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Java[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_CstyleComment,
+    &g_FixFlowerBoxMarkers,
+    &g_Fix_C_and_CPP_Todos,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_ScmSettings[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Images[] =
+{
+    &g_SvnNoExecutable,
+    &g_SvnBinary,
+    &g_SvnSyncProcess,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Xslt[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_XmlComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Xml[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_XmlComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_Wix[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_XmlComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_QtProject[] =
+{
+    &g_ForceNativeEol,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_QtResourceFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    /** @todo figure out copyright for Qt resource XML files. */
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_QtTranslations[] =
+{
+    &g_ForceNativeEol,
+    &g_SvnNoExecutable,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_QtUiFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_SvnNoExecutable,
+    &g_SvnKeywords,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    /** @todo copyright is in an XML 'comment' element. */
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_SifFiles[] =
+{
+    &g_ForceCRLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SemicolonComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_SqlFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_SqlComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_GnuAsm[] =
+{
+    &g_ForceNativeEol,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_CstyleComment,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_TextFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_StripTrailingBlanks,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    /** @todo check for plain copyright + license in text files. */
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_PlainTextFiles[] =
+{
+    &g_ForceNativeEol,
+    &g_StripTrailingBlanks,
+    &g_SvnKeywords,
+    &g_SvnNoExecutable,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_BinaryFiles[] =
+{
+    &g_SvnBinary,
+    &g_SvnSyncProcess,
+};
+
+static PCSCMREWRITERCFG const g_apRewritersFor_FileLists[] = /* both makefile and shell script */
+{
+    &g_ForceLF,
+    &g_ExpandTabs,
+    &g_StripTrailingBlanks,
+    &g_AdjustTrailingLines,
+    &g_SvnSyncProcess,
+    &g_UnicodeChecks,
+    &g_Copyright_HashComment,
+};
+
+
+/**
+ * Array of standard rewriter configurations.
+ */
+static SCMCFGENTRY const g_aConfigs[] =
+{
+#define SCM_CFG_ENTRY(a_szName, a_aRewriters, a_fBinary, a_szFilePatterns) \
+    { RT_ELEMENTS(a_aRewriters), &a_aRewriters[0], a_fBinary, a_szFilePatterns, a_szName }
+    SCM_CFG_ENTRY("kup",        g_apRewritersFor_Makefile_kup,     false, "Makefile.kup" ),
+    SCM_CFG_ENTRY("kmk",        g_apRewritersFor_Makefile_kmk,     false, "*.kmk" ),
+    SCM_CFG_ENTRY("c",          g_apRewritersFor_C_and_CPP,        false, "*.c|*.cpp|*.C|*.CPP|*.cxx|*.cc|*.m|*.mm|*.lds" ),
+    SCM_CFG_ENTRY("h",          g_apRewritersFor_H_and_HPP,        false, "*.h|*.hpp" ),
+    SCM_CFG_ENTRY("rc",         g_apRewritersFor_RC,               false, "*.rc" ),
+    SCM_CFG_ENTRY("asm",        g_apRewritersFor_ASM,              false, "*.asm|*.mac|*.inc" ),
+    SCM_CFG_ENTRY("dtrace",     g_apRewritersFor_DTrace,           false, "*.d" ),
+    SCM_CFG_ENTRY("def",        g_apRewritersFor_DEF,              false, "*.def" ),
+    SCM_CFG_ENTRY("iasl",       g_apRewritersFor_DSL,              false, "*.dsl" ),
+    SCM_CFG_ENTRY("shell",      g_apRewritersFor_ShellScripts,     false, "*.sh|configure" ),
+    SCM_CFG_ENTRY("batch",      g_apRewritersFor_BatchFiles,       false, "*.bat|*.cmd|*.btm" ),
+    SCM_CFG_ENTRY("vbs",        g_apRewritersFor_BasicScripts,     false, "*.vbs|*.vb" ),
+    SCM_CFG_ENTRY("sed",        g_apRewritersFor_SedScripts,       false, "*.sed" ),
+    SCM_CFG_ENTRY("python",     g_apRewritersFor_Python,           false, "*.py" ),
+    SCM_CFG_ENTRY("perl",       g_apRewritersFor_Perl,             false, "*.pl|*.pm" ),
+    SCM_CFG_ENTRY("drvinf",     g_apRewritersFor_DriverInfFiles,   false, "*.inf" ),
+    SCM_CFG_ENTRY("nsis",       g_apRewritersFor_NsisFiles,        false, "*.nsh|*.nsi|*.nsis" ),
+    SCM_CFG_ENTRY("java",       g_apRewritersFor_Java,             false, "*.java" ),
+    SCM_CFG_ENTRY("scm",        g_apRewritersFor_ScmSettings,      false, "*.scm-settings" ),
+    SCM_CFG_ENTRY("image",      g_apRewritersFor_Images,           true,  "*.png|*.bmp|*.jpg|*.pnm|*.ico|*.icns|*.tiff|*.tif|"
+                                                                          "*.xcf|*.gif|*.jar|*.dll|*.exe|*.ttf|*.woff|*.woff2" ),
+    SCM_CFG_ENTRY("xslt",       g_apRewritersFor_Xslt,             false, "*.xsl" ),
+    SCM_CFG_ENTRY("xml",        g_apRewritersFor_Xml,              false, "*.xml|*.dist|*.qhcp" ),
+    SCM_CFG_ENTRY("wix",        g_apRewritersFor_Wix,              false, "*.wxi|*.wxs|*.wxl" ),
+    SCM_CFG_ENTRY("qt-pro",     g_apRewritersFor_QtProject,        false, "*.pro" ),
+    SCM_CFG_ENTRY("qt-rc",      g_apRewritersFor_QtResourceFiles,  false, "*.qrc" ),
+    SCM_CFG_ENTRY("qt-ts",      g_apRewritersFor_QtTranslations,   false, "*.ts" ),
+    SCM_CFG_ENTRY("qt-ui",      g_apRewritersFor_QtUiFiles,        false, "*.ui" ),
+    SCM_CFG_ENTRY("sif",        g_apRewritersFor_SifFiles,         false, "*.sif" ),
+    SCM_CFG_ENTRY("sql",        g_apRewritersFor_SqlFiles,         false, "*.pgsql|*.sql" ),
+    SCM_CFG_ENTRY("gas",        g_apRewritersFor_GnuAsm,           false, "*.S" ),
+    SCM_CFG_ENTRY("binary",     g_apRewritersFor_BinaryFiles,      true,  "*.bin|*.pdf|*.zip|*.bz2|*.gz" ),
+    /* These should be be last: */
+    SCM_CFG_ENTRY("make",       g_apRewritersFor_OtherMakefiles,   false, "Makefile|makefile|GNUmakefile|SMakefile|Makefile.am|Makefile.in|*.cmake|*.gmk" ),
+    SCM_CFG_ENTRY("text",       g_apRewritersFor_TextFiles,        false, "*.txt|README*|readme*|ReadMe*|NOTE*|TODO*" ),
+    SCM_CFG_ENTRY("plaintext",  g_apRewritersFor_PlainTextFiles,   false, "LICENSE|ChangeLog|FAQ|AUTHORS|INSTALL|NEWS" ),
+    SCM_CFG_ENTRY("file-list",  g_apRewritersFor_FileLists,        false, "files_*" ),
+};
+
+
+
+/* -=-=-=-=-=- settings -=-=-=-=-=- */
+
+/**
+ * Delete the given config entry.
+ *
+ * @param   pEntry              The configuration entry to delete.
+ */
+static void scmCfgEntryDelete(PSCMCFGENTRY pEntry)
+{
+    RTMemFree((void *)pEntry->paRewriters);
+    pEntry->paRewriters = NULL;
+    RTMemFree(pEntry);
+}
+
+/**
+ * Create a new configuration entry.
+ *
+ * @returns The new entry. NULL if out of memory.
+ * @param   pEntry              The configuration entry to duplicate.
+ */
+static PSCMCFGENTRY scmCfgEntryNew(void)
+{
+    PSCMCFGENTRY pNew = (PSCMCFGENTRY)RTMemAlloc(sizeof(*pNew));
+    if (pNew)
+    {
+        pNew->pszName        = "custom";
+        pNew->pszFilePattern = "custom";
+        pNew->cRewriters     = 0;
+        pNew->paRewriters    = NULL;
+        pNew->fBinary        = false;
+    }
+    return pNew;
+}
+
+/**
+ * Duplicate the given config entry.
+ *
+ * @returns The duplicate. NULL if out of memory.
+ * @param   pEntry              The configuration entry to duplicate.
+ */
+static PSCMCFGENTRY scmCfgEntryDup(PCSCMCFGENTRY pEntry)
+{
+    if (pEntry)
+    {
+        PSCMCFGENTRY pDup = (PSCMCFGENTRY)RTMemDup(pEntry, sizeof(*pEntry));
+        if (pDup)
+        {
+            size_t cbSrcRewriters = sizeof(pEntry->paRewriters[0]) * pEntry->cRewriters;
+            size_t cbDstRewriters = sizeof(pEntry->paRewriters[0]) * RT_ALIGN_Z(pEntry->cRewriters, 8);
+            pDup->paRewriters = (PCSCMREWRITERCFG const *)RTMemDupEx(pEntry->paRewriters, cbSrcRewriters,
+                                                                     cbDstRewriters - cbSrcRewriters);
+            if (pDup->paRewriters)
+                return pDup;
+
+            RTMemFree(pDup);
+        }
+        return NULL;
+    }
+    return scmCfgEntryNew();
+}
+
+/**
+ * Adds a rewriter action to the given config entry (--add-action).
+ *
+ * @returns VINF_SUCCESS.
+ * @param   pEntry              The configuration entry.
+ * @param   pAction             The rewriter action to add.
+ */
+static int scmCfgEntryAddAction(PSCMCFGENTRY pEntry, PCSCMREWRITERCFG pAction)
+{
+    PCSCMREWRITERCFG *paRewriters = (PCSCMREWRITERCFG *)pEntry->paRewriters;
+    if (pEntry->cRewriters % 8 == 0)
+    {
+        size_t cbRewriters = sizeof(pEntry->paRewriters[0]) * RT_ALIGN_Z((pEntry->cRewriters + 1), 8);
+        void *pvNew = RTMemRealloc(paRewriters, cbRewriters);
+        if (pvNew)
+            pEntry->paRewriters = paRewriters = (PCSCMREWRITERCFG *)pvNew;
+        else
+            return VERR_NO_MEMORY;
+    }
+
+    paRewriters[pEntry->cRewriters++] = pAction;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Delets an rewriter action from the given config entry (--del-action).
+ *
+ * @param   pEntry              The configuration entry.
+ * @param   pAction             The rewriter action to remove.
+ */
+static void scmCfgEntryDelAction(PSCMCFGENTRY pEntry, PCSCMREWRITERCFG pAction)
+{
+    PCSCMREWRITERCFG *paRewriters = (PCSCMREWRITERCFG *)pEntry->paRewriters;
+    size_t const cEntries = pEntry->cRewriters;
+    size_t       iDst = 0;
+    for (size_t iSrc = 0; iSrc < cEntries; iSrc++)
+    {
+        PCSCMREWRITERCFG pCurAction = paRewriters[iSrc];
+        if (pCurAction != pAction)
+            paRewriters[iDst++] = pCurAction;
+    }
+    pEntry->cRewriters = iDst;
+}
+
+/**
+ * Init a settings structure with settings from @a pSrc.
+ *
+ * @returns IPRT status code
+ * @param   pSettings           The settings.
+ * @param   pSrc                The source settings.
+ */
+static int scmSettingsBaseInitAndCopy(PSCMSETTINGSBASE pSettings, PCSCMSETTINGSBASE pSrc)
+{
+    *pSettings = *pSrc;
+
+    int rc = RTStrDupEx(&pSettings->pszFilterFiles, pSrc->pszFilterFiles);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTStrDupEx(&pSettings->pszFilterOutFiles, pSrc->pszFilterOutFiles);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTStrDupEx(&pSettings->pszFilterOutDirs, pSrc->pszFilterOutDirs);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTStrDupEx(&pSettings->pszGuardPrefix, pSrc->pszGuardPrefix);
+                if (RT_SUCCESS(rc))
+                {
+                    if (pSrc->pszGuardRelativeToDir)
+                        rc = RTStrDupEx(&pSettings->pszGuardRelativeToDir, pSrc->pszGuardRelativeToDir);
+                    if (RT_SUCCESS(rc))
+                    {
+
+                        if (!pSrc->fFreeTreatAs)
+                            return VINF_SUCCESS;
+
+                        pSettings->pTreatAs = scmCfgEntryDup(pSrc->pTreatAs);
+                        if (pSettings->pTreatAs)
+                            return VINF_SUCCESS;
+
+                        RTStrFree(pSettings->pszGuardRelativeToDir);
+                    }
+                    RTStrFree(pSettings->pszGuardPrefix);
+                }
+            }
+            RTStrFree(pSettings->pszFilterOutFiles);
+        }
+        RTStrFree(pSettings->pszFilterFiles);
+    }
+
+    pSettings->pszGuardRelativeToDir = NULL;
+    pSettings->pszGuardPrefix = NULL;
+    pSettings->pszFilterFiles = NULL;
+    pSettings->pszFilterOutFiles = NULL;
+    pSettings->pszFilterOutDirs = NULL;
+    pSettings->pTreatAs = NULL;
+    return rc;
+}
+
+/**
+ * Init a settings structure.
+ *
+ * @returns IPRT status code
+ * @param   pSettings           The settings.
+ */
+static int scmSettingsBaseInit(PSCMSETTINGSBASE pSettings)
+{
+    return scmSettingsBaseInitAndCopy(pSettings, &g_Defaults);
+}
+
+/**
+ * Deletes the settings, i.e. free any dynamically allocated content.
+ *
+ * @param   pSettings           The settings.
+ */
+static void scmSettingsBaseDelete(PSCMSETTINGSBASE pSettings)
+{
+    if (pSettings)
+    {
+        Assert(pSettings->cchTab != UINT8_MAX);
+        pSettings->cchTab = UINT8_MAX;
+
+        RTStrFree(pSettings->pszGuardPrefix);
+        RTStrFree(pSettings->pszGuardRelativeToDir);
+        RTStrFree(pSettings->pszFilterFiles);
+        RTStrFree(pSettings->pszFilterOutFiles);
+        RTStrFree(pSettings->pszFilterOutDirs);
+        if (pSettings->fFreeTreatAs)
+            scmCfgEntryDelete((PSCMCFGENTRY)pSettings->pTreatAs);
+
+        pSettings->pszGuardPrefix = NULL;
+        pSettings->pszGuardRelativeToDir = NULL;
+        pSettings->pszFilterOutDirs = NULL;
+        pSettings->pszFilterOutFiles = NULL;
+        pSettings->pszFilterFiles = NULL;
+        pSettings->pTreatAs = NULL;
+        pSettings->fFreeTreatAs = false;
+    }
+}
+
+/**
+ * Processes a RTGetOpt result.
+ *
+ * @retval  VINF_SUCCESS if handled.
+ * @retval  VERR_OUT_OF_RANGE if the option value was out of range.
+ * @retval  VERR_GETOPT_UNKNOWN_OPTION if the option was not recognized.
+ *
+ * @param   pSettings           The settings to change.
+ * @param   rc                  The RTGetOpt return value.
+ * @param   pValueUnion         The RTGetOpt value union.
+ * @param   pchDir              The absolute path to the directory relative
+ *                              components in pchLine should be relative to.
+ * @param   cchDir              The length of the @a pchDir string.
+ */
+static int scmSettingsBaseHandleOpt(PSCMSETTINGSBASE pSettings, int rc, PRTGETOPTUNION pValueUnion,
+                                    const char *pchDir, size_t cchDir)
+{
+    Assert(pchDir[cchDir - 1] == '/');
+
+    switch (rc)
+    {
+        case SCMOPT_CONVERT_EOL:
+            pSettings->fConvertEol = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_CONVERT_EOL:
+            pSettings->fConvertEol = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_CONVERT_TABS:
+            pSettings->fConvertTabs = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_CONVERT_TABS:
+            pSettings->fConvertTabs = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FORCE_FINAL_EOL:
+            pSettings->fForceFinalEol = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FORCE_FINAL_EOL:
+            pSettings->fForceFinalEol = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FORCE_TRAILING_LINE:
+            pSettings->fForceTrailingLine = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FORCE_TRAILING_LINE:
+            pSettings->fForceTrailingLine = false;
+            return VINF_SUCCESS;
+
+
+        case SCMOPT_STRIP_TRAILING_BLANKS:
+            pSettings->fStripTrailingBlanks = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_STRIP_TRAILING_BLANKS:
+            pSettings->fStripTrailingBlanks = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS:
+            pSettings->cMinBlankLinesBeforeFlowerBoxMakers = pValueUnion->u8;
+            return VINF_SUCCESS;
+
+
+        case SCMOPT_STRIP_TRAILING_LINES:
+            pSettings->fStripTrailingLines = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_STRIP_TRAILING_LINES:
+            pSettings->fStripTrailingLines = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_FLOWER_BOX_MARKERS:
+            pSettings->fFixFlowerBoxMarkers = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_FLOWER_BOX_MARKERS:
+            pSettings->fFixFlowerBoxMarkers = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_HEADER_GUARDS:
+            pSettings->fFixHeaderGuards = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_HEADER_GUARDS:
+            pSettings->fFixHeaderGuards = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_PRAGMA_ONCE:
+            pSettings->fPragmaOnce = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_PRAGMA_ONCE:
+            pSettings->fPragmaOnce = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_HEADER_GUARD_ENDIF:
+            pSettings->fFixHeaderGuardEndif = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_HEADER_GUARD_ENDIF:
+            pSettings->fFixHeaderGuardEndif = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ENDIF_GUARD_COMMENT:
+            pSettings->fEndifGuardComment = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_ENDIF_GUARD_COMMENT:
+            pSettings->fEndifGuardComment = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_GUARD_PREFIX:
+            RTStrFree(pSettings->pszGuardPrefix);
+            pSettings->pszGuardPrefix = NULL;
+            return RTStrDupEx(&pSettings->pszGuardPrefix, pValueUnion->psz);
+
+        case SCMOPT_GUARD_RELATIVE_TO_DIR:
+            RTStrFree(pSettings->pszGuardRelativeToDir);
+            pSettings->pszGuardRelativeToDir = NULL;
+            if (*pValueUnion->psz != '\0')
+            {
+                if (   strcmp(pValueUnion->psz, "{dir}") == 0
+                    || strcmp(pValueUnion->psz, "{parent}") == 0)
+                    return RTStrDupEx(&pSettings->pszGuardRelativeToDir, pValueUnion->psz);
+                if (cchDir == 1 && *pchDir == '/')
+                {
+                    pSettings->pszGuardRelativeToDir = RTPathAbsDup(pValueUnion->psz);
+                    if (pSettings->pszGuardRelativeToDir)
+                        return VINF_SUCCESS;
+                }
+                else
+                {
+                    char *pszDir = RTStrDupN(pchDir, cchDir);
+                    if (pszDir)
+                    {
+                        pSettings->pszGuardRelativeToDir = RTPathAbsExDup(pszDir, pValueUnion->psz, RTPATH_STR_F_STYLE_HOST);
+                        RTStrFree(pszDir);
+                        if (pSettings->pszGuardRelativeToDir)
+                            return VINF_SUCCESS;
+                    }
+                }
+                RTMsgError("Failed to abspath --guard-relative-to-dir value '%s' - probably out of memory\n", pValueUnion->psz);
+                return VERR_NO_STR_MEMORY;
+            }
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_TODOS:
+            pSettings->fFixTodos = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_TODOS:
+            pSettings->fFixTodos = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_ERR_H:
+            pSettings->fFixErrH = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_ERR_H:
+            pSettings->fFixErrH = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ONLY_GUEST_HOST_PAGE:
+            pSettings->fOnlyGuestHostPage = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_PAGE_RESTRICTIONS:
+            pSettings->fOnlyGuestHostPage = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_NO_ASM_MEM_PAGE_USE:
+            pSettings->fNoASMMemPageUse = true;
+            return VINF_SUCCESS;
+        case SCMOPT_UNRESTRICTED_ASM_MEM_PAGE_USE:
+            pSettings->fNoASMMemPageUse = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_NO_RC_USE:
+            pSettings->fOnlyHrcVrcInsteadOfRc = true;
+            return VINF_SUCCESS;
+        case SCMOPT_UNRESTRICTED_RC_USE:
+            pSettings->fOnlyHrcVrcInsteadOfRc = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_STANDARIZE_KMK:
+            pSettings->fStandarizeKmk = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_STANDARIZE_KMK:
+            pSettings->fStandarizeKmk = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_UPDATE_COPYRIGHT_YEAR:
+            pSettings->fUpdateCopyrightYear = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_UPDATE_COPYRIGHT_YEAR:
+            pSettings->fUpdateCopyrightYear = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_EXTERNAL_COPYRIGHT:
+            pSettings->fExternalCopyright = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_EXTERNAL_COPYRIGHT:
+            pSettings->fExternalCopyright = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_NO_UPDATE_LICENSE:
+            pSettings->enmUpdateLicense = kScmLicense_LeaveAlone;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_OSE_GPL:
+            pSettings->enmUpdateLicense = kScmLicense_OseGpl;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL:
+            pSettings->enmUpdateLicense = kScmLicense_OseDualGplCddl;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_OSE_CDDL:
+            pSettings->enmUpdateLicense = kScmLicense_OseCddl;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_LGPL:
+            pSettings->enmUpdateLicense = kScmLicense_Lgpl;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_MIT:
+            pSettings->enmUpdateLicense = kScmLicense_Mit;
+            return VINF_SUCCESS;
+        case SCMOPT_LICENSE_BASED_ON_MIT:
+            pSettings->enmUpdateLicense = kScmLicense_BasedOnMit;
+            return VINF_SUCCESS;
+
+        case SCMOPT_LGPL_DISCLAIMER:
+            pSettings->fLgplDisclaimer = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_LGPL_DISCLAIMER:
+            pSettings->fLgplDisclaimer = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ONLY_SVN_DIRS:
+            pSettings->fOnlySvnDirs = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NOT_ONLY_SVN_DIRS:
+            pSettings->fOnlySvnDirs = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ONLY_SVN_FILES:
+            pSettings->fOnlySvnFiles = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NOT_ONLY_SVN_FILES:
+            pSettings->fOnlySvnFiles = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_SET_SVN_EOL:
+            pSettings->fSetSvnEol = true;
+            return VINF_SUCCESS;
+        case SCMOPT_DONT_SET_SVN_EOL:
+            pSettings->fSetSvnEol = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_SET_SVN_EXECUTABLE:
+            pSettings->fSetSvnExecutable = true;
+            return VINF_SUCCESS;
+        case SCMOPT_DONT_SET_SVN_EXECUTABLE:
+            pSettings->fSetSvnExecutable = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_SET_SVN_KEYWORDS:
+            pSettings->fSetSvnKeywords = true;
+            return VINF_SUCCESS;
+        case SCMOPT_DONT_SET_SVN_KEYWORDS:
+            pSettings->fSetSvnKeywords = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_SKIP_SVN_SYNC_PROCESS:
+            pSettings->fSkipSvnSyncProcess = true;
+            return VINF_SUCCESS;
+        case SCMOPT_DONT_SKIP_SVN_SYNC_PROCESS:
+            pSettings->fSkipSvnSyncProcess = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_SKIP_UNICODE_CHECKS:
+            pSettings->fSkipUnicodeChecks = true;
+            return VINF_SUCCESS;
+        case SCMOPT_DONT_SKIP_UNICODE_CHECKS:
+            pSettings->fSkipUnicodeChecks = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_TAB_SIZE:
+            if (   pValueUnion->u8 < 1
+                || pValueUnion->u8 >= RT_ELEMENTS(g_szTabSpaces))
+            {
+                RTMsgError("Invalid tab size: %u - must be in {1..%u}\n",
+                           pValueUnion->u8, RT_ELEMENTS(g_szTabSpaces) - 1);
+                return VERR_OUT_OF_RANGE;
+            }
+            pSettings->cchTab = pValueUnion->u8;
+            return VINF_SUCCESS;
+
+        case SCMOPT_WIDTH:
+            if (pValueUnion->u8 < 20 || pValueUnion->u8 > 200)
+            {
+                RTMsgError("Invalid width size: %u - must be in {20..200} range\n", pValueUnion->u8);
+                return VERR_OUT_OF_RANGE;
+            }
+            pSettings->cchWidth = pValueUnion->u8;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FILTER_OUT_DIRS:
+        case SCMOPT_FILTER_FILES:
+        case SCMOPT_FILTER_OUT_FILES:
+        {
+            char **ppsz = NULL;
+            switch (rc)
+            {
+                case SCMOPT_FILTER_OUT_DIRS:    ppsz = &pSettings->pszFilterOutDirs; break;
+                case SCMOPT_FILTER_FILES:       ppsz = &pSettings->pszFilterFiles; break;
+                case SCMOPT_FILTER_OUT_FILES:   ppsz = &pSettings->pszFilterOutFiles; break;
+            }
+
+            /*
+             * An empty string zaps the current list.
+             */
+            if (!*pValueUnion->psz)
+                return RTStrATruncate(ppsz, 0);
+
+            /*
+             * Non-empty strings are appended to the pattern list.
+             *
+             * Strip leading and trailing pattern separators before attempting
+             * to append it.  If it's just separators, don't do anything.
+             */
+            const char *pszSrc = pValueUnion->psz;
+            while (*pszSrc == '|')
+                pszSrc++;
+            size_t cchSrc = strlen(pszSrc);
+            while (cchSrc > 0 && pszSrc[cchSrc - 1] == '|')
+                cchSrc--;
+            if (!cchSrc)
+                return VINF_SUCCESS;
+
+            /* Append it pattern by pattern, turning settings-relative paths into absolute ones. */
+            for (;;)
+            {
+                const char *pszEnd = (const char *)memchr(pszSrc, '|', cchSrc);
+                size_t cchPattern = pszEnd ? pszEnd - pszSrc : cchSrc;
+                int rc2;
+                if (*pszSrc == '/')
+                    rc2 = RTStrAAppendExN(ppsz, 3,
+                                          "|", *ppsz && **ppsz != '\0' ? (size_t)1 : (size_t)0,
+                                          pchDir, cchDir - 1,
+                                          pszSrc, cchPattern);
+                else
+                    rc2 = RTStrAAppendExN(ppsz, 2,
+                                          "|", *ppsz && **ppsz != '\0' ? (size_t)1 : (size_t)0,
+                                          pszSrc, cchPattern);
+                if (RT_FAILURE(rc2))
+                    return rc2;
+
+                /* next */
+                cchSrc -= cchPattern;
+                if (!cchSrc)
+                    return VINF_SUCCESS;
+                cchSrc -= 1;
+                pszSrc += cchPattern + 1;
+            }
+            /* not reached */
+        }
+
+        case SCMOPT_TREAT_AS:
+            if (pSettings->fFreeTreatAs)
+            {
+                scmCfgEntryDelete((PSCMCFGENTRY)pSettings->pTreatAs);
+                pSettings->pTreatAs = NULL;
+                pSettings->fFreeTreatAs = false;
+            }
+
+            if (*pValueUnion->psz)
+            {
+                /* first check the names, then patterns (legacy). */
+                for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+                    if (strcmp(g_aConfigs[iCfg].pszName, pValueUnion->psz) == 0)
+                    {
+                        pSettings->pTreatAs = &g_aConfigs[iCfg];
+                        return VINF_SUCCESS;
+                    }
+                for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+                    if (RTStrSimplePatternMultiMatch(g_aConfigs[iCfg].pszFilePattern, RTSTR_MAX,
+                                                     pValueUnion->psz, RTSTR_MAX, NULL))
+                    {
+                        pSettings->pTreatAs = &g_aConfigs[iCfg];
+                        return VINF_SUCCESS;
+                    }
+                /* Special help for listing the possibilities?  */
+                if (strcmp(pValueUnion->psz, "help") == 0)
+                {
+                    RTPrintf("Possible --treat-as values:\n");
+                    for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+                        RTPrintf("    %s (%s)\n", g_aConfigs[iCfg].pszName, g_aConfigs[iCfg].pszFilePattern);
+                }
+                return VERR_NOT_FOUND;
+            }
+
+            pSettings->pTreatAs = NULL;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ADD_ACTION:
+            for (uint32_t iAction = 0; iAction < RT_ELEMENTS(g_papRewriterActions); iAction++)
+                if (strcmp(g_papRewriterActions[iAction]->pszName, pValueUnion->psz) == 0)
+                {
+                    PSCMCFGENTRY pEntry = (PSCMCFGENTRY)pSettings->pTreatAs;
+                    if (!pSettings->fFreeTreatAs)
+                    {
+                        pEntry = scmCfgEntryDup(pEntry);
+                        if (!pEntry)
+                            return VERR_NO_MEMORY;
+                        pSettings->pTreatAs = pEntry;
+                        pSettings->fFreeTreatAs = true;
+                    }
+                    return scmCfgEntryAddAction(pEntry, g_papRewriterActions[iAction]);
+                }
+            RTMsgError("Unknown --add-action value '%s'.  Try --help-actions for a list.", pValueUnion->psz);
+            return VERR_NOT_FOUND;
+
+        case SCMOPT_DEL_ACTION:
+        {
+            uint32_t cActions = 0;
+            for (uint32_t iAction = 0; iAction < RT_ELEMENTS(g_papRewriterActions); iAction++)
+                if (RTStrSimplePatternMatch(pValueUnion->psz, g_papRewriterActions[iAction]->pszName))
+                {
+                    cActions++;
+                    PSCMCFGENTRY pEntry = (PSCMCFGENTRY)pSettings->pTreatAs;
+                    if (!pSettings->fFreeTreatAs)
+                    {
+                        pEntry = scmCfgEntryDup(pEntry);
+                        if (!pEntry)
+                            return VERR_NO_MEMORY;
+                        pSettings->pTreatAs = pEntry;
+                        pSettings->fFreeTreatAs = true;
+                    }
+                    scmCfgEntryDelAction(pEntry, g_papRewriterActions[iAction]);
+                    if (!strchr(pValueUnion->psz, '*'))
+                        return VINF_SUCCESS;
+                }
+            if (cActions > 0)
+                return VINF_SUCCESS;
+            RTMsgError("Unknown --del-action value '%s'.  Try --help-actions for a list.", pValueUnion->psz);
+            return VERR_NOT_FOUND;
+        }
+
+        default:
+            return VERR_GETOPT_UNKNOWN_OPTION;
+    }
+}
+
+/**
+ * Parses an option string.
+ *
+ * @returns IPRT status code.
+ * @param   pBase               The base settings structure to apply the options
+ *                              to.
+ * @param   pszOptions          The options to parse.
+ * @param   pchDir              The absolute path to the directory relative
+ *                              components in pchLine should be relative to.
+ * @param   cchDir              The length of the @a pchDir string.
+ */
+static int scmSettingsBaseParseString(PSCMSETTINGSBASE pBase, const char *pszLine, const char *pchDir, size_t cchDir)
+{
+    int    cArgs;
+    char **papszArgs;
+    int rc = RTGetOptArgvFromString(&papszArgs, &cArgs, pszLine, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        RTGETOPTUNION   ValueUnion;
+        RTGETOPTSTATE   GetOptState;
+        rc = RTGetOptInit(&GetOptState, cArgs, papszArgs, &g_aScmOpts[0], RT_ELEMENTS(g_aScmOpts), 0, 0 /*fFlags*/);
+        if (RT_SUCCESS(rc))
+        {
+            while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
+            {
+                rc = scmSettingsBaseHandleOpt(pBase, rc, &ValueUnion, pchDir, cchDir);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+        }
+        RTGetOptArgvFree(papszArgs);
+    }
+
+    return rc;
+}
+
+/**
+ * Parses an unterminated option string.
+ *
+ * @returns IPRT status code.
+ * @param   pBase               The base settings structure to apply the options
+ *                              to.
+ * @param   pchLine             The line.
+ * @param   cchLine             The line length.
+ * @param   pchDir              The absolute path to the directory relative
+ *                              components in pchLine should be relative to.
+ * @param   cchDir              The length of the @a pchDir string.
+ */
+static int scmSettingsBaseParseStringN(PSCMSETTINGSBASE pBase, const char *pchLine, size_t cchLine,
+                                       const char *pchDir, size_t cchDir)
+{
+    char *pszLine = RTStrDupN(pchLine, cchLine);
+    if (!pszLine)
+        return VERR_NO_MEMORY;
+    int rc = scmSettingsBaseParseString(pBase, pszLine, pchDir, cchDir);
+    RTStrFree(pszLine);
+    return rc;
+}
+
+/**
+ * Verifies the options string.
+ *
+ * @returns IPRT status code.
+ * @param   pszOptions          The options to verify .
+ */
+static int scmSettingsBaseVerifyString(const char *pszOptions)
+{
+    SCMSETTINGSBASE Base;
+    int rc = scmSettingsBaseInit(&Base);
+    if (RT_SUCCESS(rc))
+    {
+        rc = scmSettingsBaseParseString(&Base, pszOptions, "/", 1);
+        scmSettingsBaseDelete(&Base);
+    }
+    return rc;
+}
+
+/**
+ * Loads settings found in editor and SCM settings directives within the
+ * document (@a pStream).
+ *
+ * @returns IPRT status code.
+ * @param   pBase               The settings base to load settings into.
+ * @param   pStream             The stream to scan for settings directives.
+ */
+static int scmSettingsBaseLoadFromDocument(PSCMSETTINGSBASE pBase, PSCMSTREAM pStream)
+{
+    /** @todo Editor and SCM settings directives in documents.  */
+    RT_NOREF2(pBase, pStream);
+    return VINF_SUCCESS;
+}
+
+/**
+ * Creates a new settings file struct, cloning @a pSettings.
+ *
+ * @returns IPRT status code.
+ * @param   ppSettings          Where to return the new struct.
+ * @param   pSettingsBase       The settings to inherit from.
+ */
+static int scmSettingsCreate(PSCMSETTINGS *ppSettings, PCSCMSETTINGSBASE pSettingsBase)
+{
+    PSCMSETTINGS pSettings = (PSCMSETTINGS)RTMemAlloc(sizeof(*pSettings));
+    if (!pSettings)
+        return VERR_NO_MEMORY;
+    int rc = scmSettingsBaseInitAndCopy(&pSettings->Base, pSettingsBase);
+    if (RT_SUCCESS(rc))
+    {
+        pSettings->pDown   = NULL;
+        pSettings->pUp     = NULL;
+        pSettings->paPairs = NULL;
+        pSettings->cPairs  = 0;
+        *ppSettings = pSettings;
+        return VINF_SUCCESS;
+    }
+    RTMemFree(pSettings);
+    return rc;
+}
+
+/**
+ * Destroys a settings structure.
+ *
+ * @param   pSettings           The settings structure to destroy.  NULL is OK.
+ */
+static void scmSettingsDestroy(PSCMSETTINGS pSettings)
+{
+    if (pSettings)
+    {
+        scmSettingsBaseDelete(&pSettings->Base);
+        for (size_t i = 0; i < pSettings->cPairs; i++)
+        {
+            RTStrFree(pSettings->paPairs[i].pszPattern);
+            RTStrFree(pSettings->paPairs[i].pszOptions);
+            RTStrFree(pSettings->paPairs[i].pszRelativeTo);
+            pSettings->paPairs[i].pszPattern = NULL;
+            pSettings->paPairs[i].pszOptions = NULL;
+            pSettings->paPairs[i].pszRelativeTo = NULL;
+        }
+        RTMemFree(pSettings->paPairs);
+        pSettings->paPairs = NULL;
+        RTMemFree(pSettings);
+    }
+}
+
+/**
+ * Adds a pattern/options pair to the settings structure.
+ *
+ * @returns IPRT status code.
+ * @param   pSettings           The settings.
+ * @param   pchLine             The line containing the unparsed pair.
+ * @param   cchLine             The length of the line.
+ * @param   offColon            The offset of the colon into the line.
+ * @param   pchDir              The absolute path to the directory relative
+ *                              components in pchLine should be relative to.
+ * @param   cchDir              The length of the @a pchDir string.
+ */
+static int scmSettingsAddPair(PSCMSETTINGS pSettings, const char *pchLine, size_t cchLine, size_t offColon,
+                              const char *pchDir, size_t cchDir)
+{
+    Assert(pchLine[offColon] == ':' && offColon < cchLine);
+    Assert(pchDir[cchDir - 1] == '/');
+
+    /*
+     * Split the string.
+     */
+    size_t cchPattern = offColon;
+    size_t cchOptions = cchLine - cchPattern - 1;
+
+    /* strip spaces everywhere */
+    while (cchPattern > 0 && RT_C_IS_SPACE(pchLine[cchPattern - 1]))
+        cchPattern--;
+    while (cchPattern > 0 && RT_C_IS_SPACE(*pchLine))
+        cchPattern--, pchLine++;
+
+    const char *pchOptions = &pchLine[offColon + 1];
+    while (cchOptions > 0 && RT_C_IS_SPACE(pchOptions[cchOptions - 1]))
+        cchOptions--;
+    while (cchOptions > 0 && RT_C_IS_SPACE(*pchOptions))
+        cchOptions--, pchOptions++;
+
+    /* Quietly ignore empty patterns and empty options. */
+    if (!cchOptions || !cchPattern)
+        return VINF_SUCCESS;
+
+    /*
+     * Prepair the pair and verify the option string.
+     */
+    uint32_t iPair = pSettings->cPairs;
+    if ((iPair % 32) == 0)
+    {
+        void *pvNew = RTMemRealloc(pSettings->paPairs, (iPair + 32) * sizeof(pSettings->paPairs[0]));
+        if (!pvNew)
+            return VERR_NO_MEMORY;
+        pSettings->paPairs = (PSCMPATRNOPTPAIR)pvNew;
+    }
+
+    pSettings->paPairs[iPair].pszPattern    = RTStrDupN(pchLine, cchPattern);
+    pSettings->paPairs[iPair].pszOptions    = RTStrDupN(pchOptions, cchOptions);
+    pSettings->paPairs[iPair].pszRelativeTo = RTStrDupN(pchDir, cchDir);
+    int rc;
+    if (   pSettings->paPairs[iPair].pszPattern
+        && pSettings->paPairs[iPair].pszOptions
+        && pSettings->paPairs[iPair].pszRelativeTo)
+        rc = scmSettingsBaseVerifyString(pSettings->paPairs[iPair].pszOptions);
+    else
+        rc = VERR_NO_MEMORY;
+
+    /*
+     * If it checked out fine, expand any relative paths in the pattern.
+     */
+    if (RT_SUCCESS(rc))
+    {
+        size_t cPattern = 1;
+        size_t cRelativePaths = 0;
+        const char *pszSrc = pSettings->paPairs[iPair].pszPattern;
+        for (;;)
+        {
+            if (*pszSrc == '/')
+                cRelativePaths++;
+            pszSrc = strchr(pszSrc, '|');
+            if (!pszSrc)
+                break;
+            pszSrc++;
+            cPattern++;
+        }
+        pSettings->paPairs[iPair].fMultiPattern = cPattern > 1;
+        if (cRelativePaths > 0)
+        {
+            char *pszNewPattern = RTStrAlloc(cchPattern + cRelativePaths * (cchDir - 1) + 1);
+            if (pszNewPattern)
+            {
+                char *pszDst = pszNewPattern;
+                pszSrc = pSettings->paPairs[iPair].pszPattern;
+                for (;;)
+                {
+                    if (*pszSrc == '/')
+                    {
+                        memcpy(pszDst, pchDir, cchDir);
+                        pszDst += cchDir;
+                        pszSrc += 1;
+                    }
+
+                    /* Look for the next relative path. */
+                    const char *pszSrcNext = strchr(pszSrc, '|');
+                    while (pszSrcNext && pszSrcNext[1] != '/')
+                        pszSrcNext = strchr(pszSrcNext, '|');
+                    if (!pszSrcNext)
+                        break;
+
+                    /* Copy stuff between current and the next path. */
+                    pszSrcNext++;
+                    memcpy(pszDst, pszSrc, pszSrcNext - pszSrc);
+                    pszDst += pszSrcNext - pszSrc;
+                    pszSrc = pszSrcNext;
+                }
+
+                /* Copy the final portion and replace the pattern. */
+                strcpy(pszDst, pszSrc);
+
+                RTStrFree(pSettings->paPairs[iPair].pszPattern);
+                pSettings->paPairs[iPair].pszPattern = pszNewPattern;
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+    }
+    if (RT_SUCCESS(rc))
+        /*
+         * Commit the pair.
+         */
+        pSettings->cPairs = iPair + 1;
+    else
+    {
+        RTStrFree(pSettings->paPairs[iPair].pszPattern);
+        RTStrFree(pSettings->paPairs[iPair].pszOptions);
+        RTStrFree(pSettings->paPairs[iPair].pszRelativeTo);
+    }
+    return rc;
+}
+
+/**
+ * Loads in the settings from @a pszFilename.
+ *
+ * @returns IPRT status code.
+ * @param   pSettings           Where to load the settings file.
+ * @param   pszFilename         The file to load.
+ */
+static int scmSettingsLoadFile(PSCMSETTINGS pSettings, const char *pszFilename)
+{
+    ScmVerbose(NULL, 3, "Loading settings file '%s'...\n", pszFilename);
+
+    /* Turn filename into an absolute path and drop the filename. */
+    char szAbsPath[RTPATH_MAX];
+    int rc = RTPathAbs(pszFilename, szAbsPath, sizeof(szAbsPath));
+    if (RT_FAILURE(rc))
+    {
+        RTMsgError("%s: RTPathAbs -> %Rrc\n", pszFilename, rc);
+        return rc;
+    }
+    RTPathChangeToUnixSlashes(szAbsPath, true);
+    size_t cchDir = RTPathFilename(szAbsPath) - &szAbsPath[0];
+
+    /* Try open it.*/
+    SCMSTREAM Stream;
+    rc = ScmStreamInitForReading(&Stream, pszFilename);
+    if (RT_SUCCESS(rc))
+    {
+        SCMEOL      enmEol;
+        const char *pchLine;
+        size_t      cchLine;
+        while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
+        {
+            /* Ignore leading spaces. */
+            while (cchLine > 0 && RT_C_IS_SPACE(*pchLine))
+                pchLine++, cchLine--;
+
+            /* Ignore empty lines and comment lines. */
+            if (cchLine < 1 || *pchLine == '#')
+                continue;
+
+            /* Deal with escaped newlines. */
+            size_t  iFirstLine  = ~(size_t)0;
+            char   *pszFreeLine = NULL;
+            if (   pchLine[cchLine - 1] == '\\'
+                && (   cchLine < 2
+                    || pchLine[cchLine - 2] != '\\') )
+            {
+                iFirstLine = ScmStreamTellLine(&Stream);
+
+                cchLine--;
+                while (cchLine > 0 && RT_C_IS_SPACE(pchLine[cchLine - 1]))
+                    cchLine--;
+
+                size_t cchTotal = cchLine;
+                pszFreeLine = RTStrDupN(pchLine, cchLine);
+                if (pszFreeLine)
+                {
+                    /* Append following lines. */
+                    while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
+                    {
+                        while (cchLine > 0 && RT_C_IS_SPACE(*pchLine))
+                            pchLine++, cchLine--;
+
+                        bool const fDone = cchLine == 0
+                                        || pchLine[cchLine - 1] != '\\'
+                                        || (cchLine >= 2 && pchLine[cchLine - 2] == '\\');
+                        if (!fDone)
+                        {
+                            cchLine--;
+                            while (cchLine > 0 && RT_C_IS_SPACE(pchLine[cchLine - 1]))
+                                cchLine--;
+                        }
+
+                        rc = RTStrRealloc(&pszFreeLine, cchTotal + 1 + cchLine + 1);
+                        if (RT_FAILURE(rc))
+                            break;
+                        pszFreeLine[cchTotal++] = ' ';
+                        memcpy(&pszFreeLine[cchTotal], pchLine, cchLine);
+                        cchTotal += cchLine;
+                        pszFreeLine[cchTotal] = '\0';
+
+                        if (fDone)
+                            break;
+                    }
+                }
+                else
+                    rc = VERR_NO_STR_MEMORY;
+
+                if (RT_FAILURE(rc))
+                {
+                    RTStrFree(pszFreeLine);
+                    rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: Ran out of memory deal with escaped newlines", pszFilename);
+                    break;
+                }
+
+                pchLine = pszFreeLine;
+                cchLine = cchTotal;
+            }
+
+            /* What kind of line is it? */
+            const char *pchColon = (const char *)memchr(pchLine, ':', cchLine);
+            if (pchColon)
+                rc = scmSettingsAddPair(pSettings, pchLine, cchLine, pchColon - pchLine, szAbsPath, cchDir);
+            else
+                rc = scmSettingsBaseParseStringN(&pSettings->Base, pchLine, cchLine, szAbsPath, cchDir);
+            if (pszFreeLine)
+                RTStrFree(pszFreeLine);
+            if (RT_FAILURE(rc))
+            {
+                RTMsgError("%s:%d: %Rrc\n",
+                           pszFilename, iFirstLine == ~(size_t)0 ? ScmStreamTellLine(&Stream) : iFirstLine, rc);
+                break;
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            rc = ScmStreamGetStatus(&Stream);
+            if (RT_FAILURE(rc))
+                RTMsgError("%s: ScmStreamGetStatus- > %Rrc\n", pszFilename, rc);
+        }
+        ScmStreamDelete(&Stream);
+    }
+    else
+        RTMsgError("%s: ScmStreamInitForReading -> %Rrc\n", pszFilename, rc);
+    return rc;
+}
+
+#if 0 /* unused */
+/**
+ * Parse the specified settings file creating a new settings struct from it.
+ *
+ * @returns IPRT status code
+ * @param   ppSettings          Where to return the new settings.
+ * @param   pszFilename         The file to parse.
+ * @param   pSettingsBase       The base settings we inherit from.
+ */
+static int scmSettingsCreateFromFile(PSCMSETTINGS *ppSettings, const char *pszFilename, PCSCMSETTINGSBASE pSettingsBase)
+{
+    PSCMSETTINGS pSettings;
+    int rc = scmSettingsCreate(&pSettings, pSettingsBase);
+    if (RT_SUCCESS(rc))
+    {
+        rc = scmSettingsLoadFile(pSettings, pszFilename, RTPathFilename(pszFilename) - pszFilename);
+        if (RT_SUCCESS(rc))
+        {
+            *ppSettings = pSettings;
+            return VINF_SUCCESS;
+        }
+
+        scmSettingsDestroy(pSettings);
+    }
+    *ppSettings = NULL;
+    return rc;
+}
+#endif
+
+
+/**
+ * Create an initial settings structure when starting processing a new file or
+ * directory.
+ *
+ * This will look for .scm-settings files from the root and down to the
+ * specified directory, combining them into the returned settings structure.
+ *
+ * @returns IPRT status code.
+ * @param   ppSettings          Where to return the pointer to the top stack
+ *                              object.
+ * @param   pBaseSettings       The base settings we inherit from (globals
+ *                              typically).
+ * @param   pszPath             The absolute path to the new directory or file.
+ */
+static int scmSettingsCreateForPath(PSCMSETTINGS *ppSettings, PCSCMSETTINGSBASE pBaseSettings, const char *pszPath)
+{
+    *ppSettings = NULL;                 /* try shut up gcc. */
+
+    /*
+     * We'll be working with a stack copy of the path.
+     */
+    char    szFile[RTPATH_MAX];
+    size_t  cchDir = strlen(pszPath);
+    if (cchDir >= sizeof(szFile) - sizeof(SCM_SETTINGS_FILENAME))
+        return VERR_FILENAME_TOO_LONG;
+
+    /*
+     * Create the bottom-most settings.
+     */
+    PSCMSETTINGS pSettings;
+    int rc = scmSettingsCreate(&pSettings, pBaseSettings);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Enumerate the path components from the root and down. Load any setting
+     * files we find.
+     */
+    size_t cComponents = RTPathCountComponents(pszPath);
+    for (size_t i = 1; i <= cComponents; i++)
+    {
+        rc = RTPathCopyComponents(szFile, sizeof(szFile), pszPath, i);
+        if (RT_SUCCESS(rc))
+            rc = RTPathAppend(szFile, sizeof(szFile), SCM_SETTINGS_FILENAME);
+        if (RT_FAILURE(rc))
+            break;
+        RTPathChangeToUnixSlashes(szFile, true);
+
+        if (RTFileExists(szFile))
+        {
+            rc = scmSettingsLoadFile(pSettings, szFile);
+            if (RT_FAILURE(rc))
+                break;
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+        *ppSettings = pSettings;
+    else
+        scmSettingsDestroy(pSettings);
+    return rc;
+}
+
+/**
+ * Pushes a new settings set onto the stack.
+ *
+ * @param   ppSettingsStack     The pointer to the pointer to the top stack
+ *                              element.  This will be used as input and output.
+ * @param   pSettings           The settings to push onto the stack.
+ */
+static void scmSettingsStackPush(PSCMSETTINGS *ppSettingsStack, PSCMSETTINGS pSettings)
+{
+    PSCMSETTINGS pOld = *ppSettingsStack;
+    pSettings->pDown  = pOld;
+    pSettings->pUp    = NULL;
+    if (pOld)
+        pOld->pUp = pSettings;
+    *ppSettingsStack = pSettings;
+}
+
+/**
+ * Pushes the settings of the specified directory onto the stack.
+ *
+ * We will load any .scm-settings in the directory.  A stack entry is added even
+ * if no settings file was found.
+ *
+ * @returns IPRT status code.
+ * @param   ppSettingsStack     The pointer to the pointer to the top stack
+ *                              element.  This will be used as input and output.
+ * @param   pszDir              The directory to do this for.
+ */
+static int scmSettingsStackPushDir(PSCMSETTINGS *ppSettingsStack, const char *pszDir)
+{
+    char szFile[RTPATH_MAX];
+    int rc = RTPathJoin(szFile, sizeof(szFile), pszDir, SCM_SETTINGS_FILENAME);
+    if (RT_SUCCESS(rc))
+    {
+        RTPathChangeToUnixSlashes(szFile, true);
+
+        PSCMSETTINGS pSettings;
+        rc = scmSettingsCreate(&pSettings, &(*ppSettingsStack)->Base);
+        if (RT_SUCCESS(rc))
+        {
+            if (RTFileExists(szFile))
+                rc = scmSettingsLoadFile(pSettings, szFile);
+            if (RT_SUCCESS(rc))
+            {
+                scmSettingsStackPush(ppSettingsStack, pSettings);
+                return VINF_SUCCESS;
+            }
+
+            scmSettingsDestroy(pSettings);
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * Pops a settings set off the stack.
+ *
+ * @returns The popped settings.
+ * @param   ppSettingsStack     The pointer to the pointer to the top stack
+ *                              element.  This will be used as input and output.
+ */
+static PSCMSETTINGS scmSettingsStackPop(PSCMSETTINGS *ppSettingsStack)
+{
+    PSCMSETTINGS pRet = *ppSettingsStack;
+    PSCMSETTINGS pNew = pRet ? pRet->pDown : NULL;
+    *ppSettingsStack = pNew;
+    if (pNew)
+        pNew->pUp    = NULL;
+    if (pRet)
+    {
+        pRet->pUp    = NULL;
+        pRet->pDown  = NULL;
+    }
+    return pRet;
+}
+
+/**
+ * Pops and destroys the top entry of the stack.
+ *
+ * @param   ppSettingsStack     The pointer to the pointer to the top stack
+ *                              element.  This will be used as input and output.
+ */
+static void scmSettingsStackPopAndDestroy(PSCMSETTINGS *ppSettingsStack)
+{
+    scmSettingsDestroy(scmSettingsStackPop(ppSettingsStack));
+}
+
+/**
+ * Constructs the base settings for the specified file name.
+ *
+ * @returns IPRT status code.
+ * @param   pSettingsStack      The top element on the settings stack.
+ * @param   pszFilename         The file name.
+ * @param   pszBasename         The base name (pointer within @a pszFilename).
+ * @param   cchBasename         The length of the base name.  (For passing to
+ *                              RTStrSimplePatternMultiMatch.)
+ * @param   pBase               Base settings to initialize.
+ */
+static int scmSettingsStackMakeFileBase(PCSCMSETTINGS pSettingsStack, const char *pszFilename,
+                                        const char *pszBasename, size_t cchBasename, PSCMSETTINGSBASE pBase)
+{
+    ScmVerbose(NULL, 5, "scmSettingsStackMakeFileBase(%s, %.*s)\n", pszFilename, cchBasename, pszBasename);
+
+    int rc = scmSettingsBaseInitAndCopy(pBase, &pSettingsStack->Base);
+    if (RT_SUCCESS(rc))
+    {
+        /* find the bottom entry in the stack. */
+        PCSCMSETTINGS pCur = pSettingsStack;
+        while (pCur->pDown)
+            pCur = pCur->pDown;
+
+        /* Work our way up thru the stack and look for matching pairs. */
+        while (pCur)
+        {
+            size_t const cPairs = pCur->cPairs;
+            if (cPairs)
+            {
+                for (size_t i = 0; i < cPairs; i++)
+                    if (   !pCur->paPairs[i].fMultiPattern
+                        ?    RTStrSimplePatternNMatch(pCur->paPairs[i].pszPattern, RTSTR_MAX,
+                                                      pszBasename,  cchBasename)
+                          || RTStrSimplePatternMatch(pCur->paPairs[i].pszPattern, pszFilename)
+                        :    RTStrSimplePatternMultiMatch(pCur->paPairs[i].pszPattern, RTSTR_MAX,
+                                                          pszBasename,  cchBasename, NULL)
+                          || RTStrSimplePatternMultiMatch(pCur->paPairs[i].pszPattern, RTSTR_MAX,
+                                                          pszFilename,  RTSTR_MAX, NULL))
+                    {
+                        ScmVerbose(NULL, 5, "scmSettingsStackMakeFileBase: Matched '%s' : '%s'\n",
+                                   pCur->paPairs[i].pszPattern, pCur->paPairs[i].pszOptions);
+                        rc = scmSettingsBaseParseString(pBase, pCur->paPairs[i].pszOptions,
+                                                        pCur->paPairs[i].pszRelativeTo, strlen(pCur->paPairs[i].pszRelativeTo));
+                        if (RT_FAILURE(rc))
+                            break;
+                    }
+                if (RT_FAILURE(rc))
+                    break;
+            }
+
+            /* advance */
+            pCur = pCur->pUp;
+        }
+    }
+    if (RT_FAILURE(rc))
+        scmSettingsBaseDelete(pBase);
+    return rc;
+}
+
+
+/* -=-=-=-=-=- misc -=-=-=-=-=- */
+
+
+/**
+ * Prints the per file banner needed and the message level is high enough.
+ *
+ * @param   pState              The rewrite state.
+ * @param   iLevel              The required verbosity level.
+ */
+void ScmVerboseBanner(PSCMRWSTATE pState, int iLevel)
+{
+    if (iLevel <= g_iVerbosity && !pState->fFirst)
+    {
+        RTPrintf("%s: info: --= Rewriting '%s' =--\n", g_szProgName, pState->pszFilename);
+        pState->fFirst = true;
+    }
+}
+
+
+/**
+ * Prints a verbose message if the level is high enough.
+ *
+ * @param   pState              The rewrite state.  Optional.
+ * @param   iLevel              The required verbosity level.
+ * @param   pszFormat           The message format string.  Can be NULL if we
+ *                              only want to trigger the per file message.
+ * @param   ...                 Format arguments.
+ */
+void ScmVerbose(PSCMRWSTATE pState, int iLevel, const char *pszFormat, ...)
+{
+    if (iLevel <= g_iVerbosity)
+    {
+        if (pState && !pState->fFirst)
+        {
+            RTPrintf("%s: info: --= Rewriting '%s' =--\n", g_szProgName, pState->pszFilename);
+            pState->fFirst = true;
+        }
+        RTPrintf(pState
+                 ? "%s: info:   "
+                 : "%s: info: ",
+                 g_szProgName);
+        va_list va;
+        va_start(va, pszFormat);
+        RTPrintfV(pszFormat, va);
+        va_end(va);
+    }
+}
+
+
+/**
+ * Prints an error message.
+ *
+ * @returns kScmUnmodified
+ * @param   pState              The rewrite state.  Optional.
+ * @param   rc                  The error code.
+ * @param   pszFormat           The message format string.
+ * @param   ...                 Format arguments.
+ */
+SCMREWRITERRES ScmError(PSCMRWSTATE pState, int rc, const char *pszFormat, ...)
+{
+    if (RT_SUCCESS(pState->rc))
+        pState->rc = rc;
+
+    if (!pState->fFirst)
+    {
+        RTPrintf("%s: info: --= Rewriting '%s' =--\n", g_szProgName, pState->pszFilename);
+        pState->fFirst = true;
+    }
+    va_list va;
+    va_start(va, pszFormat);
+    RTPrintf("%s: error: %s: %N", g_szProgName, pState->pszFilename, pszFormat, &va);
+    va_end(va);
+
+    return kScmUnmodified;
+}
+
+
+/**
+ * Prints message indicating that something requires manual fixing.
+ *
+ * @returns false
+ * @param   pState              The rewrite state.  Optional.
+ * @param   rc                  The error code.
+ * @param   pszFormat           The message format string.
+ * @param   ...                 Format arguments.
+ */
+bool ScmFixManually(PSCMRWSTATE pState, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    ScmFixManuallyV(pState, pszFormat, va);
+    va_end(va);
+    return false;
+}
+
+
+/**
+ * Prints message indicating that something requires manual fixing.
+ *
+ * @returns false
+ * @param   pState              The rewrite state.  Optional.
+ * @param   rc                  The error code.
+ * @param   pszFormat           The message format string.
+ * @param   va                  Format arguments.
+ */
+bool ScmFixManuallyV(PSCMRWSTATE pState, const char *pszFormat, va_list va)
+{
+    pState->fNeedsManualRepair = true;
+
+    if (!pState->fFirst)
+    {
+        RTPrintf("%s: info: --= Rewriting '%s' =--\n", g_szProgName, pState->pszFilename);
+        pState->fFirst = true;
+    }
+    va_list vaCopy;
+    va_copy(vaCopy, va);
+    RTPrintf("%s: error/fixme: %s: %N", g_szProgName, pState->pszFilename, pszFormat, &vaCopy);
+    va_end(vaCopy);
+
+    return false;
+}
+
+
+/* -=-=-=-=-=- file and directory processing -=-=-=-=-=- */
+
+
+/**
+ * Processes a file.
+ *
+ * @returns IPRT status code.
+ * @param   pState              The rewriter state.
+ * @param   pszFilename         The file name.
+ * @param   pszBasename         The base name (pointer within @a pszFilename).
+ * @param   cchBasename         The length of the base name.  (For passing to
+ *                              RTStrSimplePatternMultiMatch.)
+ * @param   pBaseSettings       The base settings to use.  It's OK to modify
+ *                              these.
+ */
+static int scmProcessFileInner(PSCMRWSTATE pState, const char *pszFilename, const char *pszBasename, size_t cchBasename,
+                               PSCMSETTINGSBASE pBaseSettings)
+{
+    /*
+     * Do the file level filtering.
+     */
+    if (   pBaseSettings->pszFilterFiles
+        && *pBaseSettings->pszFilterFiles
+        && !RTStrSimplePatternMultiMatch(pBaseSettings->pszFilterFiles, RTSTR_MAX, pszBasename, cchBasename, NULL))
+    {
+        ScmVerbose(NULL, 5, "skipping '%s': file filter mismatch\n", pszFilename);
+        g_cFilesSkipped++;
+        return VINF_SUCCESS;
+    }
+    if (   pBaseSettings->pszFilterOutFiles
+        && *pBaseSettings->pszFilterOutFiles
+        && (   RTStrSimplePatternMultiMatch(pBaseSettings->pszFilterOutFiles, RTSTR_MAX, pszBasename, cchBasename, NULL)
+            || RTStrSimplePatternMultiMatch(pBaseSettings->pszFilterOutFiles, RTSTR_MAX, pszFilename, RTSTR_MAX, NULL)) )
+    {
+        ScmVerbose(NULL, 5, "skipping '%s': filterd out\n", pszFilename);
+        g_cFilesSkipped++;
+        return VINF_SUCCESS;
+    }
+    if (   pBaseSettings->fOnlySvnFiles
+        && !ScmSvnIsInWorkingCopy(pState))
+    {
+        ScmVerbose(NULL, 5, "skipping '%s': not in SVN WC\n", pszFilename);
+        g_cFilesNotInSvn++;
+        return VINF_SUCCESS;
+    }
+
+    /*
+     * Create an input stream from the file and check that it's text.
+     */
+    SCMSTREAM Stream1;
+    int rc = ScmStreamInitForReading(&Stream1, pszFilename);
+    if (RT_FAILURE(rc))
+    {
+        RTMsgError("Failed to read '%s': %Rrc\n", pszFilename, rc);
+        return rc;
+    }
+    bool const fIsText = ScmStreamIsText(&Stream1);
+
+    /*
+     * Try find a matching rewrite config for this filename.
+     */
+    PCSCMCFGENTRY pCfg = pBaseSettings->pTreatAs;
+    if (!pCfg)
+    {
+        for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+            if (RTStrSimplePatternMultiMatch(g_aConfigs[iCfg].pszFilePattern, RTSTR_MAX, pszBasename, cchBasename, NULL))
+            {
+                pCfg = &g_aConfigs[iCfg];
+                break;
+            }
+        if (!pCfg)
+        {
+            /* On failure try check for hash-bang stuff before giving up. */
+            if (fIsText)
+            {
+                SCMEOL      enmIgn;
+                size_t      cchFirst;
+                const char *pchFirst = ScmStreamGetLine(&Stream1, &cchFirst, &enmIgn);
+                if (cchFirst >= 9 && pchFirst && *pchFirst == '#')
+                {
+                    do
+                    {
+                        pchFirst++;
+                        cchFirst--;
+                    } while (cchFirst > 0 && RT_C_IS_BLANK(*pchFirst));
+                    if (*pchFirst == '!')
+                    {
+                        do
+                        {
+                            pchFirst++;
+                            cchFirst--;
+                        } while (cchFirst > 0 && RT_C_IS_BLANK(*pchFirst));
+                        const char *pszTreatAs = NULL;
+                        if (   (cchFirst >= 7 && strncmp(pchFirst, "/bin/sh", 7) == 0)
+                            || (cchFirst >= 9 && strncmp(pchFirst, "/bin/bash", 9) == 0)
+                            || (cchFirst >= 4+9 && strncmp(pchFirst, "/usr/bin/bash", 4+9) == 0) )
+                            pszTreatAs = "shell";
+                        else if (   (cchFirst >= 15 && strncmp(pchFirst, "/usr/bin/python", 15) == 0)
+                                 || (cchFirst >= 19 && strncmp(pchFirst, "/usr/bin/env python", 19) == 0) )
+                            pszTreatAs = "python";
+                        else if (   (cchFirst >= 13 && strncmp(pchFirst, "/usr/bin/perl", 13) == 0)
+                                 || (cchFirst >= 17 && strncmp(pchFirst, "/usr/bin/env perl", 17) == 0) )
+                            pszTreatAs = "perl";
+                        if (pszTreatAs)
+                        {
+                            for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+                                if (strcmp(pszTreatAs, g_aConfigs[iCfg].pszName) == 0)
+                                {
+                                    pCfg = &g_aConfigs[iCfg];
+                                    break;
+                                }
+                            Assert(pCfg);
+                        }
+                    }
+                }
+                ScmStreamRewindForReading(&Stream1);
+            }
+            if (!pCfg)
+            {
+                ScmVerbose(NULL, 2, "skipping '%s': no rewriters configured\n", pszFilename);
+                g_cFilesNoRewriters++;
+                ScmStreamDelete(&Stream1);
+                return VINF_SUCCESS;
+            }
+        }
+        ScmVerbose(pState, 4, "matched \"%s\" (%s)\n", pCfg->pszFilePattern, pCfg->pszName);
+    }
+    else
+        ScmVerbose(pState, 4, "treat-as \"%s\"\n", pCfg->pszName);
+
+    if (fIsText || pCfg->fBinary)
+    {
+        ScmVerboseBanner(pState, 3);
+
+        /*
+         * Gather SCM and editor settings from the stream.
+         */
+        rc = scmSettingsBaseLoadFromDocument(pBaseSettings, &Stream1);
+        if (RT_SUCCESS(rc))
+        {
+            ScmStreamRewindForReading(&Stream1);
+
+            /*
+             * Create two more streams for output and push the text thru all the
+             * rewriters, switching the two streams around when something is
+             * actually rewritten.  Stream1 remains unchanged.
+             */
+            SCMSTREAM Stream2;
+            rc = ScmStreamInitForWriting(&Stream2, &Stream1);
+            if (RT_SUCCESS(rc))
+            {
+                SCMSTREAM Stream3;
+                rc = ScmStreamInitForWriting(&Stream3, &Stream1);
+                if (RT_SUCCESS(rc))
+                {
+                    bool        fModified = false;
+                    PSCMSTREAM  pIn       = &Stream1;
+                    PSCMSTREAM  pOut      = &Stream2;
+                    for (size_t iRw = 0; iRw < pCfg->cRewriters; iRw++)
+                    {
+                        pState->rc = VINF_SUCCESS;
+                        SCMREWRITERRES enmRes = pCfg->paRewriters[iRw]->pfnRewriter(pState, pIn, pOut, pBaseSettings);
+                        if (RT_FAILURE(pState->rc))
+                            break;
+                        if (enmRes == kScmMaybeModified)
+                            enmRes = ScmStreamAreIdentical(pIn, pOut) ? kScmUnmodified : kScmModified;
+                        if (enmRes == kScmModified)
+                        {
+                            PSCMSTREAM pTmp = pOut;
+                            pOut = pIn == &Stream1 ? &Stream3 : pIn;
+                            pIn  = pTmp;
+                            fModified = true;
+                        }
+
+                        ScmStreamRewindForReading(pIn);
+                        ScmStreamRewindForWriting(pOut);
+                    }
+
+                    rc = pState->rc;
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = ScmStreamGetStatus(&Stream1);
+                        if (RT_SUCCESS(rc))
+                            rc = ScmStreamGetStatus(&Stream2);
+                        if (RT_SUCCESS(rc))
+                            rc = ScmStreamGetStatus(&Stream3);
+                        if (RT_SUCCESS(rc))
+                        {
+                            /*
+                             * If rewritten, write it back to disk.
+                             */
+                            if (fModified && !pCfg->fBinary)
+                            {
+                                if (!g_fDryRun)
+                                {
+                                    ScmVerbose(pState, 1, "writing modified file to \"%s%s\"\n", pszFilename, g_pszChangedSuff);
+                                    rc = ScmStreamWriteToFile(pIn, "%s%s", pszFilename, g_pszChangedSuff);
+                                    if (RT_FAILURE(rc))
+                                        RTMsgError("Error writing '%s%s': %Rrc\n", pszFilename, g_pszChangedSuff, rc);
+                                }
+                                else
+                                {
+                                    ScmVerboseBanner(pState, 1);
+                                    ScmDiffStreams(pszFilename, &Stream1, pIn, g_fDiffIgnoreEol,
+                                                   g_fDiffIgnoreLeadingWS, g_fDiffIgnoreTrailingWS, g_fDiffSpecialChars,
+                                                   pBaseSettings->cchTab, g_pStdOut);
+                                    ScmVerbose(pState, 2, "would have modified the file \"%s%s\"\n",
+                                               pszFilename, g_pszChangedSuff);
+                                }
+                                g_cFilesModified++;
+                            }
+                            else if (fModified)
+                                rc = RTMsgErrorRc(VERR_INTERNAL_ERROR, "Rewriters modified binary file! Impossible!");
+
+                            /*
+                             * If pending SVN property changes, apply them.
+                             */
+                            if (pState->cSvnPropChanges && RT_SUCCESS(rc))
+                            {
+                                if (!g_fDryRun)
+                                {
+                                    rc = ScmSvnApplyChanges(pState);
+                                    if (RT_FAILURE(rc))
+                                        RTMsgError("%s: failed to apply SVN property changes (%Rrc)\n", pszFilename, rc);
+                                }
+                                else
+                                    ScmSvnDisplayChanges(pState);
+                                if (!fModified)
+                                    g_cFilesModified++;
+                            }
+
+                            if (!fModified && !pState->cSvnPropChanges)
+                                ScmVerbose(pState, 3, "%s: no change\n", pszFilename);
+                        }
+                        else
+                            RTMsgError("%s: stream error %Rrc\n", pszFilename, rc);
+                    }
+                    ScmStreamDelete(&Stream3);
+                }
+                else
+                    RTMsgError("Failed to init stream for writing: %Rrc\n", rc);
+                ScmStreamDelete(&Stream2);
+            }
+            else
+                RTMsgError("Failed to init stream for writing: %Rrc\n", rc);
+        }
+        else
+            RTMsgError("scmSettingsBaseLoadFromDocument: %Rrc\n", rc);
+    }
+    else
+    {
+        ScmVerbose(pState, 2, "not text file: \"%s\"\n", pszFilename);
+        g_cFilesBinaries++;
+    }
+    ScmStreamDelete(&Stream1);
+
+    return rc;
+}
+
+/**
+ * Processes a file.
+ *
+ * This is just a wrapper for scmProcessFileInner for avoid wasting stack in the
+ * directory recursion method.
+ *
+ * @returns IPRT status code.
+ * @param   pszFilename         The file name.
+ * @param   pszBasename         The base name (pointer within @a pszFilename).
+ * @param   cchBasename         The length of the base name.  (For passing to
+ *                              RTStrSimplePatternMultiMatch.)
+ * @param   pSettingsStack      The settings stack (pointer to the top element).
+ */
+static int scmProcessFile(const char *pszFilename, const char *pszBasename, size_t cchBasename,
+                          PSCMSETTINGS pSettingsStack)
+{
+    SCMSETTINGSBASE Base;
+    int rc = scmSettingsStackMakeFileBase(pSettingsStack, pszFilename, pszBasename, cchBasename, &Base);
+    if (RT_SUCCESS(rc))
+    {
+        SCMRWSTATE State;
+        State.pszFilename           = pszFilename;
+        State.fFirst                = false;
+        State.fNeedsManualRepair    = false;
+        State.fIsInSvnWorkingCopy   = 0;
+        State.cSvnPropChanges       = 0;
+        State.paSvnPropChanges      = NULL;
+        State.rc                    = VINF_SUCCESS;
+
+        rc = scmProcessFileInner(&State, pszFilename, pszBasename, cchBasename, &Base);
+
+        size_t i = State.cSvnPropChanges;
+        while (i-- > 0)
+        {
+            RTStrFree(State.paSvnPropChanges[i].pszName);
+            RTStrFree(State.paSvnPropChanges[i].pszValue);
+        }
+        RTMemFree(State.paSvnPropChanges);
+
+        scmSettingsBaseDelete(&Base);
+
+        if (State.fNeedsManualRepair)
+            g_cFilesRequiringManualFixing++;
+        g_cFilesProcessed++;
+    }
+    return rc;
+}
+
+/**
+ * Tries to correct RTDIRENTRY_UNKNOWN.
+ *
+ * @returns Corrected type.
+ * @param   pszPath             The path to the object in question.
+ */
+static RTDIRENTRYTYPE scmFigureUnknownType(const char *pszPath)
+{
+    RTFSOBJINFO Info;
+    int rc = RTPathQueryInfo(pszPath, &Info, RTFSOBJATTRADD_NOTHING);
+    if (RT_FAILURE(rc))
+        return RTDIRENTRYTYPE_UNKNOWN;
+    if (RTFS_IS_DIRECTORY(Info.Attr.fMode))
+        return RTDIRENTRYTYPE_DIRECTORY;
+    if (RTFS_IS_FILE(Info.Attr.fMode))
+        return RTDIRENTRYTYPE_FILE;
+    return RTDIRENTRYTYPE_UNKNOWN;
+}
+
+/**
+ * Recurse into a sub-directory and process all the files and directories.
+ *
+ * @returns IPRT status code.
+ * @param   pszBuf              Path buffer containing the directory path on
+ *                              entry.  This ends with a dot.  This is passed
+ *                              along when recursing in order to save stack space
+ *                              and avoid needless copying.
+ * @param   cchDir              Length of our path in pszbuf.
+ * @param   pEntry              Directory entry buffer.  This is also passed
+ *                              along when recursing to save stack space.
+ * @param   pSettingsStack      The settings stack (pointer to the top element).
+ * @param   iRecursion          The recursion depth.  This is used to restrict
+ *                              the recursions.
+ */
+static int scmProcessDirTreeRecursion(char *pszBuf, size_t cchDir, PRTDIRENTRY pEntry,
+                                      PSCMSETTINGS pSettingsStack, unsigned iRecursion)
+{
+    int rc;
+    Assert(cchDir > 1 && pszBuf[cchDir - 1] == '.');
+
+    /*
+     * Make sure we stop somewhere.
+     */
+    if (iRecursion > 128)
+    {
+        RTMsgError("recursion too deep: %d\n", iRecursion);
+        return VINF_SUCCESS; /* ignore */
+    }
+
+    /*
+     * Check if it's excluded by --only-svn-dir.
+     */
+    if (pSettingsStack->Base.fOnlySvnDirs)
+    {
+        if (!ScmSvnIsDirInWorkingCopy(pszBuf))
+            return VINF_SUCCESS;
+    }
+    g_cDirsProcessed++;
+
+    /*
+     * Try open and read the directory.
+     */
+    RTDIR hDir;
+    rc = RTDirOpenFiltered(&hDir, pszBuf, RTDIRFILTER_NONE, 0 /*fFlags*/);
+    if (RT_FAILURE(rc))
+    {
+        RTMsgError("Failed to enumerate directory '%s': %Rrc", pszBuf, rc);
+        return rc;
+    }
+    for (;;)
+    {
+        /* Read the next entry. */
+        rc = RTDirRead(hDir, pEntry, NULL);
+        if (RT_FAILURE(rc))
+        {
+            if (rc == VERR_NO_MORE_FILES)
+                rc = VINF_SUCCESS;
+            else
+                RTMsgError("RTDirRead -> %Rrc\n", rc);
+            break;
+        }
+
+        /* Skip '.' and '..'. */
+        if (    pEntry->szName[0] == '.'
+            &&  (   pEntry->cbName == 1
+                 || (   pEntry->cbName == 2
+                     && pEntry->szName[1] == '.')))
+            continue;
+
+        /* Enter it into the buffer so we've got a full name to work
+           with when needed. */
+        if (pEntry->cbName + cchDir >= RTPATH_MAX)
+        {
+            RTMsgError("Skipping too long entry: %s", pEntry->szName);
+            continue;
+        }
+        memcpy(&pszBuf[cchDir - 1], pEntry->szName, pEntry->cbName + 1);
+
+        /* Figure the type. */
+        RTDIRENTRYTYPE enmType = pEntry->enmType;
+        if (enmType == RTDIRENTRYTYPE_UNKNOWN)
+            enmType = scmFigureUnknownType(pszBuf);
+
+        /* Process the file or directory, skip the rest. */
+        if (enmType == RTDIRENTRYTYPE_FILE)
+            rc = scmProcessFile(pszBuf, pEntry->szName, pEntry->cbName, pSettingsStack);
+        else if (enmType == RTDIRENTRYTYPE_DIRECTORY)
+        {
+            /* Append the dot for the benefit of the pattern matching. */
+            if (pEntry->cbName + cchDir + 5 >= RTPATH_MAX)
+            {
+                RTMsgError("Skipping too deep dir entry: %s", pEntry->szName);
+                continue;
+            }
+            memcpy(&pszBuf[cchDir - 1 + pEntry->cbName], "/.", sizeof("/."));
+            size_t cchSubDir = cchDir - 1 + pEntry->cbName + sizeof("/.") - 1;
+
+            if (   !pSettingsStack->Base.pszFilterOutDirs
+                || !*pSettingsStack->Base.pszFilterOutDirs
+                || (   !RTStrSimplePatternMultiMatch(pSettingsStack->Base.pszFilterOutDirs, RTSTR_MAX,
+                                                     pEntry->szName, pEntry->cbName, NULL)
+                    && !RTStrSimplePatternMultiMatch(pSettingsStack->Base.pszFilterOutDirs, RTSTR_MAX,
+                                                     pszBuf, cchSubDir, NULL)
+                   )
+               )
+            {
+                rc = scmSettingsStackPushDir(&pSettingsStack, pszBuf);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = scmProcessDirTreeRecursion(pszBuf, cchSubDir, pEntry, pSettingsStack, iRecursion + 1);
+                    scmSettingsStackPopAndDestroy(&pSettingsStack);
+                }
+            }
+        }
+        if (RT_FAILURE(rc))
+            break;
+    }
+    RTDirClose(hDir);
+    return rc;
+
+}
+
+/**
+ * Process a directory tree.
+ *
+ * @returns IPRT status code.
+ * @param   pszDir              The directory to start with.  This is pointer to
+ *                              a RTPATH_MAX sized buffer.
+ */
+static int scmProcessDirTree(char *pszDir, PSCMSETTINGS pSettingsStack)
+{
+    /*
+     * Setup the recursion.
+     */
+    int rc = RTPathAppend(pszDir, RTPATH_MAX, ".");
+    if (RT_SUCCESS(rc))
+    {
+        RTPathChangeToUnixSlashes(pszDir, true);
+
+        RTDIRENTRY Entry;
+        rc = scmProcessDirTreeRecursion(pszDir, strlen(pszDir), &Entry, pSettingsStack, 0);
+    }
+    else
+        RTMsgError("RTPathAppend: %Rrc\n", rc);
+    return rc;
+}
+
+
+/**
+ * Processes a file or directory specified as an command line argument.
+ *
+ * @returns IPRT status code
+ * @param   pszSomething        What we found in the command line arguments.
+ * @param   pSettingsStack      The settings stack (pointer to the top element).
+ */
+static int scmProcessSomething(const char *pszSomething, PSCMSETTINGS pSettingsStack)
+{
+    char szBuf[RTPATH_MAX];
+    int rc = RTPathAbs(pszSomething, szBuf, sizeof(szBuf));
+    if (RT_SUCCESS(rc))
+    {
+        RTPathChangeToUnixSlashes(szBuf, false /*fForce*/);
+
+        PSCMSETTINGS pSettings;
+        rc = scmSettingsCreateForPath(&pSettings, &pSettingsStack->Base, szBuf);
+        if (RT_SUCCESS(rc))
+        {
+            scmSettingsStackPush(&pSettingsStack, pSettings);
+
+            if (RTFileExists(szBuf))
+            {
+                const char *pszBasename = RTPathFilename(szBuf);
+                if (pszBasename)
+                {
+                    size_t cchBasename = strlen(pszBasename);
+                    rc = scmProcessFile(szBuf, pszBasename, cchBasename, pSettingsStack);
+                }
+                else
+                {
+                    RTMsgError("RTPathFilename: NULL\n");
+                    rc = VERR_IS_A_DIRECTORY;
+                }
+            }
+            else
+                rc = scmProcessDirTree(szBuf, pSettingsStack);
+
+            PSCMSETTINGS pPopped = scmSettingsStackPop(&pSettingsStack);
+            Assert(pPopped == pSettings); RT_NOREF_PV(pPopped);
+            scmSettingsDestroy(pSettings);
+        }
+        else
+            RTMsgError("scmSettingsInitStack: %Rrc\n", rc);
+    }
+    else
+        RTMsgError("RTPathAbs: %Rrc\n", rc);
+    return rc;
+}
+
+/**
+ * Print some stats.
+ */
+static void scmPrintStats(void)
+{
+    ScmVerbose(NULL, 0,
+               g_fDryRun
+               ? "%u out of %u file%s in %u dir%s would be modified (%u without rewriter%s, %u binar%s, %u not in svn, %u skipped)\n"
+               : "%u out of %u file%s in %u dir%s was modified (%u without rewriter%s, %u binar%s, %u not in svn, %u skipped)\n",
+               g_cFilesModified,
+               g_cFilesProcessed, g_cFilesProcessed == 1 ? "" : "s",
+               g_cDirsProcessed,  g_cDirsProcessed == 1 ? "" : "s",
+               g_cFilesNoRewriters, g_cFilesNoRewriters == 1 ? "" : "s",
+               g_cFilesBinaries,  g_cFilesBinaries == 1 ? "y" : "ies",
+               g_cFilesNotInSvn, g_cFilesSkipped);
+}
+
+/**
+ * Display the rewriter actions.
+ *
+ * @returns RTEXITCODE_SUCCESS.
+ */
+static int scmHelpActions(void)
+{
+    RTPrintf("Available rewriter actions:\n");
+    for (uint32_t i = 0; i < RT_ELEMENTS(g_papRewriterActions); i++)
+        RTPrintf("  %s\n", g_papRewriterActions[i]->pszName);
+    return RTEXITCODE_SUCCESS;
+}
+
+/**
+ * Display the default configuration.
+ *
+ * @returns RTEXITCODE_SUCCESS.
+ */
+static int scmHelpConfig(void)
+{
+    RTPrintf("Rewriter configuration:\n");
+    for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+    {
+        RTPrintf("\n  %s%s - %s:\n",
+                 g_aConfigs[iCfg].pszName, g_aConfigs[iCfg].fBinary ? " (binary)" : "", g_aConfigs[iCfg].pszFilePattern);
+        for (size_t i = 0; i < g_aConfigs[iCfg].cRewriters; i++)
+            RTPrintf("    %s\n", g_aConfigs[iCfg].paRewriters[i]->pszName);
+    }
+    return RTEXITCODE_SUCCESS;
+}
+
+/**
+ * Display the primary help text.
+ *
+ * @returns RTEXITCODE_SUCCESS.
+ * @param   paOpts              Options.
+ * @param   cOpts               Number of options.
+ */
+static int scmHelp(PCRTGETOPTDEF paOpts, size_t cOpts)
+{
+    RTPrintf("VirtualBox Source Code Massager\n"
+             "\n"
+             "Usage: %s [options] <files & dirs>\n"
+             "\n"
+             "General options:\n", g_szProgName);
+    for (size_t i = 0; i < cOpts; i++)
+    {
+        /* Grouping. */
+        switch (paOpts[i].iShort)
+        {
+            case SCMOPT_DIFF_IGNORE_EOL:
+                RTPrintf("\nDiff options (dry runs):\n");
+                break;
+            case SCMOPT_CONVERT_EOL:
+                RTPrintf("\nRewriter action options:\n");
+                break;
+            case SCMOPT_ONLY_SVN_DIRS:
+                RTPrintf("\nInput selection options:\n");
+                break;
+            case SCMOPT_TREAT_AS:
+                RTPrintf("\nMisc options:\n");
+                break;
+        }
+
+        size_t cExtraAdvance = 0;
+        if ((paOpts[i].fFlags & RTGETOPT_REQ_MASK) == RTGETOPT_REQ_NOTHING)
+        {
+            cExtraAdvance = i + 1 < cOpts
+                         && (   strstr(paOpts[i+1].pszLong, "-no-") != NULL
+                             || strstr(paOpts[i+1].pszLong, "-not-") != NULL
+                             || strstr(paOpts[i+1].pszLong, "-dont-") != NULL
+                             || strstr(paOpts[i+1].pszLong, "-unrestricted-") != NULL
+                             || (paOpts[i].iShort == 'q' && paOpts[i+1].iShort == 'v')
+                             || (paOpts[i].iShort == 'd' && paOpts[i+1].iShort == 'D')
+                            );
+            if (cExtraAdvance)
+                RTPrintf("  %s, %s\n", paOpts[i].pszLong, paOpts[i + 1].pszLong);
+            else if (paOpts[i].iShort != SCMOPT_NO_UPDATE_LICENSE)
+                RTPrintf("  %s\n", paOpts[i].pszLong);
+            else
+            {
+                RTPrintf("  %s,\n"
+                         "  %s,\n"
+                         "  %s,\n"
+                         "  %s,\n"
+                         "  %s,\n"
+                         "  %s,\n"
+                         "  %s\n",
+                         paOpts[i].pszLong,
+                         paOpts[i + 1].pszLong,
+                         paOpts[i + 2].pszLong,
+                         paOpts[i + 3].pszLong,
+                         paOpts[i + 4].pszLong,
+                         paOpts[i + 5].pszLong,
+                         paOpts[i + 6].pszLong);
+                cExtraAdvance = 6;
+            }
+        }
+        else if ((paOpts[i].fFlags & RTGETOPT_REQ_MASK) == RTGETOPT_REQ_STRING)
+            switch (paOpts[i].iShort)
+            {
+                case SCMOPT_DEL_ACTION:
+                    RTPrintf("  %s pattern\n", paOpts[i].pszLong);
+                    break;
+                case SCMOPT_FILTER_OUT_DIRS:
+                case SCMOPT_FILTER_FILES:
+                case SCMOPT_FILTER_OUT_FILES:
+                    RTPrintf("  %s multi-pattern\n", paOpts[i].pszLong);
+                    break;
+                default:
+                    RTPrintf("  %s string\n", paOpts[i].pszLong);
+            }
+        else
+            RTPrintf("  %s value\n", paOpts[i].pszLong);
+        switch (paOpts[i].iShort)
+        {
+            case 'd':
+            case 'D':                           RTPrintf("      Default: --dry-run\n"); break;
+            case SCMOPT_CHECK_RUN:              RTPrintf("      Default: --dry-run\n"); break;
+            case 'f':                           RTPrintf("      Default: none\n"); break;
+            case 'q':
+            case 'v':                           RTPrintf("      Default: -vv\n"); break;
+            case SCMOPT_HELP_CONFIG:            RTPrintf("      Shows the standard file rewriter configurations.\n"); break;
+            case SCMOPT_HELP_ACTIONS:           RTPrintf("      Shows the available rewriter actions.\n"); break;
+
+            case SCMOPT_DIFF_IGNORE_EOL:        RTPrintf("      Default: false\n"); break;
+            case SCMOPT_DIFF_IGNORE_SPACE:      RTPrintf("      Default: false\n"); break;
+            case SCMOPT_DIFF_IGNORE_LEADING_SPACE:  RTPrintf("      Default: false\n"); break;
+            case SCMOPT_DIFF_IGNORE_TRAILING_SPACE: RTPrintf("      Default: false\n"); break;
+            case SCMOPT_DIFF_SPECIAL_CHARS:     RTPrintf("      Default: true\n"); break;
+
+            case SCMOPT_CONVERT_EOL:            RTPrintf("      Default: %RTbool\n", g_Defaults.fConvertEol); break;
+            case SCMOPT_CONVERT_TABS:           RTPrintf("      Default: %RTbool\n", g_Defaults.fConvertTabs); break;
+            case SCMOPT_FORCE_FINAL_EOL:        RTPrintf("      Default: %RTbool\n", g_Defaults.fForceFinalEol); break;
+            case SCMOPT_FORCE_TRAILING_LINE:    RTPrintf("      Default: %RTbool\n", g_Defaults.fForceTrailingLine); break;
+            case SCMOPT_STRIP_TRAILING_BLANKS:  RTPrintf("      Default: %RTbool\n", g_Defaults.fStripTrailingBlanks); break;
+            case SCMOPT_STRIP_TRAILING_LINES:   RTPrintf("      Default: %RTbool\n", g_Defaults.fStripTrailingLines); break;
+            case SCMOPT_FIX_FLOWER_BOX_MARKERS: RTPrintf("      Default: %RTbool\n", g_Defaults.fFixFlowerBoxMarkers); break;
+            case SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS: RTPrintf("      Default: %u\n", g_Defaults.cMinBlankLinesBeforeFlowerBoxMakers); break;
+
+            case SCMOPT_FIX_HEADER_GUARDS:
+                RTPrintf("      Fix header guards and #pragma once.  Default: %RTbool\n", g_Defaults.fFixHeaderGuards);
+                break;
+            case SCMOPT_PRAGMA_ONCE:
+                RTPrintf("      Whether to include #pragma once with the header guard.  Default: %RTbool\n", g_Defaults.fPragmaOnce);
+                break;
+            case SCMOPT_FIX_HEADER_GUARD_ENDIF:
+                RTPrintf("      Whether to fix the #endif of a header guard.  Default: %RTbool\n", g_Defaults.fFixHeaderGuardEndif);
+                break;
+            case SCMOPT_ENDIF_GUARD_COMMENT:
+                RTPrintf("      Put a comment on the header guard #endif or not.  Default: %RTbool\n", g_Defaults.fEndifGuardComment);
+                break;
+            case SCMOPT_GUARD_RELATIVE_TO_DIR:
+                RTPrintf("      Header guard should be normalized relative to given dir.\n"
+                         "      When relative to settings files, no preceeding slash.\n"
+                         "      Header relative directory specification: {dir} and {parent}\n"
+                         "      If empty no normalization takes place.  Default: '%s'\n", g_Defaults.pszGuardRelativeToDir);
+                break;
+            case SCMOPT_GUARD_PREFIX:
+                RTPrintf("      Prefix to use with --guard-relative-to-dir.  Default: %s\n", g_Defaults.pszGuardPrefix);
+                break;
+            case SCMOPT_FIX_TODOS:
+                RTPrintf("      Fix @todo statements so doxygen sees them.  Default: %RTbool\n", g_Defaults.fFixTodos);
+                break;
+            case SCMOPT_FIX_ERR_H:
+                RTPrintf("      Fix err.h/errcore.h usage.  Default: %RTbool\n", g_Defaults.fFixErrH);
+                break;
+            case SCMOPT_ONLY_GUEST_HOST_PAGE:
+                RTPrintf("      No PAGE_SIZE, PAGE_SHIFT or PAGE_OFFSET_MASK allowed, must have\n"
+                         "      GUEST_ or HOST_ prefix.  Also forbids use of PAGE_BASE_MASK,\n"
+                         "      PAGE_BASE_HC_MASK, PAGE_BASE_GC_MASK, PAGE_ADDRESS,\n"
+                         "      PHYS_PAGE_ADDRESS.  Default: %RTbool\n", g_Defaults.fOnlyGuestHostPage);
+                break;
+            case SCMOPT_NO_ASM_MEM_PAGE_USE:
+                RTPrintf("      No ASMMemIsZeroPage or ASMMemZeroPage allowed, must instead use\n"
+                         "      ASMMemIsZero and RT_BZERO with appropriate page size.  Default: %RTbool\n",
+                         g_Defaults.fNoASMMemPageUse);
+                break;
+            case SCMOPT_NO_RC_USE:
+                RTPrintf("      No rc declaration allowed, must instead use\n"
+                         "      vrc for IPRT status codes and hrc for COM status codes.  Default: %RTbool\n",
+                         g_Defaults.fOnlyHrcVrcInsteadOfRc);
+                break;
+            case SCMOPT_STANDARIZE_KMK:
+                RTPrintf("      Clean up kmk files (the makefile-kmk action).  Default: %RTbool\n", g_Defaults.fStandarizeKmk);
+                break;
+            case SCMOPT_UPDATE_COPYRIGHT_YEAR:
+                RTPrintf("      Update the copyright year.  Default: %RTbool\n", g_Defaults.fUpdateCopyrightYear);
+                break;
+            case SCMOPT_EXTERNAL_COPYRIGHT:
+                RTPrintf("      Only external copyright holders.  Default: %RTbool\n", g_Defaults.fExternalCopyright);
+                break;
+            case SCMOPT_NO_UPDATE_LICENSE:
+                RTPrintf("      License selection.  Default: --license-ose-gpl\n");
+                break;
+
+            case SCMOPT_LGPL_DISCLAIMER:
+                RTPrintf("      Include LGPL version disclaimer.  Default: --no-lgpl-disclaimer\n");
+                break;
+
+            case SCMOPT_SET_SVN_EOL:            RTPrintf("      Default: %RTbool\n", g_Defaults.fSetSvnEol); break;
+            case SCMOPT_SET_SVN_EXECUTABLE:     RTPrintf("      Default: %RTbool\n", g_Defaults.fSetSvnExecutable); break;
+            case SCMOPT_SET_SVN_KEYWORDS:       RTPrintf("      Default: %RTbool\n", g_Defaults.fSetSvnKeywords); break;
+            case SCMOPT_SKIP_SVN_SYNC_PROCESS:  RTPrintf("      Default: %RTbool\n", g_Defaults.fSkipSvnSyncProcess); break;
+            case SCMOPT_SKIP_UNICODE_CHECKS:    RTPrintf("      Default: %RTbool\n", g_Defaults.fSkipUnicodeChecks); break;
+            case SCMOPT_TAB_SIZE:               RTPrintf("      Default: %u\n", g_Defaults.cchTab); break;
+            case SCMOPT_WIDTH:                  RTPrintf("      Default: %u\n", g_Defaults.cchWidth); break;
+
+            case SCMOPT_ONLY_SVN_DIRS:          RTPrintf("      Default: %RTbool\n", g_Defaults.fOnlySvnDirs); break;
+            case SCMOPT_ONLY_SVN_FILES:         RTPrintf("      Default: %RTbool\n", g_Defaults.fOnlySvnFiles); break;
+            case SCMOPT_FILTER_OUT_DIRS:        RTPrintf("      Default: %s\n", g_Defaults.pszFilterOutDirs); break;
+            case SCMOPT_FILTER_FILES:           RTPrintf("      Default: %s\n", g_Defaults.pszFilterFiles); break;
+            case SCMOPT_FILTER_OUT_FILES:       RTPrintf("      Default: %s\n", g_Defaults.pszFilterOutFiles); break;
+
+            case SCMOPT_TREAT_AS:
+                RTPrintf("      For treat the input file(s) differently, restting any --add-action.\n"
+                         "      If the value is empty defaults will be used again.  Possible values:\n");
+                for (size_t iCfg = 0; iCfg < RT_ELEMENTS(g_aConfigs); iCfg++)
+                    RTPrintf("          %s (%s)\n", g_aConfigs[iCfg].pszName, g_aConfigs[iCfg].pszFilePattern);
+                break;
+
+            case SCMOPT_ADD_ACTION:
+                RTPrintf("      Adds a rewriter action.  The first use after a --treat-as will copy and\n"
+                         "      the action list selected by the --treat-as.  The action list will be\n"
+                         "      flushed by --treat-as.\n");
+                break;
+
+            case SCMOPT_DEL_ACTION:
+                RTPrintf("      Deletes one or more rewriter action (pattern). Best used after\n"
+                         "      a --treat-as.\n");
+                break;
+
+            default: AssertMsgFailed(("i=%d %d %s\n", i, paOpts[i].iShort, paOpts[i].pszLong));
+        }
+        i += cExtraAdvance;
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
+int main(int argc, char **argv)
+{
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_FAILURE(rc))
+        return 1;
+
+    /*
+     * Init the current year.
+     */
+    RTTIMESPEC  Now;
+    RTTIME      Time;
+    RTTimeExplode(&Time, RTTimeNow(&Now));
+    g_uYear = Time.i32Year;
+
+    /*
+     * Init the settings.
+     */
+    PSCMSETTINGS pSettings;
+    rc = scmSettingsCreate(&pSettings, &g_Defaults);
+    if (RT_FAILURE(rc))
+    {
+        RTMsgError("scmSettingsCreate: %Rrc\n", rc);
+        return 1;
+    }
+
+    /*
+     * Parse arguments and process input in order (because this is the only
+     * thing that works at the moment).
+     */
+    static RTGETOPTDEF s_aOpts[14 + RT_ELEMENTS(g_aScmOpts)] =
+    {
+        { "--dry-run",                          'd',                                    RTGETOPT_REQ_NOTHING },
+        { "--real-run",                         'D',                                    RTGETOPT_REQ_NOTHING },
+        { "--check-run",                        SCMOPT_CHECK_RUN,                       RTGETOPT_REQ_NOTHING },
+        { "--file-filter",                      'f',                                    RTGETOPT_REQ_STRING  },
+        { "--quiet",                            'q',                                    RTGETOPT_REQ_NOTHING },
+        { "--verbose",                          'v',                                    RTGETOPT_REQ_NOTHING },
+        { "--diff-ignore-eol",                  SCMOPT_DIFF_IGNORE_EOL,                 RTGETOPT_REQ_NOTHING },
+        { "--diff-no-ignore-eol",               SCMOPT_DIFF_NO_IGNORE_EOL,              RTGETOPT_REQ_NOTHING },
+        { "--diff-ignore-space",                SCMOPT_DIFF_IGNORE_SPACE,               RTGETOPT_REQ_NOTHING },
+        { "--diff-no-ignore-space",             SCMOPT_DIFF_NO_IGNORE_SPACE,            RTGETOPT_REQ_NOTHING },
+        { "--diff-ignore-leading-space",        SCMOPT_DIFF_IGNORE_LEADING_SPACE,       RTGETOPT_REQ_NOTHING },
+        { "--diff-no-ignore-leading-space",     SCMOPT_DIFF_NO_IGNORE_LEADING_SPACE,    RTGETOPT_REQ_NOTHING },
+        { "--diff-ignore-trailing-space",       SCMOPT_DIFF_IGNORE_TRAILING_SPACE,      RTGETOPT_REQ_NOTHING },
+        { "--diff-no-ignore-trailing-space",    SCMOPT_DIFF_NO_IGNORE_TRAILING_SPACE,   RTGETOPT_REQ_NOTHING },
+        { "--diff-special-chars",               SCMOPT_DIFF_SPECIAL_CHARS,              RTGETOPT_REQ_NOTHING },
+        { "--diff-no-special-chars",            SCMOPT_DIFF_NO_SPECIAL_CHARS,           RTGETOPT_REQ_NOTHING },
+    };
+    memcpy(&s_aOpts[RT_ELEMENTS(s_aOpts) - RT_ELEMENTS(g_aScmOpts)], &g_aScmOpts[0], sizeof(g_aScmOpts));
+
+    bool            fCheckRun = false;
+    RTGETOPTUNION   ValueUnion;
+    RTGETOPTSTATE   GetOptState;
+    rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
+    AssertReleaseRCReturn(rc, 1);
+
+    while (   (rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0
+           && rc != VINF_GETOPT_NOT_OPTION)
+    {
+        switch (rc)
+        {
+            case 'd':
+                g_fDryRun = true;
+                fCheckRun = false;
+                break;
+            case 'D':
+                g_fDryRun = fCheckRun = false;
+                break;
+            case SCMOPT_CHECK_RUN:
+                g_fDryRun = fCheckRun = true;
+                break;
+
+            case 'f':
+                g_pszFileFilter = ValueUnion.psz;
+                break;
+
+            case 'h':
+                return scmHelp(s_aOpts, RT_ELEMENTS(s_aOpts));
+
+            case SCMOPT_HELP_CONFIG:
+                return scmHelpConfig();
+
+            case SCMOPT_HELP_ACTIONS:
+                return scmHelpActions();
+
+            case 'q':
+                g_iVerbosity = 0;
+                break;
+
+            case 'v':
+                g_iVerbosity++;
+                break;
+
+            case 'V':
+            {
+                /* The following is assuming that svn does it's job here. */
+                static const char s_szRev[] = "$Revision: 155710 $";
+                const char *psz = RTStrStripL(strchr(s_szRev, ' '));
+                RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
+                return 0;
+            }
+
+            case SCMOPT_DIFF_IGNORE_EOL:
+                g_fDiffIgnoreEol = true;
+                break;
+            case SCMOPT_DIFF_NO_IGNORE_EOL:
+                g_fDiffIgnoreEol = false;
+                break;
+
+            case SCMOPT_DIFF_IGNORE_SPACE:
+                g_fDiffIgnoreTrailingWS = g_fDiffIgnoreLeadingWS = true;
+                break;
+            case SCMOPT_DIFF_NO_IGNORE_SPACE:
+                g_fDiffIgnoreTrailingWS = g_fDiffIgnoreLeadingWS = false;
+                break;
+
+            case SCMOPT_DIFF_IGNORE_LEADING_SPACE:
+                g_fDiffIgnoreLeadingWS = true;
+                break;
+            case SCMOPT_DIFF_NO_IGNORE_LEADING_SPACE:
+                g_fDiffIgnoreLeadingWS = false;
+                break;
+
+            case SCMOPT_DIFF_IGNORE_TRAILING_SPACE:
+                g_fDiffIgnoreTrailingWS = true;
+                break;
+            case SCMOPT_DIFF_NO_IGNORE_TRAILING_SPACE:
+                g_fDiffIgnoreTrailingWS = false;
+                break;
+
+            case SCMOPT_DIFF_SPECIAL_CHARS:
+                g_fDiffSpecialChars = true;
+                break;
+            case SCMOPT_DIFF_NO_SPECIAL_CHARS:
+                g_fDiffSpecialChars = false;
+                break;
+
+            default:
+            {
+                int rc2 = scmSettingsBaseHandleOpt(&pSettings->Base, rc, &ValueUnion, "/", 1);
+                if (RT_SUCCESS(rc2))
+                    break;
+                if (rc2 != VERR_GETOPT_UNKNOWN_OPTION)
+                    return 2;
+                return RTGetOptPrintError(rc, &ValueUnion);
+            }
+        }
+    }
+
+    /*
+     * Process non-options.
+     */
+    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
+    if (rc == VINF_GETOPT_NOT_OPTION)
+    {
+        ScmSvnInit();
+
+        bool fWarned = g_fDryRun;
+        while (rc == VINF_GETOPT_NOT_OPTION)
+        {
+            if (!fWarned)
+            {
+                RTPrintf("%s: Warning! This program will make changes to your source files and\n"
+                         "%s:          there is a slight risk that bugs or a full disk may cause\n"
+                         "%s:          LOSS OF DATA.   So, please make sure you have checked in\n"
+                         "%s:          all your changes already.  If you didn't, then don't blame\n"
+                         "%s:          anyone for not warning you!\n"
+                         "%s:\n"
+                         "%s:          Press any key to continue...\n",
+                         g_szProgName, g_szProgName, g_szProgName, g_szProgName, g_szProgName,
+                         g_szProgName, g_szProgName);
+                RTStrmGetCh(g_pStdIn);
+                fWarned = true;
+            }
+
+            rc = scmProcessSomething(ValueUnion.psz, pSettings);
+            if (RT_FAILURE(rc))
+            {
+                rcExit = RTEXITCODE_FAILURE;
+                break;
+            }
+
+            /* next */
+            rc = RTGetOpt(&GetOptState, &ValueUnion);
+            if (RT_FAILURE(rc))
+                rcExit = RTGetOptPrintError(rc, &ValueUnion);
+        }
+
+        scmPrintStats();
+        ScmSvnTerm();
+    }
+    else
+        RTMsgWarning("No files or directories specified. Doing nothing");
+
+    scmSettingsDestroy(pSettings);
+
+    /* If we're in checking mode, fail if any files needed modification. */
+    if (   rcExit == RTEXITCODE_SUCCESS
+        && fCheckRun
+        && g_cFilesModified > 0)
+    {
+        RTMsgError("Checking mode failed! %u file%s needs modifications", g_cFilesBinaries, g_cFilesBinaries > 1 ? "s" : "");
+        rcExit = RTEXITCODE_FAILURE;
+    }
+
+    /* Fail if any files require manual repair. */
+    if (g_cFilesRequiringManualFixing > 0)
+    {
+        RTMsgError("%u file%s needs manual modifications", g_cFilesRequiringManualFixing,
+                   g_cFilesRequiringManualFixing > 1 ? "s" : "");
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = RTEXITCODE_FAILURE;
+    }
+
+    return rcExit;
+}
+
diff --git a/src/bldprogs/scm.h b/src/bldprogs/scm.h
new file mode 100644
index 00000000..76819108
--- /dev/null
+++ b/src/bldprogs/scm.h
@@ -0,0 +1,498 @@
+/* $Id: scm.h $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_bldprogs_scm_h
+#define VBOX_INCLUDED_SRC_bldprogs_scm_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "scmstream.h"
+
+RT_C_DECLS_BEGIN
+
+/** Pointer to the rewriter state. */
+typedef struct SCMRWSTATE *PSCMRWSTATE;
+/** Pointer to const massager settings. */
+typedef struct SCMSETTINGSBASE const *PCSCMSETTINGSBASE;
+
+
+/** @name Subversion Access
+ * @{  */
+
+/**
+ * SVN property.
+ */
+typedef struct SCMSVNPROP
+{
+    /** The property. */
+    char           *pszName;
+    /** The value.
+     * When used to record updates, this can be set to NULL to trigger the
+     * deletion of the property. */
+    char           *pszValue;
+} SCMSVNPROP;
+/** Pointer to a SVN property. */
+typedef SCMSVNPROP *PSCMSVNPROP;
+/** Pointer to a const  SVN property. */
+typedef SCMSVNPROP const *PCSCMSVNPROP;
+
+
+void ScmSvnInit(void);
+void ScmSvnTerm(void);
+bool ScmSvnIsDirInWorkingCopy(const char *pszDir);
+bool ScmSvnIsInWorkingCopy(PSCMRWSTATE pState);
+int  ScmSvnQueryProperty(PSCMRWSTATE pState, const char *pszName, char **ppszValue);
+int  ScmSvnQueryParentProperty(PSCMRWSTATE pState, const char *pszName, char **ppszValue);
+int  ScmSvnSetProperty(PSCMRWSTATE pState, const char *pszName, const char *pszValue);
+int  ScmSvnDelProperty(PSCMRWSTATE pState, const char *pszName);
+int  ScmSvnDisplayChanges(PSCMRWSTATE pState);
+int  ScmSvnApplyChanges(PSCMRWSTATE pState);
+
+/** @} */
+
+
+/** @name Code Parsing
+ * @{  */
+
+/**
+ * Comment style.
+ */
+typedef enum SCMCOMMENTSTYLE
+{
+    kScmCommentStyle_Invalid = 0,
+    kScmCommentStyle_C,
+    kScmCommentStyle_Hash,
+    kScmCommentStyle_Python,    /**< Same as hash, except for copyright/license. */
+    kScmCommentStyle_Semicolon,
+    kScmCommentStyle_Rem_Upper,
+    kScmCommentStyle_Rem_Lower,
+    kScmCommentStyle_Rem_Camel,
+    kScmCommentStyle_Sql,
+    kScmCommentStyle_Tick,
+    kScmCommentStyle_Xml,
+    kScmCommentStyle_End
+} SCMCOMMENTSTYLE;
+
+/**
+ * Comment types.
+ */
+typedef enum SCMCOMMENTTYPE
+{
+    kScmCommentType_Invalid = 0,                /**< Customary invalid zero value. */
+    kScmCommentType_Line,                       /**< Line comment. */
+    kScmCommentType_Line_JavaDoc,               /**< Line comment, JavaDoc style. */
+    kScmCommentType_Line_JavaDoc_After,         /**< Line comment, JavaDoc after-member style. */
+    kScmCommentType_Line_Qt,                    /**< Line comment, JavaDoc style. */
+    kScmCommentType_Line_Qt_After,              /**< Line comment, JavaDoc after-member style. */
+    kScmCommentType_MultiLine,                  /**< Multi-line comment (e.g. ansi C).  */
+    kScmCommentType_MultiLine_JavaDoc,          /**< Multi-line comment, JavaDoc style.  */
+    kScmCommentType_MultiLine_JavaDoc_After,    /**< Multi-line comment, JavaDoc after-member style.  */
+    kScmCommentType_MultiLine_Qt,               /**< Multi-line comment, Qt style.  */
+    kScmCommentType_MultiLine_Qt_After,         /**< Multi-line comment, Qt after-member style.  */
+    kScmCommentType_DocString,                  /**< Triple quoted python doc string. */
+    kScmCommentType_Xml,                        /**< XML comment style. */
+    kScmCommentType_End                         /**< Customary exclusive end value. */
+} SCMCOMMENTTYPE;
+
+
+/**
+ * Comment information.
+ */
+typedef struct SCMCOMMENTINFO
+{
+    /** Comment type. */
+    SCMCOMMENTTYPE  enmType;
+    /** Start line number  (0-based). */
+    uint32_t        iLineStart;
+    /** Start line offset (0-based). */
+    uint32_t        offStart;
+    /** End line number  (0-based). */
+    uint32_t        iLineEnd;
+    /** End line offset  (0-based). */
+    uint32_t        offEnd;
+    /** Number of blank lines before the body (@a pszBody). */
+    uint32_t        cBlankLinesBefore;
+    /** Number of blank lines after the body (@a pszBody + @a cchBody). */
+    uint32_t        cBlankLinesAfter;
+    /** @todo add min/max indent. Raw length. Etc. */
+} SCMCOMMENTINFO;
+/** Pointer to comment info. */
+typedef SCMCOMMENTINFO *PSCMCOMMENTINFO;
+/** Pointer to const comment info. */
+typedef SCMCOMMENTINFO const *PCSCMCOMMENTINFO;
+
+
+/**
+ * Comment enumeration callback function.
+ *
+ * @returns IPRT style status code.  Failures causes immediate return.  While an
+ *          informational status code is saved (first one) and returned later.
+ * @param   pInfo           Additional comment info.
+ * @param   pszBody         The comment body.  This is somewhat stripped.
+ * @param   cchBody         The comment body length.
+ * @param   pvUser          User callback argument.
+ */
+typedef DECLCALLBACKTYPE(int, FNSCMCOMMENTENUMERATOR,(PCSCMCOMMENTINFO pInfo, const char *pszBody, size_t cchBody, void *pvUser));
+/** Poiter to a omment enumeration callback function. */
+typedef FNSCMCOMMENTENUMERATOR *PFNSCMCOMMENTENUMERATOR;
+
+int ScmEnumerateComments(PSCMSTREAM pIn, SCMCOMMENTSTYLE enmCommentStyle, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser);
+
+
+/**
+ * Include directive type.
+ */
+typedef enum SCMINCLUDEDIR
+{
+    kScmIncludeDir_Invalid = 0, /**< Constomary invalid enum value. */
+    kScmIncludeDir_Quoted,      /**< \#include \"filename.h\" */
+    kScmIncludeDir_Bracketed,   /**< \#include \<filename.h\> */
+    kScmIncludeDir_Macro,       /**< \#include MACRO_H */
+    kScmIncludeDir_End          /**< End of valid enum values. */
+} SCMINCLUDEDIR;
+
+SCMINCLUDEDIR ScmMaybeParseCIncludeLine(PSCMRWSTATE pState, const char *pchLine, size_t cchLine,
+                                        const char **ppchFilename, size_t *pcchFilename);
+
+/**
+ * Checks if the given character is a valid C identifier lead character.
+ *
+ * @returns true / false.
+ * @param   ch                  The character to inspect.
+ * @sa      vbcppIsCIdentifierLeadChar
+ */
+DECLINLINE(bool) ScmIsCIdentifierLeadChar(char ch)
+{
+    return RT_C_IS_ALPHA(ch)
+        || ch == '_';
+}
+
+
+/**
+ * Checks if the given character is a valid C identifier character.
+ *
+ * @returns true / false.
+ * @param   ch                  The character to inspect.
+ * @sa      vbcppIsCIdentifierChar
+ */
+DECLINLINE(bool) ScmIsCIdentifierChar(char ch)
+{
+    return RT_C_IS_ALNUM(ch)
+        || ch == '_';
+}
+
+size_t ScmCalcSpacesForSrcSpan(const char *pchLine, size_t offStart, size_t offEnd, PCSCMSETTINGSBASE pSettings);
+
+/** @} */
+
+
+/** @name Rewriters
+ * @{ */
+
+/**
+ * Rewriter state.
+ */
+typedef struct SCMRWSTATE
+{
+    /** The filename.  */
+    const char         *pszFilename;
+    /** Set after the printing the first verbose message about a file under
+     *  rewrite. */
+    bool                fFirst;
+    /** Set if the file requires manual repair. */
+    bool                fNeedsManualRepair;
+    /** Cached ScmSvnIsInWorkingCopy response. 0 indicates not known, 1 means it
+     * is in WC, -1 means it doesn't. */
+    int8_t              fIsInSvnWorkingCopy;
+    /** The number of SVN property changes. */
+    size_t              cSvnPropChanges;
+    /** Pointer to an array of SVN property changes. */
+    struct SCMSVNPROP  *paSvnPropChanges;
+    /** For error propagation. */
+    int32_t             rc;
+} SCMRWSTATE;
+
+/** Rewriter result. */
+typedef enum { kScmUnmodified = 0, kScmModified, kScmMaybeModified } SCMREWRITERRES;
+
+/**
+ * A rewriter.
+ *
+ * This works like a stream editor, reading @a pIn, modifying it and writing it
+ * to @a pOut.
+ *
+ * @returns kScmUnmodified, kScmModified or kScmMaybeModified.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+typedef SCMREWRITERRES FNSCMREWRITER(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings);
+/** Pointer to a rewriter method. */
+typedef FNSCMREWRITER *PFNSCMREWRITER;
+
+FNSCMREWRITER rewrite_StripTrailingBlanks;
+FNSCMREWRITER rewrite_ExpandTabs;
+FNSCMREWRITER rewrite_ForceNativeEol;
+FNSCMREWRITER rewrite_ForceLF;
+FNSCMREWRITER rewrite_ForceCRLF;
+FNSCMREWRITER rewrite_AdjustTrailingLines;
+FNSCMREWRITER rewrite_SvnNoExecutable;
+FNSCMREWRITER rewrite_SvnNoKeywords;
+FNSCMREWRITER rewrite_SvnNoEolStyle;
+FNSCMREWRITER rewrite_SvnBinary;
+FNSCMREWRITER rewrite_SvnKeywords;
+FNSCMREWRITER rewrite_SvnSyncProcess;
+FNSCMREWRITER rewrite_UnicodeChecks;
+FNSCMREWRITER rewrite_PageChecks;
+FNSCMREWRITER rewrite_ForceHrcVrcInsteadOfRc;
+FNSCMREWRITER rewrite_Copyright_CstyleComment;
+FNSCMREWRITER rewrite_Copyright_HashComment;
+FNSCMREWRITER rewrite_Copyright_PythonComment;
+FNSCMREWRITER rewrite_Copyright_RemComment;
+FNSCMREWRITER rewrite_Copyright_SemicolonComment;
+FNSCMREWRITER rewrite_Copyright_SqlComment;
+FNSCMREWRITER rewrite_Copyright_TickComment;
+FNSCMREWRITER rewrite_Copyright_XmlComment;
+FNSCMREWRITER rewrite_Makefile_kup;
+FNSCMREWRITER rewrite_Makefile_kmk;
+FNSCMREWRITER rewrite_FixFlowerBoxMarkers;
+FNSCMREWRITER rewrite_Fix_C_and_CPP_Todos;
+FNSCMREWRITER rewrite_Fix_Err_H;
+FNSCMREWRITER rewrite_FixHeaderGuards;
+FNSCMREWRITER rewrite_C_and_CPP;
+
+/**
+ * Rewriter configuration.
+ */
+typedef struct SCMREWRITERCFG
+{
+    /** The rewriter function. */
+    PFNSCMREWRITER  pfnRewriter;
+    /** The name of the rewriter. */
+    const char     *pszName;
+} SCMREWRITERCFG;
+/** Pointer to a const rewriter config. */
+typedef SCMREWRITERCFG const *PCSCMREWRITERCFG;
+
+/** @}  */
+
+
+/** @name Settings
+ * @{ */
+
+/**
+ * Configuration entry.
+ */
+typedef struct SCMCFGENTRY
+{
+    /** Number of rewriters. */
+    size_t                  cRewriters;
+    /** Pointer to an array of rewriters. */
+    PCSCMREWRITERCFG const *paRewriters;
+    /** Set if the entry handles binaries.  */
+    bool                    fBinary;
+    /** File pattern (simple).  */
+    const char             *pszFilePattern;
+    /** Name (for treat as).  */
+    const char             *pszName;
+} SCMCFGENTRY;
+typedef SCMCFGENTRY *PSCMCFGENTRY;
+typedef SCMCFGENTRY const *PCSCMCFGENTRY;
+
+
+/** License update options. */
+typedef enum SCMLICENSE
+{
+    kScmLicense_LeaveAlone = 0,     /**< Leave it alone. */
+    kScmLicense_OseGpl,             /**< VBox OSE GPL if public. */
+    kScmLicense_OseDualGplCddl,     /**< VBox OSE dual GPL & CDDL if public. */
+    kScmLicense_OseCddl,            /**< VBox OSE CDDL if public. */
+    kScmLicense_Lgpl,               /**< LGPL if public. */
+    kScmLicense_Mit,                /**< MIT if public. */
+    kScmLicense_BasedOnMit,         /**< Copyright us but based on someone else's MIT. */
+    kScmLicense_End
+} SCMLICENSE;
+
+/**
+ * Source Code Massager Settings.
+ */
+typedef struct SCMSETTINGSBASE
+{
+    bool            fConvertEol;
+    bool            fConvertTabs;
+    bool            fForceFinalEol;
+    bool            fForceTrailingLine;
+    bool            fStripTrailingBlanks;
+    bool            fStripTrailingLines;
+
+    /** Whether to fix C/C++ flower box section markers. */
+    bool            fFixFlowerBoxMarkers;
+    /** The minimum number of blank lines we want before flowerbox markers. */
+    uint8_t         cMinBlankLinesBeforeFlowerBoxMakers;
+
+    /** Whether to fix C/C++ header guards and \#pragma once directives. */
+    bool            fFixHeaderGuards;
+    /** Whether to include a pragma once statement with the header guard. */
+    bool            fPragmaOnce;
+    /** Whether to fix the \#endif part of a header guard. */
+    bool            fFixHeaderGuardEndif;
+    /** Whether to add a comment on the \#endif part of the header guard. */
+    bool            fEndifGuardComment;
+    /** The guard name prefix.   */
+    char           *pszGuardPrefix;
+    /** Header guards should be normalized using prefix and this directory.
+     * When NULL the guard identifiers found in the header is preserved. */
+    char           *pszGuardRelativeToDir;
+
+    /** Whether to fix C/C++ todos. */
+    bool            fFixTodos;
+    /** Whether to fix C/C++ err.h/errcore.h usage. */
+    bool            fFixErrH;
+    /** No PAGE_SIZE, PAGE_SHIFT, PAGE_OFFSET_MASK allowed in C/C++, only the GUEST_
+     * or HOST_ prefixed versions. */
+    bool            fOnlyGuestHostPage;
+    /** No ASMMemIsZeroPage or ASMMemZeroPage calls allowed (C/C++). */
+    bool            fNoASMMemPageUse;
+    /** No rc declarations allowed, only hrc or vrc depending on the result type. */
+    bool            fOnlyHrcVrcInsteadOfRc;
+
+    /** Whether to standarize kmk makefiles. */
+    bool            fStandarizeKmk;
+
+    /** Update the copyright year. */
+    bool            fUpdateCopyrightYear;
+    /** Only external copyright holders. */
+    bool            fExternalCopyright;
+    /** Whether there should be a LGPL disclaimer. */
+    bool            fLgplDisclaimer;
+    /** How to update the license. */
+    SCMLICENSE      enmUpdateLicense;
+
+    /** Only process files that are part of a SVN working copy. */
+    bool            fOnlySvnFiles;
+    /** Only recurse into directories containing an .svn dir.  */
+    bool            fOnlySvnDirs;
+    /** Set svn:eol-style if missing or incorrect. */
+    bool            fSetSvnEol;
+    /** Set svn:executable according to type (unusually this means deleting it). */
+    bool            fSetSvnExecutable;
+    /** Set svn:keyword if completely or partially missing. */
+    bool            fSetSvnKeywords;
+    /** Skip checking svn:sync-process. */
+    bool            fSkipSvnSyncProcess;
+    /** Skip the unicode checks. */
+    bool            fSkipUnicodeChecks;
+    /** Tab size. */
+    uint8_t         cchTab;
+    /** Optimal source code width. */
+    uint8_t         cchWidth;
+    /** Free the treat as structure. */
+    bool            fFreeTreatAs;
+    /** Prematched config entry. */
+    PCSCMCFGENTRY   pTreatAs;
+    /** Only consider files matching these patterns.  This is only applied to the
+     *  base names. */
+    char           *pszFilterFiles;
+    /** Filter out files matching the following patterns.  This is applied to base
+     *  names as well as the absolute paths.  */
+    char           *pszFilterOutFiles;
+    /** Filter out directories matching the following patterns.  This is applied
+     *  to base names as well as the absolute paths.  All absolute paths ends with a
+     *  slash and dot ("/.").  */
+    char           *pszFilterOutDirs;
+} SCMSETTINGSBASE;
+/** Pointer to massager settings. */
+typedef SCMSETTINGSBASE *PSCMSETTINGSBASE;
+
+/**
+ * File/dir pattern + options.
+ */
+typedef struct SCMPATRNOPTPAIR
+{
+    char *pszPattern;
+    char *pszOptions;
+    char *pszRelativeTo;
+    bool  fMultiPattern;
+} SCMPATRNOPTPAIR;
+/** Pointer to a pattern + option pair. */
+typedef SCMPATRNOPTPAIR *PSCMPATRNOPTPAIR;
+
+
+/** Pointer to a settings set. */
+typedef struct SCMSETTINGS *PSCMSETTINGS;
+/**
+ * Settings set.
+ *
+ * This structure is constructed from the command line arguments or any
+ * .scm-settings file found in a directory we recurse into.  When recursing in
+ * and out of a directory, we push and pop a settings set for it.
+ *
+ * The .scm-settings file has two kinds of setttings, first there are the
+ * unqualified base settings and then there are the settings which applies to a
+ * set of files or directories.  The former are lines with command line options.
+ * For the latter, the options are preceded by a string pattern and a colon.
+ * The pattern specifies which files (and/or directories) the options applies
+ * to.
+ *
+ * We parse the base options into the Base member and put the others into the
+ * paPairs array.
+ */
+typedef struct SCMSETTINGS
+{
+    /** Pointer to the setting file below us in the stack. */
+    PSCMSETTINGS        pDown;
+    /** Pointer to the setting file above us in the stack. */
+    PSCMSETTINGS        pUp;
+    /** File/dir patterns and their options. */
+    PSCMPATRNOPTPAIR    paPairs;
+    /** The number of entires in paPairs. */
+    uint32_t            cPairs;
+    /** The base settings that was read out of the file. */
+    SCMSETTINGSBASE     Base;
+} SCMSETTINGS;
+/** Pointer to a const settings set. */
+typedef SCMSETTINGS const *PCSCMSETTINGS;
+
+/** @} */
+
+
+void ScmVerboseBanner(PSCMRWSTATE pState, int iLevel);
+void ScmVerbose(PSCMRWSTATE pState, int iLevel, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
+SCMREWRITERRES ScmError(PSCMRWSTATE pState, int rc, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
+bool ScmFixManually(PSCMRWSTATE pState, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3);
+bool ScmFixManuallyV(PSCMRWSTATE pState, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(2, 0);
+
+extern const char g_szTabSpaces[16+1];
+extern const char g_szAsterisks[255+1];
+extern const char g_szSpaces[255+1];
+extern uint32_t g_uYear;
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_bldprogs_scm_h */
+
diff --git a/src/bldprogs/scmdiff.cpp b/src/bldprogs/scmdiff.cpp
new file mode 100644
index 00000000..df642c4b
--- /dev/null
+++ b/src/bldprogs/scmdiff.cpp
@@ -0,0 +1,450 @@
+/* $Id: scmdiff.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/message.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scmdiff.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static const char   g_szTabSpaces[16+1]     = "                ";
+
+
+
+/**
+ * Prints a range of lines with a prefix.
+ *
+ * @param   pState              The diff state.
+ * @param   chPrefix            The prefix.
+ * @param   pStream             The stream to get the lines from.
+ * @param   iLine               The first line.
+ * @param   cLines              The number of lines.
+ */
+static void scmDiffPrintLines(PSCMDIFFSTATE pState, char chPrefix, PSCMSTREAM pStream, size_t iLine, size_t cLines)
+{
+    while (cLines-- > 0)
+    {
+        SCMEOL      enmEol;
+        size_t      cchLine;
+        const char *pchLine = ScmStreamGetLineByNo(pStream, iLine, &cchLine, &enmEol);
+
+        RTStrmPutCh(pState->pDiff, chPrefix);
+        if (pchLine && cchLine)
+        {
+            if (!pState->fSpecialChars)
+                RTStrmWrite(pState->pDiff, pchLine, cchLine);
+            else
+            {
+                size_t      offVir   = 0;
+                const char *pchStart = pchLine;
+                const char *pchTab   = (const char *)memchr(pchLine, '\t', cchLine);
+                while (pchTab)
+                {
+                    RTStrmWrite(pState->pDiff, pchStart, pchTab - pchStart);
+                    offVir += pchTab - pchStart;
+
+                    size_t cchTab = pState->cchTab - offVir % pState->cchTab;
+                    switch (cchTab)
+                    {
+                        case 1: RTStrmPutStr(pState->pDiff, "."); break;
+                        case 2: RTStrmPutStr(pState->pDiff, ".."); break;
+                        case 3: RTStrmPutStr(pState->pDiff, "[T]"); break;
+                        case 4: RTStrmPutStr(pState->pDiff, "[TA]"); break;
+                        case 5: RTStrmPutStr(pState->pDiff, "[TAB]"); break;
+                        default: RTStrmPrintf(pState->pDiff, "[TAB%.*s]", cchTab - 5, g_szTabSpaces); break;
+                    }
+                    offVir += cchTab;
+
+                    /* next */
+                    pchStart = pchTab + 1;
+                    pchTab = (const char *)memchr(pchStart, '\t', cchLine - (pchStart - pchLine));
+                }
+                size_t cchLeft = cchLine - (pchStart - pchLine);
+                if (cchLeft)
+                    RTStrmWrite(pState->pDiff, pchStart, cchLeft);
+            }
+        }
+
+        if (!pState->fSpecialChars)
+            RTStrmPutCh(pState->pDiff, '\n');
+        else if (enmEol == SCMEOL_LF)
+            RTStrmPutStr(pState->pDiff, "[LF]\n");
+        else if (enmEol == SCMEOL_CRLF)
+            RTStrmPutStr(pState->pDiff, "[CRLF]\n");
+        else
+            RTStrmPutStr(pState->pDiff, "[NONE]\n");
+
+        iLine++;
+    }
+}
+
+
+/**
+ * Reports a difference and propels the streams to the lines following the
+ * resync.
+ *
+ *
+ * @returns New pState->cDiff value (just to return something).
+ * @param   pState              The diff state.  The cDiffs member will be
+ *                              incremented.
+ * @param   cMatches            The resync length.
+ * @param   iLeft               Where the difference starts on the left side.
+ * @param   cLeft               How long it is on this side.  ~(size_t)0 is used
+ *                              to indicate that it goes all the way to the end.
+ * @param   iRight              Where the difference starts on the right side.
+ * @param   cRight              How long it is.
+ */
+static size_t scmDiffReport(PSCMDIFFSTATE pState, size_t cMatches,
+                            size_t iLeft, size_t cLeft,
+                            size_t iRight, size_t cRight)
+{
+    /*
+     * Adjust the input.
+     */
+    if (cLeft == ~(size_t)0)
+    {
+        size_t c = ScmStreamCountLines(pState->pLeft);
+        if (c >= iLeft)
+            cLeft = c - iLeft;
+        else
+        {
+            iLeft = c;
+            cLeft = 0;
+        }
+    }
+
+    if (cRight == ~(size_t)0)
+    {
+        size_t c = ScmStreamCountLines(pState->pRight);
+        if (c >= iRight)
+            cRight = c - iRight;
+        else
+        {
+            iRight = c;
+            cRight = 0;
+        }
+    }
+
+    /*
+     * Print header if it's the first difference
+     */
+    if (!pState->cDiffs)
+        RTStrmPrintf(pState->pDiff, "diff %s %s\n", pState->pszFilename, pState->pszFilename);
+
+    /*
+     * Emit the change description.
+     */
+    char ch = cLeft == 0
+            ? 'a'
+            : cRight == 0
+            ? 'd'
+            : 'c';
+    if (cLeft > 1 && cRight > 1)
+        RTStrmPrintf(pState->pDiff, "%zu,%zu%c%zu,%zu\n", iLeft + 1, iLeft + cLeft, ch, iRight + 1, iRight + cRight);
+    else if (cLeft > 1)
+        RTStrmPrintf(pState->pDiff, "%zu,%zu%c%zu\n",     iLeft + 1, iLeft + cLeft, ch, iRight + 1);
+    else if (cRight > 1)
+        RTStrmPrintf(pState->pDiff, "%zu%c%zu,%zu\n",     iLeft + 1,                ch, iRight + 1, iRight + cRight);
+    else
+        RTStrmPrintf(pState->pDiff, "%zu%c%zu\n",         iLeft + 1,                ch, iRight + 1);
+
+    /*
+     * And the lines.
+     */
+    if (cLeft)
+        scmDiffPrintLines(pState, '<', pState->pLeft, iLeft, cLeft);
+    if (cLeft && cRight)
+        RTStrmPrintf(pState->pDiff, "---\n");
+    if (cRight)
+        scmDiffPrintLines(pState, '>', pState->pRight, iRight, cRight);
+
+    /*
+     * Reposition the streams (safely ignores return value).
+     */
+    ScmStreamSeekByLine(pState->pLeft,  iLeft  + cLeft  + cMatches);
+    ScmStreamSeekByLine(pState->pRight, iRight + cRight + cMatches);
+
+    pState->cDiffs++;
+    return pState->cDiffs;
+}
+
+/**
+ * Helper for scmDiffCompare that takes care of trailing spaces and stuff
+ * like that.
+ */
+static bool scmDiffCompareSlow(PSCMDIFFSTATE pState,
+                               const char *pchLeft,  size_t cchLeft,  SCMEOL enmEolLeft,
+                               const char *pchRight, size_t cchRight, SCMEOL enmEolRight)
+{
+    if (pState->fIgnoreTrailingWhite)
+    {
+        while (cchLeft > 0 && RT_C_IS_SPACE(pchLeft[cchLeft - 1]))
+            cchLeft--;
+        while (cchRight > 0 && RT_C_IS_SPACE(pchRight[cchRight - 1]))
+            cchRight--;
+    }
+
+    if (pState->fIgnoreLeadingWhite)
+    {
+        while (cchLeft > 0 && RT_C_IS_SPACE(*pchLeft))
+            pchLeft++, cchLeft--;
+        while (cchRight > 0 && RT_C_IS_SPACE(*pchRight))
+            pchRight++, cchRight--;
+    }
+
+    if (   cchLeft != cchRight
+        || (enmEolLeft != enmEolRight && !pState->fIgnoreEol)
+        || memcmp(pchLeft, pchRight, cchLeft))
+        return false;
+    return true;
+}
+
+/**
+ * Compare two lines.
+ *
+ * @returns true if the are equal, false if not.
+ */
+DECLINLINE(bool) scmDiffCompare(PSCMDIFFSTATE pState,
+                                const char *pchLeft,  size_t cchLeft,  SCMEOL enmEolLeft,
+                                const char *pchRight, size_t cchRight, SCMEOL enmEolRight)
+{
+    if (   cchLeft != cchRight
+        || (enmEolLeft != enmEolRight && !pState->fIgnoreEol)
+        || memcmp(pchLeft, pchRight, cchLeft))
+    {
+        if (   pState->fIgnoreTrailingWhite
+            || pState->fIgnoreLeadingWhite)
+            return scmDiffCompareSlow(pState,
+                                      pchLeft, cchLeft, enmEolLeft,
+                                      pchRight, cchRight, enmEolRight);
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Compares two sets of lines from the two files.
+ *
+ * @returns true if they matches, false if they don't.
+ * @param   pState              The diff state.
+ * @param   iLeft               Where to start in the left stream.
+ * @param   iRight              Where to start in the right stream.
+ * @param   cLines              How many lines to compare.
+ */
+static bool scmDiffCompareLines(PSCMDIFFSTATE pState, size_t iLeft, size_t iRight, size_t cLines)
+{
+    for (size_t iLine = 0; iLine < cLines; iLine++)
+    {
+        SCMEOL      enmEolLeft;
+        size_t      cchLeft;
+        const char *pchLeft  = ScmStreamGetLineByNo(pState->pLeft,  iLeft + iLine,  &cchLeft,  &enmEolLeft);
+
+        SCMEOL      enmEolRight;
+        size_t      cchRight;
+        const char *pchRight = ScmStreamGetLineByNo(pState->pRight, iRight + iLine, &cchRight, &enmEolRight);
+
+        if (!scmDiffCompare(pState, pchLeft, cchLeft, enmEolLeft, pchRight, cchRight, enmEolRight))
+            return false;
+    }
+    return true;
+}
+
+
+/**
+ * Resynchronize the two streams and reports the difference.
+ *
+ * Upon return, the streams will be positioned after the block of @a cMatches
+ * lines where it resynchronized them.
+ *
+ * @returns pState->cDiffs (just so we can use it in a return statement).
+ * @param   pState              The state.
+ * @param   cMatches            The number of lines that needs to match for the
+ *                              stream to be considered synchronized again.
+ */
+static size_t scmDiffSynchronize(PSCMDIFFSTATE pState, size_t cMatches)
+{
+    size_t const iStartLeft  = ScmStreamTellLine(pState->pLeft)  - 1;
+    size_t const iStartRight = ScmStreamTellLine(pState->pRight) - 1;
+    Assert(cMatches > 0);
+
+    /*
+     * Compare each new line from each of the streams will all the preceding
+     * ones, including iStartLeft/Right.
+     */
+    for (size_t iRange = 1; ; iRange++)
+    {
+        /*
+         * Get the next line in the left stream and compare it against all the
+         * preceding lines on the right side.
+         */
+        SCMEOL      enmEol;
+        size_t      cchLine;
+        const char *pchLine = ScmStreamGetLineByNo(pState->pLeft, iStartLeft + iRange, &cchLine, &enmEol);
+        if (!pchLine)
+            return scmDiffReport(pState, 0, iStartLeft, ~(size_t)0, iStartRight, ~(size_t)0);
+
+        for (size_t iRight = cMatches - 1; iRight < iRange; iRight++)
+        {
+            SCMEOL      enmEolRight;
+            size_t      cchRight;
+            const char *pchRight = ScmStreamGetLineByNo(pState->pRight, iStartRight + iRight,
+                                                        &cchRight, &enmEolRight);
+            if (   scmDiffCompare(pState, pchLine, cchLine, enmEol, pchRight, cchRight, enmEolRight)
+                && scmDiffCompareLines(pState,
+                                       iStartLeft  + iRange + 1 - cMatches,
+                                       iStartRight + iRight + 1 - cMatches,
+                                       cMatches - 1)
+               )
+                return scmDiffReport(pState, cMatches,
+                                     iStartLeft,  iRange + 1 - cMatches,
+                                     iStartRight, iRight + 1 - cMatches);
+        }
+
+        /*
+         * Get the next line in the right stream and compare it against all the
+         * lines on the right side.
+         */
+        pchLine = ScmStreamGetLineByNo(pState->pRight, iStartRight + iRange, &cchLine, &enmEol);
+        if (!pchLine)
+            return scmDiffReport(pState, 0, iStartLeft, ~(size_t)0, iStartRight, ~(size_t)0);
+
+        for (size_t iLeft = cMatches - 1; iLeft <= iRange; iLeft++)
+        {
+            SCMEOL      enmEolLeft;
+            size_t      cchLeft;
+            const char *pchLeft = ScmStreamGetLineByNo(pState->pLeft, iStartLeft + iLeft,
+                                                       &cchLeft, &enmEolLeft);
+            if (    scmDiffCompare(pState, pchLeft, cchLeft, enmEolLeft, pchLine, cchLine, enmEol)
+                && scmDiffCompareLines(pState,
+                                       iStartLeft  + iLeft  + 1 - cMatches,
+                                       iStartRight + iRange + 1 - cMatches,
+                                       cMatches - 1)
+               )
+                return scmDiffReport(pState, cMatches,
+                                     iStartLeft,  iLeft  + 1 - cMatches,
+                                     iStartRight, iRange + 1 - cMatches);
+        }
+    }
+}
+
+/**
+ * Creates a diff of the changes between the streams @a pLeft and @a pRight.
+ *
+ * This currently only implements the simplest diff format, so no contexts.
+ *
+ * Also, note that we won't detect differences in the final newline of the
+ * streams.
+ *
+ * @returns The number of differences.
+ * @param   pszFilename         The filename.
+ * @param   pLeft               The left side stream.
+ * @param   pRight              The right side stream.
+ * @param   fIgnoreEol          Whether to ignore end of line markers.
+ * @param   fIgnoreLeadingWhite Set if leading white space should be ignored.
+ * @param   fIgnoreTrailingWhite  Set if trailing white space should be ignored.
+ * @param   fSpecialChars       Whether to print special chars in a human
+ *                              readable form or not.
+ * @param   cchTab              The tab size.
+ * @param   pDiff               Where to write the diff.
+ */
+size_t ScmDiffStreams(const char *pszFilename, PSCMSTREAM pLeft, PSCMSTREAM pRight, bool fIgnoreEol,
+                      bool fIgnoreLeadingWhite, bool fIgnoreTrailingWhite, bool fSpecialChars,
+                      size_t cchTab, PRTSTREAM pDiff)
+{
+#ifdef RT_STRICT
+    ScmStreamCheckItegrity(pLeft);
+    ScmStreamCheckItegrity(pRight);
+#endif
+
+    /*
+     * Set up the diff state.
+     */
+    SCMDIFFSTATE State;
+    State.cDiffs                = 0;
+    State.pszFilename           = pszFilename;
+    State.pLeft                 = pLeft;
+    State.pRight                = pRight;
+    State.fIgnoreEol            = fIgnoreEol;
+    State.fIgnoreLeadingWhite   = fIgnoreLeadingWhite;
+    State.fIgnoreTrailingWhite  = fIgnoreTrailingWhite;
+    State.fSpecialChars         = fSpecialChars;
+    State.cchTab                = cchTab;
+    State.pDiff                 = pDiff;
+
+    /*
+     * Compare them line by line.
+     */
+    ScmStreamRewindForReading(pLeft);
+    ScmStreamRewindForReading(pRight);
+    const char *pchLeft;
+    const char *pchRight;
+
+    for (;;)
+    {
+        SCMEOL  enmEolLeft;
+        size_t  cchLeft;
+        pchLeft  = ScmStreamGetLine(pLeft,  &cchLeft,  &enmEolLeft);
+
+        SCMEOL  enmEolRight;
+        size_t  cchRight;
+        pchRight = ScmStreamGetLine(pRight, &cchRight, &enmEolRight);
+        if (!pchLeft || !pchRight)
+            break;
+
+        if (!scmDiffCompare(&State, pchLeft, cchLeft, enmEolLeft, pchRight, cchRight, enmEolRight))
+            scmDiffSynchronize(&State, 3);
+    }
+
+    /*
+     * Deal with any remaining differences.
+     */
+    if (pchLeft)
+        scmDiffReport(&State, 0, ScmStreamTellLine(pLeft) - 1, ~(size_t)0, ScmStreamTellLine(pRight), 0);
+    else if (pchRight)
+        scmDiffReport(&State, 0, ScmStreamTellLine(pLeft), 0, ScmStreamTellLine(pRight) - 1, ~(size_t)0);
+
+    /*
+     * Report any errors.
+     */
+    if (RT_FAILURE(ScmStreamGetStatus(pLeft)))
+        RTMsgError("Left diff stream error: %Rrc\n", ScmStreamGetStatus(pLeft));
+    if (RT_FAILURE(ScmStreamGetStatus(pRight)))
+        RTMsgError("Right diff stream error: %Rrc\n", ScmStreamGetStatus(pRight));
+
+    return State.cDiffs;
+}
+
diff --git a/src/bldprogs/scmdiff.h b/src/bldprogs/scmdiff.h
new file mode 100644
index 00000000..040904f7
--- /dev/null
+++ b/src/bldprogs/scmdiff.h
@@ -0,0 +1,74 @@
+/* $Id: scmdiff.h $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager Diff Code.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_bldprogs_scmdiff_h
+#define VBOX_INCLUDED_SRC_bldprogs_scmdiff_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/stream.h>
+#include "scmstream.h"
+
+RT_C_DECLS_BEGIN
+
+/**
+ * Diff state.
+ */
+typedef struct SCMDIFFSTATE
+{
+    size_t          cDiffs;
+    const char     *pszFilename;
+
+    PSCMSTREAM      pLeft;
+    PSCMSTREAM      pRight;
+
+    /** Whether to ignore end of line markers when diffing. */
+    bool            fIgnoreEol;
+    /** Whether to ignore trailing whitespace. */
+    bool            fIgnoreTrailingWhite;
+    /** Whether to ignore leading whitespace. */
+    bool            fIgnoreLeadingWhite;
+    /** Whether to print special characters in human readable form or not. */
+    bool            fSpecialChars;
+    /** The tab size. */
+    size_t          cchTab;
+    /** Where to push the diff. */
+    PRTSTREAM       pDiff;
+} SCMDIFFSTATE;
+/** Pointer to a diff state. */
+typedef SCMDIFFSTATE *PSCMDIFFSTATE;
+
+
+size_t ScmDiffStreams(const char *pszFilename, PSCMSTREAM pLeft, PSCMSTREAM pRight, bool fIgnoreEol,
+                      bool fIgnoreLeadingWhite, bool fIgnoreTrailingWhite, bool fSpecialChars,
+                      size_t cchTab, PRTSTREAM pDiff);
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_bldprogs_scmdiff_h */
+
diff --git a/src/bldprogs/scmparser.cpp b/src/bldprogs/scmparser.cpp
new file mode 100644
index 00000000..557190c5
--- /dev/null
+++ b/src/bldprogs/scmparser.cpp
@@ -0,0 +1,1199 @@
+/* $Id: scmparser.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager, Code Parsers.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/file.h>
+#include <iprt/errcore.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scm.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef size_t (*PFNISCOMMENT)(const char *pchLine, size_t cchLine, bool fSecond);
+
+
+/**
+ * Callback for checking if C++ line comment.
+ */
+static size_t isCppLineComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (   cchLine >= 2
+        && pchLine[0] == '/'
+        && pchLine[1] == '/')
+    {
+        if (!fSecond)
+            return 2;
+        if (cchLine >= 3 && pchLine[2] == '/')
+            return 3;
+    }
+    return 0;
+}
+
+
+/**
+ * Callback for checking if hash comment.
+ */
+static size_t isHashComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (cchLine >= 1 && *pchLine == '#')
+    {
+        if (!fSecond)
+            return 1;
+        if (cchLine >= 2 && pchLine[1] == '#')
+            return 2;
+    }
+    return 0;
+}
+
+
+/**
+ * Callback for checking if semicolon comment.
+ */
+static size_t isSemicolonComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (cchLine >= 1 && *pchLine == ';')
+    {
+        if (!fSecond)
+            return 1;
+        if (cchLine >= 2 && pchLine[1] == ';')
+            return 2;
+    }
+    return 0;
+}
+
+
+/** Macro for checking for a XML comment start. */
+#define IS_XML_COMMENT_START(a_pch, a_off, a_cch) \
+        (   (a_off) + 4 <= (a_cch) \
+         && (a_pch)[(a_off)    ] == '<' \
+         && (a_pch)[(a_off) + 1] == '!' \
+         && (a_pch)[(a_off) + 2] == '-' \
+         && (a_pch)[(a_off) + 3] == '-' \
+         && ((a_off) + 4 == (a_cch) || RT_C_IS_SPACE((a_pch)[(a_off) + 4])) )
+
+/** Macro for checking for a XML comment end. */
+#define IS_XML_COMMENT_END(a_pch, a_off, a_cch) \
+        (   (a_off) + 3 <= (a_cch) \
+         && (a_pch)[(a_off)    ] == '-' \
+         && (a_pch)[(a_off) + 1] == '-' \
+         && (a_pch)[(a_off) + 2] == '>')
+
+
+/** Macro for checking for a batch file comment prefix. */
+#define IS_REM(a_pch, a_off, a_cch) \
+        (   (a_off) + 3 <= (a_cch) \
+         && ((a_pch)[(a_off)    ] == 'R' || (a_pch)[(a_off)    ] == 'r') \
+         && ((a_pch)[(a_off) + 1] == 'E' || (a_pch)[(a_off) + 1] == 'e') \
+         && ((a_pch)[(a_off) + 2] == 'M' || (a_pch)[(a_off) + 2] == 'm') \
+         && ((a_off) + 3 == (a_cch) || RT_C_IS_SPACE((a_pch)[(a_off) + 3])) )
+
+
+/**
+ * Callback for checking if batch comment.
+ */
+static size_t isBatchComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (!fSecond)
+    {
+        if (IS_REM(pchLine, 0, cchLine))
+            return 3;
+    }
+    else
+    {
+        /* Check for the 2nd in "rem rem" lines. */
+        if (   cchLine >= 4
+            && RT_C_IS_SPACE(*pchLine)
+            && IS_REM(pchLine, 1, cchLine))
+            return 4;
+    }
+    return 0;
+}
+
+/**
+ * Callback for checking if SQL comment.
+ */
+static size_t isSqlComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (   cchLine >= 2
+        && pchLine[0] == '-'
+        && pchLine[1] == '-')
+    {
+        if (!fSecond)
+            return 2;
+        if (   cchLine >= 3
+            && pchLine[2] == '-')
+            return 3;
+    }
+    return 0;
+}
+
+/**
+ * Callback for checking if tick comment.
+ */
+static size_t isTickComment(const char *pchLine, size_t cchLine, bool fSecond)
+{
+    if (cchLine >= 1 && *pchLine == '\'')
+    {
+        if (!fSecond)
+            return 1;
+        if (cchLine >= 2 && pchLine[1] == '\'')
+            return 2;
+    }
+    return 0;
+}
+
+
+/**
+ * Common worker for enumeratePythonComments and enumerateSimpleLineComments.
+ *
+ * @returns IPRT status code.
+ * @param   pIn             The input stream.
+ * @param   pfnIsComment    Comment tester function.
+ * @param   pfnCallback     The callback.
+ * @param   pvUser          The user argument for the callback.
+ * @param   ppchLine        Pointer to the line variable.
+ * @param   pcchLine        Pointer to the line length variable.
+ * @param   penmEol         Pointer to the line ending type variable.
+ * @param   piLine          Pointer to the line number variable.
+ * @param   poff            Pointer to the line offset variable.  On input this
+ *                          is positioned at the start of the comment.
+ */
+static int handleLineComment(PSCMSTREAM pIn, PFNISCOMMENT pfnIsComment,
+                             PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser,
+                             const char **ppchLine, size_t *pcchLine, PSCMEOL penmEol,
+                             uint32_t *piLine, size_t *poff)
+{
+    /* Unpack input/output variables. */
+    uint32_t        iLine   = *piLine;
+    const char     *pchLine = *ppchLine;
+    size_t          cchLine = *pcchLine;
+    size_t          off     = *poff;
+    SCMEOL          enmEol  = *penmEol;
+
+    /*
+     * Take down the basic info about the comment.
+     */
+    SCMCOMMENTINFO  Info;
+    Info.iLineStart         = iLine;
+    Info.iLineEnd           = iLine;
+    Info.offStart           = (uint32_t)off;
+    Info.offEnd             = (uint32_t)cchLine;
+
+    size_t cchSkip = pfnIsComment(&pchLine[off], cchLine - off, false);
+    Assert(cchSkip > 0);
+    off += cchSkip;
+
+    /* Determine comment type. */
+    Info.enmType = kScmCommentType_Line;
+    char ch;
+    cchSkip = 1;
+    if (   off < cchLine
+        && (   (ch = pchLine[off]) == '!'
+            || (cchSkip = pfnIsComment(&pchLine[off], cchLine - off, true)) > 0) )
+    {
+        unsigned ch2;
+        if (   off + cchSkip == cchLine
+            || RT_C_IS_SPACE(ch2 = pchLine[off + cchSkip]) )
+        {
+            Info.enmType = ch != '!' ? kScmCommentType_Line_JavaDoc : kScmCommentType_Line_Qt;
+            off += cchSkip;
+        }
+        else if (   ch2 == '<'
+                 && (   off + cchSkip + 1 == cchLine
+                     || RT_C_IS_SPACE(pchLine[off + cchSkip + 1]) ))
+        {
+            Info.enmType = ch == '!' ? kScmCommentType_Line_JavaDoc_After : kScmCommentType_Line_Qt_After;
+            off += cchSkip + 1;
+        }
+    }
+
+    /*
+     * Copy body of the first line.  Like for C, we ignore a single space in the first comment line.
+     */
+    if (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
+        off++;
+    size_t cchBody = cchLine;
+    while (cchBody > off && RT_C_IS_SPACE(pchLine[cchBody - 1]))
+           cchBody--;
+    cchBody -= off;
+    size_t   cbBodyAlloc = RT_MAX(_1K, RT_ALIGN_Z(cchBody + 64, 128));
+    char    *pszBody     = (char *)RTMemAlloc(cbBodyAlloc);
+    if (!pszBody)
+        return VERR_NO_MEMORY;
+    memcpy(pszBody, &pchLine[off], cchBody);
+    pszBody[cchBody] = '\0';
+
+    Info.cBlankLinesBefore = cchBody == 0;
+
+    /*
+     * Look for more comment lines and append them to the body.
+     */
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        iLine++;
+
+        /* Skip leading spaces. */
+        off = 0;
+        while (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
+            off++;
+
+        /* Check if it's a comment. */
+        if (   off >= cchLine
+            || (cchSkip = pfnIsComment(&pchLine[off], cchLine - off, false)) == 0)
+            break;
+        off += cchSkip;
+
+        /* Split on doxygen comment start (if not already in one). */
+        if (   Info.enmType == kScmCommentType_Line
+            && off + 1 < cchLine
+            && (   pfnIsComment(&pchLine[off], cchLine - off, true) > 0
+                || (   pchLine[off + 1] == '!'
+                    && (   off + 2 == cchLine
+                        || pchLine[off + 2] != '!') ) ) )
+        {
+            off -= cchSkip;
+            break;
+        }
+
+        /* Append the body w/o trailing spaces and some leading ones. */
+        if (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
+            off++;
+        while (off < cchLine && off < Info.offStart + 3 && RT_C_IS_SPACE(pchLine[off]))
+            off++;
+        size_t cchAppend = cchLine;
+        while (cchAppend > off && RT_C_IS_SPACE(pchLine[cchAppend - 1]))
+            cchAppend--;
+        cchAppend -= off;
+
+        size_t cchNewBody = cchBody + 1 + cchAppend;
+        if (cchNewBody >= cbBodyAlloc)
+        {
+            cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
+            void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
+            if (pvNew)
+                pszBody = (char *)pvNew;
+            else
+            {
+                RTMemFree(pszBody);
+                return VERR_NO_MEMORY;
+            }
+        }
+
+        if (   cchBody > 0
+            || cchAppend > 0)
+        {
+            if (cchBody > 0)
+                pszBody[cchBody++] = '\n';
+            memcpy(&pszBody[cchBody], &pchLine[off], cchAppend);
+            cchBody += cchAppend;
+            pszBody[cchBody] = '\0';
+        }
+        else
+            Info.cBlankLinesBefore++;
+
+        /* Advance. */
+        Info.offEnd   = (uint32_t)cchLine;
+        Info.iLineEnd = iLine;
+    }
+
+    /*
+     * Strip trailing empty lines in the body.
+     */
+    Info.cBlankLinesAfter = 0;
+    while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
+    {
+        Info.cBlankLinesAfter++;
+        pszBody[--cchBody] = '\0';
+    }
+
+    /*
+     * Do the callback and return.
+     */
+    int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
+
+    RTMemFree(pszBody);
+
+    *piLine   = iLine;
+    *ppchLine = pchLine;
+    *pcchLine = cchLine;
+    *poff     = off;
+    *penmEol  = enmEol;
+    return rc;
+}
+
+
+
+/**
+ * Common string literal handler.
+ *
+ * @returns new pchLine value.
+ * @param   pIn         The input string.
+ * @param   chType      The quotation type.
+ * @param   pchLine     The current line.
+ * @param   ppchLine    Pointer to the line variable.
+ * @param   pcchLine    Pointer to the line length variable.
+ * @param   penmEol     Pointer to the line ending type variable.
+ * @param   piLine      Pointer to the line number variable.
+ * @param   poff        Pointer to the line offset variable.
+ */
+static const char *handleStringLiteral(PSCMSTREAM pIn, char chType, const char *pchLine, size_t *pcchLine, PSCMEOL penmEol,
+                                       uint32_t *piLine, size_t *poff)
+{
+    size_t off = *poff;
+    for (;;)
+    {
+        bool fEnd = false;
+        bool fEscaped = false;
+        size_t const cchLine = *pcchLine;
+        while (off < cchLine)
+        {
+            char ch = pchLine[off++];
+            if (!fEscaped)
+            {
+                if (ch != chType)
+                {
+                    if (ch != '\\')
+                    { /* likely */ }
+                    else
+                        fEscaped = true;
+                }
+                else
+                {
+                    fEnd = true;
+                    break;
+                }
+            }
+            else
+                fEscaped = false;
+        }
+        if (fEnd)
+            break;
+
+        /* next line */
+        pchLine = ScmStreamGetLine(pIn, pcchLine, penmEol);
+        if (!pchLine)
+            break;
+        *piLine += 1;
+        off = 0;
+    }
+
+    *poff = off;
+    return pchLine;
+}
+
+
+/**
+ * Deals with comments in C and C++ code.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumerateCStyleComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    AssertCompile('\'' < '/');
+    AssertCompile('"'  < '/');
+
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        size_t off = 0;
+        while (off < cchLine)
+        {
+            unsigned ch = pchLine[off++];
+            if (ch > (unsigned)'/')
+            { /* not interesting */ }
+            else if (ch == '/')
+            {
+                if (off < cchLine)
+                {
+                    ch = pchLine[off++];
+                    if (ch == '*')
+                    {
+                        /*
+                         * Multiline comment.  Find the end.
+                         *
+                         * Note! This is very similar to the python doc string handling further down.
+                         */
+                        SCMCOMMENTINFO  Info;
+                        Info.iLineStart         = iLine;
+                        Info.offStart           = (uint32_t)off - 2;
+                        Info.iLineEnd           = UINT32_MAX;
+                        Info.offEnd             = UINT32_MAX;
+                        Info.cBlankLinesBefore  = 0;
+
+                        /* Determine comment type (same as for line-comments). */
+                        Info.enmType = kScmCommentType_MultiLine;
+                        if (   off < cchLine
+                            && (   (ch = pchLine[off]) == '*'
+                                || ch == '!') )
+                        {
+                            unsigned ch2;
+                            if (   off + 1 == cchLine
+                                || RT_C_IS_SPACE(ch2 = pchLine[off + 1]) )
+                            {
+                                Info.enmType = ch == '*' ? kScmCommentType_MultiLine_JavaDoc : kScmCommentType_MultiLine_Qt;
+                                off += 1;
+                            }
+                            else if (   ch2 == '<'
+                                     && (   off + 2 == cchLine
+                                         || RT_C_IS_SPACE(pchLine[off + 2]) ))
+                            {
+                                Info.enmType = ch == '*' ? kScmCommentType_MultiLine_JavaDoc_After
+                                             : kScmCommentType_MultiLine_Qt_After;
+                                off += 2;
+                            }
+                        }
+
+                        /*
+                         * Copy the body and find the end of the multiline comment.
+                         */
+                        size_t          cbBodyAlloc = 0;
+                        size_t          cchBody     = 0;
+                        char           *pszBody     = NULL;
+                        for (;;)
+                        {
+                            /* Parse the line up to the end-of-comment or end-of-line. */
+                            size_t offLineStart     = off;
+                            size_t offLastNonBlank  = off;
+                            size_t offFirstNonBlank = ~(size_t)0;
+                            while (off < cchLine)
+                            {
+                                ch = pchLine[off++];
+                                if (ch != '*' || off >= cchLine || pchLine[off] != '/')
+                                {
+                                    if (RT_C_IS_BLANK(ch))
+                                    {/* kind of likely */}
+                                    else
+                                    {
+                                        offLastNonBlank = off - 1;
+                                        if (offFirstNonBlank != ~(size_t)0)
+                                        {/* likely */}
+                                        else if (   ch != '*'          /* ignore continuation-asterisks */
+                                                 || off > Info.offStart + 1 + 1
+                                                 || off > cchLine
+                                                 || (   off < cchLine
+                                                     && !RT_C_IS_SPACE(pchLine[off]))
+                                                 || pszBody == NULL)
+                                            offFirstNonBlank = off - 1;
+                                    }
+                                }
+                                else
+                                {
+                                    Info.offEnd   = (uint32_t)++off;
+                                    Info.iLineEnd = iLine;
+                                    break;
+                                }
+                            }
+
+                            /* Append line content to the comment body string. */
+                            size_t cchAppend;
+                            if (offFirstNonBlank == ~(size_t)0)
+                                cchAppend = 0; /* empty line */
+                            else
+                            {
+                                if (pszBody)
+                                    offLineStart = RT_MIN(Info.offStart + 3, offFirstNonBlank);
+                                else if (offFirstNonBlank > Info.offStart + 2) /* Skip one leading blank at the start of the comment. */
+                                    offLineStart++;
+                                cchAppend = offLastNonBlank + 1 - offLineStart;
+                                Assert(cchAppend <= cchLine);
+                            }
+
+                            size_t cchNewBody = cchBody + (cchBody > 0) + cchAppend;
+                            if (cchNewBody >= cbBodyAlloc)
+                            {
+                                cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
+                                void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
+                                if (pvNew)
+                                    pszBody = (char *)pvNew;
+                                else
+                                {
+                                    RTMemFree(pszBody);
+                                    return VERR_NO_MEMORY;
+                                }
+                            }
+
+                            if (cchBody > 0)                        /* no leading blank lines */
+                                pszBody[cchBody++] = '\n';
+                            else if (cchAppend == 0)
+                                Info.cBlankLinesBefore++;
+                            memcpy(&pszBody[cchBody], &pchLine[offLineStart], cchAppend);
+                            cchBody += cchAppend;
+                            pszBody[cchBody] = '\0';
+
+                            /* Advance to the next line, if we haven't yet seen the end of this comment. */
+                            if (Info.iLineEnd != UINT32_MAX)
+                                break;
+                            pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+                            if (!pchLine)
+                            {
+                                Info.offEnd   = (uint32_t)cchLine;
+                                Info.iLineEnd = iLine;
+                                break;
+                            }
+                            iLine++;
+                            off = 0;
+                        }
+
+                        /* Strip trailing empty lines in the body. */
+                        Info.cBlankLinesAfter = 0;
+                        while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
+                        {
+                            Info.cBlankLinesAfter++;
+                            pszBody[--cchBody] = '\0';
+                        }
+
+                        /* Do the callback. */
+                        int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
+                        RTMemFree(pszBody);
+                        if (RT_FAILURE(rc))
+                            return rc;
+                        if (rc > VINF_SUCCESS && rcRet == VINF_SUCCESS)
+                            rcRet = rc;
+                    }
+                    else if (ch == '/')
+                    {
+                        /*
+                         * Line comment.  Join the other line comment guys.
+                         */
+                        off -= 2;
+                        int rc = handleLineComment(pIn, isCppLineComment, pfnCallback, pvUser,
+                                                   &pchLine, &cchLine, &enmEol, &iLine, &off);
+                        if (RT_FAILURE(rc))
+                            return rc;
+                        if (rcRet == VINF_SUCCESS)
+                            rcRet = rc;
+                    }
+
+                    if (!pchLine)
+                        break;
+                }
+            }
+            else if (ch == '"')
+            {
+                /*
+                 * String literal may include sequences that looks like comments.  So,
+                 * they needs special handling to avoid confusion.
+                 */
+                pchLine = handleStringLiteral(pIn, '"', pchLine, &cchLine, &enmEol, &iLine, &off);
+            }
+            /* else: We don't have to deal with character literal as these shouldn't
+                     include comment-like sequences. */
+        } /* for each character in the line */
+
+        iLine++;
+    } /* for each line in the stream */
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Deals with comments in Python code.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumeratePythonComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    AssertCompile('#'  < '\'');
+    AssertCompile('"'  < '\'');
+
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine;
+    SCMCOMMENTINFO  Info;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        size_t off = 0;
+        while (off < cchLine)
+        {
+            char ch = pchLine[off++];
+            if ((unsigned char)ch > (unsigned char)'\'')
+            { /* not interesting */ }
+            else if (ch == '#')
+            {
+                /*
+                 * Line comment.  Join paths with the others.
+                 */
+                off -= 1;
+                int rc = handleLineComment(pIn, isHashComment, pfnCallback, pvUser,
+                                           &pchLine, &cchLine, &enmEol, &iLine, &off);
+                if (RT_FAILURE(rc))
+                    return rc;
+                if (rcRet == VINF_SUCCESS)
+                    rcRet = rc;
+
+                if (!pchLine)
+                    break;
+            }
+            else if (ch == '"' || ch == '\'')
+            {
+                /*
+                 * String literal may be doc strings and they may legally include hashes.
+                 */
+                const char chType = ch;
+                if (   off + 1 >= cchLine
+                    || pchLine[off] != chType
+                    || pchLine[off + 1] != chType)
+                    pchLine = handleStringLiteral(pIn, chType, pchLine, &cchLine, &enmEol, &iLine, &off);
+                else
+                {
+                    /*
+                     * Doc string (/ long string).
+                     *
+                     * Note! This is very similar to the multiline C comment handling above.
+                     */
+                    Info.iLineStart         = iLine;
+                    Info.offStart           = (uint32_t)off - 1;
+                    Info.iLineEnd           = UINT32_MAX;
+                    Info.offEnd             = UINT32_MAX;
+                    Info.cBlankLinesBefore  = 0;
+                    Info.enmType            = kScmCommentType_DocString;
+
+                    off += 2;
+
+                    /* Copy the body and find the end of the doc string comment. */
+                    size_t          cbBodyAlloc = 0;
+                    size_t          cchBody     = 0;
+                    char           *pszBody     = NULL;
+                    for (;;)
+                    {
+                        /* Parse the line up to the end-of-comment or end-of-line. */
+                        size_t offLineStart     = off;
+                        size_t offLastNonBlank  = off;
+                        size_t offFirstNonBlank = ~(size_t)0;
+                        bool fEscaped = false;
+                        while (off < cchLine)
+                        {
+                            ch = pchLine[off++];
+                            if (!fEscaped)
+                            {
+                                if (   off + 1 >= cchLine
+                                    || ch != chType
+                                    || pchLine[off] != chType
+                                    || pchLine[off + 1] != chType)
+                                {
+                                    if (RT_C_IS_BLANK(ch))
+                                    {/* kind of likely */}
+                                    else
+                                    {
+                                        offLastNonBlank = off - 1;
+                                        if (offFirstNonBlank != ~(size_t)0)
+                                        {/* likely */}
+                                        else if (   ch != '*'          /* ignore continuation-asterisks */
+                                                 || off > Info.offStart + 1 + 1
+                                                 || off > cchLine
+                                                 || (   off < cchLine
+                                                     && !RT_C_IS_SPACE(pchLine[off]))
+                                                 || pszBody == NULL)
+                                            offFirstNonBlank = off - 1;
+
+                                        if (ch != '\\')
+                                        {/* likely */ }
+                                        else
+                                            fEscaped = true;
+                                    }
+                                }
+                                else
+                                {
+                                    off += 2;
+                                    Info.offEnd   = (uint32_t)off;
+                                    Info.iLineEnd = iLine;
+                                    break;
+                                }
+                            }
+                            else
+                                fEscaped = false;
+                        }
+
+                        /* Append line content to the comment body string. */
+                        size_t cchAppend;
+                        if (offFirstNonBlank == ~(size_t)0)
+                            cchAppend = 0; /* empty line */
+                        else
+                        {
+                            if (pszBody)
+                                offLineStart = RT_MIN(Info.offStart + 3, offFirstNonBlank);
+                            else if (offFirstNonBlank > Info.offStart + 2) /* Skip one leading blank at the start of the comment. */
+                                offLineStart++;
+                            cchAppend = offLastNonBlank + 1 - offLineStart;
+                            Assert(cchAppend <= cchLine);
+                        }
+
+                        size_t cchNewBody = cchBody + (cchBody > 0) + cchAppend;
+                        if (cchNewBody >= cbBodyAlloc)
+                        {
+                            cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
+                            void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
+                            if (pvNew)
+                                pszBody = (char *)pvNew;
+                            else
+                            {
+                                RTMemFree(pszBody);
+                                return VERR_NO_MEMORY;
+                            }
+                        }
+
+                        if (cchBody > 0)                        /* no leading blank lines */
+                            pszBody[cchBody++] = '\n';
+                        else if (cchAppend == 0)
+                            Info.cBlankLinesBefore++;
+                        memcpy(&pszBody[cchBody], &pchLine[offLineStart], cchAppend);
+                        cchBody += cchAppend;
+                        pszBody[cchBody] = '\0';
+
+                        /* Advance to the next line, if we haven't yet seen the end of this comment. */
+                        if (Info.iLineEnd != UINT32_MAX)
+                            break;
+                        pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+                        if (!pchLine)
+                        {
+                            Info.offEnd   = (uint32_t)cchLine;
+                            Info.iLineEnd = iLine;
+                            break;
+                        }
+                        iLine++;
+                        off = 0;
+                    }
+
+                    /* Strip trailing empty lines in the body. */
+                    Info.cBlankLinesAfter = 0;
+                    while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
+                    {
+                        Info.cBlankLinesAfter++;
+                        pszBody[--cchBody] = '\0';
+                    }
+
+                    /* Do the callback. */
+                    int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
+                    RTMemFree(pszBody);
+                    if (RT_FAILURE(rc))
+                        return rc;
+                    if (rc > VINF_SUCCESS && rcRet == VINF_SUCCESS)
+                        rcRet = rc;
+                }
+
+                if (!pchLine)
+                    break;
+            }
+            /* else: We don't have to deal with character literal as these shouldn't
+                     include comment-like sequences. */
+        } /* for each character in the line */
+
+        iLine++;
+    } /* for each line in the stream */
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Deals with XML comments.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumerateXmlComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        size_t off = 0;
+        while (off < cchLine)
+        {
+            /*
+             * Skip leading blanks and check for start of XML comment.
+             */
+            while (off + 3 < cchLine && RT_C_IS_SPACE(pchLine[off]))
+                off++;
+            if (IS_XML_COMMENT_START(pchLine, off, cchLine))
+            {
+                /*
+                 * XML comment.  Find the end.
+                 *
+                 * Note! This is very similar to the python doc string handling above.
+                 */
+                SCMCOMMENTINFO  Info;
+                Info.iLineStart         = iLine;
+                Info.offStart           = (uint32_t)off;
+                Info.iLineEnd           = UINT32_MAX;
+                Info.offEnd             = UINT32_MAX;
+                Info.cBlankLinesBefore  = 0;
+                Info.enmType            = kScmCommentType_Xml;
+
+                off += 4;
+
+                /*
+                 * Copy the body and find the end of the XML comment.
+                 */
+                size_t          cbBodyAlloc = 0;
+                size_t          cchBody     = 0;
+                char           *pszBody     = NULL;
+                for (;;)
+                {
+                    /* Parse the line up to the end-of-comment or end-of-line. */
+                    size_t offLineStart     = off;
+                    size_t offLastNonBlank  = off;
+                    size_t offFirstNonBlank = ~(size_t)0;
+                    while (off < cchLine)
+                    {
+                        if (!IS_XML_COMMENT_END(pchLine, off, cchLine))
+                        {
+                            char ch = pchLine[off++];
+                            if (RT_C_IS_BLANK(ch))
+                            {/* kind of likely */}
+                            else
+                            {
+                                offLastNonBlank = off - 1;
+                                if (offFirstNonBlank != ~(size_t)0)
+                                {/* likely */}
+                                else if (   (ch != '*' && ch != '#')    /* ignore continuation-asterisks */
+                                         || off > Info.offStart + 1 + 1
+                                         || off > cchLine
+                                         || (   off < cchLine
+                                              && !RT_C_IS_SPACE(pchLine[off]))
+                                         || pszBody == NULL)
+                                    offFirstNonBlank = off - 1;
+                            }
+                        }
+                        else
+                        {
+                            off += 3;
+                            Info.offEnd   = (uint32_t)off;
+                            Info.iLineEnd = iLine;
+                            break;
+                        }
+                    }
+
+                    /* Append line content to the comment body string. */
+                    size_t cchAppend;
+                    if (offFirstNonBlank == ~(size_t)0)
+                        cchAppend = 0; /* empty line */
+                    else
+                    {
+                        offLineStart = offFirstNonBlank;
+                        cchAppend = offLastNonBlank + 1 - offLineStart;
+                        Assert(cchAppend <= cchLine);
+                    }
+
+                    size_t cchNewBody = cchBody + (cchBody > 0) + cchAppend;
+                    if (cchNewBody >= cbBodyAlloc)
+                    {
+                        cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
+                        void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
+                        if (pvNew)
+                            pszBody = (char *)pvNew;
+                        else
+                        {
+                            RTMemFree(pszBody);
+                            return VERR_NO_MEMORY;
+                        }
+                    }
+
+                    if (cchBody > 0)                        /* no leading blank lines */
+                        pszBody[cchBody++] = '\n';
+                    else if (cchAppend == 0)
+                        Info.cBlankLinesBefore++;
+                    memcpy(&pszBody[cchBody], &pchLine[offLineStart], cchAppend);
+                    cchBody += cchAppend;
+                    pszBody[cchBody] = '\0';
+
+                    /* Advance to the next line, if we haven't yet seen the end of this comment. */
+                    if (Info.iLineEnd != UINT32_MAX)
+                        break;
+                    pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+                    if (!pchLine)
+                    {
+                        Info.offEnd   = (uint32_t)cchLine;
+                        Info.iLineEnd = iLine;
+                        break;
+                    }
+                    iLine++;
+                    off = 0;
+                }
+
+                /* Strip trailing empty lines in the body. */
+                Info.cBlankLinesAfter = 0;
+                while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
+                {
+                    Info.cBlankLinesAfter++;
+                    pszBody[--cchBody] = '\0';
+                }
+
+                /* Do the callback. */
+                int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
+                RTMemFree(pszBody);
+                if (RT_FAILURE(rc))
+                    return rc;
+                if (rc > VINF_SUCCESS && rcRet == VINF_SUCCESS)
+                    rcRet = rc;
+            }
+            else
+                off++;
+        } /* for each character in the line */
+
+        iLine++;
+    } /* for each line in the stream */
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Deals with comments in DOS batch files.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumerateBatchComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+    while (pchLine != NULL)
+    {
+        /*
+         * Skip leading blanks and check for 'rem'.
+         * At the moment we do not parse '::label-comments'.
+         */
+        size_t off = 0;
+        while (off + 3 < cchLine && RT_C_IS_SPACE(pchLine[off]))
+            off++;
+        if (!IS_REM(pchLine, off, cchLine))
+        {
+            iLine++;
+            pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        }
+        else
+        {
+            int rc = handleLineComment(pIn, isBatchComment, pfnCallback, pvUser,
+                                       &pchLine, &cchLine, &enmEol, &iLine, &off);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (rcRet == VINF_SUCCESS)
+                rcRet = rc;
+        }
+    }
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Deals with comments in SQL files.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumerateSqlComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+    while (pchLine != NULL)
+    {
+        /*
+         * Skip leading blanks and check for '--'.
+         */
+        size_t off = 0;
+        while (off + 3 < cchLine && RT_C_IS_SPACE(pchLine[off]))
+            off++;
+        if (   cchLine < 2
+            || pchLine[0] != '-'
+            || pchLine[1] != '-')
+        {
+            iLine++;
+            pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        }
+        else
+        {
+            int rc = handleLineComment(pIn, isSqlComment, pfnCallback, pvUser,
+                                       &pchLine, &cchLine, &enmEol, &iLine, &off);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (rcRet == VINF_SUCCESS)
+                rcRet = rc;
+        }
+    }
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Deals with simple line comments.
+ *
+ * @returns VBox status code / callback return code.
+ * @param   pIn                 The stream to parse.
+ * @param   chStart             The start of comment character.
+ * @param   pfnIsComment        Comment tester function.
+ * @param   pfnCallback         The callback.
+ * @param   pvUser              The user parameter for the callback.
+ */
+static int enumerateSimpleLineComments(PSCMSTREAM pIn, char chStart, PFNISCOMMENT pfnIsComment,
+                                       PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    int             rcRet = VINF_SUCCESS;
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        size_t off = 0;
+        while (off < cchLine)
+        {
+            char ch = pchLine[off++];
+            if (ch != chStart)
+            { /* not interesting */ }
+            else
+            {
+                off -= 1;
+                int rc = handleLineComment(pIn, pfnIsComment, pfnCallback, pvUser,
+                                           &pchLine, &cchLine, &enmEol,  &iLine, &off);
+                if (RT_FAILURE(rc))
+                    return rc;
+                if (rcRet == VINF_SUCCESS)
+                    rcRet = rc;
+
+                if (!pchLine)
+                    break;
+            }
+        } /* for each character in the line */
+
+        iLine++;
+    } /* for each line in the stream */
+
+    int rcStream = ScmStreamGetStatus(pIn);
+    if (RT_SUCCESS(rcStream))
+        return rcRet;
+    return rcStream;
+}
+
+
+/**
+ * Enumerates the comments in the given stream, calling @a pfnCallback for each.
+ *
+ * @returns IPRT status code.
+ * @param   pIn             The stream to parse.
+ * @param   enmCommentStyle The comment style of the source stream.
+ * @param   pfnCallback     The function to call.
+ * @param   pvUser          User argument to the callback.
+ */
+int ScmEnumerateComments(PSCMSTREAM pIn, SCMCOMMENTSTYLE enmCommentStyle, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
+{
+    switch (enmCommentStyle)
+    {
+        case kScmCommentStyle_C:
+            return enumerateCStyleComments(pIn, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Python:
+            return enumeratePythonComments(pIn, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Semicolon:
+            return enumerateSimpleLineComments(pIn, ';', isSemicolonComment, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Hash:
+            return enumerateSimpleLineComments(pIn, '#', isHashComment, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Rem_Upper:
+        case kScmCommentStyle_Rem_Lower:
+        case kScmCommentStyle_Rem_Camel:
+            return enumerateBatchComments(pIn, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Sql:
+            return enumerateSqlComments(pIn, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Tick:
+            return enumerateSimpleLineComments(pIn, '\'', isTickComment, pfnCallback, pvUser);
+
+        case kScmCommentStyle_Xml:
+            return enumerateXmlComments(pIn, pfnCallback, pvUser);
+
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
+}
+
diff --git a/src/bldprogs/scmrw-kmk.cpp b/src/bldprogs/scmrw-kmk.cpp
new file mode 100644
index 00000000..7907150b
--- /dev/null
+++ b/src/bldprogs/scmrw-kmk.cpp
@@ -0,0 +1,2273 @@
+/* $Id: scmrw-kmk.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager, Makefile.kmk/kup.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scm.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef enum KMKASSIGNTYPE
+{
+    kKmkAssignType_Recursive,
+    kKmkAssignType_Conditional,
+    kKmkAssignType_Appending,
+    kKmkAssignType_Prepending,
+    kKmkAssignType_Simple,
+    kKmkAssignType_Immediate
+} KMKASSIGNTYPE;
+
+/** Context for scmKmkWordLength. */
+typedef enum
+{
+    /** Target file or assignment.
+     *  Separators: space, '=', ':' */
+    kKmkWordCtx_TargetFileOrAssignment,
+    /** Target file.
+     *  Separators: space, ':' */
+    kKmkWordCtx_TargetFile,
+    /** Dependency file or (target variable) assignment.
+     *  Separators: space, '=', ':', '|' */
+    kKmkWordCtx_DepFileOrAssignment,
+    /** Dependency file.
+     *  Separators: space, '|' */
+    kKmkWordCtx_DepFile,
+    /** Last context which may do double expansion. */
+    kKmkWordCtx_LastDoubleExpansion = kKmkWordCtx_DepFile
+} KMKWORDCTX;
+
+typedef struct KMKWORDSTATE
+{
+    uint16_t uDepth;
+    char     chOpen;
+} KMKWORDSTATE;
+
+typedef enum KMKTOKEN
+{
+    kKmkToken_Word = 0,
+    kKmkToken_Comment,
+
+    /* Conditionals: */
+    kKmkToken_ifeq,
+    kKmkToken_ifneq,
+    kKmkToken_if1of,
+    kKmkToken_ifn1of,
+    kKmkToken_ifdef,
+    kKmkToken_ifndef,
+    kKmkToken_if,
+    kKmkToken_else,
+    kKmkToken_endif,
+
+    /* Includes: */
+    kKmkToken_include,
+    kKmkToken_sinclude,
+    kKmkToken_dash_include,
+    kKmkToken_includedep,
+    kKmkToken_includedep_queue,
+    kKmkToken_includedep_flush,
+
+    /* Others: */
+    kKmkToken_define,
+    kKmkToken_endef,
+    kKmkToken_export,
+    kKmkToken_unexport,
+    kKmkToken_local,
+    kKmkToken_override,
+    kKmkToken_undefine
+} KMKTOKEN;
+
+typedef struct KMKPARSER
+{
+    struct
+    {
+        KMKTOKEN        enmToken;
+        bool            fIgnoreNesting;
+        size_t          iLine;
+    } aDepth[64];
+    unsigned            iDepth;
+    unsigned            iActualDepth;
+    bool                fInRecipe;
+
+    /** The EOL type of the current line. */
+    SCMEOL              enmEol;
+    /** The length of the current line. */
+    size_t              cchLine;
+    /** Pointer to the start of the current line. */
+    char const         *pchLine;
+
+    /** @name Only used for rule/assignment parsing.
+     * @{ */
+    /** Number of continuation lines at current rule/assignment. */
+    uint32_t            cLines;
+    /** Characters in continuation lines at current rule/assignment. */
+    size_t              cchTotalLine;
+    /** @} */
+
+    /** The SCM rewriter state. */
+    PSCMRWSTATE         pState;
+    /** The input stream. */
+    PSCMSTREAM          pIn;
+    /** The output stream. */
+    PSCMSTREAM          pOut;
+    /** The settings. */
+    PCSCMSETTINGSBASE   pSettings;
+    /** Scratch buffer. */
+    char                szBuf[4096];
+} KMKPARSER;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static char const g_szTabs[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+
+
+static KMKTOKEN scmKmkIdentifyToken(const char *pchWord, size_t cchWord)
+{
+    static struct { const char *psz; uint32_t cch; KMKTOKEN enmToken; } s_aTokens[] =
+    {
+        { RT_STR_TUPLE("if"),               kKmkToken_if },
+        { RT_STR_TUPLE("ifeq"),             kKmkToken_ifeq },
+        { RT_STR_TUPLE("ifneq"),            kKmkToken_ifneq },
+        { RT_STR_TUPLE("if1of"),            kKmkToken_if1of },
+        { RT_STR_TUPLE("ifn1of"),           kKmkToken_ifn1of },
+        { RT_STR_TUPLE("ifdef"),            kKmkToken_ifdef },
+        { RT_STR_TUPLE("ifndef"),           kKmkToken_ifndef },
+        { RT_STR_TUPLE("else"),             kKmkToken_else },
+        { RT_STR_TUPLE("endif"),            kKmkToken_endif },
+        { RT_STR_TUPLE("include"),          kKmkToken_include },
+        { RT_STR_TUPLE("sinclude"),         kKmkToken_sinclude },
+        { RT_STR_TUPLE("-include"),         kKmkToken_dash_include },
+        { RT_STR_TUPLE("includedep"),       kKmkToken_includedep },
+        { RT_STR_TUPLE("includedep-queue"), kKmkToken_includedep_queue },
+        { RT_STR_TUPLE("includedep-flush"), kKmkToken_includedep_flush },
+        { RT_STR_TUPLE("define"),           kKmkToken_define },
+        { RT_STR_TUPLE("endef"),            kKmkToken_endef },
+        { RT_STR_TUPLE("export"),           kKmkToken_export },
+        { RT_STR_TUPLE("unexport"),         kKmkToken_unexport },
+        { RT_STR_TUPLE("local"),            kKmkToken_local },
+        { RT_STR_TUPLE("override"),         kKmkToken_override },
+        { RT_STR_TUPLE("undefine"),         kKmkToken_undefine },
+    };
+    char chFirst = *pchWord;
+    if (   chFirst == 'i'
+        || chFirst == 'e'
+        || chFirst == 'd'
+        || chFirst == 's'
+        || chFirst == '-'
+        || chFirst == 'u'
+        || chFirst == 'l'
+        || chFirst == 'o')
+    {
+        for (size_t i = 0; i < RT_ELEMENTS(s_aTokens); i++)
+            if (   s_aTokens[i].cch == cchWord
+                && *s_aTokens[i].psz == chFirst
+                && memcmp(s_aTokens[i].psz, pchWord, cchWord) == 0)
+                return s_aTokens[i].enmToken;
+    }
+#ifdef VBOX_STRICT
+    else
+        for (size_t i = 0; i < RT_ELEMENTS(s_aTokens); i++)
+            Assert(chFirst != *s_aTokens[i].psz);
+#endif
+
+    if (chFirst == '#')
+        return kKmkToken_Comment;
+    return kKmkToken_Word;
+}
+
+
+/**
+ * Modifies the fInRecipe state variable, logging changes in verbose mode.
+ */
+static void scmKmkSetInRecipe(KMKPARSER *pParser, bool fInRecipe)
+{
+    if (pParser->fInRecipe != fInRecipe)
+        ScmVerbose(pParser->pState, 4, "%u: debug: %s\n",
+                   ScmStreamTellLine(pParser->pIn), fInRecipe ? "in-recipe" : "not-in-recipe");
+    pParser->fInRecipe = fInRecipe;
+}
+
+
+/**
+ * Gives up on the current line, copying it as it and requesting manual repair.
+ */
+static bool scmKmkGiveUp(KMKPARSER *pParser, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    ScmFixManually(pParser->pState, "%u: %N\n", ScmStreamTellLine(pParser->pIn), pszFormat, &va);
+    va_end(va);
+
+    ScmStreamPutLine(pParser->pOut, pParser->pchLine, pParser->cchLine, pParser->enmEol);
+    return false;
+}
+
+
+static bool scmKmkIsLineWithContinuationSlow(const char *pchLine, size_t cchLine)
+{
+    size_t cchSlashes = 1;
+    cchLine--;
+    while (cchSlashes < cchLine && pchLine[cchLine - cchSlashes - 1] == '\\')
+        cchSlashes++;
+    return RT_BOOL(cchSlashes & 1);
+}
+
+
+DECLINLINE(bool) scmKmkIsLineWithContinuation(const char *pchLine, size_t cchLine)
+{
+    if (cchLine == 0 || pchLine[cchLine - 1] != '\\')
+        return false;
+    return scmKmkIsLineWithContinuationSlow(pchLine, cchLine);
+}
+
+
+/**
+ * Finds the length of a line where line continuation is in play.
+ *
+ * @returns Length from start of current line to the final unescaped EOL.
+ * @param   pParser         The KMK parser state.
+ * @param   pcLine          Where to return the number of lines.  Optional.
+ * @param   pcchMaxLeadWord Where to return the max lead word length on
+ *                          subsequent lines. Used to help balance multi-line
+ *                          'if' statements (imperfect).  Optional.
+ */
+static size_t scmKmkLineContinuationPeek(KMKPARSER *pParser, uint32_t *pcLines, size_t *pcchMaxLeadWord)
+{
+    size_t const offSaved       = ScmStreamTell(pParser->pIn);
+    uint32_t     cLines         = 1;
+    size_t       cchMaxLeadWord = 0;
+    const char  *pchLine        = pParser->pchLine;
+    size_t       cchLine        = pParser->cchLine;
+    SCMEOL       enmEol;
+    for (;;)
+    {
+        /* Return if no line continuation (or end of stream): */
+        if (   cchLine == 0
+            || !scmKmkIsLineWithContinuation(pchLine, cchLine)
+            || ScmStreamIsEndOfStream(pParser->pIn))
+        {
+            ScmStreamSeekAbsolute(pParser->pIn, offSaved);
+            if (pcLines)
+                *pcLines = cLines;
+            if (pcchMaxLeadWord)
+                *pcchMaxLeadWord = cchMaxLeadWord;
+            return (size_t)(pchLine - pParser->pchLine) + cchLine;
+        }
+
+        /* Get the next line: */
+        pchLine = ScmStreamGetLine(pParser->pIn, &cchLine, &enmEol);
+        cLines++;
+
+        /* Check the length of the first word if requested: */
+        if (pcchMaxLeadWord)
+        {
+            size_t offLine = 0;
+            while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
+                offLine++;
+
+            size_t const offStartWord = offLine;
+            while (offLine < cchLine && !RT_C_IS_BLANK(pchLine[offLine]))
+                offLine++;
+
+            if (offLine - offStartWord > cchMaxLeadWord)
+                cchMaxLeadWord = offLine - offStartWord;
+        }
+    }
+}
+
+
+/**
+ * Checks if the given line contains a comment with the @a pszMarker word in it.
+ *
+ * This can be used to disable warnings.
+ *
+ * @returns true if this is the case, false if not
+ * @param   pchLine     The line.
+ * @param   cchLine     The line length.
+ * @param   offLine     The current line position, 0 if uncertain.
+ * @param   pszMarker   The marker to check for.
+ * @param   cchMarker   The length of the marker string.
+ */
+static bool scmKmkHasCommentMarker(const char *pchLine, size_t cchLine, size_t offLine, const char *pszMarker, size_t cchMarker)
+{
+    const char *pchCur = (const char *)memchr(&pchLine[offLine], '#', cchLine - RT_MIN(offLine, cchLine));
+    if (pchCur)
+    {
+        pchCur++;
+        size_t cchLeft = (size_t)(&pchLine[cchLine] - pchCur);
+        while (cchLeft >= cchMarker)
+        {
+            const char *pchHit = (char *)memchr(pchCur, *pszMarker, cchLeft - cchMarker + 1);
+            if (!pchHit)
+                break;
+            if (memcmp(pchHit, pszMarker, cchMarker) == 0)
+                return true;
+            pchCur  = pchHit + 1;
+            cchLeft = (size_t)(&pchLine[cchLine] - pchCur);
+        }
+    }
+    return false;
+}
+
+
+/**
+ * Pushes a if or define on the nesting stack.
+ */
+static bool scmKmkPushNesting(KMKPARSER *pParser, KMKTOKEN enmToken)
+{
+    uint32_t iDepth = pParser->iDepth;
+    if (iDepth + 1 >= RT_ELEMENTS(pParser->aDepth))
+    {
+        ScmError(pParser->pState, VERR_ASN1_TOO_DEEPLY_NESTED /*?*/,
+                 "%u: Too deep if/define nesting!\n", ScmStreamTellLine(pParser->pIn));
+        return false;
+    }
+
+    pParser->aDepth[iDepth].enmToken       = enmToken;
+    pParser->aDepth[iDepth].iLine          = ScmStreamTellLine(pParser->pIn);
+    pParser->aDepth[iDepth].fIgnoreNesting = false;
+    pParser->iDepth        = iDepth + 1;
+    pParser->iActualDepth += 1;
+    ScmVerbose(pParser->pState, 5, "%u: debug: nesting %u (token %u)\n", pParser->aDepth[iDepth].iLine, iDepth + 1, enmToken);
+    return true;
+}
+
+
+/**
+ * Checks if we're inside a define or not.
+ */
+static bool scmKmkIsInsideDefine(KMKPARSER const *pParser)
+{
+    unsigned iDepth = pParser->iDepth;
+    while (iDepth-- > 0)
+        if (pParser->aDepth[iDepth].enmToken == kKmkToken_define)
+            return true;
+    return false;
+}
+
+
+/**
+ * Skips a string stopping at @a chStop1 or @a chStop2, taking $() and ${} into
+ * account.
+ */
+static size_t scmKmkSkipExpString(const char *pchLine, size_t cchLine, size_t off, char chStop1, char chStop2 = '\0')
+{
+    unsigned iExpDepth = 0;
+    char     ch;
+    while (   off < cchLine
+           && (ch = pchLine[off])
+           && (    (ch != chStop1 && ch != chStop2)
+                || iExpDepth > 0))
+    {
+        off++;
+        if (ch == '$')
+        {
+            ch = pchLine[off];
+            if (ch == '(' || ch == '{')
+            {
+                iExpDepth++;
+                off++;
+            }
+        }
+        else if ((ch == ')' || ch == '}') && iExpDepth > 0)
+            iExpDepth--;
+    }
+    return off;
+}
+
+
+/**
+ * Finds the length of the word (file) @a offStart.
+ *
+ * This only takes one line into account, so variable expansions (function
+ * calls) spanning multiple lines will be handled as one word per line with help
+ * from @a pState.  This allows the caller to properly continutation intend the
+ * additional lines.
+ *
+ * @returns Length of word starting at @a offStart. Zero if there is whitespace
+ *          at given offset or it's beyond the end of the line (both cases will
+ *          assert).
+ * @param   pchLine             The line.
+ * @param   cchLine             The line length.
+ * @param   offStart            Offset to the start of the word.
+ * @param   pState              Where multiline variable expansion is tracked.
+ */
+static size_t scmKmkWordLength(const char *pchLine, size_t cchLine, size_t offStart, KMKWORDCTX enmCtx, KMKWORDSTATE *pState)
+{
+    AssertReturn(offStart < cchLine && !RT_C_IS_BLANK(pchLine[offStart]), 0);
+
+    /*
+     * Drop any line continuation slash from the line length, so we don't count
+     * it into the word length. Also, any spaces preceeding it (for multiline
+     * variable function expansion).  ASSUMES no trailing slash escaping.
+     */
+    if (cchLine > 0 && pchLine[cchLine - 1] == '\\')
+        do
+            cchLine--;
+        while (cchLine > offStart && RT_C_IS_SPACE(pchLine[cchLine - 1]));
+
+    /*
+     * If we were inside a variable function expansion, continue till we reach the end.
+     * This kind of duplicates the code below.
+     */
+    size_t off = offStart;
+    if (pState->uDepth > 0)
+    {
+        Assert(pState->chOpen == '(' || pState->chOpen == '{');
+        char const chOpen  = pState->chOpen;
+        char const chClose = chOpen == '(' ? ')' : '}';
+        unsigned   uDepth  = pState->uDepth;
+        for (;;)
+        {
+            char ch;
+            if (off < cchLine)
+                ch = pchLine[off++];
+            else /* Reached the end while still inside the expansion. */
+            {
+                pState->chOpen = chOpen;
+                pState->uDepth = (uint16_t)uDepth;
+                return cchLine - offStart;
+            }
+            if (ch == chOpen)
+                uDepth++;
+            else if (ch == chClose && --uDepth == 0)
+                break;
+        }
+        pState->uDepth = 0;
+        pState->chOpen = 0;
+    }
+
+    /*
+     * Process till we find blank or end of the line.
+     */
+    while (off < cchLine)
+    {
+        char ch = pchLine[off];
+        if (RT_C_IS_BLANK(ch))
+            break;
+
+        if (ch == '$')
+        {
+            /*
+             * Skip variable expansion. ASSUMING double expansion being enabled
+             * for rules, we respond to both $() and $$() here, $$$$()
+             */
+            size_t cDollars = 0;
+            do
+            {
+                off++;
+                if (off >= cchLine)
+                    return cchLine - offStart;
+                cDollars++;
+                ch = pchLine[off];
+            } while (ch == '$');
+            if ((cDollars & 1) || (cDollars == 2 && enmCtx <= kKmkWordCtx_LastDoubleExpansion))
+            {
+                char const chOpen = ch;
+                if (ch == '(' || ch == '{')
+                {
+                    char const chClose = chOpen == '(' ? ')' : '}';
+                    unsigned   uDepth  = 1;
+                    off++;
+                    for (;;)
+                    {
+                        if (off < cchLine)
+                            ch = pchLine[off++];
+                        else /* Reached the end while inside the expansion. */
+                        {
+                            pState->chOpen = chOpen;
+                            pState->uDepth = (uint16_t)uDepth;
+                            return cchLine - offStart;
+                        }
+                        if (ch == chOpen)
+                            uDepth++;
+                        else if (ch == chClose && --uDepth == 0)
+                            break;
+                    }
+                }
+                else if (cDollars & 1)
+                    off++; /* $X */
+            }
+            continue;
+        }
+        else if (ch == ':')
+        {
+            /*
+             * Check for plain driver letter, omitting the archive member variant.
+             */
+            if (off - offStart != 1 || !RT_C_IS_ALPHA(pchLine[off - 1]))
+            {
+                if (off == offStart)
+                {
+                    /* We need to check for single and double colon rules as well as
+                       simple and immediate assignments here. */
+                    off++;
+                    if (pchLine[off] == ':')
+                    {
+                        off++;
+                        if (pchLine[off] == '=')
+                        {
+                            if (enmCtx == kKmkWordCtx_TargetFileOrAssignment || enmCtx == kKmkWordCtx_DepFileOrAssignment)
+                                return 3;   /* ::=  - immediate assignment. */
+                            off++;
+                        }
+                        else if (enmCtx != kKmkWordCtx_DepFile)
+                            return 2;       /* ::   - double colon rule */
+                    }
+                    else if (pchLine[off] == '=')
+                    {
+                        if (enmCtx == kKmkWordCtx_TargetFileOrAssignment || enmCtx == kKmkWordCtx_DepFileOrAssignment)
+                            return 2;       /* :=   - simple assignment. */
+                        off++;
+                    }
+                    else if (enmCtx != kKmkWordCtx_DepFile)
+                        return 1;           /* :    - regular rule. */
+                    continue;
+                }
+                /* ':' is a separator except in DepFile context. */
+                else if (enmCtx != kKmkWordCtx_DepFile)
+                    return off - offStart;
+            }
+        }
+        else if (ch == '=')
+        {
+            /*
+             * Assignment.  We check for the previous character too so we'll catch
+             * append, prepend and conditional assignments.  Simple and immediate
+             * assignments are handled above.
+             */
+            if (   enmCtx == kKmkWordCtx_TargetFileOrAssignment
+                || enmCtx == kKmkWordCtx_DepFileOrAssignment)
+            {
+                if (off > offStart)
+                {
+                    ch = pchLine[off - 1];
+                    if (ch == '?' || ch == '+' || ch == '>')
+                        off = off - 1 == offStart
+                            ? off + 2  /* return '+=', '?=', '<=' */
+                            : off - 1; /* up to '+=', '?=', '<=' */
+                    else
+                        Assert(ch != ':'); /* handled above */
+                }
+                else
+                    off++;  /* '=' */
+                return off - offStart;
+            }
+        }
+        else if (ch == '|')
+        {
+            /*
+             * This is rather straight forward.
+             */
+            if (enmCtx == kKmkWordCtx_DepFileOrAssignment || enmCtx == kKmkWordCtx_DepFile)
+            {
+                if (off == offStart)
+                    return 1;
+                return off - offStart;
+            }
+        }
+        off++;
+    }
+    return off - offStart;
+}
+
+
+static bool scmKmkTailComment(KMKPARSER *pParser, const char *pchLine, size_t cchLine, size_t offSrc, char **ppszDst)
+{
+    /* Wind back offSrc to the first blank space (not all callers can do this). */
+    Assert(offSrc <= cchLine);
+    while (offSrc > 0 && RT_C_IS_SPACE(pchLine[offSrc - 1]))
+        offSrc--;
+    size_t const offSrcStart = offSrc;
+
+    /* Skip blanks. */
+    while (offSrc < cchLine && RT_C_IS_SPACE(pchLine[offSrc]))
+        offSrc++;
+    if (offSrc >= cchLine)
+        return true;
+
+    /* Is it a comment? */
+    char *pszDst = *ppszDst;
+    if (pchLine[offSrc] == '#')
+    {
+        /* Try preserve the start column number. */
+/** @todo tabs */
+        size_t const offDst = pszDst - pParser->szBuf;
+        if (offDst < offSrc)
+        {
+            memset(pszDst, ' ', offSrc - offDst);
+            pszDst += offSrc - offDst;
+        }
+        else if (offSrc != offSrcStart)
+            *pszDst++ = ' ';
+
+        *ppszDst = pszDst = (char *)mempcpy(pszDst, &pchLine[offSrc], cchLine - offSrc);
+        return false; /*dummy*/
+    }
+
+    /* Complain and copy out the text unmodified. */
+    ScmError(pParser->pState, VERR_PARSE_ERROR, "%u:%u: Expected comment, found: %.*s",
+             ScmStreamTellLine(pParser->pIn), offSrc, cchLine - offSrc, &pchLine[offSrc]);
+    *ppszDst = (char *)mempcpy(pszDst, &pchLine[offSrcStart], cchLine - offSrcStart);
+    return false; /*dummy*/
+}
+
+
+/**
+ * Deals with: ifeq, ifneq, if1of and ifn1of
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleIfParentheses(KMKPARSER *pParser, size_t offToken, KMKTOKEN enmToken, size_t cchToken, bool fElse)
+{
+    const char * const pchLine   = pParser->pchLine;
+    size_t  const      cchLine   = pParser->cchLine;
+    uint32_t const     cchIndent = pParser->iActualDepth
+                                 - (fElse && pParser->iActualDepth > 0 && !pParser->aDepth[pParser->iDepth - 1].fIgnoreNesting);
+
+    /*
+     * Push it onto the stack.  All these nestings are relevant.
+     */
+    if (!fElse)
+    {
+        if (!scmKmkPushNesting(pParser, enmToken))
+            return false;
+    }
+    else
+    {
+        pParser->aDepth[pParser->iDepth - 1].enmToken = enmToken;
+        pParser->aDepth[pParser->iDepth - 1].iLine    = ScmStreamTellLine(pParser->pIn);
+    }
+
+    /*
+     * We do not allow line continuation for these.
+     */
+    if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+        return scmKmkGiveUp(pParser, "Line continuation not allowed with '%.*s' directive.", cchToken, &pchLine[offToken]);
+
+    /*
+     * We stage the modified line in the buffer, so check that the line isn't
+     * too long (it seriously should be).
+     */
+    if (cchLine + cchIndent + 32 > sizeof(pParser->szBuf))
+        return scmKmkGiveUp(pParser, "Line too long for a '%.*s' directive: %u chars", cchToken, &pchLine[offToken], cchLine);
+    char *pszDst = pParser->szBuf;
+
+    /*
+     * Emit indent and initial token.
+     */
+    memset(pszDst, ' ', cchIndent);
+    pszDst += cchIndent;
+
+    if (fElse)
+        pszDst = (char *)mempcpy(pszDst, RT_STR_TUPLE("else "));
+
+    memcpy(pszDst, &pchLine[offToken], cchToken);
+    pszDst += cchToken;
+
+    size_t offSrc = offToken + cchToken;
+
+    /*
+     * There shall be exactly one space between the token and the opening parenthesis.
+     */
+    if (pchLine[offSrc] == ' ' && pchLine[offSrc + 1] == '(')
+        offSrc += 2;
+    else
+    {
+        while (offSrc < cchLine && RT_C_IS_BLANK(pchLine[offSrc]))
+            offSrc++;
+        if (pchLine[offSrc] != '(')
+            return scmKmkGiveUp(pParser, "Expected '(' to follow '%.*s'", cchToken, &pchLine[offToken]);
+        offSrc++;
+    }
+    *pszDst++ = ' ';
+    *pszDst++ = '(';
+
+    /*
+     * Skip spaces after the opening parenthesis.
+     */
+    while (offSrc < cchLine && RT_C_IS_BLANK(pchLine[offSrc]))
+        offSrc++;
+
+    /*
+     * Work up to the ',' separator.  It shall likewise not be preceeded by any spaces.
+     * Need to take $(func 1,2,3) calls into account here, so we trac () and {} while
+     * skipping ahead.
+     */
+    if (pchLine[offSrc] != ',')
+    {
+        size_t const offSrcStart = offSrc;
+        offSrc = scmKmkSkipExpString(pchLine, cchLine, offSrc, ',');
+        if (pchLine[offSrc] != ',')
+            return scmKmkGiveUp(pParser, "Expected ',' somewhere after '%.*s('", cchToken, &pchLine[offToken]);
+
+        size_t cchCopy = offSrc - offSrcStart;
+        while (cchCopy > 0 && RT_C_IS_BLANK(pchLine[offSrcStart + cchCopy - 1]))
+            cchCopy--;
+
+        pszDst = (char *)mempcpy(pszDst, &pchLine[offSrcStart], cchCopy);
+    }
+    /* 'if1of(, stuff)' does not make sense in committed code: */
+    else if (enmToken == kKmkToken_if1of || enmToken == kKmkToken_ifn1of)
+        return scmKmkGiveUp(pParser, "Left set cannot be empty for '%.*s'", cchToken, &pchLine[offToken]);
+    offSrc++;
+    *pszDst++ = ',';
+
+    /*
+     * For if1of and ifn1of we require a space after the comma, whereas ifeq and
+     * ifneq shall not have any blanks.  This is to help tell them apart.
+     */
+    if (enmToken == kKmkToken_if1of || enmToken == kKmkToken_ifn1of)
+    {
+        *pszDst++ = ' ';
+        if (pchLine[offSrc] == ' ')
+            offSrc++;
+    }
+    while (offSrc < cchLine && RT_C_IS_BLANK(pchLine[offSrc]))
+        offSrc++;
+
+    if (pchLine[offSrc] != ')')
+    {
+        size_t const offSrcStart = offSrc;
+        offSrc = scmKmkSkipExpString(pchLine, cchLine, offSrc, ')');
+        if (pchLine[offSrc] != ')')
+            return scmKmkGiveUp(pParser, "No closing parenthesis for '%.*s'?", cchToken, &pchLine[offToken]);
+
+        size_t cchCopy = offSrc - offSrcStart;
+        while (cchCopy > 0 && RT_C_IS_BLANK(pchLine[offSrcStart + cchCopy - 1]))
+            cchCopy--;
+
+        pszDst = (char *)mempcpy(pszDst, &pchLine[offSrcStart], cchCopy);
+    }
+    /* 'if1of(stuff, )' does not make sense in committed code: */
+    else if (   (enmToken == kKmkToken_if1of || enmToken == kKmkToken_ifn1of)
+             && !scmKmkHasCommentMarker(pchLine, cchLine, offSrc, RT_STR_TUPLE("scm:ignore-empty-if1of-set")))
+        return scmKmkGiveUp(pParser, "Right set cannot be empty for '%.*s'", cchToken, &pchLine[offToken]);
+    offSrc++;
+    *pszDst++ = ')';
+
+    /*
+     * Handle comment.
+     */
+    if (offSrc < cchLine)
+        scmKmkTailComment(pParser, pchLine, cchLine, offSrc, &pszDst);
+
+    /*
+     * Done.
+     */
+    *pszDst = '\0';
+    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+    return false; /* dummy */
+}
+
+
+/**
+ * Deals with: if, ifdef and ifndef
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleIfSpace(KMKPARSER *pParser, size_t offToken, KMKTOKEN enmToken, size_t cchToken, bool fElse)
+{
+    const char     *pchLine   = pParser->pchLine;
+    size_t          cchLine   = pParser->cchLine;
+    uint32_t const  cchIndent = pParser->iActualDepth
+                              - (fElse && pParser->iActualDepth > 0 && !pParser->aDepth[pParser->iDepth - 1].fIgnoreNesting);
+
+    /*
+     * Push it onto the stack.
+     *
+     * For ifndef we ignore the outmost ifndef in non-Makefile.kmk files, if
+     * the define matches the typical pattern for a file blocker.
+     */
+    bool fIgnoredNesting = false;
+    if (!fElse)
+    {
+        if (!scmKmkPushNesting(pParser, enmToken))
+            return false;
+        if (enmToken == kKmkToken_ifndef)
+        {
+            /** @todo */
+        }
+    }
+    else
+    {
+        pParser->aDepth[pParser->iDepth - 1].enmToken = enmToken;
+        pParser->aDepth[pParser->iDepth - 1].iLine    = ScmStreamTellLine(pParser->pIn);
+    }
+
+    /*
+     * We do not allow line continuation for these.
+     */
+    uint32_t cLines         = 1;
+    size_t   cchMaxLeadWord = 0;
+    size_t   cchTotalLine   = cchLine;
+    if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+    {
+        if (enmToken != kKmkToken_if)
+            return scmKmkGiveUp(pParser, "Line continuation not allowed with '%.*s' directive.", cchToken, &pchLine[offToken]);
+        cchTotalLine = scmKmkLineContinuationPeek(pParser, &cLines, &cchMaxLeadWord);
+    }
+
+    /*
+     * We stage the modified line in the buffer, so check that the line isn't
+     * too long (plain if can be long, but not ifndef/ifdef).
+     */
+    if (cchTotalLine + pParser->iActualDepth + 32 > sizeof(pParser->szBuf))
+        return scmKmkGiveUp(pParser, "Line too long for a '%.*s' directive: %u chars",
+                            cchToken, &pchLine[offToken], cchTotalLine);
+    char *pszDst = pParser->szBuf;
+
+    /*
+     * Emit indent and initial token.
+     */
+    memset(pszDst, ' ', cchIndent);
+    pszDst += cchIndent;
+
+    if (fElse)
+        pszDst = (char *)mempcpy(pszDst, RT_STR_TUPLE("else "));
+
+    memcpy(pszDst, &pchLine[offToken], cchToken);
+    pszDst += cchToken;
+
+    size_t offSrc = offToken + cchToken;
+
+    /*
+     * ifndef/ifdef shall have exactly one space.  For 'if' we allow up to 4, but
+     * we'll deal with that further down.
+     */
+    size_t cchSpaces = 0;
+    while (offSrc < cchLine && RT_C_IS_BLANK(pchLine[offSrc]))
+    {
+        cchSpaces++;
+        offSrc++;
+    }
+    if (cchSpaces == 0)
+        return scmKmkGiveUp(pParser, "Nothing following '%.*s' or bogus line continuation?", cchToken, &pchLine[offToken]);
+    *pszDst++ = ' ';
+
+    /*
+     * For ifdef and ifndef there now comes a single word.
+     */
+    if (enmToken != kKmkToken_if)
+    {
+        size_t const offSrcStart = offSrc;
+        offSrc = scmKmkSkipExpString(pchLine, cchLine, offSrc, ' ', '\t'); /** @todo probably not entirely correct */
+        if (offSrc == offSrcStart)
+            return scmKmkGiveUp(pParser, "No word following '%.*s'?", cchToken, &pchLine[offToken]);
+
+        pszDst = (char *)mempcpy(pszDst, &pchLine[offSrcStart], offSrc - offSrcStart);
+    }
+    /*
+     * While for 'if' things are more complicated, especially if it spans more
+     * than one line.
+     */
+    else if (cLines <= 1)
+    {
+        /* Single line expression: Just assume the expression goes up to the
+           EOL or comment hash. Strip and copy as-is for now. */
+        const char *pchSrcHash = (const char *)memchr(&pchLine[offSrc], '#', cchLine - offSrc);
+        size_t      cchExpr    = pchSrcHash ? pchSrcHash - &pchLine[offSrc] : cchLine - offSrc;
+        while (cchExpr > 0 && RT_C_IS_BLANK(pchLine[offSrc + cchExpr - 1]))
+            cchExpr--;
+
+        pszDst = (char *)mempcpy(pszDst, &pchLine[offSrc], cchExpr);
+        offSrc += cchExpr;
+    }
+    else
+    {
+        /* Multi line expression: We normalize leading whitespace using
+           cchMaxLeadWord for now.  Expression on line 2+ are indented by two
+           extra characters, because we'd otherwise be puttin the operator on
+           the same level as the 'if', which would be confusing.  Thus:
+
+                if  expr1
+                  + expr2
+                endif
+
+                if   expr1
+                  || expr2
+                endif
+
+                if    expr3
+                  vtg expr4
+                endif
+
+           We do '#' / EOL handling for the final line the same way as above.
+
+           Later we should add the ability to rework the expression properly,
+           making sure new lines starts with operators and such. */
+        /** @todo Implement simples expression parser and indenter, possibly also
+         *        removing unnecessary parentheses.  Can be shared with C/C++. */
+        if (cchMaxLeadWord > 3)
+            return scmKmkGiveUp(pParser,
+                                "Bogus multi-line 'if' expression! Extra lines must start with operator (cchMaxLeadWord=%u).",
+                                cchMaxLeadWord);
+        memset(pszDst, ' ', cchMaxLeadWord);
+        pszDst += cchMaxLeadWord;
+
+        size_t cchSrcContIndent = offToken + 2;
+        for (uint32_t iSubLine = 0; iSubLine < cLines - 1; iSubLine++)
+        {
+            /* Trim the line. */
+            size_t offSrcEnd = cchLine;
+            Assert(pchLine[offSrcEnd - 1] == '\\');
+            offSrcEnd--;
+
+            if (pchLine[offSrcEnd - 1] == '\\')
+                return scmKmkGiveUp(pParser, "Escaped '\\' before line continuation in 'if' expression is not allowed!");
+
+            while (offSrcEnd > offSrc && RT_C_IS_BLANK(pchLine[offSrcEnd - 1]))
+                offSrcEnd--;
+
+            /* Comments with line continuation is not allowed in commited makefiles. */
+            if (offSrc < offSrcEnd && memchr(&pchLine[offSrc], '#', cchLine - offSrc) != NULL)
+                return scmKmkGiveUp(pParser, "Comment in multi-line 'if' expression is not allowed to start before the final line!");
+
+            /* Output it. */
+            if (offSrc < offSrcEnd)
+            {
+                if (iSubLine > 0 && offSrc > cchSrcContIndent)
+                {
+                    memset(pszDst, ' ', offSrc - cchSrcContIndent);
+                    pszDst += offSrc - cchSrcContIndent;
+                }
+                pszDst = (char *)mempcpy(pszDst, &pchLine[offSrc], offSrcEnd - offSrc);
+                *pszDst++ = ' ';
+            }
+            else if (iSubLine == 0)
+                return scmKmkGiveUp(pParser, "Expected expression after 'if', not line continuation!");
+            *pszDst++ = '\\';
+            *pszDst   = '\0';
+            size_t cchDst = (size_t)(pszDst - pParser->szBuf);
+            ScmStreamPutLine(pParser->pOut, pParser->szBuf, cchDst, pParser->enmEol);
+
+            /*
+             * Fetch the next line and start processing it.
+             */
+            pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+            if (!pchLine)
+            {
+                ScmError(pParser->pState, VERR_INTERNAL_ERROR_3, "ScmStreamGetLine unexpectedly returned NULL!");
+                return false;
+            }
+            cchLine = pParser->cchLine;
+
+            /* Skip leading whitespace and adjust the source continuation indent: */
+            offSrc = 0;
+            while (offSrc < cchLine && RT_C_IS_SPACE(pchLine[offSrc]))
+                offSrc++;
+            /** @todo tabs */
+
+            if (iSubLine == 0)
+                cchSrcContIndent = offSrc;
+
+            /* Initial indent: */
+            pszDst = pParser->szBuf;
+            memset(pszDst, ' ', cchIndent + 2);
+            pszDst += cchIndent + 2;
+        }
+
+        /* Output the expression on the final line. */
+        const char *pchSrcHash = (const char *)memchr(&pchLine[offSrc], '#', cchLine - offSrc);
+        size_t      cchExpr    = pchSrcHash ? pchSrcHash - &pchLine[offSrc] : cchLine - offSrc;
+        while (cchExpr > 0 && RT_C_IS_BLANK(pchLine[offSrc + cchExpr - 1]))
+            cchExpr--;
+
+        pszDst = (char *)mempcpy(pszDst, &pchLine[offSrc], cchExpr);
+        offSrc += cchExpr;
+    }
+
+
+    /*
+     * Handle comment.
+     *
+     * Here we check for the "scm:ignore-nesting" directive that makes us not
+     * add indentation for this directive.  We do this on the destination buffer
+     * as that can be zero terminated and is therefore usable with strstr.
+     */
+    if (offSrc >= cchLine)
+        *pszDst = '\0';
+    else
+    {
+        char * const pszDstSrc = pszDst;
+        scmKmkTailComment(pParser, pchLine, cchLine, offSrc, &pszDst);
+        *pszDst = '\0';
+
+        /* Check for special comment making us ignore the nesting.  We do this
+           on the destination buffer since it's zero terminated allowing normal
+           strstr use. */
+        if (!fIgnoredNesting && strstr(pszDstSrc, "scm:ignore-nesting") != NULL)
+        {
+            pParser->aDepth[pParser->iDepth - 1].fIgnoreNesting = true;
+            pParser->iActualDepth--;
+            ScmVerbose(pParser->pState, 5, "%u: debug: ignoring nesting - actual depth: %u\n",
+                       pParser->aDepth[pParser->iDepth - 1].iLine, pParser->iActualDepth);
+        }
+    }
+
+    /*
+     * Done.
+     */
+    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+    return false; /* dummy */
+}
+
+
+/**
+ * Deals with: else
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleElse(KMKPARSER *pParser, size_t offToken)
+{
+    const char * const pchLine   = pParser->pchLine;
+    size_t  const      cchLine   = pParser->cchLine;
+
+    if (pParser->iDepth < 1)
+        return scmKmkGiveUp(pParser, "Lone 'else'");
+    uint32_t const cchIndent = pParser->iActualDepth
+                             - (pParser->iActualDepth > 0 && !pParser->aDepth[pParser->iDepth - 1].fIgnoreNesting);
+
+    /*
+     * Look past the else and check if there any ifxxx token following it.
+     */
+    size_t offSrc = offToken + 4;
+    while (offSrc < cchLine && RT_C_IS_BLANK(pchLine[offSrc]))
+        offSrc++;
+    if (offSrc < cchLine)
+    {
+        size_t cchWord = 0;
+        while (offSrc + cchWord < cchLine && RT_C_IS_ALNUM(pchLine[offSrc + cchWord]))
+            cchWord++;
+        if (cchWord)
+        {
+            KMKTOKEN enmToken = scmKmkIdentifyToken(&pchLine[offSrc], cchWord);
+            switch (enmToken)
+            {
+                case kKmkToken_ifeq:
+                case kKmkToken_ifneq:
+                case kKmkToken_if1of:
+                case kKmkToken_ifn1of:
+                    return scmKmkHandleIfParentheses(pParser, offSrc, enmToken, cchWord, true /*fElse*/);
+
+                case kKmkToken_ifdef:
+                case kKmkToken_ifndef:
+                case kKmkToken_if:
+                    return scmKmkHandleIfSpace(pParser, offSrc, enmToken, cchWord, true /*fElse*/);
+
+                default:
+                    break;
+            }
+        }
+    }
+
+    /*
+     * We do not allow line continuation for these.
+     */
+    if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+        return scmKmkGiveUp(pParser, "Line continuation not allowed with 'else' directive.");
+
+    /*
+     * We stage the modified line in the buffer, so check that the line isn't
+     * too long (it seriously should be).
+     */
+    if (cchLine + cchIndent + 32 > sizeof(pParser->szBuf))
+        return scmKmkGiveUp(pParser, "Line too long for a 'else' directive: %u chars", cchLine);
+    char *pszDst = pParser->szBuf;
+
+    /*
+     * Emit indent and initial token.
+     */
+    memset(pszDst, ' ', cchIndent);
+    pszDst = (char *)mempcpy(&pszDst[cchIndent], RT_STR_TUPLE("else"));
+
+    offSrc = offToken + 4;
+
+    /*
+     * Handle comment.
+     */
+    if (offSrc < cchLine)
+        scmKmkTailComment(pParser, pchLine, cchLine, offSrc, &pszDst);
+
+    /*
+     * Done.
+     */
+    *pszDst = '\0';
+    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+    return false; /* dummy */
+}
+
+
+/**
+ * Deals with: endif
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleEndif(KMKPARSER *pParser, size_t offToken)
+{
+    const char * const pchLine   = pParser->pchLine;
+    size_t  const      cchLine   = pParser->cchLine;
+
+    /*
+     * Pop a nesting.
+     */
+    if (pParser->iDepth < 1)
+        return scmKmkGiveUp(pParser, "Lone 'endif'");
+    uint32_t iDepth = pParser->iDepth - 1;
+    pParser->iDepth = iDepth;
+    if (!pParser->aDepth[iDepth].fIgnoreNesting)
+    {
+        AssertStmt(pParser->iActualDepth > 0, pParser->iActualDepth++);
+        pParser->iActualDepth -= 1;
+    }
+    ScmVerbose(pParser->pState, 5, "%u: debug: unnesting %u/%u (endif)\n",
+               ScmStreamTellLine(pParser->pIn), iDepth, pParser->iActualDepth);
+    uint32_t const cchIndent = pParser->iActualDepth;
+
+    /*
+     * We do not allow line continuation for these.
+     */
+    if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+        return scmKmkGiveUp(pParser, "Line continuation not allowed with 'endif' directive.");
+
+    /*
+     * We stage the modified line in the buffer, so check that the line isn't
+     * too long (it seriously should be).
+     */
+    if (cchLine + cchIndent + 32 > sizeof(pParser->szBuf))
+        return scmKmkGiveUp(pParser, "Line too long for a 'else' directive: %u chars", cchLine);
+    char *pszDst = pParser->szBuf;
+
+    /*
+     * Emit indent and initial token.
+     */
+    memset(pszDst, ' ', cchIndent);
+    pszDst = (char *)mempcpy(&pszDst[cchIndent], RT_STR_TUPLE("endif"));
+
+    size_t offSrc = offToken + 5;
+
+    /*
+     * Handle comment.
+     */
+    if (offSrc < cchLine)
+        scmKmkTailComment(pParser, pchLine, cchLine, offSrc, &pszDst);
+
+    /*
+     * Done.
+     */
+    *pszDst = '\0';
+    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+    return false; /* dummy */
+}
+
+
+/**
+ * Passing thru any line continuation lines following the current one.
+ */
+static bool scmKmkPassThruLineContinuationLines(KMKPARSER *pParser)
+{
+    while (scmKmkIsLineWithContinuation(pParser->pchLine, pParser->cchLine))
+    {
+        pParser->pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+        if (!pParser->pchLine)
+            break;
+        ScmStreamPutLine(pParser->pOut, pParser->pchLine, pParser->cchLine, pParser->enmEol);
+    }
+    return false; /* dummy */
+}
+
+
+/**
+ * For dealing with a directive w/o special formatting rules (yet).
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleSimple(KMKPARSER *pParser, size_t offToken, bool fIndentIt = true)
+{
+    const char    *pchLine   = pParser->pchLine;
+    size_t         cchLine   = pParser->cchLine;
+    uint32_t const cchIndent = fIndentIt ? pParser->iActualDepth : 0;
+
+    /*
+     * Just reindent the statement.
+     */
+    ScmStreamWrite(pParser->pOut, g_szSpaces, cchIndent);
+    ScmStreamWrite(pParser->pOut, &pchLine[offToken], cchLine - offToken);
+    ScmStreamPutEol(pParser->pOut, pParser->enmEol);
+
+    /*
+     * Check for line continuation and output concatenated lines.
+     */
+    scmKmkPassThruLineContinuationLines(pParser);
+    return false; /* dummy */
+}
+
+
+static bool scmKmkHandleDefine(KMKPARSER *pParser, size_t offToken)
+{
+    scmKmkHandleSimple(pParser, offToken);
+
+    /* Hack Alert! Start out parsing the define in recipe mode.
+
+       Technically, we shouldn't evaluate the content of a define till it's
+       used. However, we ASSUME they are either makefile code snippets or
+       recipe templates.  */
+    scmKmkPushNesting(pParser, kKmkToken_define);
+    scmKmkSetInRecipe(pParser, true);
+    return false;
+}
+
+
+static bool scmKmkHandleEndef(KMKPARSER *pParser, size_t offToken)
+{
+    /* Leaving a define resets the recipt mode. */
+    scmKmkSetInRecipe(pParser, false);
+
+    /*
+     * Pop a nesting.
+     */
+    if (pParser->iDepth < 1)
+        return scmKmkGiveUp(pParser, "Lone 'endef'");
+    uint32_t iDepth = pParser->iDepth - 1;
+    if (pParser->aDepth[iDepth].enmToken != kKmkToken_define)
+        return scmKmkGiveUp(pParser, "Unpexected 'endef', expected 'endif' for line %u", pParser->aDepth[iDepth].iLine);
+    pParser->iDepth = iDepth;
+    if (!pParser->aDepth[iDepth].fIgnoreNesting)
+    {
+        AssertStmt(pParser->iActualDepth > 0, pParser->iActualDepth++);
+        pParser->iActualDepth -= 1;
+    }
+    ScmVerbose(pParser->pState, 5, "%u: debug: unnesting %u/%u (endef)\n",
+               ScmStreamTellLine(pParser->pIn), iDepth, pParser->iActualDepth);
+
+    return scmKmkHandleSimple(pParser, offToken);
+}
+
+
+/**
+ * Checks for escaped trailing slashes on a line, giving up and asking the
+ * developer to fix those manually.
+ *
+ * @returns true if we gave up. false if no escaped slashed and we didn't.
+ */
+static bool scmKmkGiveUpIfTrailingEscapedSlashed(KMKPARSER *pParser, const char *pchLine, size_t cchLine)
+{
+    if (cchLine > 2 && pchLine[cchLine - 2] == '\\' && pchLine[cchLine - 1] == '\\')
+    {
+        scmKmkGiveUp(pParser, "Escaped slashes at end of line not allowed. Insert space before line continuation slash!");
+        return true;
+    }
+    return false;
+}
+
+/**
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleAssignment2(KMKPARSER *pParser, size_t offVarStart, size_t offVarEnd, KMKASSIGNTYPE enmType,
+                                    size_t offAssignOp, unsigned fFlags)
+{
+    unsigned const      cchIndent    = pParser->iActualDepth;
+    const char         *pchLine      = pParser->pchLine;
+    size_t              cchLine      = pParser->cchLine;
+    uint32_t const      cLines       = pParser->cLines;
+    uint32_t            iSubLine     = 0;
+
+    RT_NOREF(fFlags);
+    Assert(offVarStart < cchLine);
+    Assert(offVarEnd  <= cchLine);
+    Assert(offVarStart < offVarEnd);
+    Assert(!RT_C_IS_SPACE(pchLine[offVarStart]));
+    Assert(!RT_C_IS_SPACE(pchLine[offVarEnd - 1]));
+
+    /* Assignments takes us out of recipe mode. */
+    ScmVerbose(pParser->pState, 6, "%u: debug: assignment\n", ScmStreamTellLine(pParser->pIn));
+    scmKmkSetInRecipe(pParser, false);
+
+    /* This is too much hazzle to deal with. */
+    if (cLines > 1 && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+        return false;
+    if (cchLine + 64 > sizeof(pParser->szBuf))
+        return scmKmkGiveUp(pParser, "Line too long!");
+
+    /*
+     * Indent and output the variable name.
+     */
+    char *pszDst = pParser->szBuf;
+    memset(pszDst, ' ', cchIndent);
+    pszDst += cchIndent;
+    pszDst = (char *)mempcpy(pszDst, &pchLine[offVarStart], offVarEnd - offVarStart);
+
+    /*
+     * Try preserve the assignment operator position, but make sure we've got a
+     * space in front of it.
+     */
+    if (offAssignOp < cchLine)
+    {
+        size_t offDst         = (size_t)(pszDst - pParser->szBuf);
+        size_t offEffAssignOp = ScmCalcSpacesForSrcSpan(pchLine, 0, offAssignOp, pParser->pSettings);
+        if (offDst < offEffAssignOp)
+        {
+            size_t cchSpacesToWrite = offEffAssignOp - offDst;
+            memset(pszDst, ' ', cchSpacesToWrite);
+            pszDst += cchSpacesToWrite;
+        }
+        else
+            *pszDst++ = ' ';
+    }
+    else
+    {
+        /* Pull up the assignment operator to the variable line. */
+        *pszDst++ = ' ';
+
+        /* Eat up lines till we hit the operator. */
+        while (offAssignOp < cchLine)
+        {
+            const char * const pchPrevLine = pchLine;
+            Assert(iSubLine + 1 < cLines);
+            pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+            AssertReturn(pchLine, false /*dummy*/);
+            cchLine = pParser->cchLine;
+            iSubLine++;
+            if (iSubLine + 1 < cLines && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+                return false;
+
+            /* Adjust offAssignOp: */
+            offAssignOp -= (uintptr_t)pchLine - (uintptr_t)pchPrevLine;
+            Assert(offAssignOp < ~(size_t)0 / 2);
+        }
+
+        if ((size_t)(pszDst - pParser->szBuf) > sizeof(pParser->szBuf))
+            return scmKmkGiveUp(pParser, "Line too long!");
+    }
+
+    /*
+     * Emit the operator.
+     */
+    size_t offLine = offAssignOp;
+    switch (enmType)
+    {
+        default:
+            AssertReleaseFailed();
+            RT_FALL_THRU();
+        case kKmkAssignType_Recursive:
+            *pszDst++ = '=';
+            Assert(pchLine[offLine] == '=');
+            offLine++;
+            break;
+        case kKmkAssignType_Conditional:
+            *pszDst++ = '?';
+            *pszDst++ = '=';
+            Assert(pchLine[offLine] == '?'); Assert(pchLine[offLine + 1] == '=');
+            offLine += 2;
+            break;
+        case kKmkAssignType_Appending:
+            *pszDst++ = '+';
+            *pszDst++ = '=';
+            Assert(pchLine[offLine] == '+'); Assert(pchLine[offLine + 1] == '=');
+            offLine += 2;
+            break;
+        case kKmkAssignType_Prepending:
+            *pszDst++ = '<';
+            *pszDst++ = '=';
+            Assert(pchLine[offLine] == '<'); Assert(pchLine[offLine + 1] == '=');
+            offLine += 2;
+            break;
+        case kKmkAssignType_Immediate:
+            *pszDst++ = ':';
+            Assert(pchLine[offLine] == ':');
+            offLine++;
+            RT_FALL_THRU();
+        case kKmkAssignType_Simple:
+            *pszDst++ = ':';
+            *pszDst++ = '=';
+            Assert(pchLine[offLine] == ':'); Assert(pchLine[offLine + 1] == '=');
+            offLine += 2;
+            break;
+    }
+
+    /*
+     * Skip space till we hit the value or comment.
+     */
+    while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+        offLine++;
+
+/** @todo this block can probably be merged into the final loop below. */
+    unsigned cPendingEols = 0;
+    while (iSubLine + 1 < cLines && offLine + 1 == cchLine && pchLine[offLine] == '\\')
+    {
+        pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+        AssertReturn(pchLine, false /*dummy*/);
+        cchLine = pParser->cchLine;
+        iSubLine++;
+        if (iSubLine + 1 < cLines && pchLine[cchLine - 2] == '\\')
+        {
+            *pszDst++ = ' ';
+            *pszDst++ = '\\';
+            *pszDst   = '\0';
+            ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+            return scmKmkGiveUp(pParser, "Escaped slashes at end of line not allowed. Insert space before line continuation slash!");
+        }
+        cPendingEols = 1;
+
+        /* Skip indent/whitespace. */
+        offLine = 0;
+        while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+            offLine++;
+    }
+
+    /*
+     * Okay, we've gotten to the value / comment part.
+     */
+    for (;;)
+    {
+        /*
+         * The end? Flush what we've got.
+         */
+        if (offLine == cchLine)
+        {
+            Assert(iSubLine + 1 == cLines);
+            *pszDst = '\0';
+            ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+            if (cPendingEols > 0)
+                ScmStreamPutEol(pParser->pOut, pParser->enmEol);
+            return false; /* dummy */
+        }
+
+        /*
+         * Output any non-comment stuff, stripping off newlines.
+         */
+        const char *pchHash = (const char *)memchr(&pchLine[offLine], '#', cchLine - offLine);
+        if (pchHash != &pchLine[offLine])
+        {
+            /* Add space or flush pending EOLs. */
+            if (!cPendingEols)
+                *pszDst++ = ' ';
+            else
+            {
+                unsigned iEol = 0;
+                cPendingEols = RT_MIN(2, cPendingEols); /* reduce to two, i.e. only one empty separator line */
+                do
+                {
+                    if (iEol++ == 0)  /* skip this for the 2nd empty line. */
+                        *pszDst++ = ' ';
+                    *pszDst++ = '\\';
+                    *pszDst = '\0';
+                    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+
+                    pszDst = pParser->szBuf;
+                    memset(pszDst, ' ', cchIndent);
+                    pszDst += cchIndent;
+                    *pszDst++ = '\t';
+                    cPendingEols--;
+                } while (cPendingEols > 0);
+            }
+
+            /* Strip backwards. */
+            size_t const offValueEnd2 = pchHash ? (size_t)(pchHash - pchLine) : cchLine - (iSubLine + 1 < cLines);
+            size_t       offValueEnd  = offValueEnd2;
+            while (offValueEnd > offLine && RT_C_IS_BLANK(pchLine[offValueEnd - 1]))
+                offValueEnd--;
+            Assert(offValueEnd > offLine);
+
+            /* Append the value part we found. */
+            pszDst = (char *)mempcpy(pszDst, &pchLine[offLine], offValueEnd - offLine);
+            offLine = offValueEnd2;
+        }
+
+        /*
+         * If we found a comment hash, emit it and whatever follows just as-is w/o
+         * any particular reformatting.  Comments within a variable definition are
+         * usually to disable portitions of a property like _DEFS or _SOURCES.
+         */
+        if (pchHash != NULL)
+        {
+            if (cPendingEols == 0)
+                scmKmkTailComment(pParser, pchLine, cchLine, offLine, &pszDst);
+            size_t const cchDst = (size_t)(pszDst - pParser->szBuf);
+            *pszDst = '\0';
+            ScmStreamPutLine(pParser->pOut, pParser->szBuf, cchDst, pParser->enmEol);
+
+            if (cPendingEols > 1)
+                ScmStreamPutEol(pParser->pOut, pParser->enmEol);
+
+            if (cPendingEols > 0)
+                ScmStreamPutLine(pParser->pOut, pchLine, cchLine, pParser->enmEol);
+            scmKmkPassThruLineContinuationLines(pParser);
+            return false; /* dummy */
+        }
+
+        /*
+         * Fetch another line, if we've got one.
+         */
+        if (iSubLine + 1 >= cLines)
+            Assert(offLine == cchLine);
+        else
+        {
+            Assert(offLine + 1 == cchLine);
+            while (iSubLine + 1 < cLines && offLine + 1 == cchLine && pchLine[offLine] == '\\')
+            {
+                pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+                AssertReturn(pchLine, false /*dummy*/);
+                cchLine = pParser->cchLine;
+                iSubLine++;
+                if (iSubLine + 1 < cLines && pchLine[cchLine - 2] == '\\')
+                {
+                    *pszDst++ = ' ';
+                    *pszDst++ = '\\';
+                    *pszDst   = '\0';
+                    ScmStreamPutLine(pParser->pOut, pParser->szBuf, pszDst - pParser->szBuf, pParser->enmEol);
+                    if (cPendingEols > 1)
+                        ScmError(pParser->pState, VERR_NOT_SUPPORTED, "oops #1: Manually fix the next issue after reverting edits!");
+                    return scmKmkGiveUp(pParser, "Escaped slashes at end of line not allowed. Insert space before line continuation slash!");
+                }
+                cPendingEols++;
+
+                /* Deal with indent/whitespace. */
+                offLine = 0;
+                while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+                    offLine++;
+            }
+        }
+    }
+}
+
+
+/**
+ * A rule.
+ *
+ * This is a bit involved. Sigh.
+ *
+ * @returns dummy (false) to facility return + call.
+ */
+static bool scmKmkHandleRule(KMKPARSER *pParser, size_t offFirstWord, bool fDoubleColon, size_t offColon)
+{
+    SCMSTREAM          *pOut         = pParser->pOut;
+    unsigned const      cchIndent    = pParser->iActualDepth;
+    const char         *pchLine      = pParser->pchLine;
+    size_t              cchLine      = pParser->cchLine;
+    Assert(offFirstWord < cchLine);
+    uint32_t const      cLines       = pParser->cLines;
+    uint32_t            iSubLine     = 0;
+
+    /* Following this, we'll be in recipe-mode. */
+    ScmVerbose(pParser->pState, 4, "%u: debug: start rule\n", ScmStreamTellLine(pParser->pIn));
+    scmKmkSetInRecipe(pParser, true);
+
+    /* This is too much hazzle to deal with. */
+    if (cLines > 0 && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+        return false;
+
+    /* Too special case. */
+    if (offColon <= offFirstWord)
+        return scmKmkGiveUp(pParser, "Missing target file before colon!");
+
+    /*
+     * Indent it.
+     */
+    ScmStreamWrite(pOut, g_szSpaces, cchIndent);
+    size_t offLine = offFirstWord;
+
+    /*
+     * Process word by word past the colon, taking new lines into account.
+     */
+    KMKWORDSTATE WordState    = { 0, 0 };
+    KMKWORDCTX   enmCtx       = kKmkWordCtx_TargetFileOrAssignment;
+    unsigned     cPendingEols = 0;
+    for (;;)
+    {
+        /*
+         * Output the next word.
+         */
+        size_t cchWord = scmKmkWordLength(pchLine, cchLine, offLine, enmCtx, &WordState);
+        Assert(offLine + cchWord <= offColon);
+        ScmStreamWrite(pOut, &pchLine[offLine], cchWord);
+        offLine += cchWord;
+
+        /* Skip whitespace (if any). */
+        while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+            offLine++;
+
+        /* Have we reached the colon already? */
+        if (offLine >= offColon)
+        {
+            Assert(pchLine[offLine] == ':');
+            Assert(!fDoubleColon || pchLine[offLine + 1] == ':');
+            offLine += fDoubleColon ? 2 : 1;
+
+            ScmStreamPutCh(pOut, ':');
+            if (fDoubleColon)
+                ScmStreamPutCh(pOut, ':');
+            break;
+        }
+
+        /* Deal with new line and emit indentation. */
+        if (offLine + 1 == cchLine && pchLine[offLine] == '\\')
+        {
+            /* Get the next input line. */
+            for (;;)
+            {
+                const char * const pchPrevLine = pchLine;
+                Assert(iSubLine + 1 < cLines);
+                pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+                AssertReturn(pchLine, false /*dummy*/);
+                cchLine = pParser->cchLine;
+                iSubLine++;
+                if (iSubLine + 1 < cLines && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+                    return false;
+
+                /* Adjust offColon: */
+                offColon -= (uintptr_t)pchLine - (uintptr_t)pchPrevLine;
+                Assert(offColon < ~(size_t)0 / 2);
+
+                /* Skip leading spaces. */
+                offLine = 0;
+                while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+                    offLine++;
+
+                /* Just drop empty lines. */
+                if (offLine + 1 == cchLine && pchLine[offLine] == '\\')
+                    continue;
+
+                /* Complete the current line and emit indent, unless we reached the colon: */
+                if (offLine >= offColon)
+                {
+                    Assert(pchLine[offLine] == ':');
+                    Assert(!fDoubleColon || pchLine[offLine + 1] == ':');
+                    offLine += fDoubleColon ? 2 : 1;
+
+                    ScmStreamPutCh(pOut, ':');
+                    if (fDoubleColon)
+                        ScmStreamPutCh(pOut, ':');
+
+                    cPendingEols = 1;
+                }
+                else
+                {
+                    ScmStreamWrite(pOut, RT_STR_TUPLE(" \\"));
+                    ScmStreamPutEol(pOut, pParser->enmEol);
+                    ScmStreamWrite(pOut, g_szSpaces, cchIndent);
+                    if (WordState.uDepth > 0)
+                        ScmStreamWrite(pOut, g_szTabs, RT_MIN(WordState.uDepth, sizeof(g_szTabs) - 1));
+                }
+                break;
+            }
+            if (offLine >= offColon)
+                break;
+        }
+        else
+            ScmStreamPutCh(pOut, ' ');
+        enmCtx = kKmkWordCtx_TargetFile;
+    }
+
+    /*
+     * We're immediately past the colon now, so eat whitespace and newlines and
+     * whatever till we get to a solid word or the end of the line.
+     */
+    /* Skip spaces - there should be exactly one. */
+    while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+        offLine++;
+
+    /* Deal with new lines: */
+    while (offLine + 1 == cchLine && pchLine[offLine] == '\\')
+    {
+        cPendingEols = 1;
+
+        Assert(iSubLine + 1 < cLines);
+        pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+        AssertReturn(pchLine, false /*dummy*/);
+        cchLine = pParser->cchLine;
+        iSubLine++;
+        if (iSubLine + 1 < cLines && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+            return false;
+
+         /* Skip leading spaces. */
+         offLine = 0;
+         while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+             offLine++;
+
+         /* Just drop empty lines. */
+         if (offLine + 1 == cchLine && pchLine[offLine] == '\\')
+             continue;
+    }
+
+    /*
+     * Special case: No dependencies.
+     */
+    if (offLine == cchLine && iSubLine + 1 >= cLines)
+    {
+        ScmStreamPutEol(pOut, pParser->enmEol);
+        return false /*dummy*/;
+    }
+
+    /*
+     * Work the dependencies word for word.  Indent in spaces + two tabs.
+     * (Pattern rules will also end up here, but we'll just ignore that for now.)
+     */
+    enmCtx = kKmkWordCtx_DepFileOrAssignment;
+    for (;;)
+    {
+        /* Indent the next word. */
+        if (cPendingEols == 0)
+            ScmStreamPutCh(pOut, ' ');
+        else
+        {
+            ScmStreamWrite(pOut, RT_STR_TUPLE(" \\"));
+            ScmStreamPutEol(pOut, pParser->enmEol);
+            ScmStreamWrite(pOut, g_szSpaces, cchIndent);
+            ScmStreamWrite(pOut, RT_STR_TUPLE("\t\t"));
+            if (cPendingEols > 1)
+            {
+                ScmStreamWrite(pOut, RT_STR_TUPLE("\\"));
+                ScmStreamPutEol(pOut, pParser->enmEol);
+                ScmStreamWrite(pOut, g_szSpaces, cchIndent);
+                ScmStreamWrite(pOut, RT_STR_TUPLE("\t\t"));
+            }
+            cPendingEols = 0;
+        }
+        if (WordState.uDepth > 0)
+            ScmStreamWrite(pOut, g_szTabs, RT_MIN(WordState.uDepth, sizeof(g_szTabs) - 1));
+
+        /* Get the next word and output it. */
+        size_t cchWord = scmKmkWordLength(pchLine, cchLine, offLine, enmCtx, &WordState);
+        Assert(offLine + cchWord <= cchLine);
+
+        ScmStreamWrite(pOut, &pchLine[offLine], cchWord);
+        offLine += cchWord;
+
+        /* Skip whitespace (if any). */
+        while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+            offLine++;
+
+        /* Deal with new line and emit indentation. */
+        if (iSubLine + 1 < cLines && offLine + 1 == cchLine && pchLine[offLine] == '\\')
+        {
+            /* Get the next input line. */
+            for (;;)
+            {
+                Assert(iSubLine + 1 < cLines);
+                pParser->pchLine = pchLine = ScmStreamGetLine(pParser->pIn, &pParser->cchLine, &pParser->enmEol);
+                AssertReturn(pchLine, false /*dummy*/);
+                cchLine = pParser->cchLine;
+                iSubLine++;
+                if (iSubLine + 1 < cLines && scmKmkGiveUpIfTrailingEscapedSlashed(pParser, pchLine, cchLine))
+                    return false;
+
+                /* Skip leading spaces. */
+                offLine = 0;
+                while (offLine < cchLine && RT_C_IS_SPACE(pchLine[offLine]))
+                    offLine++;
+
+                /* Just drop empty lines, we'll re-add one of them afterward if we find more dependencies. */
+                cPendingEols++;
+                if (offLine + 1 == cchLine && pchLine[offLine] == '\\')
+                    continue;
+                break;
+            }
+        }
+
+        if (offLine >= cchLine)
+        {
+            /* End of input. */
+/** @todo deal with comments */
+            Assert(iSubLine + 1 == cLines);
+            ScmStreamPutEol(pOut, pParser->enmEol);
+            return false; /* dummmy */
+        }
+        enmCtx = kKmkWordCtx_DepFile;
+    }
+}
+
+
+/**
+ * Checks if the (extended) line is a variable assignment.
+ *
+ * We scan past line continuation stuff here as the assignment operator could be
+ * on the next line, even if that's very unlikely it is recommened by the coding
+ * guide lines if the line needs to be split.  Fortunately, though, the caller
+ * already removes empty empty leading lines, so we only have to consider the
+ * line continuation issue if no '=' was found on the first line.
+ *
+ * @returns Modified or not.
+ * @param   pParser         The parser.
+ * @param   cLines          Number of lines to consider.
+ * @param   cchTotalLine    Total length of all the lines to consider.
+ * @param   offWord         Where the first word of the line starts.
+ * @param   pfIsAssignment  Where to return whether this is an assignment or
+ *                          not.
+ */
+static bool scmKmkHandleAssignmentOrRule(KMKPARSER *pParser, size_t offWord)
+{
+    const char  *pchLine      = pParser->pchLine;
+    size_t const cchTotalLine = pParser->cchTotalLine;
+
+    /*
+     * Scan words till we find ':' or '='.
+     */
+    uint32_t iWord      = 0;
+    size_t   offCurWord = offWord;
+    size_t   offEndPrev = 0;
+    size_t   offLine    = offWord;
+    while (offLine < cchTotalLine)
+    {
+        char ch = pchLine[offLine++];
+        if (ch == '$')
+        {
+            /*
+             * Skip variable expansion.
+             */
+            char const chOpen = pchLine[offLine++];
+            if (chOpen == '(' || chOpen == '{')
+            {
+                char const chClose = chOpen == '(' ? ')' : '}';
+                unsigned   cDepth  = 1;
+                while (offLine < cchTotalLine)
+                {
+                    ch = pchLine[offLine++];
+                    if (ch == chOpen)
+                        cDepth++;
+                    else if (ch == chClose)
+                        if (!--cDepth)
+                            break;
+                }
+            }
+            /* else: $x or $$, so just skip the next character. */
+        }
+        else if (RT_C_IS_SPACE(ch))
+        {
+            /*
+             * End of word. Skip whitespace till the next word starts.
+             */
+            offEndPrev = offLine - 1;
+            Assert(offLine != offWord);
+            while (offLine < cchTotalLine)
+            {
+                ch = pchLine[offLine];
+                if (RT_C_IS_SPACE(ch))
+                    offLine++;
+                else if (ch == '\\' && (pchLine[offLine] == '\r' || pchLine[offLine] == '\n'))
+                    offLine += 2;
+                else
+                    break;
+            }
+            offCurWord = offLine;
+            iWord++;
+
+            /*
+             * To simplify the assignment operator checks, we just check the
+             * start of the 2nd word when we're here.
+             */
+            if (iWord == 1 && offLine < cchTotalLine)
+            {
+                ch = pchLine[offLine];
+                if (ch == '=')
+                    return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Recursive, offLine, 0);
+                if (offLine + 1 < cchTotalLine && pchLine[offLine + 1] == '=')
+                {
+                    if (ch == ':')
+                        return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Simple,      offLine, 0);
+                    if (ch == '+')
+                        return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Appending,   offLine, 0);
+                    if (ch == '<')
+                        return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Prepending,  offLine, 0);
+                    if (ch == '?')
+                        return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Conditional, offLine, 0);
+                }
+                else if (   ch                   == ':'
+                         && pchLine[offLine + 1] == ':'
+                         && pchLine[offLine + 2] == '=')
+                    return scmKmkHandleAssignment2(pParser, offWord, offEndPrev, kKmkAssignType_Immediate, offLine, 0);
+
+                /* Check for rule while we're here. */
+                if (ch == ':')
+                    return scmKmkHandleRule(pParser, offWord, pchLine[offLine + 1] == ':', offLine);
+            }
+        }
+        /*
+         * If '=' is found in the first word it's an assignment.
+         */
+        else if (ch == '=')
+        {
+            if (iWord == 0)
+            {
+                KMKASSIGNTYPE enmType = kKmkAssignType_Recursive;
+                ch = pchLine[offLine - 2];
+                if (ch == '+')
+                    enmType = kKmkAssignType_Appending;
+                else if (ch == '?')
+                    enmType = kKmkAssignType_Conditional;
+                else if (ch == '<')
+                    enmType = kKmkAssignType_Prepending;
+                else
+                {
+                    Assert(ch != ':');
+                    return scmKmkHandleAssignment2(pParser, offWord, offLine - 1, enmType, offLine - 1, 0);
+                }
+                return scmKmkHandleAssignment2(pParser, offWord, offLine - 2, enmType, offLine - 2, 0);
+            }
+        }
+        /*
+         * When ':' is found it can mean a drive letter, a rule or in the
+         * first word a simple or immediate assignment.
+         */
+        else if (ch == ':')
+        {
+            /* Check for drive letters (we ignore the archive form): */
+            if (offLine - offWord == 2 && RT_C_IS_ALPHA(pchLine[offLine - 2]))
+            {  /* ignore */ }
+            else
+            {
+                /* Simple or immediate assignment? */
+                ch = pchLine[offLine];
+                if (iWord == 0)
+                {
+                    if (ch == '=')
+                        return scmKmkHandleAssignment2(pParser, offWord, offLine - 1, kKmkAssignType_Simple, offLine - 1, 0);
+                    if (ch == ':' && pchLine[offLine + 1] == '=')
+                        return scmKmkHandleAssignment2(pParser, offWord, offLine - 1, kKmkAssignType_Immediate, offLine - 1, 0);
+                }
+
+                /* Okay, it's a rule then. */
+                return scmKmkHandleRule(pParser, offWord, ch == ':', offLine - 1);
+            }
+        }
+    }
+
+    /*
+     * Check if this is a $(error ) or similar function call line.
+     *
+     * If we're inside a 'define' we treat $$ as $ as it's probably a case of
+     * double expansion (e.g. def_vmm_lib_dtrace_preprocess in VMM/Makefile.kmk).
+     */
+    if (pchLine[offWord] == '$')
+    {
+        size_t const cDollars = pchLine[offWord + 1] != '$' || !scmKmkIsInsideDefine(pParser) ? 1 : 2;
+        if (   pchLine[offWord + cDollars] == '('
+            || pchLine[offWord + cDollars] == '{')
+        {
+            size_t const cchLine = pParser->cchLine;
+            size_t       offEnd  = offWord + cDollars + 1;
+            char         ch      = '\0';
+            while (offEnd < cchLine && (RT_C_IS_LOWER(ch = pchLine[offEnd]) || RT_C_IS_DIGIT(ch) || ch == '-'))
+                offEnd++;
+            if (offEnd >= cchLine || RT_C_IS_SPACE(ch) || (offEnd == cchLine - 1 && ch == '\\'))
+            {
+                static const RTSTRTUPLE s_aAllowedFunctions[] =
+                {
+                    { RT_STR_TUPLE("info") },
+                    { RT_STR_TUPLE("error") },
+                    { RT_STR_TUPLE("warning") },
+                    { RT_STR_TUPLE("set-umask") },
+                    { RT_STR_TUPLE("foreach") },
+                    { RT_STR_TUPLE("call") },
+                    { RT_STR_TUPLE("eval") },
+                    { RT_STR_TUPLE("evalctx") },
+                    { RT_STR_TUPLE("evalval") },
+                    { RT_STR_TUPLE("evalvalctx") },
+                    { RT_STR_TUPLE("evalcall") },
+                    { RT_STR_TUPLE("evalcall2") },
+                    { RT_STR_TUPLE("eval-opt-var") },
+                    { RT_STR_TUPLE("kb-src-one") },
+                };
+                size_t cchFunc = offEnd - offWord - cDollars - 1;
+                for (size_t i = 0; i < RT_ELEMENTS(s_aAllowedFunctions); i++)
+                    if (   cchFunc == s_aAllowedFunctions[i].cch
+                        && memcmp(&pchLine[offWord + cDollars + 1], s_aAllowedFunctions[i].psz, cchFunc) == 0)
+                        return scmKmkHandleSimple(pParser, offWord);
+            }
+        }
+    }
+
+    /*
+     * If we didn't find anything, output it as-as.
+     * We use scmKmkHandleSimple in a special way to do this.
+     */
+    if (!RTStrStartsWith(pchLine, "$(TOOL_")) /* ValKit/Config.kmk */
+        ScmVerbose(pParser->pState, 1, "%u: debug: Unable to make sense of this line!\n", ScmStreamTellLine(pParser->pIn));
+    return scmKmkHandleSimple(pParser, 0 /*offToken*/, false /*fIndentIt*/);
+}
+
+
+static bool scmKmkHandleAssignKeyword(KMKPARSER *pParser, size_t offToken, KMKTOKEN enmToken, size_t cchWord,
+                                      bool fMustBeAssignment)
+{
+    /* Assignments takes us out of recipe mode. */
+    scmKmkSetInRecipe(pParser, false);
+
+    RT_NOREF(pParser, offToken, enmToken, cchWord, fMustBeAssignment);
+    return scmKmkHandleSimple(pParser, offToken);
+}
+
+
+/**
+ * Rewrite a kBuild makefile.
+ *
+ * @returns kScmMaybeModified or kScmUnmodified.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ *
+ * @todo
+ *
+ * Ideas for Makefile.kmk and Config.kmk:
+ *      - sort if1of/ifn1of sets.
+ *      - line continuation slashes should only be preceded by one space.
+ */
+SCMREWRITERRES rewrite_Makefile_kmk(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fStandarizeKmk)
+        return kScmUnmodified;
+
+    /*
+     * Parser state.
+     */
+    KMKPARSER Parser;
+    Parser.iDepth       = 0;
+    Parser.iActualDepth = 0;
+    Parser.fInRecipe    = false;
+    Parser.pState       = pState;
+    Parser.pIn          = pIn;
+    Parser.pOut         = pOut;
+    Parser.pSettings    = pSettings;
+
+    /*
+     * Iterate the file.
+     */
+    const char *pchLine;
+    while ((Parser.pchLine = pchLine = ScmStreamGetLine(pIn, &Parser.cchLine, &Parser.enmEol)) != NULL)
+    {
+        size_t cchLine = Parser.cchLine;
+
+        /*
+         * If we're in the command part of a recipe, anything starting with a
+         * tab is considered another command for the recipe.
+         */
+        if (Parser.fInRecipe && *pchLine == '\t')
+        {
+            /* Do we do anything here? */
+        }
+        else
+        {
+            /*
+             * Skip leading whitespace and check for directives (simplified).
+             *
+             * This is simplified in the sense that GNU make first checks for variable
+             * assignments, so that directive can be used as variable names.  We don't
+             * want that, so we do the variable assignment check later.
+             */
+            size_t offLine = 0;
+            while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
+                offLine++;
+
+            /* Find end of word (if any) - only looking for keywords here: */
+            size_t cchWord = 0;
+            while (   offLine + cchWord < cchLine
+                   && (   RT_C_IS_ALNUM(pchLine[offLine + cchWord])
+                       || pchLine[offLine + cchWord] == '-'))
+                cchWord++;
+            if (cchWord > 0)
+            {
+                /* If the line is just a line continuation slash, simply remove it
+                   (this also makes the parsing a lot easier). */
+                if (cchWord == 1 && offLine == cchLine - 1 && pchLine[cchLine] == '\\')
+                    continue;
+
+                /* Unlike the GNU make parser, we won't recognize 'if' or any other
+                   directives as variable names, so we can  */
+                KMKTOKEN enmToken = scmKmkIdentifyToken(&pchLine[offLine], cchWord);
+                switch (enmToken)
+                {
+                    case kKmkToken_ifeq:
+                    case kKmkToken_ifneq:
+                    case kKmkToken_if1of:
+                    case kKmkToken_ifn1of:
+                        scmKmkHandleIfParentheses(&Parser, offLine, enmToken, cchWord, false /*fElse*/);
+                        continue;
+
+                    case kKmkToken_ifdef:
+                    case kKmkToken_ifndef:
+                    case kKmkToken_if:
+                        scmKmkHandleIfSpace(&Parser, offLine, enmToken, cchWord, false /*fElse*/);
+                        continue;
+
+                    case kKmkToken_else:
+                        scmKmkHandleElse(&Parser, offLine);
+                        continue;
+
+                    case kKmkToken_endif:
+                        scmKmkHandleEndif(&Parser, offLine);
+                        continue;
+
+                    /* Includes: */
+                    case kKmkToken_include:
+                    case kKmkToken_sinclude:
+                    case kKmkToken_dash_include:
+                    case kKmkToken_includedep:
+                    case kKmkToken_includedep_queue:
+                    case kKmkToken_includedep_flush:
+                        scmKmkHandleSimple(&Parser, offLine);
+                        continue;
+
+                    /* Others: */
+                    case kKmkToken_define:
+                        scmKmkHandleDefine(&Parser, offLine);
+                        continue;
+                    case kKmkToken_endef:
+                        scmKmkHandleEndef(&Parser, offLine);
+                        continue;
+
+                    case kKmkToken_override:
+                    case kKmkToken_local:
+                        scmKmkHandleAssignKeyword(&Parser, offLine, enmToken, cchWord, true /*fMustBeAssignment*/);
+                        continue;
+
+                    case kKmkToken_export:
+                        scmKmkHandleAssignKeyword(&Parser, offLine, enmToken, cchWord, false /*fMustBeAssignment*/);
+                        continue;
+
+                    case kKmkToken_unexport:
+                    case kKmkToken_undefine:
+                        scmKmkHandleSimple(&Parser, offLine);
+                        continue;
+
+                    case kKmkToken_Comment:
+                        AssertFailed(); /* not possible */
+                        break;
+
+                    /*
+                     * Check if it's perhaps an variable assignment or start of a rule.
+                     * We'll do this in a very simple fashion.
+                     */
+                    case kKmkToken_Word:
+                    {
+                        Parser.cLines       = 1;
+                        Parser.cchTotalLine = cchLine;
+                        if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+                            Parser.cchTotalLine = scmKmkLineContinuationPeek(&Parser, &Parser.cLines, NULL);
+                        scmKmkHandleAssignmentOrRule(&Parser, offLine);
+                        continue;
+                    }
+                }
+            }
+            /*
+             * Not keyword, check for assignment, rule or comment:
+             */
+            else if (offLine < cchLine)
+            {
+                if (pchLine[offLine] != '#')
+                {
+                    Parser.cLines       = 1;
+                    Parser.cchTotalLine = cchLine;
+                    if (scmKmkIsLineWithContinuation(pchLine, cchLine))
+                        Parser.cchTotalLine = scmKmkLineContinuationPeek(&Parser, &Parser.cLines, NULL);
+                    scmKmkHandleAssignmentOrRule(&Parser, offLine);
+                    continue;
+                }
+
+                /*
+                 * Indent comment lines, unless the comment is too far too the right.
+                 */
+                size_t const offEffLine = ScmCalcSpacesForSrcSpan(pchLine, 0, offLine, pSettings);
+                if (offEffLine <= Parser.iActualDepth + 7)
+                {
+                    ScmStreamWrite(pOut, g_szSpaces, Parser.iActualDepth);
+                    ScmStreamWrite(pOut, &pchLine[offLine], cchLine - offLine);
+                    ScmStreamPutEol(pOut, Parser.enmEol);
+
+                    /* If line continuation is used, it's typically to disable
+                       a property variable, so we just pass it thru as-is */
+                    while (scmKmkIsLineWithContinuation(pchLine, cchLine))
+                    {
+                        Parser.pchLine = pchLine = ScmStreamGetLine(pIn, &Parser.cchLine, &Parser.enmEol);
+                        if (!pchLine)
+                            break;
+                        cchLine = Parser.cchLine;
+                        ScmStreamPutLine(pOut, pchLine, cchLine, Parser.enmEol);
+                    }
+                    continue;
+                }
+            }
+        }
+
+        /*
+         * Pass it thru as-is with line continuation.
+         */
+        while (scmKmkIsLineWithContinuation(pchLine, cchLine))
+        {
+            ScmStreamPutLine(pOut, pchLine, cchLine, Parser.enmEol);
+            Parser.pchLine = pchLine = ScmStreamGetLine(pIn, &Parser.cchLine, &Parser.enmEol);
+            if (!pchLine)
+                break;
+            cchLine = Parser.cchLine;
+        }
+        if (pchLine)
+            ScmStreamPutLine(pOut, pchLine, cchLine, Parser.enmEol);
+    }
+
+    return kScmMaybeModified; /* Make the caller check */
+}
+
+
+/**
+ * Makefile.kup are empty files, enforce this.
+ *
+ * @returns true if modifications were made, false if not.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_Makefile_kup(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pOut, pSettings);
+
+    /* These files should be zero bytes. */
+    if (pIn->cb == 0)
+        return kScmUnmodified;
+    ScmVerbose(pState, 2, " * Truncated file to zero bytes\n");
+    return kScmModified;
+}
+
diff --git a/src/bldprogs/scmrw.cpp b/src/bldprogs/scmrw.cpp
new file mode 100644
index 00000000..526a38da
--- /dev/null
+++ b/src/bldprogs/scmrw.cpp
@@ -0,0 +1,3613 @@
+/* $Id: scmrw.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/file.h>
+#include <iprt/err.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scm.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** License types. */
+typedef enum SCMLICENSETYPE
+{
+    kScmLicenseType_Invalid = 0,
+    kScmLicenseType_OseGpl,
+    kScmLicenseType_OseDualGplCddl,
+    kScmLicenseType_OseCddl,
+    kScmLicenseType_VBoxLgpl,
+    kScmLicenseType_Mit,
+    kScmLicenseType_Confidential
+} SCMLICENSETYPE;
+
+/** A license. */
+typedef struct SCMLICENSETEXT
+{
+    /** The license type. */
+    SCMLICENSETYPE  enmType;
+    /** The license option. */
+    SCMLICENSE      enmOpt;
+    /** The license text.   */
+    const char     *psz;
+    /** The license text length. */
+    size_t          cch;
+} SCMLICENSETEXT;
+/** Pointer to a license. */
+typedef SCMLICENSETEXT const *PCSCMLICENSETEXT;
+
+/**
+ * Copyright + license rewriter state.
+ */
+typedef struct SCMCOPYRIGHTINFO
+{
+    /** State. */
+    PSCMRWSTATE         pState;                 /**< input */
+    /** The comment style (neede for C/C++). */
+    SCMCOMMENTSTYLE     enmCommentStyle;        /**< input */
+
+    /** Number of comments we've parsed. */
+    uint32_t            cComments;
+
+    /** Copy of the contributed-by line if present. */
+    char               *pszContributedBy;
+
+    /** @name Common info
+     * @{ */
+    uint32_t            iLineComment;
+    uint32_t            cLinesComment;          /**< This excludes any external license lines. */
+    /** @} */
+
+    /** @name Copyright info
+     * @{ */
+    uint32_t            iLineCopyright;
+    uint32_t            uFirstYear;
+    uint32_t            uLastYear;
+    bool                fWellFormedCopyright;
+    bool                fUpToDateCopyright;
+    /** @} */
+
+    /** @name License info
+     * @{ */
+    bool                fOpenSource;            /**< input */
+    PCSCMLICENSETEXT    pExpectedLicense;       /**< input */
+    PCSCMLICENSETEXT    paLicenses;             /**< input */
+    SCMLICENSE          enmLicenceOpt;          /**< input */
+    uint32_t            iLineLicense;
+    uint32_t            cLinesLicense;
+    PCSCMLICENSETEXT    pCurrentLicense;
+    bool                fIsCorrectLicense;
+    bool                fWellFormedLicense;
+    bool                fExternalLicense;
+    /** @} */
+
+    /** @name LGPL licence notice and disclaimer info
+     * @{ */
+    /** Wheter to check for LGPL license notices and disclaimers. */
+    bool                fCheckforLgpl;
+    /** The approximate line we found the (first) LGPL licence notice on. */
+    uint32_t            iLineLgplNotice;
+    /** The line number after the LGPL notice comment. */
+    uint32_t            iLineAfterLgplComment;
+    /** The LGPL disclaimer line. */
+    uint32_t            iLineLgplDisclaimer;
+    /** @} */
+
+} SCMCOPYRIGHTINFO;
+typedef SCMCOPYRIGHTINFO *PSCMCOPYRIGHTINFO;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** --license-ose-gpl */
+static const char g_szVBoxOseGpl[] =
+    "This file is part of VirtualBox base platform packages, as\n"
+    "available from https://www.virtualbox.org.\n"
+    "\n"
+    "This program is free software; you can redistribute it and/or\n"
+    "modify it under the terms of the GNU General Public License\n"
+    "as published by the Free Software Foundation, in version 3 of the\n"
+    "License.\n"
+    "\n"
+    "This program is distributed in the hope that it will be useful, but\n"
+    "WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
+    "General Public License for more details.\n"
+    "\n"
+    "You should have received a copy of the GNU General Public License\n"
+    "along with this program; if not, see <https://www.gnu.org/licenses>.\n"
+    "\n"
+    "SPDX-License-Identifier: GPL-3.0-only\n";
+
+static const char g_szVBoxOseOldGpl2[] =
+    "This file is part of VirtualBox Open Source Edition (OSE), as\n"
+    "available from http://www.virtualbox.org. This file is free software;\n"
+    "you can redistribute it and/or modify it under the terms of the GNU\n"
+    "General Public License (GPL) as published by the Free Software\n"
+    "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
+    "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
+    "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n";
+
+/** --license-ose-dual */
+static const char g_szVBoxOseDualGplCddl[] =
+    "This file is part of VirtualBox base platform packages, as\n"
+    "available from https://www.virtualbox.org.\n"
+    "\n"
+    "This program is free software; you can redistribute it and/or\n"
+    "modify it under the terms of the GNU General Public License\n"
+    "as published by the Free Software Foundation, in version 3 of the\n"
+    "License.\n"
+    "\n"
+    "This program is distributed in the hope that it will be useful, but\n"
+    "WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
+    "General Public License for more details.\n"
+    "\n"
+    "You should have received a copy of the GNU General Public License\n"
+    "along with this program; if not, see <https://www.gnu.org/licenses>.\n"
+    "\n"
+    "The contents of this file may alternatively be used under the terms\n"
+    "of the Common Development and Distribution License Version 1.0\n"
+    "(CDDL), a copy of it is provided in the \"COPYING.CDDL\" file included\n"
+    "in the VirtualBox distribution, in which case the provisions of the\n"
+    "CDDL are applicable instead of those of the GPL.\n"
+    "\n"
+    "You may elect to license modified versions of this file under the\n"
+    "terms and conditions of either the GPL or the CDDL or both.\n"
+    "\n"
+    "SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0\n";
+
+static const char g_szVBoxOseOldDualGpl2Cddl[] =
+    "This file is part of VirtualBox Open Source Edition (OSE), as\n"
+    "available from http://www.virtualbox.org. This file is free software;\n"
+    "you can redistribute it and/or modify it under the terms of the GNU\n"
+    "General Public License (GPL) as published by the Free Software\n"
+    "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
+    "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
+    "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
+    "\n"
+    "The contents of this file may alternatively be used under the terms\n"
+    "of the Common Development and Distribution License Version 1.0\n"
+    "(CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
+    "VirtualBox OSE distribution, in which case the provisions of the\n"
+    "CDDL are applicable instead of those of the GPL.\n"
+    "\n"
+    "You may elect to license modified versions of this file under the\n"
+    "terms and conditions of either the GPL or the CDDL or both.\n";
+
+/** --license-ose-cddl   */
+static const char g_szVBoxOseCddl[] =
+    "This file is part of VirtualBox base platform packages, as\n"
+    "available from http://www.virtualbox.org.\n"
+    "\n"
+    "The contents of this file are subject to the terms of the Common\n"
+    "Development and Distribution License Version 1.0 (CDDL) only, as it\n"
+    "comes in the \"COPYING.CDDL\" file of the VirtualBox distribution.\n"
+    "\n"
+    "SPDX-License-Identifier: CDDL-1.0\n";
+
+static const char g_szVBoxOseOldCddl[] =
+    "This file is part of VirtualBox Open Source Edition (OSE), as\n"
+    "available from http://www.virtualbox.org. This file is free software;\n"
+    "you can redistribute it and/or modify it under the terms of the Common\n"
+    "Development and Distribution License Version 1.0 (CDDL) only, as it\n"
+    "comes in the \"COPYING.CDDL\" file of the VirtualBox OSE distribution.\n"
+    "VirtualBox OSE is distributed in the hope that it will be useful, but\n"
+    "WITHOUT ANY WARRANTY of any kind.\n";
+
+/** --license-lgpl */
+static const char g_szVBoxLgpl[] =
+    "This file is part of a free software library; you can redistribute\n"
+    "it and/or modify it under the terms of the GNU Lesser General\n"
+    "Public License version 2.1 as published by the Free Software\n"
+    "Foundation and shipped in the \"COPYING.LIB\" file with this library.\n"
+    "The library is distributed in the hope that it will be useful,\n"
+    "but WITHOUT ANY WARRANTY of any kind.\n"
+    "\n"
+    "Oracle LGPL Disclaimer: For the avoidance of doubt, except that if\n"
+    "any license choice other than GPL or LGPL is available it will\n"
+    "apply instead, Oracle elects to use only the Lesser General Public\n"
+    "License version 2.1 (LGPLv2) at this time for any software where\n"
+    "a choice of LGPL license versions is made available with the\n"
+    "language indicating that LGPLv2 or any later version may be used,\n"
+    "or where a choice of which version of the LGPL is applied is\n"
+    "otherwise unspecified.\n"
+    "\n"
+    "SPDX-License-Identifier: LGPL-2.1-only\n";
+
+/** --license-mit
+ * @note This isn't detectable as VirtualBox or Oracle specific.
+ */
+static const char g_szMit[] =
+    "Permission is hereby granted, free of charge, to any person\n"
+    "obtaining a copy of this software and associated documentation\n"
+    "files (the \"Software\"), to deal in the Software without\n"
+    "restriction, including without limitation the rights to use,\n"
+    "copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
+    "copies of the Software, and to permit persons to whom the\n"
+    "Software is furnished to do so, subject to the following\n"
+    "conditions:\n"
+    "\n"
+    "The above copyright notice and this permission notice shall be\n"
+    "included in all copies or substantial portions of the Software.\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
+    "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n"
+    "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
+    "NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n"
+    "HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n"
+    "WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
+    "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
+    "OTHER DEALINGS IN THE SOFTWARE.\n";
+
+/** --license-mit, alternative wording \#1.
+ * @note This differes from g_szMit in "AUTHORS OR COPYRIGHT HOLDERS" is written
+ *       "COPYRIGHT HOLDER(S) OR AUTHOR(S)". Its layout is wider, so it is a
+ *       couple of lines shorter. */
+static const char g_szMitAlt1[] =
+    "Permission is hereby granted, free of charge, to any person obtaining a\n"
+    "copy of this software and associated documentation files (the \"Software\"),\n"
+    "to deal in the Software without restriction, including without limitation\n"
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
+    "and/or sell copies of the Software, and to permit persons to whom the\n"
+    "Software is furnished to do so, subject to the following conditions:\n"
+    "\n"
+    "The above copyright notice and this permission notice shall be included in\n"
+    "all copies or substantial portions of the Software.\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\n"
+    "THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR\n"
+    "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n"
+    "ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
+    "OTHER DEALINGS IN THE SOFTWARE.\n";
+
+/** --license-mit, alternative wording \#2.
+ * @note This differes from g_szMit in that "AUTHORS OR COPYRIGHT HOLDERS" is
+ *       replaced with "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS".
+ *       Its layout is wider, so it is a couple of lines shorter. */
+static const char g_szMitAlt2[] =
+    "Permission is hereby granted, free of charge, to any person obtaining a\n"
+    "copy of this software and associated documentation files (the \"Software\"),\n"
+    "to deal in the Software without restriction, including without limitation\n"
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
+    "and/or sell copies of the Software, and to permit persons to whom the\n"
+    "Software is furnished to do so, subject to the following conditions:\n"
+    "\n"
+    "The above copyright notice and this permission notice shall be included in\n"
+    "all copies or substantial portions of the Software.\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+    "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
+    "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
+    "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
+    "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
+    "USE OR OTHER DEALINGS IN THE SOFTWARE.\n";
+
+/** --license-mit, alternative wording \#3.
+ * @note This differes from g_szMitAlt2 in that the second and third sections
+ *       have been switch. */
+static const char g_szMitAlt3[] =
+    "Permission is hereby granted, free of charge, to any person obtaining a\n"
+    "copy of this software and associated documentation files (the \"Software\"),\n"
+    "to deal in the Software without restriction, including without limitation\n"
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
+    "and/or sell copies of the Software, and to permit persons to whom the\n"
+    "Software is furnished to do so, subject to the following conditions:\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+    "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
+    "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
+    "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
+    "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
+    "USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
+    "\n"
+    "The above copyright notice and this permission notice shall be included in\n"
+    "all copies or substantial portions of the Software.\n";
+
+/** --license-(based-on)mit, alternative wording \#4.
+ * @note This differs from g_szMitAlt2 in injecting "(including the next
+ *       paragraph)". */
+static const char g_szMitAlt4[] =
+    "Permission is hereby granted, free of charge, to any person obtaining a\n"
+    "copy of this software and associated documentation files (the \"Software\"),\n"
+    "to deal in the Software without restriction, including without limitation\n"
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
+    "and/or sell copies of the Software, and to permit persons to whom the\n"
+    "Software is furnished to do so, subject to the following conditions:\n"
+    "\n"
+    "The above copyright notice and this permission notice (including the next\n"
+    "paragraph) shall be included in all copies or substantial portions of the\n"
+    "Software.\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\n"
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
+    "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n"
+    "DEALINGS IN THE SOFTWARE.\n";
+
+/** --license-(based-on)mit, alternative wording \#5.
+ * @note This differs from g_szMitAlt3 in using "sub license" instead of
+ *       "sublicense" and adding an illogical "(including the next
+ *       paragraph)" remark to the final paragraph. (vbox_ttm.c) */
+static const char g_szMitAlt5[] =
+    "Permission is hereby granted, free of charge, to any person obtaining a\n"
+    "copy of this software and associated documentation files (the\n"
+    "\"Software\"), to deal in the Software without restriction, including\n"
+    "without limitation the rights to use, copy, modify, merge, publish,\n"
+    "distribute, sub license, and/or sell copies of the Software, and to\n"
+    "permit persons to whom the Software is furnished to do so, subject to\n"
+    "the following conditions:\n"
+    "\n"
+    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+    "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
+    "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
+    "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
+    "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
+    "USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
+    "\n"
+    "The above copyright notice and this permission notice (including the\n"
+    "next paragraph) shall be included in all copies or substantial portions\n"
+    "of the Software.\n";
+
+/** Oracle confidential. */
+static const char g_szOracleConfidential[] =
+    "Oracle Corporation confidential\n";
+
+/** Oracle confidential, old style. */
+static const char g_szOracleConfidentialOld[] =
+    "Oracle Corporation confidential\n"
+    "All rights reserved\n";
+
+/** Licenses to detect when --license-mit isn't used. */
+static const SCMLICENSETEXT g_aLicenses[] =
+{
+    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseGpl)},
+    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseOldGpl2)},
+    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
+    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseOldDualGpl2Cddl) },
+    { kScmLicenseType_OseCddl,          kScmLicense_OseCddl,        RT_STR_TUPLE(g_szVBoxOseCddl) },
+    { kScmLicenseType_OseCddl,          kScmLicense_OseCddl,        RT_STR_TUPLE(g_szVBoxOseOldCddl) },
+    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidentialOld) },
+    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
+};
+
+/** Licenses to detect when --license-mit or --license-based-on-mit are used. */
+static const SCMLICENSETEXT g_aLicensesWithMit[] =
+{
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMit) },
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMitAlt1) },
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMitAlt2) },
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMitAlt3) },
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMitAlt4) },
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMitAlt5) },
+    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseGpl)},
+    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseOldGpl2)},
+    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
+    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseOldDualGpl2Cddl) },
+    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidentialOld) },
+    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
+};
+
+/** Copyright holder. */
+static const char g_szCopyrightHolder[] = "Oracle and/or its affiliates.";
+
+/** Old copyright holder. */
+static const char g_szOldCopyrightHolder[] = "Oracle Corporation";
+
+/** LGPL disclaimer. */
+static const char g_szLgplDisclaimer[] =
+    "Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice\n"
+    "other than GPL or LGPL is available it will apply instead, Oracle elects to use only\n"
+    "the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where\n"
+    "a choice of LGPL license versions is made available with the language indicating\n"
+    "that LGPLv2 or any later version may be used, or where a choice of which version\n"
+    "of the LGPL is applied is otherwise unspecified.\n";
+
+/** Copyright+license comment start for each SCMCOMMENTSTYLE. */
+static RTSTRTUPLE const g_aCopyrightCommentStart[] =
+{
+    { RT_STR_TUPLE("<invalid> ") },
+    { RT_STR_TUPLE("/*") },
+    { RT_STR_TUPLE("#") },
+    { RT_STR_TUPLE("\"\"\"") },
+    { RT_STR_TUPLE(";") },
+    { RT_STR_TUPLE("REM") },
+    { RT_STR_TUPLE("rem") },
+    { RT_STR_TUPLE("Rem") },
+    { RT_STR_TUPLE("--") },
+    { RT_STR_TUPLE("'") },
+    { RT_STR_TUPLE("<!--") },
+    { RT_STR_TUPLE("<end>") },
+};
+
+/** Copyright+license line prefix for each SCMCOMMENTSTYLE. */
+static RTSTRTUPLE const g_aCopyrightCommentPrefix[] =
+{
+    { RT_STR_TUPLE("<invalid> ") },
+    { RT_STR_TUPLE(" * ") },
+    { RT_STR_TUPLE("# ") },
+    { RT_STR_TUPLE("") },
+    { RT_STR_TUPLE("; ") },
+    { RT_STR_TUPLE("REM ") },
+    { RT_STR_TUPLE("rem ") },
+    { RT_STR_TUPLE("Rem ") },
+    { RT_STR_TUPLE("-- ") },
+    { RT_STR_TUPLE("' ") },
+    { RT_STR_TUPLE("    ") },
+    { RT_STR_TUPLE("<end>") },
+};
+
+/** Copyright+license empty line for each SCMCOMMENTSTYLE. */
+static RTSTRTUPLE const g_aCopyrightCommentEmpty[] =
+{
+    { RT_STR_TUPLE("<invalid>") },
+    { RT_STR_TUPLE(" *") },
+    { RT_STR_TUPLE("#") },
+    { RT_STR_TUPLE("") },
+    { RT_STR_TUPLE(";") },
+    { RT_STR_TUPLE("REM") },
+    { RT_STR_TUPLE("rem") },
+    { RT_STR_TUPLE("Rem") },
+    { RT_STR_TUPLE("--") },
+    { RT_STR_TUPLE("'") },
+    { RT_STR_TUPLE("") },
+    { RT_STR_TUPLE("<end>") },
+};
+
+/** Copyright+license end of comment for each SCMCOMMENTSTYLE. */
+static RTSTRTUPLE const g_aCopyrightCommentEnd[] =
+{
+    { RT_STR_TUPLE("<invalid> ") },
+    { RT_STR_TUPLE(" */") },
+    { RT_STR_TUPLE("#") },
+    { RT_STR_TUPLE("\"\"\"") },
+    { RT_STR_TUPLE(";") },
+    { RT_STR_TUPLE("REM") },
+    { RT_STR_TUPLE("rem") },
+    { RT_STR_TUPLE("Rem") },
+    { RT_STR_TUPLE("--") },
+    { RT_STR_TUPLE("'") },
+    { RT_STR_TUPLE("-->") },
+    { RT_STR_TUPLE("<end>") },
+};
+
+
+/**
+ * Figures out the predominant casing of the "REM" keyword in a batch file.
+ *
+ * @returns Predominant comment style.
+ * @param   pIn         The file to scan.  Will be rewound.
+ */
+static SCMCOMMENTSTYLE determineBatchFileCommentStyle(PSCMSTREAM pIn)
+{
+    /*
+     * Figure out whether it's using upper or lower case REM comments before
+     * doing the work.
+     */
+    uint32_t    cUpper = 0;
+    uint32_t    cLower = 0;
+    uint32_t    cCamel = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        while (   cchLine > 2
+               && RT_C_IS_SPACE(*pchLine))
+        {
+            pchLine++;
+            cchLine--;
+        }
+        if (   (   cchLine > 3
+                && RT_C_IS_SPACE(pchLine[2]))
+            || cchLine == 3)
+        {
+            if (   pchLine[0] == 'R'
+                && pchLine[1] == 'E'
+                && pchLine[2] == 'M')
+                cUpper++;
+            else if (   pchLine[0] == 'r'
+                     && pchLine[1] == 'e'
+                     && pchLine[2] == 'm')
+                cLower++;
+            else if (   pchLine[0] == 'R'
+                     && pchLine[1] == 'e'
+                     && pchLine[2] == 'm')
+                cCamel++;
+        }
+    }
+
+    ScmStreamRewindForReading(pIn);
+
+    if (cLower >= cUpper && cLower >= cCamel)
+        return kScmCommentStyle_Rem_Lower;
+    if (cCamel >= cLower && cCamel >= cUpper)
+        return kScmCommentStyle_Rem_Camel;
+    return kScmCommentStyle_Rem_Upper;
+}
+
+
+/**
+ * Calculates the number of spaces from @a offStart to @a offEnd in @a pchLine,
+ * taking tabs into account.
+ */
+size_t ScmCalcSpacesForSrcSpan(const char *pchLine, size_t offStart, size_t offEnd, PCSCMSETTINGSBASE pSettings)
+{
+    size_t cchRet = 0;
+    if (offStart < offEnd)
+    {
+        offEnd  -= offStart; /* becomes cchLeft now */
+        pchLine += offStart;
+        while (offEnd > 0)
+        {
+            const char *pszTab = (const char *)memchr(pchLine, '\t', offEnd);
+            if (!pszTab)
+            {
+                cchRet += offEnd;
+                break;
+            }
+            size_t offTab   = (size_t)(pszTab - pchLine);
+            size_t cchToTab = pSettings->cchTab - offTab % pSettings->cchTab;
+            cchRet += offTab + cchToTab;
+            offEnd -= offTab + 1;
+            pchLine = pszTab + 1;
+        }
+    }
+    return cchRet;
+}
+
+
+/**
+ * Worker for isBlankLine.
+ *
+ * @returns true if blank, false if not.
+ * @param   pchLine     Pointer to the start of the line.
+ * @param   cchLine     The (encoded) length of the line, excluding EOL char.
+ */
+static bool isBlankLineSlow(const char *pchLine, size_t cchLine)
+{
+    /*
+     * From the end, more likely to hit a non-blank char there.
+     */
+    while (cchLine-- > 0)
+        if (!RT_C_IS_BLANK(pchLine[cchLine]))
+            return false;
+    return true;
+}
+
+/**
+ * Helper for checking whether a line is blank.
+ *
+ * @returns true if blank, false if not.
+ * @param   pchLine     Pointer to the start of the line.
+ * @param   cchLine     The (encoded) length of the line, excluding EOL char.
+ */
+DECLINLINE(bool) isBlankLine(const char *pchLine, size_t cchLine)
+{
+    if (cchLine == 0)
+        return true;
+    /*
+     * We're more likely to fine a non-space char at the end of the line than
+     * at the start, due to source code indentation.
+     */
+    if (pchLine[cchLine - 1])
+        return false;
+
+    /*
+     * Don't bother inlining loop code.
+     */
+    return isBlankLineSlow(pchLine, cchLine);
+}
+
+
+/**
+ * Checks if there are @a cch blanks at @a pch.
+ *
+ * @returns true if span of @a cch blanks, false if not.
+ * @param   pch                 The start of the span to check.
+ * @param   cch                 The length of the span.
+ */
+DECLINLINE(bool) isSpanOfBlanks(const char *pch, size_t cch)
+{
+    while (cch-- > 0)
+    {
+        char const ch = *pch++;
+        if (!RT_C_IS_BLANK(ch))
+            return false;
+    }
+    return true;
+}
+
+
+/**
+ * Strip trailing blanks (space & tab).
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_StripTrailingBlanks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fStripTrailingBlanks)
+        return kScmUnmodified;
+
+    bool        fModified = false;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        int rc;
+        if (    cchLine == 0
+            ||  !RT_C_IS_BLANK(pchLine[cchLine - 1]) )
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        else
+        {
+            cchLine--;
+            while (cchLine > 0 && RT_C_IS_BLANK(pchLine[cchLine - 1]))
+                cchLine--;
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+            fModified = true;
+        }
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+    if (fModified)
+        ScmVerbose(pState, 2, " * Stripped trailing blanks\n");
+    return fModified ? kScmModified : kScmUnmodified;
+}
+
+/**
+ * Expand tabs.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_ExpandTabs(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fConvertTabs)
+        return kScmUnmodified;
+
+    size_t const    cchTab = pSettings->cchTab;
+    bool            fModified = false;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char     *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        int rc;
+        const char *pchTab = (const char *)memchr(pchLine, '\t', cchLine);
+        if (!pchTab)
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        else
+        {
+            size_t      offTab   = 0;
+            const char *pchChunk = pchLine;
+            for (;;)
+            {
+                size_t  cchChunk = pchTab - pchChunk;
+                offTab += cchChunk;
+                ScmStreamWrite(pOut, pchChunk, cchChunk);
+
+                size_t  cchToTab = cchTab - offTab % cchTab;
+                ScmStreamWrite(pOut, g_szTabSpaces, cchToTab);
+                offTab += cchToTab;
+
+                pchChunk = pchTab + 1;
+                size_t  cchLeft  = cchLine - (pchChunk - pchLine);
+                pchTab = (const char *)memchr(pchChunk, '\t', cchLeft);
+                if (!pchTab)
+                {
+                    rc = ScmStreamPutLine(pOut, pchChunk, cchLeft, enmEol);
+                    break;
+                }
+            }
+
+            fModified = true;
+        }
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+    if (fModified)
+        ScmVerbose(pState, 2, " * Expanded tabs\n");
+    return fModified ? kScmModified : kScmUnmodified;
+}
+
+/**
+ * Worker for rewrite_ForceNativeEol, rewrite_ForceLF and rewrite_ForceCRLF.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ * @param   enmDesiredEol       The desired end of line indicator type.
+ * @param   pszDesiredSvnEol    The desired svn:eol-style.
+ */
+static SCMREWRITERRES rewrite_ForceEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
+                                       SCMEOL enmDesiredEol, const char *pszDesiredSvnEol)
+{
+    if (!pSettings->fConvertEol)
+        return kScmUnmodified;
+
+    bool        fModified = false;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        if (   enmEol != enmDesiredEol
+            && enmEol != SCMEOL_NONE)
+        {
+            fModified = true;
+            enmEol = enmDesiredEol;
+        }
+        int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+    if (fModified)
+        ScmVerbose(pState, 2, " * Converted EOL markers\n");
+
+    /* Check svn:eol-style if appropriate */
+    if (   pSettings->fSetSvnEol
+        && ScmSvnIsInWorkingCopy(pState))
+    {
+        char *pszEol;
+        int rc = ScmSvnQueryProperty(pState, "svn:eol-style", &pszEol);
+        if (   (RT_SUCCESS(rc) && strcmp(pszEol, pszDesiredSvnEol))
+            || rc == VERR_NOT_FOUND)
+        {
+            if (rc == VERR_NOT_FOUND)
+                ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (missing)\n", pszDesiredSvnEol);
+            else
+                ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (was: %s)\n", pszDesiredSvnEol, pszEol);
+            int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
+            if (RT_FAILURE(rc2))
+                ScmError(pState, rc2, "ScmSvnSetProperty: %Rrc\n", rc2);
+        }
+        if (RT_SUCCESS(rc))
+            RTStrFree(pszEol);
+    }
+
+    /** @todo also check the subversion svn:eol-style state! */
+    return fModified ? kScmModified : kScmUnmodified;
+}
+
+/**
+ * Force native end of line indicator.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_ForceNativeEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+    return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "native");
+#else
+    return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF,   "native");
+#endif
+}
+
+/**
+ * Force the stream to use LF as the end of line indicator.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_ForceLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "LF");
+}
+
+/**
+ * Force the stream to use CRLF as the end of line indicator.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_ForceCRLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "CRLF");
+}
+
+/**
+ * Strip trailing blank lines and/or make sure there is exactly one blank line
+ * at the end of the file.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ *
+ * @remarks ASSUMES trailing white space has been removed already.
+ */
+SCMREWRITERRES rewrite_AdjustTrailingLines(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (   !pSettings->fStripTrailingLines
+        && !pSettings->fForceTrailingLine
+        && !pSettings->fForceFinalEol)
+        return kScmUnmodified;
+
+    size_t const cLines = ScmStreamCountLines(pIn);
+
+    /* Empty files remains empty. */
+    if (cLines <= 1)
+        return kScmUnmodified;
+
+    /* Figure out if we need to adjust the number of lines or not. */
+    size_t cLinesNew = cLines;
+
+    if (   pSettings->fStripTrailingLines
+        && ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
+    {
+        while (   cLinesNew > 1
+               && ScmStreamIsWhiteLine(pIn, cLinesNew - 2))
+            cLinesNew--;
+    }
+
+    if (    pSettings->fForceTrailingLine
+        && !ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
+        cLinesNew++;
+
+    bool fFixMissingEol = pSettings->fForceFinalEol
+                       && ScmStreamGetEolByLine(pIn, cLinesNew - 1) == SCMEOL_NONE;
+
+    if (   !fFixMissingEol
+        && cLines == cLinesNew)
+        return kScmUnmodified;
+
+    /* Copy the number of lines we've arrived at. */
+    ScmStreamRewindForReading(pIn);
+
+    size_t cCopied = RT_MIN(cLinesNew, cLines);
+    ScmStreamCopyLines(pOut, pIn, cCopied);
+
+    if (cCopied != cLinesNew)
+    {
+        while (cCopied++ < cLinesNew)
+            ScmStreamPutLine(pOut, "", 0, ScmStreamGetEol(pIn));
+    }
+    /* Fix missing EOL if required. */
+    else if (fFixMissingEol)
+    {
+        if (ScmStreamGetEol(pIn) == SCMEOL_LF)
+            ScmStreamWrite(pOut, "\n", 1);
+        else
+            ScmStreamWrite(pOut, "\r\n", 2);
+    }
+
+    ScmVerbose(pState, 2, " * Adjusted trailing blank lines\n");
+    return kScmModified;
+}
+
+/**
+ * Make sure there is no svn:executable property on the current file.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnNoExecutable(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   !pSettings->fSetSvnExecutable
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    int rc = ScmSvnQueryProperty(pState, "svn:executable", NULL);
+    if (RT_SUCCESS(rc))
+    {
+        ScmVerbose(pState, 2, " * removing svn:executable\n");
+        rc = ScmSvnDelProperty(pState, "svn:executable");
+        if (RT_FAILURE(rc))
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+    }
+    return kScmUnmodified;
+}
+
+/**
+ * Make sure there is no svn:keywords property on the current file.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnNoKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   !pSettings->fSetSvnExecutable
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    int rc = ScmSvnQueryProperty(pState, "svn:keywords", NULL);
+    if (RT_SUCCESS(rc))
+    {
+        ScmVerbose(pState, 2, " * removing svn:keywords\n");
+        rc = ScmSvnDelProperty(pState, "svn:keywords");
+        if (RT_FAILURE(rc))
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+    }
+    return kScmUnmodified;
+}
+
+/**
+ * Make sure there is no svn:eol-style property on the current file.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnNoEolStyle(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   !pSettings->fSetSvnExecutable
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    int rc = ScmSvnQueryProperty(pState, "svn:eol-style", NULL);
+    if (RT_SUCCESS(rc))
+    {
+        ScmVerbose(pState, 2, " * removing svn:eol-style\n");
+        rc = ScmSvnDelProperty(pState, "svn:eol-style");
+        if (RT_FAILURE(rc))
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+    }
+    return kScmUnmodified;
+}
+
+/**
+ * Makes sure the svn properties are appropriate for a binary.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnBinary(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   !pSettings->fSetSvnExecutable
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    /* remove svn:eol-style and svn:keywords */
+    static const char * const s_apszRemove[] = { "svn:eol-style", "svn:keywords" };
+    for (uint32_t i = 0; i < RT_ELEMENTS(s_apszRemove); i++)
+    {
+        char *pszValue;
+        int rc = ScmSvnQueryProperty(pState, s_apszRemove[i], &pszValue);
+        if (RT_SUCCESS(rc))
+        {
+            ScmVerbose(pState, 2, " * removing %s=%s\n", s_apszRemove[i], pszValue);
+            RTStrFree(pszValue);
+            rc = ScmSvnDelProperty(pState, s_apszRemove[i]);
+            if (RT_FAILURE(rc))
+                ScmError(pState, rc, "ScmSvnSetProperty(,%s): %Rrc\n", s_apszRemove[i], rc);
+        }
+        else if (rc != VERR_NOT_FOUND)
+            ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
+    }
+
+    /* Make sure there is a svn:mime-type set. */
+    int rc = ScmSvnQueryProperty(pState, "svn:mime-type", NULL);
+    if (rc == VERR_NOT_FOUND)
+    {
+        ScmVerbose(pState, 2, " * settings svn:mime-type\n");
+        rc = ScmSvnSetProperty(pState, "svn:mime-type", "application/octet-stream");
+        if (RT_FAILURE(rc))
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+    }
+    else if (RT_FAILURE(rc))
+        ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
+
+    return kScmUnmodified;
+}
+
+/**
+ * Make sure the Id and Revision keywords are expanded.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   !pSettings->fSetSvnKeywords
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    char *pszKeywords;
+    int rc = ScmSvnQueryProperty(pState, "svn:keywords", &pszKeywords);
+    if (    RT_SUCCESS(rc)
+        && (   !strstr(pszKeywords, "Id") /** @todo need some function for finding a word in a string.  */
+            || !strstr(pszKeywords, "Revision")) )
+    {
+        if (!strstr(pszKeywords, "Id") && !strstr(pszKeywords, "Revision"))
+            rc = RTStrAAppend(&pszKeywords, " Id Revision");
+        else if (!strstr(pszKeywords, "Id"))
+            rc = RTStrAAppend(&pszKeywords, " Id");
+        else
+            rc = RTStrAAppend(&pszKeywords, " Revision");
+        if (RT_SUCCESS(rc))
+        {
+            ScmVerbose(pState, 2, " * changing svn:keywords to '%s'\n", pszKeywords);
+            rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
+            if (RT_FAILURE(rc))
+                ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+        }
+        else
+            ScmError(pState, rc, "RTStrAppend: %Rrc\n", rc);
+        RTStrFree(pszKeywords);
+    }
+    else if (rc == VERR_NOT_FOUND)
+    {
+        ScmVerbose(pState, 2, " * setting svn:keywords to 'Id Revision'\n");
+        rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
+        if (RT_FAILURE(rc))
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
+    }
+    else if (RT_SUCCESS(rc))
+        RTStrFree(pszKeywords);
+
+    return kScmUnmodified;
+}
+
+/**
+ * Checks the svn:sync-process value and that parent is exported too.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_SvnSyncProcess(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (   pSettings->fSkipSvnSyncProcess
+        || !ScmSvnIsInWorkingCopy(pState))
+        return kScmUnmodified;
+
+    char *pszSyncProcess;
+    int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
+    if (RT_SUCCESS(rc))
+    {
+        if (strcmp(pszSyncProcess, "export") == 0)
+        {
+            char *pszParentSyncProcess;
+            rc = ScmSvnQueryParentProperty(pState, "svn:sync-process", &pszParentSyncProcess);
+            if (RT_SUCCESS(rc))
+            {
+                if (strcmp(pszSyncProcess, "export") != 0)
+                    ScmError(pState, VERR_INVALID_STATE,
+                             "svn:sync-process=export, but parent directory differs: %s\n"
+                             "WARNING! Make sure to unexport everything inside the directory first!\n"
+                             "         Then you may export the directory and stuff inside it if you want.\n"
+                             "         (Just exporting the directory will not make anything inside it externally visible.)\n"
+                             , pszParentSyncProcess);
+                RTStrFree(pszParentSyncProcess);
+            }
+            else if (rc == VERR_NOT_FOUND)
+                ScmError(pState, VERR_NOT_FOUND,
+                         "svn:sync-process=export, but parent directory is not exported!\n"
+                         "WARNING! Make sure to unexport everything inside the directory first!\n"
+                         "         Then you may export the directory and stuff inside it if you want.\n"
+                         "         (Just exporting the directory will not make anything inside it externally visible.)\n");
+            else
+                ScmError(pState, rc, "ScmSvnQueryParentProperty: %Rrc\n", rc);
+        }
+        else if (strcmp(pszSyncProcess, "ignore") != 0)
+            ScmError(pState, VERR_INVALID_NAME, "Bad sync-process value: %s\n", pszSyncProcess);
+        RTStrFree(pszSyncProcess);
+    }
+    else if (rc != VERR_NOT_FOUND)
+        ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
+
+    return kScmUnmodified;
+}
+
+/**
+ * Checks the that there is no bidirectional unicode fun in the file.
+ *
+ * @returns kScmUnmodified - the state carries these kinds of changes.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_UnicodeChecks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF2(pIn, pOut);
+    if (pSettings->fSkipUnicodeChecks)
+        return kScmUnmodified;
+
+    /*
+     * Just scan the input for weird stuff and fail if we find anything we don't like.
+     */
+    uint32_t    iLine = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        iLine++;
+        const char *pchCur  = pchLine;
+        size_t      cchLeft = cchLine;
+        while (cchLeft > 0)
+        {
+            RTUNICP uc = 0;
+            int rc = RTStrGetCpNEx(&pchCur, &cchLeft, &uc);
+            if (RT_SUCCESS(rc))
+            {
+                const char *pszWhat;
+                switch (uc)
+                {
+                    default:
+                        continue;
+
+                    /* Potentially evil bi-directional control codes (Table I, trojan-source.pdf):  */
+                    case 0x202a: pszWhat = "LRE - left-to-right embedding"; break;
+                    case 0x202b: pszWhat = "RLE - right-to-left embedding"; break;
+                    case 0x202d: pszWhat = "LRO - left-to-right override"; break;
+                    case 0x202e: pszWhat = "RLO - right-to-left override"; break;
+                    case 0x2066: pszWhat = "LRI - left-to-right isolate"; break;
+                    case 0x2067: pszWhat = "RLI - right-to-left isolate"; break;
+                    case 0x2068: pszWhat = "FSI - first strong isolate"; break;
+                    case 0x202c: pszWhat = "PDF - pop directional formatting (LRE, RLE, LRO, RLO)"; break;
+                    case 0x2069: pszWhat = "PDI - pop directional isolate (LRI, RLI)"; break;
+
+                    /** @todo add checks for homoglyphs too. */
+                }
+                ScmFixManually(pState, "%u:%zu: Evil unicode codepoint: %s\n", iLine, pchCur - pchLine, pszWhat);
+            }
+            else
+                ScmFixManually(pState, "%u:%zu: Invalid UTF-8 encoding: %Rrc\n", iLine, pchCur - pchLine, rc);
+        }
+    }
+
+    return kScmUnmodified;
+}
+
+
+
+/*********************************************************************************************************************************
+*   Copyright & License                                                                                                          *
+*********************************************************************************************************************************/
+
+/**
+ * Compares two strings word-by-word, ignoring spaces, punctuation and case.
+ *
+ * Assumes ASCII strings.
+ *
+ * @returns true if they match, false if not.
+ * @param   psz1        The first string.  This is typically the known one.
+ * @param   psz2        The second string.  This is typically the unknown one,
+ *                      which is why we return a next pointer for this one.
+ * @param   ppsz2Next   Where to return the next part of the 2nd string.  If
+ *                      this is NULL, the whole string must match.
+ */
+static bool IsEqualWordByWordIgnoreCase(const char *psz1, const char *psz2, const char **ppsz2Next)
+{
+    for (;;)
+    {
+        /* Try compare raw strings first. */
+        char ch1 = *psz1;
+        char ch2 = *psz2;
+        if (   ch1 == ch2
+            || RT_C_TO_LOWER(ch1) == RT_C_TO_LOWER(ch2))
+        {
+            if (ch1)
+            {
+                psz1++;
+                psz2++;
+            }
+            else
+            {
+                if (ppsz2Next)
+                    *ppsz2Next = psz2;
+                return true;
+            }
+        }
+        else
+        {
+            /* Try skip spaces an punctuation. */
+            while (   RT_C_IS_SPACE(ch1)
+                   || RT_C_IS_PUNCT(ch1))
+                ch1 = *++psz1;
+
+            if (ch1 == '\0' && ppsz2Next)
+            {
+                *ppsz2Next = psz2;
+                return true;
+            }
+
+            while (   RT_C_IS_SPACE(ch2)
+                   || RT_C_IS_PUNCT(ch2))
+                ch2 = *++psz2;
+
+            if (   ch1 != ch2
+                && RT_C_TO_LOWER(ch1) != RT_C_TO_LOWER(ch2))
+            {
+                if (ppsz2Next)
+                    *ppsz2Next = psz2;
+                return false;
+            }
+        }
+    }
+}
+
+/**
+ * Looks for @a pszFragment anywhere in @a pszText, ignoring spaces, punctuation
+ * and case.
+ *
+ * @returns true if found, false if not.
+ * @param   pszText             The haystack to search in.
+ * @param   cchText             The length @a pszText.
+ * @param   pszFragment         The needle to search for.
+ * @param   ppszStart           Where to return the address in @a pszText where
+ *                              the fragment was found.  Optional.
+ * @param   ppszNext            Where to return the pointer to the first char in
+ *                              @a pszText after the fragment.  Optional.
+ *
+ * @remarks First character of @a pszFragment must be an 7-bit ASCII character!
+ *          This character must not be space or punctuation.
+ */
+static bool scmContainsWordByWordIgnoreCase(const char *pszText, size_t cchText, const char *pszFragment,
+                                            const char **ppszStart, const char **ppszNext)
+{
+    Assert(!((unsigned)*pszFragment & 0x80));
+    Assert(pszText[cchText] == '\0');
+    Assert(!RT_C_IS_BLANK(*pszFragment));
+    Assert(!RT_C_IS_PUNCT(*pszFragment));
+
+    char chLower = RT_C_TO_LOWER(*pszFragment);
+    char chUpper = RT_C_TO_UPPER(*pszFragment);
+    for (;;)
+    {
+        const char *pszHit = (const char *)memchr(pszText, chLower, cchText);
+        const char *pszHit2 = (const char *)memchr(pszText, chUpper, cchText);
+        if (!pszHit && !pszHit2)
+        {
+            if (ppszStart)
+                *ppszStart = NULL;
+            if (ppszNext)
+                *ppszNext = NULL;
+            return false;
+        }
+
+        if (   pszHit == NULL
+            || (   pszHit2 != NULL
+                && ((uintptr_t)pszHit2 < (uintptr_t)pszHit)) )
+            pszHit = pszHit2;
+
+        const char *pszNext;
+        if (IsEqualWordByWordIgnoreCase(pszFragment, pszHit, &pszNext))
+        {
+            if (ppszStart)
+                *ppszStart = pszHit;
+            if (ppszNext)
+                *ppszNext = pszNext;
+            return true;
+        }
+
+        cchText -= pszHit - pszText + 1;
+        pszText = pszHit + 1;
+    }
+}
+
+
+/**
+ * Counts the number of lines in the given substring.
+ *
+ * @returns The number of lines.
+ * @param   psz          The start of the substring.
+ * @param   cch          The length of the substring.
+ */
+static uint32_t CountLinesInSubstring(const char *psz, size_t cch)
+{
+    uint32_t cLines = 0;
+    for (;;)
+    {
+        const char *pszEol = (const char *)memchr(psz, '\n', cch);
+        if (pszEol)
+            cLines++;
+        else
+            return cLines + (*psz != '\0');
+        cch -= pszEol + 1 - psz;
+        if (!cch)
+            return cLines;
+        psz  = pszEol + 1;
+    }
+}
+
+
+/**
+ * Comment parser callback for locating copyright and license.
+ */
+static DECLCALLBACK(int)
+rewrite_Copyright_CommentCallback(PCSCMCOMMENTINFO pInfo, const char *pszBody, size_t cchBody, void *pvUser)
+{
+    PSCMCOPYRIGHTINFO pState = (PSCMCOPYRIGHTINFO)pvUser;
+    Assert(strlen(pszBody) == cchBody);
+    //RTPrintf("--- comment at %u, type %u ---\n%s\n--- end ---\n", pInfo->iLineStart, pInfo->enmType, pszBody);
+    ScmVerbose(pState->pState, 5,
+               "--- comment at %u col %u, %u lines, type %u, %u lines before body, %u lines after body\n",
+               pInfo->iLineStart, pInfo->offStart, pInfo->iLineEnd - pInfo->iLineStart + 1, pInfo->enmType,
+               pInfo->cBlankLinesBefore, pInfo->cBlankLinesAfter);
+
+    pState->cComments++;
+
+    uint32_t iLine = pInfo->iLineStart + pInfo->cBlankLinesBefore;
+
+    /*
+     * Look for a 'contributed by' or 'includes contributions from' line, these
+     * comes first when present.
+     */
+    const char *pchContributedBy = NULL;
+    size_t      cchContributedBy = 0;
+    size_t      cBlankLinesAfterContributedBy = 0;
+    if (    pState->pszContributedBy == NULL
+        && (   pState->iLineCopyright == UINT32_MAX
+            || pState->iLineLicense == UINT32_MAX)
+        && (   (    cchBody > sizeof("Contributed by")
+                && RTStrNICmp(pszBody, RT_STR_TUPLE("contributed by")) == 0)
+            || (    cchBody > sizeof("Includes contributions from")
+                && RTStrNICmp(pszBody, RT_STR_TUPLE("Includes contributions from")) == 0) ) )
+    {
+        const char *pszNextLine = (const char *)memchr(pszBody, '\n', cchBody);
+        while (pszNextLine && pszNextLine[1] != '\n')
+            pszNextLine = (const char *)memchr(pszNextLine + 1, '\n', cchBody);
+        if (pszNextLine)
+        {
+            pchContributedBy = pszBody;
+            cchContributedBy = pszNextLine - pszBody;
+
+            /* Skip the copyright line and any blank lines following it. */
+            cchBody -= cchContributedBy + 1;
+            pszBody  = pszNextLine + 1;
+            iLine   += 1;
+            while (*pszBody == '\n')
+            {
+                pszBody++;
+                cchBody--;
+                iLine++;
+                cBlankLinesAfterContributedBy++;
+            }
+        }
+    }
+
+    /*
+     * Look for the copyright line.
+     */
+    bool     fFoundCopyright = false;
+    uint32_t cBlankLinesAfterCopyright = 0;
+    if (   pState->iLineCopyright == UINT32_MAX
+        && cchBody > sizeof("Copyright") + RT_MIN(sizeof(g_szCopyrightHolder), sizeof(g_szOldCopyrightHolder))
+        && RTStrNICmp(pszBody, RT_STR_TUPLE("copyright")) == 0)
+    {
+        const char *pszNextLine = (const char *)memchr(pszBody, '\n', cchBody);
+
+        /* Oracle copyright? */
+        const char *pszEnd  = pszNextLine ? pszNextLine : &pszBody[cchBody];
+        while (RT_C_IS_SPACE(pszEnd[-1]))
+            pszEnd--;
+        if (   (   (uintptr_t)(pszEnd - pszBody) > sizeof(g_szCopyrightHolder)
+                && (*(unsigned char *)(pszEnd - sizeof(g_szCopyrightHolder) + 1) & 0x80) == 0 /* to avoid annoying assertion */
+                && RTStrNICmp(pszEnd - sizeof(g_szCopyrightHolder) + 1, RT_STR_TUPLE(g_szCopyrightHolder)) == 0)
+            || (   (uintptr_t)(pszEnd - pszBody) > sizeof(g_szOldCopyrightHolder)
+                && (*(unsigned char *)(pszEnd - sizeof(g_szOldCopyrightHolder) + 1) & 0x80) == 0 /* to avoid annoying assertion */
+                && RTStrNICmp(pszEnd - sizeof(g_szOldCopyrightHolder) + 1, RT_STR_TUPLE(g_szOldCopyrightHolder)) == 0) )
+        {
+            /* Parse out the year(s). */
+            const char *psz = pszBody + sizeof("copyright");
+            while ((uintptr_t)psz < (uintptr_t)pszEnd && !RT_C_IS_DIGIT(*psz))
+                psz++;
+            if (RT_C_IS_DIGIT(*psz))
+            {
+                char *pszNext;
+                int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &pState->uFirstYear);
+                if (   RT_SUCCESS(rc)
+                    && rc != VWRN_NUMBER_TOO_BIG
+                    && rc != VWRN_NEGATIVE_UNSIGNED)
+                {
+                    if (   pState->uFirstYear < 1975
+                        || pState->uFirstYear > 3000)
+                    {
+                        char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                        RTStrPurgeEncoding(pszCopy);
+                        ScmError(pState->pState, VERR_OUT_OF_RANGE, "Copyright year is out of range: %u ('%s')\n",
+                                 pState->uFirstYear, pszCopy);
+                        RTStrFree(pszCopy);
+                        pState->uFirstYear = UINT32_MAX;
+                    }
+
+                    while (RT_C_IS_SPACE(*pszNext))
+                        pszNext++;
+                    if (*pszNext == '-')
+                    {
+                        do
+                            pszNext++;
+                        while (RT_C_IS_SPACE(*pszNext));
+                        rc = RTStrToUInt32Ex(pszNext, &pszNext, 10, &pState->uLastYear);
+                        if (   RT_SUCCESS(rc)
+                            && rc != VWRN_NUMBER_TOO_BIG
+                            && rc != VWRN_NEGATIVE_UNSIGNED)
+                        {
+                            if (   pState->uLastYear < 1975
+                                || pState->uLastYear > 3000)
+                            {
+                                char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                                RTStrPurgeEncoding(pszCopy);
+                                ScmError(pState->pState, VERR_OUT_OF_RANGE, "Second copyright year is out of range: %u ('%s')\n",
+                                         pState->uLastYear, pszCopy);
+                                RTStrFree(pszCopy);
+                                pState->uLastYear = UINT32_MAX;
+                            }
+                            else if (pState->uFirstYear > pState->uLastYear)
+                            {
+                                char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                                RTStrPurgeEncoding(pszCopy);
+                                RTMsgWarning("Copyright years switched(?): '%s'\n", pszCopy);
+                                RTStrFree(pszCopy);
+                                uint32_t iTmp = pState->uLastYear;
+                                pState->uLastYear = pState->uFirstYear;
+                                pState->uFirstYear = iTmp;
+                            }
+                        }
+                        else
+                        {
+                            pState->uLastYear = UINT32_MAX;
+                            char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                            RTStrPurgeEncoding(pszCopy);
+                            ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
+                                     "Failed to parse second copyright year: '%s'\n", pszCopy);
+                            RTMemFree(pszCopy);
+                        }
+                    }
+                    else if (*pszNext != g_szCopyrightHolder[0])
+                    {
+                        char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                        RTStrPurgeEncoding(pszCopy);
+                        ScmError(pState->pState, VERR_PARSE_ERROR,
+                                 "Failed to parse copyright: '%s'\n", pszCopy);
+                        RTMemFree(pszCopy);
+                    } else
+                        pState->uLastYear = pState->uFirstYear;
+                }
+                else
+                {
+                    pState->uFirstYear = UINT32_MAX;
+                    char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+                    RTStrPurgeEncoding(pszCopy);
+                    ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
+                             "Failed to parse copyright year: '%s'\n", pszCopy);
+                    RTMemFree(pszCopy);
+                }
+            }
+
+            /* The copyright comment must come before the license. */
+            if (pState->iLineLicense != UINT32_MAX)
+                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright (line %u) must come before the license (line %u)!\n",
+                         iLine, pState->iLineLicense);
+
+            /* In C/C++ code, this must be a multiline comment.  While in python it
+               must be a */
+            if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
+                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a multiline comment (no doxygen stuff)\n");
+            else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
+                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a doc-string\n");
+
+            /* The copyright must be followed by the license. */
+            if (!pszNextLine)
+                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
+
+            /* Quit if we've flagged a failure. */
+            if (RT_FAILURE(pState->pState->rc))
+                return VERR_CALLBACK_RETURN;
+
+            /* Check if it's well formed and up to date. */
+            char   szWellFormed[256];
+            size_t cchWellFormed;
+            if (pState->uFirstYear == pState->uLastYear)
+                cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u %s",
+                                            pState->uFirstYear, g_szCopyrightHolder);
+            else
+                cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u-%u %s",
+                                            pState->uFirstYear, pState->uLastYear, g_szCopyrightHolder);
+            pState->fUpToDateCopyright   = pState->uLastYear == g_uYear;
+            pState->iLineCopyright       = iLine;
+            pState->fWellFormedCopyright = cchWellFormed == (uintptr_t)(pszEnd - pszBody)
+                                        && memcmp(pszBody, szWellFormed, cchWellFormed) == 0;
+            if (!pState->fWellFormedCopyright)
+                ScmVerbose(pState->pState, 1, "* copyright isn't well formed\n");
+
+            /* If there wasn't exactly one blank line before the comment, trigger a rewrite. */
+            if (pInfo->cBlankLinesBefore != 1)
+            {
+                ScmVerbose(pState->pState, 1, "* copyright comment is preceeded by %u blank lines instead of 1\n",
+                           pInfo->cBlankLinesBefore);
+                pState->fWellFormedCopyright = false;
+            }
+
+            /* If the comment doesn't start in column 1, trigger rewrite. */
+            if (pInfo->offStart != 0)
+            {
+                ScmVerbose(pState->pState, 1, "* copyright comment starts in column %u instead of 1\n", pInfo->offStart + 1);
+                pState->fWellFormedCopyright = false;
+                /** @todo check that there isn't any code preceeding the comment. */
+            }
+
+            if (pchContributedBy)
+            {
+                pState->pszContributedBy = RTStrDupN(pchContributedBy, cchContributedBy);
+                if (cBlankLinesAfterContributedBy != 1)
+                {
+                    ScmVerbose(pState->pState, 1, "* %u blank lines between contributed by and copyright, should be 1\n",
+                               cBlankLinesAfterContributedBy);
+                    pState->fWellFormedCopyright = false;
+                }
+            }
+
+            fFoundCopyright = true;
+            ScmVerbose(pState->pState, 3, "oracle copyright %u-%u: up-to-date=%RTbool well-formed=%RTbool\n",
+                       pState->uFirstYear, pState->uLastYear, pState->fUpToDateCopyright, pState->fWellFormedCopyright);
+        }
+        else
+        {
+            char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
+            RTStrPurgeEncoding(pszCopy);
+            ScmVerbose(pState->pState, 3, "not oracle copyright: '%s'\n", pszCopy);
+            RTStrFree(pszCopy);
+        }
+
+        if (!pszNextLine)
+            return VINF_SUCCESS;
+
+        /* Skip the copyright line and any blank lines following it. */
+        cchBody -= pszNextLine - pszBody + 1;
+        pszBody  = pszNextLine + 1;
+        iLine   += 1;
+        while (*pszBody == '\n')
+        {
+            pszBody++;
+            cchBody--;
+            iLine++;
+            cBlankLinesAfterCopyright++;
+        }
+
+        /*
+         * If we have a based-on-mit scenario, check for the lead in now and
+         * complain if not found.
+         */
+        if (   fFoundCopyright
+            && pState->enmLicenceOpt == kScmLicense_BasedOnMit
+            && pState->iLineLicense == UINT32_MAX)
+        {
+            if (RTStrNICmp(pszBody, RT_STR_TUPLE("This file is based on ")) == 0)
+            {
+                /* Take down a comment area which goes up to 'this file is based on'.
+                   The license line and length isn't used but gets set to cover the current line. */
+                pState->iLineComment        = pInfo->iLineStart;
+                pState->cLinesComment       = iLine - pInfo->iLineStart;
+                pState->iLineLicense        = iLine;
+                pState->cLinesLicense       = 1;
+                pState->fExternalLicense    = true;
+                pState->fIsCorrectLicense   = true;
+                pState->fWellFormedLicense  = true;
+
+                /* Check if we've got a MIT a license here or not. */
+                pState->pCurrentLicense     = NULL;
+                do
+                {
+                    const char *pszEol = (const char *)memchr(pszBody, '\n', cchBody);
+                    if (!pszEol || pszEol[1] == '\0')
+                    {
+                        pszBody += cchBody;
+                        cchBody = 0;
+                        break;
+                    }
+                    cchBody -= pszEol - pszBody + 1;
+                    pszBody  = pszEol + 1;
+                    iLine++;
+
+                    for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
+                    {
+                        const char *pszNext;
+                        if (   pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
+                            && IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
+                        {
+                            pState->pCurrentLicense = pCur;
+                            break;
+                        }
+                    }
+                } while (!pState->pCurrentLicense);
+                if (!pState->pCurrentLicense)
+                    ScmError(pState->pState, VERR_NOT_FOUND, "Could not find the based-on license!\n");
+                else if (pState->pCurrentLicense->enmType != kScmLicenseType_Mit)
+                    ScmError(pState->pState, VERR_NOT_FOUND, "The based-on license is not MIT (%.32s...)\n",
+                             pState->pCurrentLicense->psz);
+            }
+            else
+                ScmError(pState->pState, VERR_WRONG_ORDER, "Expected 'This file is based on ...' after our copyright!\n");
+            return VINF_SUCCESS;
+        }
+    }
+
+    /*
+     * Look for LGPL like text in the comment.
+     */
+    if (pState->fCheckforLgpl && cchBody > 128)
+    {
+        /* We look for typical LGPL notices. */
+        if (pState->iLineLgplNotice == UINT32_MAX)
+        {
+            static const char * const s_apszFragments[] =
+            {
+                "under the terms of the GNU Lesser General Public License",
+            };
+            for (unsigned i = 0; i < RT_ELEMENTS(s_apszFragments); i++)
+                if (scmContainsWordByWordIgnoreCase(pszBody, cchBody, s_apszFragments[i], NULL, NULL))
+                {
+                    pState->iLineLgplNotice = iLine;
+                    pState->iLineAfterLgplComment = pInfo->iLineEnd + 1;
+                    ScmVerbose(pState->pState, 3, "Found LGPL notice at %u\n", iLine);
+                    break;
+                }
+        }
+
+        if (   pState->iLineLgplDisclaimer == UINT32_MAX
+            && scmContainsWordByWordIgnoreCase(pszBody, cchBody, g_szLgplDisclaimer, NULL, NULL))
+        {
+            pState->iLineLgplDisclaimer = iLine;
+            ScmVerbose(pState->pState, 3, "Found LGPL disclaimer at %u\n", iLine);
+        }
+    }
+
+    /*
+     * Look for the license text.
+     */
+    if (pState->iLineLicense == UINT32_MAX)
+    {
+        for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
+        {
+            const char *pszNext;
+            if (   pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
+                && IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
+            {
+                while (   RT_C_IS_SPACE(*pszNext)
+                       || (RT_C_IS_PUNCT(*pszNext) && *pszNext != '-'))
+                    pszNext++;
+
+                uint32_t cDashes = 0;
+                while (*pszNext == '-')
+                    cDashes++, pszNext++;
+                bool fExternal = cDashes > 10;
+
+                if (   *pszNext == '\0'
+                    || fExternal)
+                {
+                    /* In C/C++ code, this must be a multiline comment.  While in python it
+                       must be a doc-string. */
+                    if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
+                        ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a multiline comment (no doxygen stuff)\n");
+                    else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
+                        ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a doc-string\n");
+
+                    /* Quit if we've flagged a failure. */
+                    if (RT_FAILURE(pState->pState->rc))
+                        return VERR_CALLBACK_RETURN;
+
+                    /* Record it. */
+                    pState->iLineLicense        = iLine;
+                    pState->cLinesLicense       = CountLinesInSubstring(pszBody, pszNext - pszBody) - fExternal;
+                    pState->pCurrentLicense     = pCur;
+                    pState->fExternalLicense    = fExternal;
+                    pState->fIsCorrectLicense   = pCur == pState->pExpectedLicense;
+                    pState->fWellFormedLicense  = memcmp(pszBody, pCur->psz, pCur->cch - 1) == 0;
+                    if (!pState->fWellFormedLicense)
+                        ScmVerbose(pState->pState, 1, "* license text isn't well-formed\n");
+
+                    /* If there was more than one blank line between the copyright and the
+                       license text, extend the license text area and force a rewrite of it. */
+                    if (cBlankLinesAfterCopyright > 1)
+                    {
+                        ScmVerbose(pState->pState, 1, "* %u blank lines between copyright and license text, instead of 1\n",
+                                   cBlankLinesAfterCopyright);
+                        pState->iLineLicense -= cBlankLinesAfterCopyright - 1;
+                        pState->cLinesLicense += cBlankLinesAfterCopyright - 1;
+                        pState->fWellFormedLicense = false;
+                    }
+
+                    /* If there was more than one blank line after the license, trigger a rewrite. */
+                    if (!fExternal && pInfo->cBlankLinesAfter != 1)
+                    {
+                        ScmVerbose(pState->pState, 1, "* copyright comment is followed by %u blank lines instead of 1\n",
+                                   pInfo->cBlankLinesAfter);
+                        pState->fWellFormedLicense = false;
+                    }
+
+                    /** @todo Check that the last comment line doesn't have any code on it. */
+                    /** @todo Check that column 2 contains '*' for C/C++ files. */
+
+                    ScmVerbose(pState->pState, 3,
+                               "Found license %d/%d at %u..%u: is-correct=%RTbool well-formed=%RTbool external-part=%RTbool open-source=%RTbool\n",
+                               pCur->enmType, pCur->enmOpt, pState->iLineLicense, pState->iLineLicense + pState->cLinesLicense,
+                               pState->fIsCorrectLicense, pState->fWellFormedLicense,
+                               pState->fExternalLicense, pState->fOpenSource);
+
+                    if (fFoundCopyright)
+                    {
+                        pState->iLineComment  = pInfo->iLineStart;
+                        pState->cLinesComment = (fExternal ? pState->iLineLicense + pState->cLinesLicense : pInfo->iLineEnd + 1)
+                                              - pInfo->iLineStart;
+                    }
+                    else
+                        ScmError(pState->pState, VERR_WRONG_ORDER, "License should be preceeded by the copyright!\n");
+                    break;
+                }
+            }
+        }
+    }
+
+    if (fFoundCopyright && pState->iLineLicense == UINT32_MAX)
+        ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
+
+    /*
+     * Stop looking for stuff after 100 comments.
+     */
+    if (pState->cComments > 100)
+        return VERR_CALLBACK_RETURN;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Writes comment body text.
+ *
+ * @returns Stream status.
+ * @param   pOut                The output stream.
+ * @param   pszText             The text to write.
+ * @param   cchText             The length of the text.
+ * @param   enmCommentStyle     The comment style.
+ * @param   enmEol              The EOL style.
+ */
+static int scmWriteCommentBody(PSCMSTREAM pOut, const char *pszText, size_t cchText,
+                               SCMCOMMENTSTYLE enmCommentStyle, SCMEOL enmEol)
+{
+    Assert(pszText[cchText - 1] == '\n');
+    Assert(pszText[cchText - 2] != '\n');
+    NOREF(cchText);
+    do
+    {
+        const char *pszEol = strchr(pszText, '\n');
+        if (pszEol != pszText)
+        {
+            ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
+                           g_aCopyrightCommentPrefix[enmCommentStyle].cch);
+            ScmStreamWrite(pOut, pszText, pszEol - pszText);
+            ScmStreamPutEol(pOut, enmEol);
+        }
+        else
+            ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
+                             g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
+        pszText = pszEol + 1;
+    } while (*pszText != '\0');
+    return ScmStreamGetStatus(pOut);
+}
+
+
+/**
+ * Updates the copyright year and/or license text.
+ *
+ * @returns Modification state.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ * @param   enmCommentStyle     The comment style used by the file.
+ */
+static SCMREWRITERRES rewrite_Copyright_Common(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut,
+                                                 PCSCMSETTINGSBASE pSettings, SCMCOMMENTSTYLE enmCommentStyle)
+{
+    if (   !pSettings->fUpdateCopyrightYear
+        && pSettings->enmUpdateLicense == kScmLicense_LeaveAlone)
+        return kScmUnmodified;
+
+    /*
+     * Try locate the relevant comments.
+     */
+    SCMCOPYRIGHTINFO Info =
+    {
+        /*.pState = */                  pState,
+        /*.enmCommentStyle = */         enmCommentStyle,
+
+        /*.cComments = */               0,
+
+        /*.pszContributedBy = */        NULL,
+
+        /*.iLineComment = */            UINT32_MAX,
+        /*.cLinesComment = */           0,
+
+        /*.iLineCopyright = */          UINT32_MAX,
+        /*.uFirstYear = */              UINT32_MAX,
+        /*.uLastYear = */               UINT32_MAX,
+        /*.fWellFormedCopyright = */    false,
+        /*.fUpToDateCopyright = */      false,
+
+        /*.fOpenSource = */             true,
+        /*.pExpectedLicense = */        NULL,
+        /*.paLicenses = */                   pSettings->enmUpdateLicense != kScmLicense_Mit
+                                          && pSettings->enmUpdateLicense != kScmLicense_BasedOnMit
+                                        ? &g_aLicenses[0] : &g_aLicensesWithMit[0],
+        /*.enmLicenceOpt = */           pSettings->enmUpdateLicense,
+        /*.iLineLicense = */            UINT32_MAX,
+        /*.cLinesLicense = */           0,
+        /*.pCurrentLicense = */         NULL,
+        /*.fIsCorrectLicense = */       false,
+        /*.fWellFormedLicense = */      false,
+        /*.fExternalLicense = */        false,
+
+        /*.fCheckForLgpl = */           true,
+        /*.iLineLgplNotice = */         UINT32_MAX,
+        /*.iLineAfterLgplComment = */   UINT32_MAX,
+        /*.iLineLgplDisclaimer = */     UINT32_MAX,
+    };
+
+    /* Figure Info.fOpenSource and the desired license: */
+    char *pszSyncProcess;
+    int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
+    if (RT_SUCCESS(rc))
+    {
+        Info.fOpenSource = strcmp(RTStrStrip(pszSyncProcess), "export") == 0;
+        RTStrFree(pszSyncProcess);
+    }
+    else if (rc == VERR_NOT_FOUND)
+        Info.fOpenSource = false;
+    else
+        return ScmError(pState, rc, "ScmSvnQueryProperty(svn:sync-process): %Rrc\n", rc);
+
+    Info.pExpectedLicense = Info.paLicenses;
+    if (Info.fOpenSource)
+    {
+        if (   pSettings->enmUpdateLicense != kScmLicense_Mit
+            && pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
+            while (Info.pExpectedLicense->enmOpt != pSettings->enmUpdateLicense)
+                Info.pExpectedLicense++;
+        else
+            Assert(Info.pExpectedLicense->enmOpt == kScmLicense_Mit);
+    }
+    else
+        while (Info.pExpectedLicense->enmType != kScmLicenseType_Confidential)
+            Info.pExpectedLicense++;
+
+    /* Scan the comments. */
+    rc = ScmEnumerateComments(pIn, enmCommentStyle, rewrite_Copyright_CommentCallback, &Info);
+    if (   (rc == VERR_CALLBACK_RETURN || RT_SUCCESS(rc))
+        && RT_SUCCESS(pState->rc))
+    {
+        /*
+         * Do conformity checks.
+         */
+        bool fAddLgplDisclaimer = false;
+        if (Info.fCheckforLgpl)
+        {
+            if (   Info.iLineLgplNotice != UINT32_MAX
+                && Info.iLineLgplDisclaimer == UINT32_MAX)
+            {
+                if (!pSettings->fLgplDisclaimer) /** @todo reconcile options with common sense. */
+                    ScmError(pState, VERR_NOT_FOUND, "LGPL licence notice on line %u, but no LGPL disclaimer was found!\n",
+                             Info.iLineLgplNotice + 1);
+                else
+                {
+                    ScmVerbose(pState, 1, "* Need to add LGPL disclaimer\n");
+                    fAddLgplDisclaimer = true;
+                }
+            }
+            else if (   Info.iLineLgplNotice == UINT32_MAX
+                     && Info.iLineLgplDisclaimer != UINT32_MAX)
+                ScmError(pState, VERR_NOT_FOUND, "LGPL disclaimer on line %u, but no LGPL copyright notice!\n",
+                         Info.iLineLgplDisclaimer + 1);
+        }
+
+        if (!pSettings->fExternalCopyright)
+        {
+            if (Info.iLineCopyright == UINT32_MAX)
+                ScmError(pState, VERR_NOT_FOUND, "Missing copyright!\n");
+            if (Info.iLineLicense == UINT32_MAX)
+                ScmError(pState, VERR_NOT_FOUND, "Missing license!\n");
+        }
+        else if (Info.iLineCopyright != UINT32_MAX)
+            ScmError(pState, VERR_NOT_FOUND,
+                     "Marked as external copyright only, but found non-external copyright statement at line %u!\n",
+                     Info.iLineCopyright + 1);
+
+
+        if (RT_SUCCESS(pState->rc))
+        {
+            /*
+             * Do we need to make any changes?
+             */
+            bool fUpdateCopyright = !pSettings->fExternalCopyright
+                                 && (   !Info.fWellFormedCopyright
+                                     || (!Info.fUpToDateCopyright && pSettings->fUpdateCopyrightYear));
+            bool fUpdateLicense   = !pSettings->fExternalCopyright
+                                 && Info.enmLicenceOpt != kScmLicense_LeaveAlone
+                                 && (   !Info.fWellFormedLicense
+                                     || !Info.fIsCorrectLicense);
+            if (   fUpdateCopyright
+                || fUpdateLicense
+                || fAddLgplDisclaimer)
+            {
+                Assert(Info.iLineComment != UINT32_MAX);
+                Assert(Info.cLinesComment > 0);
+
+                /*
+                 * Okay, do the work.
+                 */
+                ScmStreamRewindForReading(pIn);
+
+                if (pSettings->fUpdateCopyrightYear)
+                    Info.uLastYear = g_uYear;
+
+                uint32_t    iLine = 0;
+                SCMEOL      enmEol;
+                size_t      cchLine;
+                const char *pchLine;
+                while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+                {
+                    if (   iLine == Info.iLineComment
+                        && (fUpdateCopyright || fUpdateLicense) )
+                    {
+                        /* Leading blank line. */
+                        ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
+                                         g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
+
+                        /* Contributed by someone? */
+                        if (Info.pszContributedBy)
+                        {
+                            const char *psz = Info.pszContributedBy;
+                            for (;;)
+                            {
+                                const char *pszEol = strchr(psz, '\n');
+                                size_t cchContribLine = pszEol ? pszEol - psz : strlen(psz);
+                                ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
+                                               g_aCopyrightCommentPrefix[enmCommentStyle].cch);
+                                ScmStreamWrite(pOut, psz, cchContribLine);
+                                ScmStreamPutEol(pOut, enmEol);
+                                if (!pszEol)
+                                    break;
+                                psz = pszEol + 1;
+                            }
+
+                            ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
+                                             g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
+                        }
+
+                        /* Write the copyright comment line. */
+                        ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
+                                       g_aCopyrightCommentPrefix[enmCommentStyle].cch);
+
+                        char   szCopyright[256];
+                        size_t cchCopyright;
+                        if (Info.uFirstYear == Info.uLastYear)
+                            cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u %s",
+                                                       Info.uFirstYear, g_szCopyrightHolder);
+                        else
+                            cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u-%u %s",
+                                                       Info.uFirstYear, Info.uLastYear, g_szCopyrightHolder);
+
+                        ScmStreamWrite(pOut, szCopyright, cchCopyright);
+                        ScmStreamPutEol(pOut, enmEol);
+
+                        if (pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
+                        {
+                            /* Blank line separating the two. */
+                            ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
+                                             g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
+
+                            /* Write the license text. */
+                            scmWriteCommentBody(pOut, Info.pExpectedLicense->psz, Info.pExpectedLicense->cch,
+                                                enmCommentStyle, enmEol);
+
+                            /* Final comment line. */
+                            if (!Info.fExternalLicense)
+                                ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
+                                                 g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
+                        }
+                        else
+                            Assert(Info.fExternalLicense);
+
+                        /* Skip the copyright and license text in the input file. */
+                        rc = ScmStreamGetStatus(pOut);
+                        if (RT_SUCCESS(rc))
+                        {
+                            iLine = Info.iLineComment + Info.cLinesComment;
+                            rc = ScmStreamSeekByLine(pIn, iLine);
+                        }
+                    }
+                    /*
+                     * Add LGPL disclaimer?
+                     */
+                    else if (   iLine == Info.iLineAfterLgplComment
+                             && fAddLgplDisclaimer)
+                    {
+                        ScmStreamPutEol(pOut, enmEol);
+                        ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
+                                         g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
+                        scmWriteCommentBody(pOut, g_szLgplDisclaimer, sizeof(g_szLgplDisclaimer) - 1,
+                                            enmCommentStyle, enmEol);
+                        ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
+                                         g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
+
+                        /* put the actual line */
+                        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+                        iLine++;
+                    }
+                    else
+                    {
+                        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+                        iLine++;
+                    }
+                    if (RT_FAILURE(rc))
+                    {
+                        RTStrFree(Info.pszContributedBy);
+                        return kScmUnmodified;
+                    }
+                } /* for each source line */
+
+                RTStrFree(Info.pszContributedBy);
+                return kScmModified;
+            }
+        }
+    }
+    else
+        ScmError(pState, rc,  "ScmEnumerateComments: %Rrc\n", rc);
+    NOREF(pState); NOREF(pOut);
+    RTStrFree(Info.pszContributedBy);
+    return kScmUnmodified;
+}
+
+
+/** Copyright updater for C-style comments.   */
+SCMREWRITERRES rewrite_Copyright_CstyleComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_C);
+}
+
+/** Copyright updater for hash-prefixed comments.   */
+SCMREWRITERRES rewrite_Copyright_HashComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Hash);
+}
+
+/** Copyright updater for REM-prefixed comments.   */
+SCMREWRITERRES rewrite_Copyright_RemComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, determineBatchFileCommentStyle(pIn));
+}
+
+/** Copyright updater for python comments.   */
+SCMREWRITERRES rewrite_Copyright_PythonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Python);
+}
+
+/** Copyright updater for semicolon-prefixed comments.   */
+SCMREWRITERRES rewrite_Copyright_SemicolonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut,
+                                                  PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Semicolon);
+}
+
+/** Copyright updater for sql  comments.   */
+SCMREWRITERRES rewrite_Copyright_SqlComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Sql);
+}
+
+/** Copyright updater for tick-prefixed comments.   */
+SCMREWRITERRES rewrite_Copyright_TickComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Tick);
+}
+
+/** Copyright updater for XML comments.   */
+SCMREWRITERRES rewrite_Copyright_XmlComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Xml);
+}
+
+
+
+/*********************************************************************************************************************************
+*   Flower Box Section Markers                                                                                                   *
+*********************************************************************************************************************************/
+
+static bool isFlowerBoxSectionMarker(PSCMSTREAM pIn, const char *pchLine, size_t cchLine, uint32_t cchWidth,
+                                     const char **ppchText, size_t *pcchText, bool *pfNeedFixing)
+{
+    *ppchText = NULL;
+    *pcchText = 0;
+    *pfNeedFixing = false;
+
+    /*
+     * The first line.
+     */
+    if (pchLine[0] != '/')
+        return false;
+    size_t offLine = 1;
+    while (offLine < cchLine && pchLine[offLine] == '*')
+        offLine++;
+    if (offLine < 20)                   /* (Code below depend on a reasonable minimum here.) */
+        return false;
+    while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
+        offLine++;
+    if (offLine != cchLine)
+        return false;
+
+    size_t const cchBox = cchLine;
+    *pfNeedFixing = cchBox != cchWidth;
+
+    /*
+     * The next line, extracting the text.
+     */
+    SCMEOL enmEol;
+    pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+    if (cchLine < cchBox - 3)
+        return false;
+
+    offLine = 0;
+    if (RT_C_IS_BLANK(pchLine[0]))
+    {
+        *pfNeedFixing = true;
+        offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
+    }
+
+    if (pchLine[offLine] != '*')
+        return false;
+    offLine++;
+
+    if (!RT_C_IS_BLANK(pchLine[offLine + 1]))
+        return false;
+    offLine++;
+
+    while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
+        offLine++;
+    if (offLine >= cchLine)
+        return false;
+    if (!RT_C_IS_UPPER(pchLine[offLine]))
+        return false;
+
+    if (offLine != 4 || cchLine != cchBox)
+        *pfNeedFixing = true;
+
+    *ppchText = &pchLine[offLine];
+    size_t const offText = offLine;
+
+    /* From the end now. */
+    offLine = cchLine - 1;
+    while (RT_C_IS_BLANK(pchLine[offLine]))
+        offLine--;
+
+    if (pchLine[offLine] != '*')
+        return false;
+    offLine--;
+    if (!RT_C_IS_BLANK(pchLine[offLine]))
+        return false;
+    offLine--;
+    while (RT_C_IS_BLANK(pchLine[offLine]))
+        offLine--;
+    *pcchText = offLine - offText + 1;
+
+    /*
+     * Third line closes the box.
+     */
+    pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+    if (cchLine < cchBox - 3)
+        return false;
+
+    offLine = 0;
+    if (RT_C_IS_BLANK(pchLine[0]))
+    {
+        *pfNeedFixing = true;
+        offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
+    }
+    while (offLine < cchLine && pchLine[offLine] == '*')
+        offLine++;
+    if (offLine < cchBox - 4)
+        return false;
+
+    if (pchLine[offLine] != '/')
+        return false;
+    offLine++;
+
+    if (offLine != cchBox)
+        *pfNeedFixing = true;
+
+    while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
+        offLine++;
+    if (offLine != cchLine)
+        return false;
+
+    return true;
+}
+
+
+/**
+ * Flower box marker comments in C and C++ code.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_FixFlowerBoxMarkers(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fFixFlowerBoxMarkers)
+        return kScmUnmodified;
+
+    /*
+     * Work thru the file line by line looking for flower box markers.
+     */
+    size_t      cChanges = 0;
+    size_t      cBlankLines = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        /*
+         * Get a likely match for a first line.
+         */
+        if (   pchLine[0] == '/'
+            && cchLine > 20
+            && pchLine[1] == '*'
+            && pchLine[2] == '*'
+            && pchLine[3] == '*')
+        {
+            size_t const offSaved = ScmStreamTell(pIn);
+            char const  *pchText;
+            size_t       cchText;
+            bool         fNeedFixing;
+            bool         fIsFlowerBoxSection = isFlowerBoxSectionMarker(pIn, pchLine, cchLine, pSettings->cchWidth,
+                                                                        &pchText, &cchText, &fNeedFixing);
+            if (   fIsFlowerBoxSection
+                && (   fNeedFixing
+                    || cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers) )
+            {
+                while (cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers)
+                {
+                    ScmStreamPutEol(pOut, enmEol);
+                    cBlankLines++;
+                }
+
+                ScmStreamPutCh(pOut, '/');
+                ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
+                ScmStreamPutEol(pOut, enmEol);
+
+                static const char s_szLead[] = "*   ";
+                ScmStreamWrite(pOut, s_szLead, sizeof(s_szLead) - 1);
+                ScmStreamWrite(pOut, pchText, cchText);
+                size_t offCurPlus1 = sizeof(s_szLead) - 1 + cchText + 1;
+                ScmStreamWrite(pOut, g_szSpaces, offCurPlus1 < pSettings->cchWidth ? pSettings->cchWidth - offCurPlus1 : 1);
+                ScmStreamPutCh(pOut, '*');
+                ScmStreamPutEol(pOut, enmEol);
+
+                ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
+                ScmStreamPutCh(pOut, '/');
+                ScmStreamPutEol(pOut, enmEol);
+
+                cChanges++;
+                cBlankLines = 0;
+                continue;
+            }
+
+            int rc = ScmStreamSeekAbsolute(pIn, offSaved);
+            if (RT_FAILURE(rc))
+                return kScmUnmodified;
+        }
+
+        int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+
+        /* Do blank line accounting so we can ensure at least two blank lines
+           before each section marker. */
+        if (!isBlankLine(pchLine, cchLine))
+            cBlankLines = 0;
+        else
+            cBlankLines++;
+    }
+    if (cChanges > 0)
+        ScmVerbose(pState, 2, " * Converted %zu flower boxer markers\n", cChanges);
+    return cChanges != 0 ? kScmModified : kScmUnmodified;
+}
+
+
+/**
+ * Looks for the start of a todo comment.
+ *
+ * @returns Offset into the line of the comment start sequence.
+ * @param   pchLine             The line to search.
+ * @param   cchLineBeforeTodo   The length of the line before the todo.
+ * @param   pfSameLine          Indicates whether it's refering to a statemtn on
+ *                              the same line comment (true), or the next
+ *                              statement (false).
+ */
+static size_t findTodoCommentStart(char const *pchLine, size_t cchLineBeforeTodo, bool *pfSameLine)
+{
+    *pfSameLine = false;
+
+    /* Skip one '@' or  '\\'. */
+    char ch;
+    if (   cchLineBeforeTodo > 2
+        && (   ((ch = pchLine[cchLineBeforeTodo - 1]) == '@')
+            || ch == '\\' ) )
+        cchLineBeforeTodo--;
+
+    /* Skip blanks. */
+    while (   cchLineBeforeTodo > 2
+           && RT_C_IS_BLANK(pchLine[cchLineBeforeTodo - 1]))
+        cchLineBeforeTodo--;
+
+    /* Look for same line indicator. */
+    if (   cchLineBeforeTodo > 0
+        && pchLine[cchLineBeforeTodo - 1] == '<')
+    {
+        *pfSameLine = true;
+        cchLineBeforeTodo--;
+    }
+
+    /* Skip *s */
+    while (   cchLineBeforeTodo > 1
+           && pchLine[cchLineBeforeTodo - 1] == '*')
+        cchLineBeforeTodo--;
+
+    /* Do we have a comment opening sequence. */
+    if (   cchLineBeforeTodo > 0
+        && pchLine[cchLineBeforeTodo - 1] == '/'
+        && (   (   cchLineBeforeTodo >= 2
+                && pchLine[cchLineBeforeTodo - 2] == '/')
+            || pchLine[cchLineBeforeTodo] == '*'))
+    {
+        /* Skip slashes at the start. */
+        while (   cchLineBeforeTodo > 0
+               && pchLine[cchLineBeforeTodo - 1] == '/')
+            cchLineBeforeTodo--;
+
+        return cchLineBeforeTodo;
+    }
+
+    return ~(size_t)0;
+}
+
+
+/**
+ * Looks for a TODO or todo in the given line.
+ *
+ * @returns Offset into the line of found, ~(size_t)0 if not.
+ * @param   pchLine             The line to search.
+ * @param   cchLine             The length of the line.
+ */
+static size_t findTodo(char const *pchLine, size_t cchLine)
+{
+    if (cchLine >= 4 + 2)
+    {
+        /* We don't search the first to chars because we need the start of a comment.
+           Also, skip the last three chars since we need at least four for a match. */
+        size_t const cchLineT = cchLine - 3;
+        if (   memchr(pchLine + 2, 't', cchLineT - 2) != NULL
+            || memchr(pchLine + 2, 'T', cchLineT - 2) != NULL)
+        {
+            for (size_t off = 2; off < cchLineT; off++)
+            {
+                char ch = pchLine[off];
+                if (   (   ch != 't'
+                        && ch != 'T')
+                    || (   (ch = pchLine[off + 1]) != 'o'
+                        && ch != 'O')
+                    || (   (ch = pchLine[off + 2]) != 'd'
+                        && ch != 'D')
+                    || (   (ch = pchLine[off + 3]) != 'o'
+                        && ch != 'O')
+                    || (   off + 4 != cchLine
+                        && (ch = pchLine[off + 4]) != ' '
+                        && ch != '\t'
+                        && ch != ':'                /** @todo */
+                        && (ch != '*' || off + 5 > cchLine || pchLine[off + 5] != '/')  /** @todo */
+                        ) )
+                { /* not a hit - likely */ }
+                else
+                    return off;
+            }
+        }
+    }
+    return ~(size_t)0;
+}
+
+
+/**
+ * Doxygen todos in C and C++ code.
+ *
+ * @returns Modification state.
+ * @param   pState              The rewriter state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_Fix_C_and_CPP_Todos(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fFixTodos)
+        return kScmUnmodified;
+
+    /*
+     * Work thru the file line by line looking for the start of todo comments.
+     */
+    size_t      cChanges = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        /*
+         * Look for the word 'todo' in the line.  We're currently only trying
+         * to catch comments starting with the word todo and adjust the start of
+         * the doxygen statement.
+         */
+        size_t offTodo = findTodo(pchLine, cchLine);
+        if (   offTodo != ~(size_t)0
+            && offTodo >= 2)
+        {
+            /* Work backwards to find the start of the comment. */
+            bool fSameLine = false;
+            size_t offCommentStart = findTodoCommentStart(pchLine, offTodo, &fSameLine);
+            if (offCommentStart != ~(size_t)0)
+            {
+                char    szNew[64];
+                size_t  cchNew = 0;
+                szNew[cchNew++] = '/';
+                szNew[cchNew++] = pchLine[offCommentStart + 1];
+                szNew[cchNew++] = pchLine[offCommentStart + 1];
+                if (fSameLine)
+                    szNew[cchNew++] = '<';
+                szNew[cchNew++] = ' ';
+                szNew[cchNew++] = '@';
+                szNew[cchNew++] = 't';
+                szNew[cchNew++] = 'o';
+                szNew[cchNew++] = 'd';
+                szNew[cchNew++] = 'o';
+
+                /* Figure out wheter to continue after the @todo statement opening, we'll strip ':'
+                   but need to take into account that we might be at the end of the line before
+                   adding the space. */
+                size_t offTodoAfter = offTodo + 4;
+                if (   offTodoAfter < cchLine
+                    && pchLine[offTodoAfter] == ':')
+                    offTodoAfter++;
+                if (   offTodoAfter < cchLine
+                    && RT_C_IS_BLANK(pchLine[offTodoAfter]))
+                    offTodoAfter++;
+                if (offTodoAfter < cchLine)
+                    szNew[cchNew++] = ' ';
+
+                /* Write it out. */
+                ScmStreamWrite(pOut, pchLine, offCommentStart);
+                ScmStreamWrite(pOut, szNew, cchNew);
+                if (offTodoAfter < cchLine)
+                    ScmStreamWrite(pOut, &pchLine[offTodoAfter], cchLine - offTodoAfter);
+                ScmStreamPutEol(pOut, enmEol);
+
+                /* Check whether we actually made any changes. */
+                if (   cchNew != offTodoAfter - offCommentStart
+                    || memcmp(szNew, &pchLine[offCommentStart], cchNew))
+                    cChanges++;
+                continue;
+            }
+        }
+
+        int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+    if (cChanges > 0)
+        ScmVerbose(pState, 2, " * Converted %zu todo statements.\n", cChanges);
+    return cChanges != 0 ? kScmModified : kScmUnmodified;
+}
+
+
+/**
+ * Tries to parse a C/C++ preprocessor include directive.
+ *
+ * This is resonably forgiving and expects sane input.
+ *
+ * @retval  kScmIncludeDir_Invalid if not a valid include directive.
+ * @retval  kScmIncludeDir_Quoted
+ * @retval  kScmIncludeDir_Bracketed
+ * @retval  kScmIncludeDir_Macro
+ *
+ * @param   pState          The rewriter state (for repording malformed
+ *                          directives).
+ * @param   pchLine         The line to try parse as an include statement.
+ * @param   cchLine         The line length.
+ * @param   ppchFilename    Where to return the pointer to the filename part.
+ * @param   pcchFilename    Where to return the length of the filename.
+ */
+SCMINCLUDEDIR ScmMaybeParseCIncludeLine(PSCMRWSTATE pState, const char *pchLine, size_t cchLine,
+                                        const char **ppchFilename, size_t *pcchFilename)
+{
+    /* Skip leading spaces: */
+    while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
+        cchLine--, pchLine++;
+
+    /* Check for '#': */
+    if (cchLine > 0 && *pchLine == '#')
+    {
+        cchLine--;
+        pchLine++;
+
+        /* Skip spaces after '#' (optional): */
+        while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
+            cchLine--, pchLine++;
+
+        /* Check for 'include': */
+        static char const s_szInclude[] = "include";
+        if (   cchLine >= sizeof(s_szInclude)
+            && memcmp(pchLine, RT_STR_TUPLE(s_szInclude)) == 0)
+        {
+            cchLine -= sizeof(s_szInclude) - 1;
+            pchLine += sizeof(s_szInclude) - 1;
+
+            /* Skip spaces after 'include' word (optional): */
+            while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
+                cchLine--, pchLine++;
+            if (cchLine > 0)
+            {
+                /* Quoted or bracketed? */
+                char const chFirst = *pchLine;
+                if (chFirst == '"' || chFirst == '<')
+                {
+                    cchLine--;
+                    pchLine++;
+                    const char *pchEnd = (const char *)memchr(pchLine, chFirst == '"' ? '"' : '>', cchLine);
+                    if (pchEnd)
+                    {
+                        if (ppchFilename)
+                            *ppchFilename = pchLine;
+                        if (pcchFilename)
+                            *pcchFilename = pchEnd - pchLine;
+                        return chFirst == '"' ? kScmIncludeDir_Quoted : kScmIncludeDir_Bracketed;
+                    }
+                    ScmError(pState, VERR_PARSE_ERROR, "Unbalanced #include filename %s: %.*s\n",
+                             chFirst == '"' ? "quotes" : "brackets" , cchLine, pchLine);
+                }
+                /* C prepreprocessor macro? */
+                else if (ScmIsCIdentifierLeadChar(chFirst))
+                {
+                    size_t cchFilename = 1;
+                    while (   cchFilename < cchLine
+                           && ScmIsCIdentifierChar(pchLine[cchFilename]))
+                        cchFilename++;
+                    if (ppchFilename)
+                        *ppchFilename = pchLine;
+                    if (pcchFilename)
+                        *pcchFilename = cchFilename;
+                    return kScmIncludeDir_Macro;
+                }
+                else
+                    ScmError(pState, VERR_PARSE_ERROR, "Malformed #include filename part: %.*s\n", cchLine, pchLine);
+            }
+            else
+                ScmError(pState, VERR_PARSE_ERROR, "Missing #include filename!\n");
+        }
+    }
+
+    if (ppchFilename)
+        *ppchFilename = NULL;
+    if (pcchFilename)
+        *pcchFilename = 0;
+    return kScmIncludeDir_Invalid;
+}
+
+
+/**
+ * Fix err.h/errcore.h usage.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_Fix_Err_H(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fFixErrH)
+        return kScmUnmodified;
+
+    static struct
+    {
+        const char *pszHeader;
+        unsigned    cchHeader;
+        int         iLevel;
+    } const s_aHeaders[] =
+    {
+        { RT_STR_TUPLE("iprt/errcore.h"), 1 },
+        { RT_STR_TUPLE("iprt/err.h"),     2 },
+        { RT_STR_TUPLE("VBox/err.h"),     3 },
+    };
+    static RTSTRTUPLE const g_aLevel1Statuses[] =  /* Note! Keep in sync with errcore.h content! */
+    {
+        { RT_STR_TUPLE("VINF_SUCCESS") },
+        { RT_STR_TUPLE("VERR_GENERAL_FAILURE") },
+        { RT_STR_TUPLE("VERR_INVALID_PARAMETER") },
+        { RT_STR_TUPLE("VWRN_INVALID_PARAMETER") },
+        { RT_STR_TUPLE("VERR_INVALID_MAGIC") },
+        { RT_STR_TUPLE("VWRN_INVALID_MAGIC") },
+        { RT_STR_TUPLE("VERR_INVALID_HANDLE") },
+        { RT_STR_TUPLE("VWRN_INVALID_HANDLE") },
+        { RT_STR_TUPLE("VERR_INVALID_POINTER") },
+        { RT_STR_TUPLE("VERR_NO_MEMORY") },
+        { RT_STR_TUPLE("VERR_PERMISSION_DENIED") },
+        { RT_STR_TUPLE("VINF_PERMISSION_DENIED") },
+        { RT_STR_TUPLE("VERR_VERSION_MISMATCH") },
+        { RT_STR_TUPLE("VERR_NOT_IMPLEMENTED") },
+        { RT_STR_TUPLE("VERR_INVALID_FLAGS") },
+        { RT_STR_TUPLE("VERR_WRONG_ORDER") },
+        { RT_STR_TUPLE("VERR_INVALID_FUNCTION") },
+        { RT_STR_TUPLE("VERR_NOT_SUPPORTED") },
+        { RT_STR_TUPLE("VINF_NOT_SUPPORTED") },
+        { RT_STR_TUPLE("VERR_ACCESS_DENIED") },
+        { RT_STR_TUPLE("VERR_INTERRUPTED") },
+        { RT_STR_TUPLE("VINF_INTERRUPTED") },
+        { RT_STR_TUPLE("VERR_TIMEOUT") },
+        { RT_STR_TUPLE("VINF_TIMEOUT") },
+        { RT_STR_TUPLE("VERR_BUFFER_OVERFLOW") },
+        { RT_STR_TUPLE("VINF_BUFFER_OVERFLOW") },
+        { RT_STR_TUPLE("VERR_TOO_MUCH_DATA") },
+        { RT_STR_TUPLE("VERR_TRY_AGAIN") },
+        { RT_STR_TUPLE("VINF_TRY_AGAIN") },
+        { RT_STR_TUPLE("VERR_PARSE_ERROR") },
+        { RT_STR_TUPLE("VERR_OUT_OF_RANGE") },
+        { RT_STR_TUPLE("VERR_NUMBER_TOO_BIG") },
+        { RT_STR_TUPLE("VWRN_NUMBER_TOO_BIG") },
+        { RT_STR_TUPLE("VERR_CANCELLED") },
+        { RT_STR_TUPLE("VERR_TRAILING_CHARS") },
+        { RT_STR_TUPLE("VWRN_TRAILING_CHARS") },
+        { RT_STR_TUPLE("VERR_TRAILING_SPACES") },
+        { RT_STR_TUPLE("VWRN_TRAILING_SPACES") },
+        { RT_STR_TUPLE("VERR_NOT_FOUND") },
+        { RT_STR_TUPLE("VWRN_NOT_FOUND") },
+        { RT_STR_TUPLE("VERR_INVALID_STATE") },
+        { RT_STR_TUPLE("VWRN_INVALID_STATE") },
+        { RT_STR_TUPLE("VERR_OUT_OF_RESOURCES") },
+        { RT_STR_TUPLE("VWRN_OUT_OF_RESOURCES") },
+        { RT_STR_TUPLE("VERR_END_OF_STRING") },
+        { RT_STR_TUPLE("VERR_CALLBACK_RETURN") },
+        { RT_STR_TUPLE("VINF_CALLBACK_RETURN") },
+        { RT_STR_TUPLE("VERR_DUPLICATE") },
+        { RT_STR_TUPLE("VERR_MISSING") },
+        { RT_STR_TUPLE("VERR_BUFFER_UNDERFLOW") },
+        { RT_STR_TUPLE("VINF_BUFFER_UNDERFLOW") },
+        { RT_STR_TUPLE("VERR_NOT_AVAILABLE") },
+        { RT_STR_TUPLE("VERR_MISMATCH") },
+        { RT_STR_TUPLE("VERR_WRONG_TYPE") },
+        { RT_STR_TUPLE("VWRN_WRONG_TYPE") },
+        { RT_STR_TUPLE("VERR_WRONG_PARAMETER_COUNT") },
+        { RT_STR_TUPLE("VERR_WRONG_PARAMETER_TYPE") },
+        { RT_STR_TUPLE("VERR_INVALID_CLIENT_ID") },
+        { RT_STR_TUPLE("VERR_INVALID_SESSION_ID") },
+        { RT_STR_TUPLE("VERR_INCOMPATIBLE_CONFIG") },
+        { RT_STR_TUPLE("VERR_INTERNAL_ERROR") },
+        { RT_STR_TUPLE("VINF_GETOPT_NOT_OPTION") },
+        { RT_STR_TUPLE("VERR_GETOPT_UNKNOWN_OPTION") },
+    };
+
+    /*
+     * First pass: Scout #include err.h/errcore.h locations and usage.
+     *
+     * Note! This isn't entirely optimal since it's also parsing comments and
+     *       strings, not just code.  However it does a decent job for now.
+     */
+    int         iIncludeLevel = 0;
+    int         iUsageLevel   = 0;
+    uint32_t    iLine         = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        iLine++;
+        if (cchLine < 6)
+            continue;
+
+        /*
+         * Look for #includes.
+         */
+        const char *pchHash = (const char *)memchr(pchLine, '#', cchLine);
+        if (    pchHash
+            && isSpanOfBlanks(pchLine, pchHash - pchLine))
+        {
+            const char     *pchFilename;
+            size_t          cchFilename;
+            SCMINCLUDEDIR   enmIncDir = ScmMaybeParseCIncludeLine(pState, pchLine, cchLine, &pchFilename, &cchFilename);
+            if (   enmIncDir == kScmIncludeDir_Bracketed
+                || enmIncDir == kScmIncludeDir_Quoted)
+            {
+                unsigned i = RT_ELEMENTS(s_aHeaders);
+                while (i-- > 0)
+                    if (   s_aHeaders[i].cchHeader == cchFilename
+                        && RTStrNICmpAscii(pchFilename, s_aHeaders[i].pszHeader, cchFilename) == 0)
+                    {
+                        if (iIncludeLevel < s_aHeaders[i].iLevel)
+                            iIncludeLevel = s_aHeaders[i].iLevel;
+                        break;
+                    }
+
+                /* Special hack for error info. */
+                if (cchFilename == sizeof("errmsgdata.h") - 1 && memcmp(pchFilename, RT_STR_TUPLE("errmsgdata.h")) == 0)
+                    iUsageLevel = 4;
+
+                /* Special hack for code templates. */
+                if (   cchFilename >= sizeof(".cpp.h")
+                    && memcmp(&pchFilename[cchFilename - sizeof(".cpp.h") + 1], RT_STR_TUPLE(".cpp.h")) == 0)
+                    iUsageLevel = 4;
+                continue;
+            }
+        }
+        /*
+         * Look for VERR_, VWRN_, VINF_ prefixed identifiers in the current line.
+         */
+        const char *pchHit = (const char *)memchr(pchLine, 'V', cchLine);
+        if (pchHit)
+        {
+            const char *pchLeft = pchLine;
+            size_t      cchLeft = cchLine;
+            do
+            {
+                size_t cchLeftHit = &pchLeft[cchLeft] - pchHit;
+                if (cchLeftHit < 6)
+                    break;
+                if (    pchHit[4] == '_'
+                    && (   pchHit == pchLine
+                        || !ScmIsCIdentifierChar(pchHit[-1]))
+                    && (   (pchHit[1] == 'E' && pchHit[2] == 'R' && pchHit[3] == 'R')
+                        || (pchHit[1] == 'W' && pchHit[2] == 'R' && pchHit[3] == 'N')
+                        || (pchHit[1] == 'I' && pchHit[2] == 'N' && pchHit[3] == 'F') ) )
+                {
+                    size_t cchIdentifier = 5;
+                    while (cchIdentifier < cchLeftHit && ScmIsCIdentifierChar(pchHit[cchIdentifier]))
+                        cchIdentifier++;
+                    ScmVerbose(pState, 4, "--- status code at %u col %zu: %.*s\n",
+                               iLine, pchHit - pchLine, cchIdentifier, pchHit);
+
+                    if (iUsageLevel <= 1)
+                    {
+                        iUsageLevel = 3; /* Cannot distingish between iprt/err.h and VBox/err.h, so pick the latter for now. */
+                        for (unsigned i = 0; i < RT_ELEMENTS(g_aLevel1Statuses); i++)
+                            if (   cchIdentifier == g_aLevel1Statuses[i].cch
+                                && memcmp(pchHit, g_aLevel1Statuses[i].psz, cchIdentifier) == 0)
+                            {
+                                iUsageLevel = 1;
+                                break;
+                            }
+                    }
+
+                    pchLeft = pchHit     + cchIdentifier;
+                    cchLeft = cchLeftHit - cchIdentifier;
+                }
+                else
+                {
+                    pchLeft = pchHit     + 1;
+                    cchLeft = cchLeftHit - 1;
+                }
+                pchHit  = (const char *)memchr(pchLeft, 'V', cchLeft);
+            } while (pchHit != NULL);
+        }
+    }
+    ScmVerbose(pState, 3, "--- iIncludeLevel=%d iUsageLevel=%d\n", iIncludeLevel, iUsageLevel);
+
+    /*
+     * Second pass: Change err.h to errcore.h if we detected a need for change.
+     */
+    if (   iIncludeLevel <= iUsageLevel
+        || iIncludeLevel <= 1 /* we cannot safely eliminate errcore.h includes atm. */)
+        return kScmUnmodified;
+
+    unsigned cChanges = 0;
+    ScmStreamRewindForReading(pIn);
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        /*
+         * Look for #includes to modify.
+         */
+        if (cchLine >= 6)
+        {
+            const char *pchHash = (const char *)memchr(pchLine, '#', cchLine);
+            if (    pchHash
+                && isSpanOfBlanks(pchLine, pchHash - pchLine))
+            {
+                const char     *pchFilename;
+                size_t          cchFilename;
+                SCMINCLUDEDIR   enmIncDir = ScmMaybeParseCIncludeLine(pState, pchLine, cchLine, &pchFilename, &cchFilename);
+                if (   enmIncDir == kScmIncludeDir_Bracketed
+                    || enmIncDir == kScmIncludeDir_Quoted)
+                {
+                    unsigned i = RT_ELEMENTS(s_aHeaders);
+                    while (i-- > 0)
+                        if (   s_aHeaders[i].cchHeader == cchFilename
+                            && RTStrNICmpAscii(pchFilename, s_aHeaders[i].pszHeader, cchFilename) == 0)
+                        {
+                            ScmStreamWrite(pOut, pchLine, pchFilename - pchLine - 1);
+                            ScmStreamWrite(pOut, RT_STR_TUPLE("<iprt/errcore.h>"));
+                            size_t cchTrailing = &pchLine[cchLine] - &pchFilename[cchFilename + 1];
+                            if (cchTrailing > 0)
+                                ScmStreamWrite(pOut, &pchFilename[cchFilename + 1], cchTrailing);
+                            ScmStreamPutEol(pOut, enmEol);
+                            cChanges++;
+                            pchLine = NULL;
+                            break;
+                        }
+                    if (!pchLine)
+                        continue;
+                }
+            }
+        }
+
+        int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+    ScmVerbose(pState, 2, " * Converted %zu err.h/errcore.h include statements.\n", cChanges);
+    return kScmModified;
+}
+
+typedef struct
+{
+    const char     *pch;
+    uint8_t         cch;
+    uint8_t         cchSpaces;          /**< Number of expected spaces before the word. */
+    bool            fSpacesBefore : 1;  /**< Whether there may be spaces or tabs before the word. */
+    bool            fIdentifier   : 1;  /**< Whether we're to expect a C/C++ identifier rather than pch/cch. */
+} SCMMATCHWORD;
+
+
+int ScmMatchWords(const char *pchLine, size_t cchLine, SCMMATCHWORD const *paWords, size_t cWords,
+                  size_t *poffNext, PRTSTRTUPLE paIdentifiers, PRTERRINFO pErrInfo)
+{
+    int rc = VINF_SUCCESS;
+
+    size_t offLine = 0;
+    for (size_t i = 0; i < cWords; i++)
+    {
+        SCMMATCHWORD const *pWord = &paWords[i];
+
+        /*
+         * Deal with spaces preceeding the word first:
+         */
+        if (pWord->fSpacesBefore)
+        {
+            size_t cchSpaces = 0;
+            size_t cchTabs   = 0;
+            while (offLine < cchLine)
+            {
+                const char ch = pchLine[offLine];
+                if (ch == ' ')
+                    cchSpaces++;
+                else if (ch == '\t')
+                    cchTabs++;
+                else
+                    break;
+                offLine++;
+            }
+
+            if (cchSpaces == pWord->cchSpaces && cchTabs == 0)
+            { /* likely */ }
+            else if (cchSpaces == 0 && cchTabs == 0)
+                return RTErrInfoSetF(pErrInfo, VERR_PARSE_ERROR, "expected space at offset %u", offLine);
+            else
+                rc = VWRN_TRAILING_SPACES;
+        }
+        else
+            Assert(pWord->cchSpaces == 0);
+
+        /*
+         * C/C++ identifier?
+         */
+        if (pWord->fIdentifier)
+        {
+            if (offLine >= cchLine)
+                return RTErrInfoSetF(pErrInfo, VERR_END_OF_STRING,
+                                     "expected '%.*s' (C/C++ identifier) at offset %u, not end of string",
+                                     pWord->cch, pWord->pch, offLine);
+            if (!ScmIsCIdentifierLeadChar(pchLine[offLine]))
+                return RTErrInfoSetF(pErrInfo, VERR_MISMATCH, "expected '%.*s' (C/C++ identifier) at offset %u",
+                                     pWord->cch, pWord->pch, offLine);
+            size_t const offStart = offLine++;
+            while (offLine < cchLine && ScmIsCIdentifierChar(pchLine[offLine]))
+                offLine++;
+            if (paIdentifiers)
+            {
+                paIdentifiers->cch = offLine - offStart;
+                paIdentifiers->psz = &pchLine[offStart];
+                paIdentifiers++;
+            }
+        }
+        /*
+         * Match the exact word.
+         */
+        else if (   pWord->cch == 0
+                 || (   pWord->cch <= cchLine - offLine
+                     && !memcmp(pWord->pch, &pchLine[offLine], pWord->cch)))
+            offLine += pWord->cch;
+        else
+            return RTErrInfoSetF(pErrInfo, VERR_MISMATCH, "expected '%.*s' at offset %u", pWord->cch, pWord->pch, offLine);
+    }
+
+    /*
+     * Check for trailing characters/whatnot.
+     */
+    if (poffNext)
+        *poffNext = offLine;
+    else if (offLine != cchLine)
+        rc = RTErrInfoSetF(pErrInfo, VERR_TRAILING_CHARS, "unexpected trailing characters at offset %u", offLine);
+    return rc;
+}
+
+
+/**
+ * Fix header file include guards and \#pragma once.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_FixHeaderGuards(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fFixHeaderGuards)
+        return kScmUnmodified;
+
+    /* always skip .cpp.h files */
+    size_t cchFilename = strlen(pState->pszFilename);
+    if (   cchFilename > sizeof(".cpp.h")
+        && RTStrICmpAscii(&pState->pszFilename[cchFilename - sizeof(".cpp.h") + 1], ".cpp.h") == 0)
+        return kScmUnmodified;
+
+    RTERRINFOSTATIC ErrInfo;
+    char            szNormalized[168];
+    size_t          cchNormalized = 0;
+    int             rc;
+    bool            fRet = false;
+
+    /*
+     * Calculate the expected guard for this file, if so tasked.
+     * ASSUMES pState->pszFilename is absolute as is pSettings->pszGuardRelativeToDir.
+     */
+    szNormalized[0] = '\0';
+    if (pSettings->pszGuardRelativeToDir)
+    {
+        rc = RTStrCopy(szNormalized, sizeof(szNormalized), pSettings->pszGuardPrefix);
+        if (RT_FAILURE(rc))
+            return ScmError(pState, rc, "Guard prefix too long (or something): %s\n", pSettings->pszGuardPrefix);
+        cchNormalized = strlen(szNormalized);
+        if (strcmp(pSettings->pszGuardRelativeToDir, "{dir}") == 0)
+            rc = RTStrCopy(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized,
+                           RTPathFilename(pState->pszFilename));
+        else if (strcmp(pSettings->pszGuardRelativeToDir, "{parent}") == 0)
+        {
+            const char *pszSrc = RTPathFilename(pState->pszFilename);
+            if (!pszSrc || (uintptr_t)&pszSrc[-2] < (uintptr_t)pState->pszFilename || !RTPATH_IS_SLASH(pszSrc[-1]))
+                return ScmError(pState, VERR_INTERNAL_ERROR, "Error calculating {parent} header guard!\n");
+            pszSrc -= 2;
+            while (   (uintptr_t)pszSrc > (uintptr_t)pState->pszFilename
+                   && !RTPATH_IS_SLASH(pszSrc[-1])
+                   && !RTPATH_IS_VOLSEP(pszSrc[-1]))
+                pszSrc--;
+            rc = RTStrCopy(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized, pszSrc);
+        }
+        else
+            rc = RTPathCalcRelative(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized,
+                                    pSettings->pszGuardRelativeToDir, false /*fFromFile*/, pState->pszFilename);
+        if (RT_FAILURE(rc))
+            return ScmError(pState, rc, "Error calculating guard prefix (RTPathCalcRelative): %Rrc\n", rc);
+        char ch;
+        while ((ch = szNormalized[cchNormalized]) != '\0')
+        {
+            if (!ScmIsCIdentifierChar(ch))
+                szNormalized[cchNormalized] = '_';
+            cchNormalized++;
+        }
+    }
+
+    /*
+     * First part looks for the #ifndef xxxx paired with #define xxxx.
+     *
+     * We blindly assume the first preprocessor directive in the file is the guard
+     * and will be upset if this isn't the case.
+     */
+    RTSTRTUPLE  Guard       = { NULL, 0 };
+    uint32_t    cBlankLines = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    for (;;)
+    {
+        pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        if (pchLine == NULL)
+            return ScmError(pState, VERR_PARSE_ERROR, "Did not find any include guards!\n");
+        if (cchLine >= 2)
+        {
+            const char *pchHash = (const char *)memchr(pchLine, '#', cchLine);
+            if (    pchHash
+                && isSpanOfBlanks(pchLine, pchHash - pchLine))
+            {
+                /* #ifndef xxxx */
+                static const SCMMATCHWORD s_aIfndefGuard[] =
+                {
+                    { RT_STR_TUPLE("#"),                0, true, false },
+                    { RT_STR_TUPLE("ifndef"),           0, true, false },
+                    { RT_STR_TUPLE("IDENTIFIER"),       1, true, true },
+                    { RT_STR_TUPLE(""),                 0, true, false },
+                };
+                rc = ScmMatchWords(pchLine, cchLine, s_aIfndefGuard, RT_ELEMENTS(s_aIfndefGuard),
+                                   NULL /*poffNext*/, &Guard, RTErrInfoInitStatic(&ErrInfo));
+                if (RT_FAILURE(rc))
+                    return ScmError(pState, rc, "%u: Expected first preprocessor directive to be '#ifndef xxxx'. %s (%.*s)\n",
+                                    ScmStreamTellLine(pIn) - 1, ErrInfo.Core.pszMsg, cchLine, pchLine);
+                fRet |= rc != VINF_SUCCESS;
+                ScmVerbose(pState, 3, "line %u in %s: #ifndef %.*s\n",
+                           ScmStreamTellLine(pIn) - 1, pState->pszFilename, Guard.cch, Guard.psz);
+
+                /* #define xxxx */
+                pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+                if (!pchLine)
+                    return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef %.*s'\n",
+                                    ScmStreamTellLine(pIn) - 1, Guard.cch, Guard.psz);
+                const SCMMATCHWORD aDefineGuard[] =
+                {
+                    { RT_STR_TUPLE("#"),                0, true, false },
+                    { RT_STR_TUPLE("define"),           0, true, false },
+                    { Guard.psz, (uint8_t)Guard.cch,    1, true, false },
+                    { RT_STR_TUPLE(""),                 0, true, false },
+                };
+                rc = ScmMatchWords(pchLine, cchLine, aDefineGuard, RT_ELEMENTS(aDefineGuard),
+                                   NULL /*poffNext*/, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+                if (RT_FAILURE(rc))
+                    return ScmError(pState, rc, "%u: Expected '#define %.*s' to follow '#ifndef %.*s'. %s (%.*s)\n",
+                                    ScmStreamTellLine(pIn) - 1, Guard.cch, Guard.psz, Guard.cch, Guard.psz,
+                                    ErrInfo.Core.pszMsg, cchLine, pchLine);
+                fRet |= rc != VINF_SUCCESS;
+
+                if (Guard.cch >= sizeof(szNormalized))
+                    return ScmError(pState, VERR_BUFFER_OVERFLOW, "%u: Guard macro too long! %.*s\n",
+                                    ScmStreamTellLine(pIn) - 2, Guard.cch, Guard.psz);
+
+                if (szNormalized[0] != '\0')
+                {
+                    if (   Guard.cch != cchNormalized
+                        || memcmp(Guard.psz, szNormalized, cchNormalized) != 0)
+                    {
+                        ScmVerbose(pState, 2, "guard changed from %.*s to %s\n", Guard.cch, Guard.psz, szNormalized);
+                        ScmVerbose(pState, 2, "grep -rw %.*s ${WCROOT} | grep -Fv %s\n",
+                                   Guard.cch, Guard.psz, pState->pszFilename);
+                        fRet = true;
+                    }
+                    Guard.psz = szNormalized;
+                    Guard.cch = cchNormalized;
+                }
+
+                /*
+                 * Write guard, making sure we've got a single blank line preceeding it.
+                 */
+                ScmStreamPutEol(pOut, enmEol);
+                ScmStreamWrite(pOut, RT_STR_TUPLE("#ifndef "));
+                ScmStreamWrite(pOut, Guard.psz, Guard.cch);
+                ScmStreamPutEol(pOut, enmEol);
+                ScmStreamWrite(pOut, RT_STR_TUPLE("#define "));
+                ScmStreamWrite(pOut, Guard.psz, Guard.cch);
+                rc = ScmStreamPutEol(pOut, enmEol);
+                if (RT_FAILURE(rc))
+                    return kScmUnmodified;
+                break;
+            }
+        }
+
+        if (!isBlankLine(pchLine, cchLine))
+        {
+            while (cBlankLines-- > 0)
+                ScmStreamPutEol(pOut, enmEol);
+            cBlankLines = 0;
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+            if (RT_FAILURE(rc))
+                return kScmUnmodified;
+        }
+        else
+            cBlankLines++;
+    }
+
+    /*
+     * Look for pragma once wrapped in #ifndef RT_WITHOUT_PRAGMA_ONCE.
+     */
+    size_t const iPragmaOnce = ScmStreamTellLine(pIn);
+    static const SCMMATCHWORD s_aIfndefRtWithoutPragmaOnce[] =
+    {
+        { RT_STR_TUPLE("#"),                        0, true, false },
+        { RT_STR_TUPLE("ifndef"),                   0, true, false },
+        { RT_STR_TUPLE("RT_WITHOUT_PRAGMA_ONCE"),   1, true, false },
+        { RT_STR_TUPLE(""),                         0, true, false },
+    };
+    static const SCMMATCHWORD s_aPragmaOnce[] =
+    {
+        { RT_STR_TUPLE("#"),                        0, true, false },
+        { RT_STR_TUPLE("pragma"),                   1, true, false },
+        { RT_STR_TUPLE("once"),                     1, true, false},
+        { RT_STR_TUPLE(""),                         0, true, false },
+    };
+    static const SCMMATCHWORD s_aEndif[] =
+    {
+        { RT_STR_TUPLE("#"),                        0, true, false },
+        { RT_STR_TUPLE("endif"),                    0, true, false },
+        { RT_STR_TUPLE(""),                         0, true, false },
+    };
+
+    /* #ifndef RT_WITHOUT_PRAGMA_ONCE */
+    pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+    if (!pchLine)
+        return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after header guard!\n", iPragmaOnce + 1);
+    size_t offNext;
+    rc = ScmMatchWords(pchLine, cchLine, s_aIfndefRtWithoutPragmaOnce, RT_ELEMENTS(s_aIfndefRtWithoutPragmaOnce),
+                       &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+    if (RT_SUCCESS(rc))
+    {
+        fRet |= rc != VINF_SUCCESS;
+        if (offNext != cchLine)
+            return ScmError(pState, VERR_PARSE_ERROR, "%u: Characters trailing '#ifndef RT_WITHOUT_PRAGMA_ONCE' (%.*s)\n",
+                            iPragmaOnce + 1, cchLine, pchLine);
+
+        /* # pragma once */
+        pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        if (!pchLine)
+            return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef RT_WITHOUT_PRAGMA_ONCE'\n",
+                            iPragmaOnce + 2);
+        rc = ScmMatchWords(pchLine, cchLine, s_aPragmaOnce, RT_ELEMENTS(s_aPragmaOnce),
+                           NULL /*poffNext*/, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+            fRet |= rc != VINF_SUCCESS;
+        else
+            return ScmError(pState, rc, "%u: Expected '# pragma once' to follow '#ifndef RT_WITHOUT_PRAGMA_ONCE'! %s (%.*s)\n",
+                            iPragmaOnce + 2, ErrInfo.Core.pszMsg, cchLine, pchLine);
+
+        /* #endif */
+        pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        if (!pchLine)
+            return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef RT_WITHOUT_PRAGMA_ONCE' and '#pragma once'\n",
+                            iPragmaOnce + 3);
+        rc = ScmMatchWords(pchLine, cchLine, s_aEndif, RT_ELEMENTS(s_aEndif),
+                           NULL /*poffNext*/, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+            fRet |= rc != VINF_SUCCESS;
+        else
+            return ScmError(pState, rc,
+                            "%u: Expected '#endif' to follow '#ifndef RT_WITHOUT_PRAGMA_ONCE' and '# pragma once'! %s (%.*s)\n",
+                            iPragmaOnce + 3, ErrInfo.Core.pszMsg, cchLine, pchLine);
+        ScmVerbose(pState, 3, "Found pragma once\n");
+        fRet |= !pSettings->fPragmaOnce;
+    }
+    else
+    {
+        rc = ScmStreamSeekByLine(pIn, iPragmaOnce);
+        if (RT_FAILURE(rc))
+            return ScmError(pState, rc, "seek error\n");
+        fRet |= pSettings->fPragmaOnce;
+        ScmVerbose(pState, pSettings->fPragmaOnce ? 2 : 3, "Missing #pragma once\n");
+    }
+
+    /*
+     * Write the pragma once stuff.
+     */
+    if (pSettings->fPragmaOnce)
+    {
+        ScmStreamPutLine(pOut, RT_STR_TUPLE("#ifndef RT_WITHOUT_PRAGMA_ONCE"), enmEol);
+        ScmStreamPutLine(pOut, RT_STR_TUPLE("# pragma once"), enmEol);
+        rc = ScmStreamPutLine(pOut, RT_STR_TUPLE("#endif"), enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+
+    /*
+     * Copy the rest of the file and remove pragma once statements, while
+     * looking for the last #endif in the file.
+     */
+    size_t iEndIfIn = 0;
+    size_t iEndIfOut = 0;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        if (cchLine > 2)
+        {
+            const char *pchHash = (const char *)memchr(pchLine, '#', cchLine);
+            if (    pchHash
+                && isSpanOfBlanks(pchLine, pchHash - pchLine))
+            {
+                size_t off = pchHash - pchLine + 1;
+                while (off < cchLine && RT_C_IS_BLANK(pchLine[off]))
+                    off++;
+                /* #pragma once */
+                if (   off + sizeof("pragma") - 1 <= cchLine
+                    && !memcmp(&pchLine[off], RT_STR_TUPLE("pragma")))
+                {
+                    rc = ScmMatchWords(pchLine, cchLine, s_aPragmaOnce, RT_ELEMENTS(s_aPragmaOnce),
+                                       &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+                    if (RT_SUCCESS(rc))
+                    {
+                        fRet = true;
+                        continue;
+                    }
+                }
+                /* #endif */
+                else if (   off + sizeof("endif") - 1 <= cchLine
+                         && !memcmp(&pchLine[off], RT_STR_TUPLE("endif")))
+                {
+                    iEndIfIn  = ScmStreamTellLine(pIn) - 1;
+                    iEndIfOut = ScmStreamTellLine(pOut);
+                }
+            }
+        }
+
+        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+    }
+
+    /*
+     * Check out the last endif, making sure it's well formed and make sure it has the
+     * right kind of comment following it.
+     */
+    if (pSettings->fFixHeaderGuardEndif)
+    {
+        if (iEndIfOut == 0)
+            return ScmError(pState, VERR_PARSE_ERROR, "Expected '#endif' at the end of the file...\n");
+        rc = ScmStreamSeekByLine(pIn, iEndIfIn);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+        rc = ScmStreamSeekByLine(pOut, iEndIfOut);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+
+        pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
+        if (!pchLine)
+            return ScmError(pState, VERR_INTERNAL_ERROR, "ScmStreamGetLine failed re-reading #endif!\n");
+
+        char   szTmp[64 + sizeof(szNormalized)];
+        size_t cchTmp;
+        if (pSettings->fEndifGuardComment)
+            cchTmp = RTStrPrintf(szTmp, sizeof(szTmp), "#endif /* !%.*s */", Guard.cch, Guard.psz);
+        else
+            cchTmp = RTStrPrintf(szTmp, sizeof(szTmp), "#endif"); /* lazy bird */
+        fRet |= cchTmp != cchLine || memcmp(szTmp, pchLine, cchTmp) != 0;
+        rc = ScmStreamPutLine(pOut, szTmp, cchTmp, enmEol);
+        if (RT_FAILURE(rc))
+            return kScmUnmodified;
+
+        /* Copy out the remaining lines (assumes no #pragma once here). */
+        while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+        {
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+            if (RT_FAILURE(rc))
+                return kScmUnmodified;
+        }
+    }
+
+    return fRet ? kScmModified : kScmUnmodified;
+}
+
+
+/**
+ * Checks for PAGE_SIZE, PAGE_SHIFT and PAGE_OFFSET_MASK w/o a GUEST_ or HOST_
+ * prefix as well as banning PAGE_BASE_HC_MASK, PAGE_BASE_GC_MASK and
+ * PAGE_BASE_MASK.
+ *
+ * @returns kScmUnmodified - requires manual fix.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+SCMREWRITERRES rewrite_PageChecks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF(pOut);
+    if (!pSettings->fOnlyGuestHostPage && !pSettings->fNoASMMemPageUse)
+        return kScmUnmodified;
+
+    static RTSTRTUPLE const g_aWords[] =
+    {
+        { RT_STR_TUPLE("PAGE_SIZE") },
+        { RT_STR_TUPLE("PAGE_SHIFT") },
+        { RT_STR_TUPLE("PAGE_OFFSET_MASK") },
+        { RT_STR_TUPLE("PAGE_BASE_MASK") },
+        { RT_STR_TUPLE("PAGE_BASE_GC_MASK") },
+        { RT_STR_TUPLE("PAGE_BASE_HC_MASK") },
+        { RT_STR_TUPLE("PAGE_ADDRESS") },
+        { RT_STR_TUPLE("PHYS_PAGE_ADDRESS") },
+        { RT_STR_TUPLE("ASMMemIsZeroPage") },
+        { RT_STR_TUPLE("ASMMemZeroPage") },
+    };
+    size_t const iFirstWord = pSettings->fOnlyGuestHostPage ? 0 : 7;
+    size_t const iEndWords  = pSettings->fNoASMMemPageUse   ? 9 : 7;
+
+    uint32_t    iLine = 0;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        iLine++;
+        for (size_t i = iFirstWord; i < iEndWords; i++)
+        {
+            size_t const cchWord = g_aWords[i].cch;
+            if (cchLine >= cchWord)
+            {
+                const char * const pszWord = g_aWords[i].psz;
+                const char        *pchHit  = (const char *)memchr(pchLine, *pszWord, cchLine);
+                while (pchHit)
+                {
+                    size_t cchLeft = (uintptr_t)&pchLine[cchLine] - (uintptr_t)pchHit;
+                    if (   cchLeft >= cchWord
+                        && memcmp(pchHit, pszWord, cchWord) == 0
+                        && (   pchHit == pchLine
+                            || !ScmIsCIdentifierChar(pchHit[-1]))
+                        && (   cchLeft == cchWord
+                            || !ScmIsCIdentifierChar(pchHit[cchWord])) )
+                    {
+                        if (i < 3)
+                            ScmFixManually(pState, "%u:%zu: %s is not allow! Use GUEST_%s or HOST_%s instead.\n",
+                                           iLine, pchHit - pchLine + 1, pszWord, pszWord, pszWord);
+                        else if (i < 7)
+                            ScmFixManually(pState, "%u:%zu: %s is not allow! Rewrite using GUEST/HOST_PAGE_OFFSET_MASK.\n",
+                                           iLine, pchHit - pchLine + 1, pszWord);
+                        else
+                            ScmFixManually(pState, "%u:%zu: %s is not allow! Use %s with correct page size instead.\n",
+                                           iLine, pchHit - pchLine + 1, pszWord, i == 3 ? "ASMMemIsZero" : "RT_BZERO");
+                    }
+
+                    /* next */
+                    cchLeft -= 1;
+                    if (cchLeft < cchWord)
+                        break;
+                    pchHit = (const char *)memchr(pchHit + 1, *pszWord, cchLeft);
+                }
+            }
+        }
+    }
+
+    return kScmUnmodified;
+}
+
+
+/**
+ * Checks for usage of rc in code instead of vrc for IPRT status codes (int) and hrc for COM
+ * status codes (HRESULT).
+ *
+ * @returns kScmUnmodified - requires manual fix.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ *
+ * @note Used in Main to avoid ambiguity when just using rc.
+ */
+SCMREWRITERRES rewrite_ForceHrcVrcInsteadOfRc(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    RT_NOREF(pOut);
+    if (!pSettings->fOnlyHrcVrcInsteadOfRc)
+        return kScmUnmodified;
+
+    static const SCMMATCHWORD s_aHresultVrc[] =
+    {
+        { RT_STR_TUPLE("HRESULT"),                  0, true, false },
+        { RT_STR_TUPLE("vrc"),                      1, true, false }
+    };
+
+    static const SCMMATCHWORD s_aIntHrc[] =
+    {
+        { RT_STR_TUPLE("int"),                      0, true, false },
+        { RT_STR_TUPLE("hrc"),                      1, true, false }
+    };
+
+    uint32_t        iLine = 0;
+    SCMEOL          enmEol;
+    size_t          cchLine;
+    const char      *pchLine;
+    RTERRINFOSTATIC ErrInfo;
+    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
+    {
+        iLine++;
+
+        /* Look for forbidden declarations first. */
+        size_t offNext = 0;
+        int rc = ScmMatchWords(pchLine, cchLine, s_aHresultVrc, RT_ELEMENTS(s_aHresultVrc),
+                               &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+        {
+            ScmFixManually(pState, "%u:%zu: 'HRESULT vrc' is not allowed! Use 'HRESULT hrc' instead.\n",
+                           iLine, offNext);
+            continue;
+        }
+
+        rc = ScmMatchWords(pchLine, cchLine, s_aIntHrc, RT_ELEMENTS(s_aIntHrc),
+                           &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+        {
+            ScmFixManually(pState, "%u:%zu: 'int hrc' is not allowed! Use 'int vrc' instead.\n",
+                           iLine, offNext);
+            continue;
+        }
+
+#if 0 /* This is too broad and triggers on things we don't want to trigger on (like autoCaller.rc()). */
+        const RTSTRTUPLE RcTuple = { RT_STR_TUPLE("rc") };
+        size_t const cchWord = RcTuple.cch;
+        if (cchLine >= cchWord)
+        {
+            const char        *pchHit  = (const char *)memchr(pchLine, *RcTuple.psz, cchLine);
+            while (pchHit)
+            {
+                size_t cchLeft = (uintptr_t)&pchLine[cchLine] - (uintptr_t)pchHit;
+                if (   cchLeft >= cchWord
+                    && memcmp(pchHit, RcTuple.psz, cchWord) == 0
+                    && (   pchHit == pchLine
+                        || !ScmIsCIdentifierChar(pchHit[-1]))
+                    && (   cchLeft == cchWord
+                        || !ScmIsCIdentifierChar(pchHit[cchWord])) )
+                    ScmFixManually(pState, "%u:%zu: %s is not allowed! Use hrc or vrc instead.\n",
+                                   iLine, pchHit - pchLine + 1, RcTuple.psz);
+
+                /* next */
+                cchLeft -= 1;
+                if (cchLeft < cchWord)
+                    break;
+                pchHit = (const char *)memchr(pchHit + 1, *RcTuple.psz, cchLeft);
+            }
+        }
+#else
+        /* Trigger on declarations of 'HRESULT rc' and 'int rc'. */
+        static const SCMMATCHWORD s_aHresultRc[] =
+        {
+            { RT_STR_TUPLE("HRESULT"),                  0, true, false },
+            { RT_STR_TUPLE("rc"),                       1, true, false }
+        };
+
+        static const SCMMATCHWORD s_aIntRc[] =
+        {
+            { RT_STR_TUPLE("int"),                      0, true, false },
+            { RT_STR_TUPLE("rc"),                       1, true, false }
+        };
+
+        rc = ScmMatchWords(pchLine, cchLine, s_aHresultRc, RT_ELEMENTS(s_aHresultRc),
+                           &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+        {
+            ScmFixManually(pState, "%u:%zu: 'HRESULT rc' is not allowed! Use 'HRESULT hrc' instead.\n",
+                           iLine, offNext);
+            continue;
+        }
+
+        rc = ScmMatchWords(pchLine, cchLine, s_aIntRc, RT_ELEMENTS(s_aIntRc),
+                           &offNext, NULL /*paIdentifiers*/, RTErrInfoInitStatic(&ErrInfo));
+        if (RT_SUCCESS(rc))
+        {
+            ScmFixManually(pState, "%u:%zu: 'int rc' is not allowed! Use 'int vrc' instead.\n",
+                           iLine, offNext);
+            continue;
+        }
+#endif
+    }
+
+    return kScmUnmodified;
+}
+
+
+/**
+ * Rewrite a C/C++ source or header file.
+ *
+ * @returns Modification state.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ *
+ * @todo
+ *
+ * Ideas for C/C++:
+ *      - space after if, while, for, switch
+ *      - spaces in for (i=0;i<x;i++)
+ *      - complex conditional, bird style.
+ *      - remove unnecessary parentheses.
+ *      - sort defined RT_OS_*||  and RT_ARCH
+ *      - sizeof without parenthesis.
+ *      - defined without parenthesis.
+ *      - trailing spaces.
+ *      - parameter indentation.
+ *      - space after comma.
+ *      - while (x--); -> multi line + comment.
+ *      - else statement;
+ *      - space between function and left parenthesis.
+ *      - TODO, XXX, @todo cleanup.
+ *      - Space before/after '*'.
+ *      - ensure new line at end of file.
+ *      - Indentation of precompiler statements (#ifdef, #defines).
+ *      - space between functions.
+ *      - string.h -> iprt/string.h, stdarg.h -> iprt/stdarg.h, etc.
+ */
+SCMREWRITERRES rewrite_C_and_CPP(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+
+    RT_NOREF4(pState, pIn, pOut, pSettings);
+    return kScmUnmodified;
+}
+
diff --git a/src/bldprogs/scmstream.cpp b/src/bldprogs/scmstream.cpp
new file mode 100644
index 00000000..e14cdf30
--- /dev/null
+++ b/src/bldprogs/scmstream.cpp
@@ -0,0 +1,1478 @@
+/* $Id: scmstream.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager Stream Code.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/handle.h>
+#include <iprt/mem.h>
+#include <iprt/pipe.h>
+#include <iprt/string.h>
+
+#include "scmstream.h"
+
+
+/**
+ * Initializes the stream structure.
+ *
+ * @param   pStream             The stream structure.
+ * @param   fWriteOrRead        The value of the fWriteOrRead stream member.
+ */
+static void scmStreamInitInternal(PSCMSTREAM pStream, bool fWriteOrRead)
+{
+    pStream->pch                = NULL;
+    pStream->off                = 0;
+    pStream->cb                 = 0;
+    pStream->cbAllocated        = 0;
+
+    pStream->paLines            = NULL;
+    pStream->iLine              = 0;
+    pStream->cLines             = 0;
+    pStream->cLinesAllocated    = 0;
+
+    pStream->fWriteOrRead       = fWriteOrRead;
+    pStream->fFileMemory        = false;
+    pStream->fFullyLineated     = false;
+
+    pStream->rc                 = VINF_SUCCESS;
+}
+
+/**
+ * Initialize an input stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream to initialize.
+ * @param   pszFilename         The file to take the stream content from.
+ */
+int ScmStreamInitForReading(PSCMSTREAM pStream, const char *pszFilename)
+{
+    scmStreamInitInternal(pStream, false /*fWriteOrRead*/);
+
+    void *pvFile;
+    size_t cbFile;
+    int rc = pStream->rc = RTFileReadAll(pszFilename, &pvFile, &cbFile);
+    if (RT_SUCCESS(rc))
+    {
+        pStream->pch            = (char *)pvFile;
+        pStream->cb             = cbFile;
+        pStream->cbAllocated    = cbFile;
+        pStream->fFileMemory    = true;
+    }
+    return rc;
+}
+
+/**
+ * Initialize an output stream.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream to initialize.
+ * @param   pRelatedStream      Pointer to a related stream.  NULL is fine.
+ */
+int ScmStreamInitForWriting(PSCMSTREAM pStream, PCSCMSTREAM pRelatedStream)
+{
+    scmStreamInitInternal(pStream, true /*fWriteOrRead*/);
+
+    /* allocate stuff */
+    size_t cbEstimate = !pRelatedStream ? _64K
+                      : pRelatedStream->cb > 0 ? pRelatedStream->cb + pRelatedStream->cb / 10 : 64;
+    cbEstimate = RT_ALIGN(cbEstimate, _4K);
+    pStream->pch = (char *)RTMemAlloc(cbEstimate);
+    if (pStream->pch)
+    {
+        size_t cLinesEstimate = pRelatedStream && pRelatedStream->fFullyLineated
+                              ? pRelatedStream->cLines + pRelatedStream->cLines / 10
+                              : cbEstimate / 24;
+        cLinesEstimate = RT_ALIGN(cLinesEstimate, 512);
+        if (cLinesEstimate == 0)
+            cLinesEstimate = 16;
+        pStream->paLines = (PSCMSTREAMLINE)RTMemAlloc(cLinesEstimate * sizeof(SCMSTREAMLINE));
+        if (pStream->paLines)
+        {
+            pStream->paLines[0].off     = 0;
+            pStream->paLines[0].cch     = 0;
+            pStream->paLines[0].enmEol  = SCMEOL_NONE;
+            pStream->cbAllocated        = cbEstimate;
+            pStream->cLinesAllocated    = cLinesEstimate;
+            return VINF_SUCCESS;
+        }
+
+        RTMemFree(pStream->pch);
+        pStream->pch = NULL;
+    }
+    return pStream->rc = VERR_NO_MEMORY;
+}
+
+/**
+ * Frees the resources associated with the stream.
+ *
+ * Nothing is happens to whatever the stream was initialized from or dumped to.
+ *
+ * @param   pStream             The stream to delete.
+ */
+void ScmStreamDelete(PSCMSTREAM pStream)
+{
+    if (pStream->pch)
+    {
+        if (pStream->fFileMemory)
+            RTFileReadAllFree(pStream->pch, pStream->cbAllocated);
+        else
+            RTMemFree(pStream->pch);
+        pStream->pch = NULL;
+    }
+    pStream->cbAllocated = 0;
+
+    if (pStream->paLines)
+    {
+        RTMemFree(pStream->paLines);
+        pStream->paLines = NULL;
+    }
+    pStream->cLinesAllocated = 0;
+}
+
+/**
+ * Get the stream status code.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.
+ */
+int ScmStreamGetStatus(PCSCMSTREAM pStream)
+{
+    return pStream->rc;
+}
+
+/**
+ * Grows the buffer of a write stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.  Must be in write mode.
+ * @param   cbAppending         The minimum number of bytes to grow the buffer
+ *                              with.
+ */
+static int scmStreamGrowBuffer(PSCMSTREAM pStream, size_t cbAppending)
+{
+    size_t cbAllocated = pStream->cbAllocated;
+    cbAllocated += RT_MAX(0x1000 + cbAppending, cbAllocated);
+    cbAllocated = RT_ALIGN(cbAllocated, 0x1000);
+    void *pvNew;
+    if (!pStream->fFileMemory)
+    {
+        pvNew = RTMemRealloc(pStream->pch, cbAllocated);
+        if (!pvNew)
+            return pStream->rc = VERR_NO_MEMORY;
+    }
+    else
+    {
+        pvNew = RTMemDupEx(pStream->pch, pStream->off, cbAllocated - pStream->off);
+        if (!pvNew)
+            return pStream->rc = VERR_NO_MEMORY;
+        RTFileReadAllFree(pStream->pch, pStream->cbAllocated);
+        pStream->fFileMemory = false;
+    }
+    pStream->pch = (char *)pvNew;
+    pStream->cbAllocated = cbAllocated;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Grows the line array of a stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.
+ * @param   iMinLine            Minimum line number.
+ */
+static int scmStreamGrowLines(PSCMSTREAM pStream, size_t iMinLine)
+{
+    size_t cLinesAllocated = pStream->cLinesAllocated;
+    cLinesAllocated += RT_MAX(512 + iMinLine, cLinesAllocated);
+    cLinesAllocated = RT_ALIGN(cLinesAllocated, 512);
+    void *pvNew = RTMemRealloc(pStream->paLines, cLinesAllocated * sizeof(SCMSTREAMLINE));
+    if (!pvNew)
+        return pStream->rc = VERR_NO_MEMORY;
+
+    pStream->paLines = (PSCMSTREAMLINE)pvNew;
+    pStream->cLinesAllocated = cLinesAllocated;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Rewinds the stream and sets the mode to read.
+ *
+ * @param   pStream             The stream.
+ */
+void ScmStreamRewindForReading(PSCMSTREAM pStream)
+{
+    pStream->off          = 0;
+    pStream->iLine        = 0;
+    pStream->fWriteOrRead = false;
+    pStream->rc           = VINF_SUCCESS;
+}
+
+/**
+ * Rewinds the stream and sets the mode to write.
+ *
+ * @param   pStream             The stream.
+ */
+void ScmStreamRewindForWriting(PSCMSTREAM pStream)
+{
+    pStream->off            = 0;
+    pStream->iLine          = 0;
+    pStream->cLines         = 0;
+    pStream->fWriteOrRead   = true;
+    pStream->fFullyLineated = true;
+    pStream->rc             = VINF_SUCCESS;
+
+    /* Initialize the first line with a zero length so ScmStreamWrite won't misbehave. */
+    if (pStream->cLinesAllocated == 0)
+        scmStreamGrowLines(pStream, 1);
+    if (pStream->cLinesAllocated > 0)
+    {
+        pStream->paLines[0].off    = 0;
+        pStream->paLines[0].cch    = 0;
+        pStream->paLines[0].enmEol = SCMEOL_NONE;
+    }
+}
+
+/**
+ * Checks if it's a text stream.
+ *
+ * Not 100% proof.
+ *
+ * @returns true if it probably is a text file, false if not.
+ * @param   pStream             The stream. Write or read, doesn't matter.
+ */
+bool ScmStreamIsText(PSCMSTREAM pStream)
+{
+    if (RTStrEnd(pStream->pch, pStream->cb))
+        return false;
+    if (!pStream->cb)
+        return true;
+    return true;
+}
+
+/**
+ * Performs an integrity check of the stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.
+ */
+int ScmStreamCheckItegrity(PSCMSTREAM pStream)
+{
+    /*
+     * Perform sanity checks.
+     */
+    size_t const cbFile = pStream->cb;
+    for (size_t iLine = 0; iLine < pStream->cLines; iLine++)
+    {
+        size_t offEol = pStream->paLines[iLine].off + pStream->paLines[iLine].cch;
+        AssertReturn(offEol + pStream->paLines[iLine].enmEol <= cbFile, VERR_INTERNAL_ERROR_2);
+        switch (pStream->paLines[iLine].enmEol)
+        {
+            case SCMEOL_LF:
+                AssertReturn(pStream->pch[offEol] == '\n', VERR_INTERNAL_ERROR_3);
+                break;
+            case SCMEOL_CRLF:
+                AssertReturn(pStream->pch[offEol] == '\r', VERR_INTERNAL_ERROR_3);
+                AssertReturn(pStream->pch[offEol + 1] == '\n', VERR_INTERNAL_ERROR_3);
+                break;
+            case SCMEOL_NONE:
+                AssertReturn(iLine + 1 >= pStream->cLines, VERR_INTERNAL_ERROR_4);
+                break;
+            default:
+                AssertReturn(iLine + 1 >= pStream->cLines, VERR_INTERNAL_ERROR_5);
+        }
+    }
+    return VINF_SUCCESS;
+}
+
+/**
+ * Writes the stream to a file.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream.
+ * @param   pszFilenameFmt      The filename format string.
+ * @param   ...                 Format arguments.
+ */
+int ScmStreamWriteToFile(PSCMSTREAM pStream, const char *pszFilenameFmt, ...)
+{
+    int rc;
+
+#ifdef RT_STRICT
+    /*
+     * Check that what we're going to write makes sense first.
+     */
+    rc = ScmStreamCheckItegrity(pStream);
+    if (RT_FAILURE(rc))
+        return rc;
+#endif
+
+    /*
+     * Do the actual writing.
+     */
+    RTFILE hFile;
+    va_list va;
+    va_start(va, pszFilenameFmt);
+    rc = RTFileOpenV(&hFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE, pszFilenameFmt, va);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTFileWrite(hFile, pStream->pch, pStream->cb, NULL);
+        RTFileClose(hFile);
+    }
+    va_end(va);
+    return rc;
+}
+
+/**
+ * Writes the stream to standard output.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream.
+ */
+int ScmStreamWriteToStdOut(PSCMSTREAM pStream)
+{
+    int rc;
+
+#ifdef RT_STRICT
+    /*
+     * Check that what we're going to write makes sense first.
+     */
+    rc = ScmStreamCheckItegrity(pStream);
+    if (RT_FAILURE(rc))
+        return rc;
+#endif
+
+    /*
+     * Do the actual writing.
+     */
+    RTHANDLE h;
+    rc = RTHandleGetStandard(RTHANDLESTD_OUTPUT, true /*fLeaveOpen*/, &h);
+    if (RT_SUCCESS(rc))
+    {
+        switch (h.enmType)
+        {
+            case RTHANDLETYPE_FILE:
+                rc = RTFileWrite(h.u.hFile, pStream->pch, pStream->cb, NULL);
+                /** @todo RTFileClose */
+                break;
+            case RTHANDLETYPE_PIPE:
+                rc = RTPipeWriteBlocking(h.u.hPipe, pStream->pch, pStream->cb, NULL);
+                RTPipeClose(h.u.hPipe);
+                break;
+            default:
+                rc = VERR_INVALID_HANDLE;
+                break;
+        }
+    }
+    return rc;
+}
+
+/**
+ * Worker for ScmStreamGetLine that builds the line number index while parsing
+ * the stream.
+ *
+ * @returns Same as SCMStreamGetLine.
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   pcchLine            Where to return the line length.
+ * @param   penmEol             Where to return the kind of end of line marker.
+ */
+static const char *scmStreamGetLineInternal(PSCMSTREAM pStream, size_t *pcchLine, PSCMEOL penmEol)
+{
+    AssertReturn(!pStream->fWriteOrRead, NULL);
+    if (RT_FAILURE(pStream->rc))
+        return NULL;
+
+    size_t off = pStream->off;
+    size_t cb  = pStream->cb;
+    if (RT_UNLIKELY(off >= cb))
+    {
+        pStream->fFullyLineated = true;
+        return NULL;
+    }
+
+    size_t iLine = pStream->iLine;
+    if (RT_UNLIKELY(iLine >= pStream->cLinesAllocated))
+    {
+        int rc = scmStreamGrowLines(pStream, iLine);
+        if (RT_FAILURE(rc))
+            return NULL;
+    }
+    pStream->paLines[iLine].off = off;
+
+    cb -= off;
+    const char *pchRet = &pStream->pch[off];
+    const char *pch = (const char *)memchr(pchRet, '\n', cb);
+    if (RT_LIKELY(pch))
+    {
+        cb = pch - pchRet;
+        pStream->off = off + cb + 1;
+        if (   cb < 1
+            || pch[-1] != '\r')
+            pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_LF;
+        else
+        {
+            pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_CRLF;
+            cb--;
+        }
+    }
+    else
+    {
+        pStream->off = off + cb;
+        pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_NONE;
+    }
+    *pcchLine = cb;
+    pStream->paLines[iLine].cch = cb;
+    pStream->cLines = pStream->iLine = ++iLine;
+
+    return pchRet;
+}
+
+/**
+ * Internal worker that delineates a stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.  Caller must check that it is in
+ *                              read mode.
+ */
+static int scmStreamLineate(PSCMSTREAM pStream)
+{
+    /* Save the stream position. */
+    size_t const offSaved   = pStream->off;
+    size_t const iLineSaved = pStream->iLine;
+
+    /* Get each line. */
+    size_t cchLine;
+    SCMEOL enmEol;
+    while (scmStreamGetLineInternal(pStream, &cchLine, &enmEol))
+        /* nothing */;
+    Assert(RT_FAILURE(pStream->rc) || pStream->fFullyLineated);
+
+    /* Restore the position */
+    pStream->off   = offSaved;
+    pStream->iLine = iLineSaved;
+
+    return pStream->rc;
+}
+
+/**
+ * Get the current stream position as an byte offset.
+ *
+ * @returns The current byte offset
+ * @param   pStream             The stream.
+ */
+size_t ScmStreamTell(PSCMSTREAM pStream)
+{
+    return pStream->off;
+}
+
+/**
+ * Get the current stream position as a line number.
+ *
+ * @returns The current line (0-based).
+ * @param   pStream             The stream.
+ */
+size_t ScmStreamTellLine(PSCMSTREAM pStream)
+{
+    return pStream->iLine;
+}
+
+
+/**
+ * Gets the stream offset of a given line.
+ *
+ * @returns The offset of the line, or the stream size if the line number is too
+ *          high.
+ * @param   pStream             The stream. Must be in read mode.
+ * @param   iLine               The line we're asking about.
+ */
+size_t ScmStreamTellOffsetOfLine(PSCMSTREAM pStream, size_t iLine)
+{
+    AssertReturn(!pStream->fWriteOrRead, pStream->cb);
+    if (!pStream->fFullyLineated)
+    {
+        int rc = scmStreamLineate(pStream);
+        AssertRCReturn(rc, pStream->cb);
+    }
+    if (iLine >= pStream->cLines)
+        return pStream->cb;
+    return pStream->paLines[iLine].off;
+}
+
+
+/**
+ * Get the current stream size in bytes.
+ *
+ * @returns Count of bytes.
+ * @param   pStream             The stream.
+ */
+size_t ScmStreamSize(PSCMSTREAM pStream)
+{
+    return pStream->cb;
+}
+
+/**
+ * Gets the number of lines in the stream.
+ *
+ * @returns The number of lines.
+ * @param   pStream             The stream.
+ */
+size_t ScmStreamCountLines(PSCMSTREAM pStream)
+{
+    if (!pStream->fFullyLineated)
+        scmStreamLineate(pStream);
+    return pStream->cLines;
+}
+
+/**
+ * Seeks to a given byte offset in the stream.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_SEEK if the new stream position is the middle of an EOL marker.
+ *          This is a temporary restriction.
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   offAbsolute         The offset to seek to.  If this is beyond the
+ *                              end of the stream, the position is set to the
+ *                              end.
+ */
+int ScmStreamSeekAbsolute(PSCMSTREAM pStream, size_t offAbsolute)
+{
+    AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /* Must be fully delineated. (lazy bird) */
+    if (RT_UNLIKELY(!pStream->fFullyLineated))
+    {
+        int rc = scmStreamLineate(pStream);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /* Ok, do the job. */
+    if (offAbsolute < pStream->cb)
+    {
+        /** @todo Should do a binary search here, but I'm too darn lazy tonight. */
+        pStream->off = ~(size_t)0;
+        for (size_t i = 0; i < pStream->cLines; i++)
+        {
+            if (offAbsolute < pStream->paLines[i].off + pStream->paLines[i].cch + pStream->paLines[i].enmEol)
+            {
+                pStream->off   = offAbsolute;
+                pStream->iLine = i;
+                if (offAbsolute > pStream->paLines[i].off + pStream->paLines[i].cch)
+                    return pStream->rc = VERR_SEEK;
+                break;
+            }
+        }
+        AssertReturn(pStream->off != ~(size_t)0, pStream->rc = VERR_INTERNAL_ERROR_3);
+    }
+    else
+    {
+        pStream->off   = pStream->cb;
+        pStream->iLine = pStream->cLines;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Seeks a number of bytes relative to the current stream position.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_SEEK if the new stream position is the middle of an EOL marker.
+ *          This is a temporary restriction.
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   offRelative         The offset to seek to.  A negative offset
+ *                              rewinds and positive one fast forwards the
+ *                              stream.  Will quietly stop at the beginning and
+ *                              end of the stream.
+ */
+int ScmStreamSeekRelative(PSCMSTREAM pStream, ssize_t offRelative)
+{
+    size_t offAbsolute;
+    if (offRelative >= 0)
+        offAbsolute = pStream->off + offRelative;
+    else if ((size_t)-offRelative <= pStream->off)
+        offAbsolute = pStream->off + offRelative;
+    else
+        offAbsolute = 0;
+    return ScmStreamSeekAbsolute(pStream, offAbsolute);
+}
+
+/**
+ * Seeks to a given line in the stream.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   iLine               The line to seek to.  If this is beyond the end
+ *                              of the stream, the position is set to the end.
+ */
+int ScmStreamSeekByLine(PSCMSTREAM pStream, size_t iLine)
+{
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /* Must be fully delineated. (lazy bird) */
+    if (RT_UNLIKELY(!pStream->fFullyLineated))
+    {
+        AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+        int rc = scmStreamLineate(pStream);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /* Ok, do the job. */
+    if (iLine < pStream->cLines)
+    {
+        pStream->iLine = iLine;
+        pStream->off   = pStream->paLines[iLine].off;
+        if (pStream->fWriteOrRead)
+        {
+            pStream->cb     = pStream->paLines[iLine].off;
+            pStream->cLines = iLine;
+            pStream->paLines[iLine].cch    = 0;
+            pStream->paLines[iLine].enmEol = SCMEOL_NONE;
+        }
+    }
+    else
+    {
+        AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+        pStream->off   = pStream->cb;
+        pStream->iLine = pStream->cLines;
+    }
+    return VINF_SUCCESS;
+}
+
+/**
+ * Checks if the stream position is at the start of a line.
+ *
+ * @returns @c true if at the start, @c false if not.
+ * @param   pStream             The stream.
+ */
+bool ScmStreamIsAtStartOfLine(PSCMSTREAM pStream)
+{
+    if (   !pStream->fFullyLineated
+        && !pStream->fWriteOrRead)
+    {
+        int rc = scmStreamLineate(pStream);
+        if (RT_FAILURE(rc))
+            return false;
+    }
+    return pStream->off == pStream->paLines[pStream->iLine].off;
+}
+
+/**
+ * Compares the two streams from the start to end, binary fashion.
+ *
+ * The stream position does not change nor does it matter whether they are
+ * writable or readable.
+ *
+ * @returns true if identical, false if not.
+ * @param   pStream1            The first stream.
+ * @param   pStream2            The second stream.
+ */
+bool ScmStreamAreIdentical(PCSCMSTREAM pStream1, PCSCMSTREAM pStream2)
+{
+    return pStream1->cb == pStream2->cb
+        && memcmp(pStream1->pch, pStream2->pch, pStream1->cb) == 0;
+}
+
+
+/**
+ * Worker for ScmStreamGetLineByNo and ScmStreamGetLine.
+ *
+ * Works on a fully lineated stream.
+ *
+ * @returns Pointer to the first character in the line, not NULL terminated.
+ *          NULL if the end of the stream has been reached or some problem
+ *          occurred.
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   iLine               The line to get (0-based).
+ * @param   pcchLine            The length.
+ * @param   penmEol             Where to return the end of line type indicator.
+ */
+DECLINLINE(const char *) scmStreamGetLineByNoCommon(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol)
+{
+    Assert(!pStream->fWriteOrRead);
+    Assert(pStream->fFullyLineated);
+
+    /* Check stream status. */
+    if (RT_SUCCESS(pStream->rc))
+    {
+        /* Not at the end of the stream yet? */
+        if (RT_LIKELY(iLine < pStream->cLines))
+        {
+            /* Get the data. */
+            const char *pchRet = &pStream->pch[pStream->paLines[iLine].off];
+            *pcchLine          = pStream->paLines[iLine].cch;
+            *penmEol           = pStream->paLines[iLine].enmEol;
+
+            /* update the stream position. */
+            pStream->off       = pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol;
+            pStream->iLine     = iLine + 1;
+            return pchRet;
+        }
+        pStream->off   = pStream->cb;
+        pStream->iLine = pStream->cLines;
+    }
+    *pcchLine = 0;
+    *penmEol  = SCMEOL_NONE;
+    return NULL;
+}
+
+
+/**
+ * Get a numbered line from the stream (changes the position).
+ *
+ * A line is always delimited by a LF character or the end of the stream.  The
+ * delimiter is not included in returned line length, but instead returned via
+ * the @a penmEol indicator.
+ *
+ * @returns Pointer to the first character in the line, not NULL terminated.
+ *          NULL if the end of the stream has been reached or some problem
+ *          occurred (*pcchLine set to zero and *penmEol to SCMEOL_NONE).
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   iLine               The line to get (0-based).
+ * @param   pcchLine            The length.
+ * @param   penmEol             Where to return the end of line type indicator.
+ */
+const char *ScmStreamGetLineByNo(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol)
+{
+    AssertReturn(!pStream->fWriteOrRead, NULL);
+
+    /* Make sure it's fully delineated so we can use the index. */
+    if (RT_LIKELY(pStream->fFullyLineated))
+        return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
+
+    int rc = pStream->rc;
+    if (RT_SUCCESS(rc))
+    {
+        rc = scmStreamLineate(pStream);
+        if (RT_SUCCESS(rc))
+            return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
+    }
+
+    *pcchLine = 0;
+    *penmEol  = SCMEOL_NONE;
+    return NULL;
+}
+
+/**
+ * Get a line from the stream.
+ *
+ * A line is always delimited by a LF character or the end of the stream.  The
+ * delimiter is not included in returned line length, but instead returned via
+ * the @a penmEol indicator.
+ *
+ * @returns Pointer to the first character in the line, not NULL terminated.
+ *          NULL if the end of the stream has been reached or some problem
+ *          occurred (*pcchLine set to zero and *penmEol to SCMEOL_NONE).
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   pcchLine            The length.
+ * @param   penmEol             Where to return the end of line type indicator.
+ */
+const char *ScmStreamGetLine(PSCMSTREAM pStream, size_t *pcchLine, PSCMEOL penmEol)
+{
+    if (RT_LIKELY(pStream->fFullyLineated))
+    {
+        size_t      offCur   = pStream->off;
+        size_t      iCurLine = pStream->iLine;
+        const char *pszLine  = scmStreamGetLineByNoCommon(pStream, iCurLine, pcchLine, penmEol);
+        if (   pszLine
+            && offCur > pStream->paLines[iCurLine].off)
+        {
+            offCur -= pStream->paLines[iCurLine].off;
+            Assert(offCur <= pStream->paLines[iCurLine].cch + pStream->paLines[iCurLine].enmEol);
+            if (offCur < pStream->paLines[iCurLine].cch)
+                *pcchLine  -= offCur;
+            else
+                *pcchLine   = 0;
+            pszLine        += offCur;
+        }
+        return pszLine;
+    }
+    return scmStreamGetLineInternal(pStream, pcchLine, penmEol);
+}
+
+/**
+ * Get the current buffer pointer.
+ *
+ * @returns Buffer pointer on success, NULL on failure (asserted).
+ * @param   pStream             The stream.  Must be in read mode.
+ */
+const char *ScmStreamGetCur(PSCMSTREAM pStream)
+{
+    AssertReturn(!pStream->fWriteOrRead, NULL);
+    return pStream->pch + pStream->off;
+}
+
+/**
+ * Gets a character from the stream.
+ *
+ * @returns The next unsigned character in the stream.
+ *          ~(unsigned)0 on failure.
+ * @param   pStream             The stream.  Must be in read mode.
+ */
+unsigned ScmStreamGetCh(PSCMSTREAM pStream)
+{
+    /* Check stream state. */
+    AssertReturn(!pStream->fWriteOrRead, ~(unsigned)0);
+    if (RT_FAILURE(pStream->rc))
+        return ~(unsigned)0;
+    if (RT_UNLIKELY(!pStream->fFullyLineated))
+    {
+        int rc = scmStreamLineate(pStream);
+        if (RT_FAILURE(rc))
+            return ~(unsigned)0;
+    }
+
+    /* If there isn't enough stream left, fail already. */
+    if (RT_UNLIKELY(pStream->off >= pStream->cb))
+        return ~(unsigned)0;
+
+    /* Read a character. */
+    char ch = pStream->pch[pStream->off++];
+
+    /* Advance the line indicator. */
+    size_t iLine = pStream->iLine;
+    if (pStream->off >= pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol)
+        pStream->iLine++;
+
+    return (unsigned)ch;
+}
+
+
+/**
+ * Peeks at the next character from the stream.
+ *
+ * @returns The next unsigned character in the stream.
+ *          ~(unsigned)0 on failure.
+ * @param   pStream             The stream.  Must be in read mode.
+ */
+unsigned ScmStreamPeekCh(PSCMSTREAM pStream)
+{
+    /* Check stream state. */
+    AssertReturn(!pStream->fWriteOrRead, ~(unsigned)0);
+    if (RT_FAILURE(pStream->rc))
+        return ~(unsigned)0;
+    if (RT_UNLIKELY(!pStream->fFullyLineated))
+    {
+        int rc = scmStreamLineate(pStream);
+        if (RT_FAILURE(rc))
+            return ~(unsigned)0;
+    }
+
+    /* If there isn't enough stream left, fail already. */
+    if (RT_UNLIKELY(pStream->off >= pStream->cb))
+        return ~(unsigned)0;
+
+    /* Peek at the next character. */
+    char ch = pStream->pch[pStream->off];
+    return (unsigned)ch;
+}
+
+
+/**
+ * Reads @a cbToRead bytes into @a pvBuf.
+ *
+ * Will fail if end of stream is encountered before the entire read has been
+ * completed.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_EOF if there isn't @a cbToRead bytes left to read.  Stream
+ *          position will be unchanged.
+ *
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   pvBuf               The buffer to read into.
+ * @param   cbToRead            The number of bytes to read.
+ */
+int ScmStreamRead(PSCMSTREAM pStream, void *pvBuf, size_t cbToRead)
+{
+    AssertReturn(!pStream->fWriteOrRead, VERR_PERMISSION_DENIED);
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /* If there isn't enough stream left, fail already. */
+    if (RT_UNLIKELY(pStream->cb - pStream->off < cbToRead))
+        return VERR_EOF;
+
+    /* Copy the data and simply seek to the new stream position. */
+    memcpy(pvBuf, &pStream->pch[pStream->off], cbToRead);
+    return ScmStreamSeekAbsolute(pStream, pStream->off + cbToRead);
+}
+
+
+/**
+ * Checks if we're at the end of the stream.
+ *
+ * @returns true if end of stream, false if not.
+ * @param   pStream             The stream.  Must be in read mode.
+ */
+bool ScmStreamIsEndOfStream(PSCMSTREAM pStream)
+{
+    AssertReturn(!pStream->fWriteOrRead, false);
+    return pStream->off >= pStream->cb
+        || RT_FAILURE(pStream->rc);
+}
+
+
+/**
+ * Checks if the given line is empty or full of white space.
+ *
+ * @returns true if white space only, false if not (or if non-existant).
+ * @param   pStream             The stream.  Must be in read mode.
+ * @param   iLine               The line in question.
+ */
+bool ScmStreamIsWhiteLine(PSCMSTREAM pStream, size_t iLine)
+{
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pchLine = ScmStreamGetLineByNo(pStream, iLine, &cchLine, &enmEol);
+    if (!pchLine)
+        return false;
+    while (cchLine && RT_C_IS_SPACE(*pchLine))
+        pchLine++, cchLine--;
+    return cchLine == 0;
+}
+
+
+/**
+ * Try figure out the end of line style of the give stream.
+ *
+ * @returns Most likely end of line style.
+ * @param   pStream             The stream.
+ */
+SCMEOL ScmStreamGetEol(PSCMSTREAM pStream)
+{
+    SCMEOL enmEol;
+    if (pStream->cLines > 0)
+        enmEol = pStream->paLines[0].enmEol;
+    else if (pStream->cb == 0)
+        enmEol = SCMEOL_NONE;
+    else
+    {
+        const char *pchLF = (const char *)memchr(pStream->pch, '\n', pStream->cb);
+        if (pchLF && pchLF != pStream->pch && pchLF[-1] == '\r')
+            enmEol = SCMEOL_CRLF;
+        else
+            enmEol = SCMEOL_LF;
+    }
+
+    if (enmEol == SCMEOL_NONE)
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+        enmEol = SCMEOL_CRLF;
+#else
+        enmEol = SCMEOL_LF;
+#endif
+    return enmEol;
+}
+
+
+/**
+ * Get the end of line indicator type for a line.
+ *
+ * @returns The EOL indicator.  If the line isn't found, the default EOL
+ *          indicator is return.
+ * @param   pStream             The stream.
+ * @param   iLine               The line (0-base).
+ */
+SCMEOL ScmStreamGetEolByLine(PSCMSTREAM pStream, size_t iLine)
+{
+    SCMEOL enmEol;
+    if (iLine < pStream->cLines)
+        enmEol = pStream->paLines[iLine].enmEol;
+    else
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+        enmEol = SCMEOL_CRLF;
+#else
+        enmEol = SCMEOL_LF;
+#endif
+    return enmEol;
+}
+
+
+/**
+ * Appends a line to the stream.
+ *
+ * @returns IPRT status code.
+ * @param   pStream             The stream.  Must be in write mode.
+ * @param   pchLine             Pointer to the line.
+ * @param   cchLine             Line length.
+ * @param   enmEol              Which end of line indicator to use.
+ */
+int ScmStreamPutLine(PSCMSTREAM pStream, const char *pchLine, size_t cchLine, SCMEOL enmEol)
+{
+    AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /*
+     * Make sure the previous line has a new-line indicator.
+     */
+    size_t off   = pStream->off;
+    size_t iLine = pStream->iLine;
+    if (RT_UNLIKELY(   iLine != 0
+                    && pStream->paLines[iLine - 1].enmEol == SCMEOL_NONE))
+    {
+        AssertReturn(pStream->paLines[iLine].cch == 0, VERR_INTERNAL_ERROR_3);
+        SCMEOL enmEol2 = enmEol != SCMEOL_NONE ? enmEol : ScmStreamGetEol(pStream);
+        if (RT_UNLIKELY(off + cchLine + enmEol + enmEol2 > pStream->cbAllocated))
+        {
+            int rc = scmStreamGrowBuffer(pStream, cchLine + enmEol + enmEol2);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+        if (enmEol2 == SCMEOL_LF)
+            pStream->pch[off++] = '\n';
+        else
+        {
+            pStream->pch[off++] = '\r';
+            pStream->pch[off++] = '\n';
+        }
+        pStream->paLines[iLine - 1].enmEol = enmEol2;
+        pStream->paLines[iLine].off = off;
+        pStream->off = off;
+        pStream->cb  = off;
+    }
+
+    /*
+     * Ensure we've got sufficient buffer space.
+     */
+    if (RT_UNLIKELY(off + cchLine + enmEol > pStream->cbAllocated))
+    {
+        int rc = scmStreamGrowBuffer(pStream, cchLine + enmEol);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /*
+     * Add a line record.
+     */
+    if (RT_UNLIKELY(iLine + 1 >= pStream->cLinesAllocated))
+    {
+        int rc = scmStreamGrowLines(pStream, iLine);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    pStream->paLines[iLine].cch    = off - pStream->paLines[iLine].off + cchLine;
+    pStream->paLines[iLine].enmEol = enmEol;
+
+    iLine++;
+    pStream->cLines = iLine;
+    pStream->iLine  = iLine;
+
+    /*
+     * Copy the line
+     */
+    memcpy(&pStream->pch[off], pchLine, cchLine);
+    off += cchLine;
+    if (enmEol == SCMEOL_LF)
+        pStream->pch[off++] = '\n';
+    else if (enmEol == SCMEOL_CRLF)
+    {
+        pStream->pch[off++] = '\r';
+        pStream->pch[off++] = '\n';
+    }
+    pStream->off = off;
+    pStream->cb  = off;
+
+    /*
+     * Start a new line.
+     */
+    pStream->paLines[iLine].off    = off;
+    pStream->paLines[iLine].cch    = 0;
+    pStream->paLines[iLine].enmEol = SCMEOL_NONE;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Writes to the stream.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream.  Must be in write mode.
+ * @param   pchBuf              What to write.
+ * @param   cchBuf              How much to write.
+ */
+int ScmStreamWrite(PSCMSTREAM pStream, const char *pchBuf, size_t cchBuf)
+{
+    AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /*
+     * Ensure we've got sufficient buffer space.
+     */
+    size_t off = pStream->off;
+    if (RT_UNLIKELY(off + cchBuf > pStream->cbAllocated))
+    {
+        int rc = scmStreamGrowBuffer(pStream, cchBuf);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    /*
+     * Deal with the odd case where we've already pushed a line with SCMEOL_NONE.
+     */
+    size_t iLine = pStream->iLine;
+    if (RT_UNLIKELY(   iLine > 0
+                    && pStream->paLines[iLine - 1].enmEol == SCMEOL_NONE))
+    {
+        iLine--;
+        pStream->cLines = iLine;
+        pStream->iLine  = iLine;
+    }
+
+    /*
+     * Deal with lines.
+     */
+    const char *pchLF = (const char *)memchr(pchBuf, '\n', cchBuf);
+    if (!pchLF)
+        pStream->paLines[iLine].cch += cchBuf;
+    else
+    {
+        const char *pchLine = pchBuf;
+        for (;;)
+        {
+            if (RT_UNLIKELY(iLine + 1 >= pStream->cLinesAllocated))
+            {
+                int rc = scmStreamGrowLines(pStream, iLine);
+                if (RT_FAILURE(rc))
+                {
+                    iLine = pStream->iLine;
+                    pStream->paLines[iLine].cch    = off - pStream->paLines[iLine].off;
+                    pStream->paLines[iLine].enmEol = SCMEOL_NONE;
+                    return rc;
+                }
+            }
+
+            size_t cchLine = pchLF - pchLine;
+            if (   cchLine
+                ?  pchLF[-1] != '\r'
+                :     !pStream->paLines[iLine].cch
+                   || pStream->pch[pStream->paLines[iLine].off + pStream->paLines[iLine].cch - 1] != '\r')
+                pStream->paLines[iLine].enmEol = SCMEOL_LF;
+            else
+            {
+                pStream->paLines[iLine].enmEol = SCMEOL_CRLF;
+                cchLine--;
+            }
+            pStream->paLines[iLine].cch += cchLine;
+
+            iLine++;
+            size_t offBuf = pchLF + 1 - pchBuf;
+            pStream->paLines[iLine].off    = off + offBuf;
+            pStream->paLines[iLine].cch    = 0;
+            pStream->paLines[iLine].enmEol = SCMEOL_NONE;
+
+            size_t cchLeft = cchBuf - offBuf;
+            pchLine = pchLF + 1;
+            pchLF = (const char *)memchr(pchLine, '\n', cchLeft);
+            if (!pchLF)
+            {
+                pStream->paLines[iLine].cch = cchLeft;
+                break;
+            }
+        }
+
+        pStream->iLine  = iLine;
+        pStream->cLines = iLine;
+    }
+
+    /*
+     * Copy the data and update position and size.
+     */
+    memcpy(&pStream->pch[off], pchBuf, cchBuf);
+    off += cchBuf;
+    pStream->off = off;
+    pStream->cb  = off;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Write a character to the stream.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream.  Must be in write mode.
+ * @param   pchBuf              What to write.
+ * @param   cchBuf              How much to write.
+ */
+int ScmStreamPutCh(PSCMSTREAM pStream, char ch)
+{
+    AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pStream->rc))
+        return pStream->rc;
+
+    /*
+     * Only deal with the simple cases here, use ScmStreamWrite for the
+     * annoying stuff.
+     */
+    size_t off = pStream->off;
+    if (   ch == '\n'
+        || RT_UNLIKELY(off + 1 > pStream->cbAllocated))
+        return ScmStreamWrite(pStream, &ch, 1);
+
+    /*
+     * Just append it.
+     */
+    pStream->pch[off] = ch;
+    pStream->off = off + 1;
+    pStream->paLines[pStream->iLine].cch++;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Puts an EOL marker to the stream.
+ *
+ * @returns IPRt status code.
+ * @param   pStream             The stream.  Must be in write mode.
+ * @param   enmEol              The end-of-line marker to write.
+ */
+int ScmStreamPutEol(PSCMSTREAM pStream, SCMEOL enmEol)
+{
+    if (enmEol == SCMEOL_LF)
+        return ScmStreamWrite(pStream, "\n", 1);
+    if (enmEol == SCMEOL_CRLF)
+        return ScmStreamWrite(pStream, "\r\n", 2);
+    if (enmEol == SCMEOL_NONE)
+        return VINF_SUCCESS;
+    AssertFailedReturn(VERR_INVALID_PARAMETER);
+}
+
+/**
+ * Formats a string and writes it to the SCM stream.
+ *
+ * @returns The number of bytes written (>= 0). Negative value are IPRT error
+ *          status codes.
+ * @param   pStream             The stream to write to.
+ * @param   pszFormat           The format string.
+ * @param   va                  The arguments to format.
+ */
+ssize_t ScmStreamPrintfV(PSCMSTREAM pStream, const char *pszFormat, va_list va)
+{
+    char   *psz;
+    ssize_t cch = RTStrAPrintfV(&psz, pszFormat, va);
+    if (cch)
+    {
+        int rc = ScmStreamWrite(pStream, psz, cch);
+        RTStrFree(psz);
+        if (RT_FAILURE(rc))
+            cch = rc;
+    }
+    return cch;
+}
+
+/**
+ * Formats a string and writes it to the SCM stream.
+ *
+ * @returns The number of bytes written (>= 0). Negative value are IPRT error
+ *          status codes.
+ * @param   pStream             The stream to write to.
+ * @param   pszFormat           The format string.
+ * @param   ...                 The arguments to format.
+ */
+ssize_t ScmStreamPrintf(PSCMSTREAM pStream, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    ssize_t cch = ScmStreamPrintfV(pStream, pszFormat, va);
+    va_end(va);
+    return cch;
+}
+
+/**
+ * Copies @a cLines from the @a pSrc stream onto the @a pDst stream.
+ *
+ * The stream positions will be used and changed in both streams.
+ *
+ * @returns IPRT status code.
+ * @param   pDst                The destination stream.  Must be in write mode.
+ * @param   cLines              The number of lines.  (0 is accepted.)
+ * @param   pSrc                The source stream.  Must be in read mode.
+ */
+int ScmStreamCopyLines(PSCMSTREAM pDst, PSCMSTREAM pSrc, size_t cLines)
+{
+    AssertReturn(pDst->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pDst->rc))
+        return pDst->rc;
+
+    AssertReturn(!pSrc->fWriteOrRead, VERR_ACCESS_DENIED);
+    if (RT_FAILURE(pSrc->rc))
+        return pSrc->rc;
+
+    while (cLines-- > 0)
+    {
+        SCMEOL      enmEol;
+        size_t      cchLine;
+        const char *pchLine = ScmStreamGetLine(pSrc, &cchLine, &enmEol);
+        if (!pchLine)
+            return pDst->rc = RT_FAILURE(pSrc->rc) ? pSrc->rc : VERR_EOF;
+
+        int rc = ScmStreamPutLine(pDst, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * If the given C word is at off - 1, return @c true and skip beyond it,
+ * otherwise return @c false.
+ *
+ * @retval  true if the given C-word is at the current position minus one char.
+ *          The stream position changes.
+ * @retval  false if not. The stream position is unchanged.
+ *
+ * @param   pStream             The stream.
+ * @param   cchWord             The length of the word.
+ * @param   pszWord             The word.
+ */
+bool ScmStreamCMatchingWordM1(PSCMSTREAM pStream, const char *pszWord, size_t cchWord)
+{
+    /* Check stream state. */
+    AssertReturn(!pStream->fWriteOrRead, false);
+    AssertReturn(RT_SUCCESS(pStream->rc), false);
+    AssertReturn(pStream->fFullyLineated, false);
+
+    /* Sufficient chars left on the line? */
+    size_t const    iLine   = pStream->iLine;
+    AssertReturn(pStream->off > pStream->paLines[iLine].off, false);
+    size_t const    cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - (pStream->off - 1);
+    if (cchWord > cchLeft)
+        return false;
+
+    /* Do they match? */
+    const char     *psz     = &pStream->pch[pStream->off - 1];
+    if (memcmp(psz, pszWord, cchWord))
+        return false;
+
+    /* Is it the end of a C word? */
+    if (cchWord < cchLeft)
+    {
+        psz += cchWord;
+        if (RT_C_IS_ALNUM(*psz) || *psz == '_')
+            return false;
+    }
+
+    /* Skip ahead. */
+    pStream->off += cchWord - 1;
+    return true;
+}
+
+
+/**
+ * Get's the C word starting at the current position.
+ *
+ * @returns Pointer to the word on success and the stream position advanced to
+ *          the end of it.
+ *          NULL on failure, stream position normally unchanged.
+ * @param   pStream             The stream to get the C word from.
+ * @param   pcchWord            Where to return the word length.
+ */
+const char *ScmStreamCGetWord(PSCMSTREAM pStream, size_t *pcchWord)
+{
+    /* Check stream state. */
+    AssertReturn(!pStream->fWriteOrRead, NULL);
+    AssertReturn(RT_SUCCESS(pStream->rc), NULL);
+    AssertReturn(pStream->fFullyLineated, NULL);
+
+    /* Get the number of chars left on the line and locate the current char. */
+    size_t const    iLine   = pStream->iLine;
+    size_t const    cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - pStream->off;
+    const char     *psz     = &pStream->pch[pStream->off];
+
+    /* Is it a leading C character. */
+    if (!RT_C_IS_ALPHA(*psz) && *psz != '_')
+        return NULL;
+
+    /* Find the end of the word. */
+    char    ch;
+    size_t  off = 1;
+    while (     off < cchLeft
+           &&  (   (ch = psz[off]) == '_'
+                || RT_C_IS_ALNUM(ch)))
+        off++;
+
+    pStream->off += off;
+    *pcchWord = off;
+    return psz;
+}
+
+
+/**
+ * Get's the C word starting at the current position minus one.
+ *
+ * @returns Pointer to the word on success and the stream position advanced to
+ *          the end of it.
+ *          NULL on failure, stream position normally unchanged.
+ * @param   pStream             The stream to get the C word from.
+ * @param   pcchWord            Where to return the word length.
+ */
+const char *ScmStreamCGetWordM1(PSCMSTREAM pStream, size_t *pcchWord)
+{
+    /* Check stream state. */
+    AssertReturn(!pStream->fWriteOrRead, NULL);
+    AssertReturn(RT_SUCCESS(pStream->rc), NULL);
+    AssertReturn(pStream->fFullyLineated, NULL);
+
+    /* Get the number of chars left on the line and locate the current char. */
+    size_t const    iLine   = pStream->iLine;
+    size_t const    cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - (pStream->off - 1);
+    const char     *psz     = &pStream->pch[pStream->off - 1];
+
+    /* Is it a leading C character. */
+    if (!RT_C_IS_ALPHA(*psz) && *psz != '_')
+        return NULL;
+
+    /* Find the end of the word. */
+    char    ch;
+    size_t  off = 1;
+    while (     off < cchLeft
+           &&  (   (ch = psz[off]) == '_'
+                || RT_C_IS_ALNUM(ch)))
+        off++;
+
+    pStream->off += off - 1;
+    *pcchWord = off;
+    return psz;
+}
+
diff --git a/src/bldprogs/scmstream.h b/src/bldprogs/scmstream.h
new file mode 100644
index 00000000..e66311ca
--- /dev/null
+++ b/src/bldprogs/scmstream.h
@@ -0,0 +1,152 @@
+/* $Id: scmstream.h $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager Stream Code.
+ */
+
+/*
+ * Copyright (C) 2012-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_bldprogs_scmstream_h
+#define VBOX_INCLUDED_SRC_bldprogs_scmstream_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/types.h>
+
+RT_C_DECLS_BEGIN
+
+/** End of line marker type. */
+typedef enum SCMEOL
+{
+    SCMEOL_NONE = 0,
+    SCMEOL_LF = 1,
+    SCMEOL_CRLF = 2
+} SCMEOL;
+/** Pointer to an end of line marker type. */
+typedef SCMEOL *PSCMEOL;
+
+/**
+ * Line record.
+ */
+typedef struct SCMSTREAMLINE
+{
+    /** The offset of the line. */
+    size_t          off;
+    /** The line length, excluding the LF character.
+     * @todo This could be derived from the offset of the next line if that wasn't
+     *       so tedious. */
+    size_t          cch;
+    /** The end of line marker type. */
+    SCMEOL          enmEol;
+} SCMSTREAMLINE;
+/** Pointer to a line record. */
+typedef SCMSTREAMLINE *PSCMSTREAMLINE;
+
+/**
+ * Source code massager stream.
+ */
+typedef struct SCMSTREAM
+{
+    /** Pointer to the file memory. */
+    char           *pch;
+    /** The current stream position. */
+    size_t          off;
+    /** The current stream size. */
+    size_t          cb;
+    /** The size of the memory pb points to. */
+    size_t          cbAllocated;
+
+    /** Line records. */
+    PSCMSTREAMLINE  paLines;
+    /** The current line. */
+    size_t          iLine;
+    /** The current stream size given in lines.   */
+    size_t          cLines;
+    /** The sizeof the memory backing paLines.   */
+    size_t          cLinesAllocated;
+
+    /** Set if write-only, clear if read-only. */
+    bool            fWriteOrRead;
+    /** Set if the memory pb points to is from RTFileReadAll. */
+    bool            fFileMemory;
+    /** Set if fully broken into lines. */
+    bool            fFullyLineated;
+
+    /** Stream status code (IPRT). */
+    int             rc;
+} SCMSTREAM;
+/** Pointer to a SCM stream. */
+typedef SCMSTREAM *PSCMSTREAM;
+/** Pointer to a const SCM stream. */
+typedef SCMSTREAM const *PCSCMSTREAM;
+
+
+int         ScmStreamInitForReading(PSCMSTREAM pStream, const char *pszFilename);
+int         ScmStreamInitForWriting(PSCMSTREAM pStream, PCSCMSTREAM pRelatedStream);
+void        ScmStreamDelete(PSCMSTREAM pStream);
+int         ScmStreamGetStatus(PCSCMSTREAM pStream);
+void        ScmStreamRewindForReading(PSCMSTREAM pStream);
+void        ScmStreamRewindForWriting(PSCMSTREAM pStream);
+bool        ScmStreamIsText(PSCMSTREAM pStream);
+int         ScmStreamCheckItegrity(PSCMSTREAM pStream);
+int         ScmStreamWriteToFile(PSCMSTREAM pStream, const char *pszFilenameFmt, ...);
+int         ScmStreamWriteToStdOut(PSCMSTREAM pStream);
+
+size_t      ScmStreamTell(PSCMSTREAM pStream);
+size_t      ScmStreamTellLine(PSCMSTREAM pStream);
+size_t      ScmStreamTellOffsetOfLine(PSCMSTREAM pStream, size_t iLine);
+size_t      ScmStreamSize(PSCMSTREAM pStream);
+size_t      ScmStreamCountLines(PSCMSTREAM pStream);
+int         ScmStreamSeekAbsolute(PSCMSTREAM pStream, size_t offAbsolute);
+int         ScmStreamSeekRelative(PSCMSTREAM pStream, ssize_t offRelative);
+int         ScmStreamSeekByLine(PSCMSTREAM pStream, size_t iLine);
+bool        ScmStreamIsAtStartOfLine(PSCMSTREAM pStream);
+bool        ScmStreamAreIdentical(PCSCMSTREAM pStream1, PCSCMSTREAM pStream2);
+
+const char *ScmStreamGetLineByNo(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol);
+const char *ScmStreamGetLine(PSCMSTREAM pStream, size_t *pcchLine, PSCMEOL penmEol);
+unsigned    ScmStreamGetCh(PSCMSTREAM pStream);
+const char *ScmStreamGetCur(PSCMSTREAM pStream);
+unsigned    ScmStreamPeekCh(PSCMSTREAM pStream);
+int         ScmStreamRead(PSCMSTREAM pStream, void *pvBuf, size_t cbToRead);
+bool        ScmStreamIsEndOfStream(PSCMSTREAM pStream);
+bool        ScmStreamIsWhiteLine(PSCMSTREAM pStream, size_t iLine);
+SCMEOL      ScmStreamGetEol(PSCMSTREAM pStream);
+SCMEOL      ScmStreamGetEolByLine(PSCMSTREAM pStream, size_t iLine);
+
+int         ScmStreamPutLine(PSCMSTREAM pStream, const char *pchLine, size_t cchLine, SCMEOL enmEol);
+int         ScmStreamWrite(PSCMSTREAM pStream, const char *pchBuf, size_t cchBuf);
+int         ScmStreamPutCh(PSCMSTREAM pStream, char ch);
+int         ScmStreamPutEol(PSCMSTREAM pStream, SCMEOL enmEol);
+ssize_t     ScmStreamPrintf(PSCMSTREAM pStream, const char *pszFormat, ...);
+ssize_t     ScmStreamPrintfV(PSCMSTREAM pStream, const char *pszFormat, va_list va);
+int         ScmStreamCopyLines(PSCMSTREAM pDst, PSCMSTREAM pSrc, size_t cLines);
+
+bool        ScmStreamCMatchingWordM1(PSCMSTREAM pStream, const char *pszWord, size_t cchWord);
+const char *ScmStreamCGetWord(PSCMSTREAM pStream, size_t *pcchWord);
+const char *ScmStreamCGetWordM1(PSCMSTREAM pStream, size_t *pcchWord);
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_bldprogs_scmstream_h */
+
diff --git a/src/bldprogs/scmsubversion.cpp b/src/bldprogs/scmsubversion.cpp
new file mode 100644
index 00000000..f55ee85e
--- /dev/null
+++ b/src/bldprogs/scmsubversion.cpp
@@ -0,0 +1,1690 @@
+/* $Id: scmsubversion.cpp $ */
+/** @file
+ * IPRT Testcase / Tool - Source Code Massager, Subversion Access.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#define SCM_WITH_DYNAMIC_LIB_SVN
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/getopt.h>
+#include <iprt/handle.h>
+#include <iprt/initterm.h>
+#include <iprt/ldr.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/pipe.h>
+#include <iprt/poll.h>
+#include <iprt/process.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+#include "scm.h"
+
+#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && defined(SCM_WITH_SVN_HEADERS)
+# include <svn_client.h>
+#endif
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+# if defined(RT_OS_WINDOWS) && defined(RT_ARCH_X86)
+#  define APR_CALL                       __stdcall
+#  define SVN_CALL                       /* __stdcall ?? */
+# else
+#  define APR_CALL
+#  define SVN_CALL
+# endif
+#endif
+#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && !defined(SCM_WITH_SVN_HEADERS)
+# define SVN_ERR_MISC_CATEGORY_START    200000
+# define SVN_ERR_UNVERSIONED_RESOURCE   (SVN_ERR_MISC_CATEGORY_START + 5)
+#endif
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && !defined(SCM_WITH_SVN_HEADERS)
+typedef int                         apr_status_t;
+typedef int64_t                     apr_time_t;
+typedef struct apr_pool_t           apr_pool_t;
+typedef struct apr_hash_t           apr_hash_t;
+typedef struct apr_hash_index_t     apr_hash_index_t;
+typedef struct apr_array_header_t   apr_array_header_t;
+
+
+typedef struct svn_error_t
+{
+    apr_status_t                    apr_err;
+    const char                     *_dbgr_message;
+    struct svn_error_t             *_dbgr_child;
+    apr_pool_t                     *_dbgr_pool;
+    const char                     *_dbgr_file;
+    long                            _dbgr_line;
+} svn_error_t;
+typedef int                         svn_boolean_t;
+typedef long int                    svn_revnum_t;
+typedef struct svn_client_ctx_t     svn_client_ctx_t;
+typedef enum svn_opt_revision_kind
+{
+    svn_opt_revision_unspecified = 0,
+    svn_opt_revision_number,
+    svn_opt_revision_date,
+    svn_opt_revision_committed,
+    svn_opt_revision_previous,
+    svn_opt_revision_base,
+    svn_opt_revision_working,
+    svn_opt_revision_head
+} svn_opt_revision_kind;
+typedef union svn_opt_revision_value_t
+{
+    svn_revnum_t                    number;
+    apr_time_t                      date;
+} svn_opt_revision_value_t;
+typedef struct svn_opt_revision_t
+{
+  svn_opt_revision_kind             kind;
+  svn_opt_revision_value_t          value;
+} svn_opt_revision_t;
+typedef enum svn_depth_t
+{
+    svn_depth_unknown = -2,
+    svn_depth_exclude,
+    svn_depth_empty,
+    svn_depth_files,
+    svn_depth_immediates,
+    svn_depth_infinity
+} svn_depth_t;
+
+#endif /* SCM_WITH_DYNAMIC_LIB_SVN && !SCM_WITH_SVN_HEADERS */
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static char g_szSvnPath[RTPATH_MAX];
+static enum
+{
+    kScmSvnVersion_Ancient = 1,
+    kScmSvnVersion_1_6,
+    kScmSvnVersion_1_7,
+    kScmSvnVersion_1_8,
+    kScmSvnVersion_End
+}           g_enmSvnVersion = kScmSvnVersion_Ancient;
+
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+/** Set if all the function pointers are valid. */
+static bool                             g_fSvnFunctionPointersValid;
+/** @name SVN and APR imports.
+ * @{ */
+static apr_status_t          (APR_CALL *g_pfnAprInitialize)(void);
+static apr_hash_index_t *    (APR_CALL *g_pfnAprHashFirst)(apr_pool_t *pPool, apr_hash_t *pHashTab);
+static apr_hash_index_t *    (APR_CALL *g_pfnAprHashNext)(apr_hash_index_t *pCurIdx);
+static void *                (APR_CALL *g_pfnAprHashThisVal)(apr_hash_index_t *pHashIdx);
+static apr_pool_t *          (SVN_CALL *g_pfnSvnPoolCreateEx)(apr_pool_t *pParent, void *pvAllocator);
+static void                  (APR_CALL *g_pfnAprPoolClear)(apr_pool_t *pPool);
+static void                  (APR_CALL *g_pfnAprPoolDestroy)(apr_pool_t *pPool);
+
+static svn_error_t *         (SVN_CALL *g_pfnSvnClientCreateContext)(svn_client_ctx_t **ppCtx, apr_pool_t *pPool);
+static svn_error_t *         (SVN_CALL *g_pfnSvnClientPropGet4)(apr_hash_t **ppHashProps, const char *pszPropName,
+                                                                const char *pszTarget, const svn_opt_revision_t *pPeggedRev,
+                                                                const svn_opt_revision_t *pRevision, svn_revnum_t *pActualRev,
+                                                                svn_depth_t enmDepth, const apr_array_header_t *pChangeList,
+                                                                svn_client_ctx_t *pCtx, apr_pool_t *pResultPool,
+                                                                apr_pool_t *pScratchPool);
+/**@} */
+
+/** Cached APR pool. */
+static apr_pool_t          *g_pSvnPool = NULL;
+/** Cached SVN client context. */
+static svn_client_ctx_t    *g_pSvnClientCtx = NULL;
+/** Number of times the current context has been used. */
+static uint32_t             g_cSvnClientCtxUsed = 0;
+
+#endif
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+static void scmSvnFlushClientContextAndPool(void);
+#endif
+
+
+
+/**
+ * Callback that is call for each path to search.
+ */
+static DECLCALLBACK(int) scmSvnFindSvnBinaryCallback(char const *pchPath, size_t cchPath, void *pvUser1, void *pvUser2)
+{
+    char   *pszDst = (char *)pvUser1;
+    size_t  cchDst = (size_t)pvUser2;
+    if (cchDst > cchPath)
+    {
+        memcpy(pszDst, pchPath, cchPath);
+        pszDst[cchPath] = '\0';
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+        int rc = RTPathAppend(pszDst, cchDst, "svn.exe");
+#else
+        int rc = RTPathAppend(pszDst, cchDst, "svn");
+#endif
+        if (   RT_SUCCESS(rc)
+            && RTFileExists(pszDst))
+            return VINF_SUCCESS;
+    }
+    return VERR_TRY_AGAIN;
+}
+
+
+/**
+ * Reads from a pipe.
+ *
+ * @returns @a rc or other status code.
+ * @param   rc              The current status of the operation.  Error status
+ *                          are preserved and returned.
+ * @param   phPipeR         Pointer to the pipe handle.
+ * @param   pcbAllocated    Pointer to the buffer size variable.
+ * @param   poffCur         Pointer to the buffer offset variable.
+ * @param   ppszBuffer      Pointer to the buffer pointer variable.
+ */
+static int rtProcProcessOutput(int rc, PRTPIPE phPipeR, size_t *pcbAllocated, size_t *poffCur, char **ppszBuffer,
+                               RTPOLLSET hPollSet, uint32_t idPollSet)
+{
+    size_t  cbRead;
+    char    szTmp[_4K - 1];
+    for (;;)
+    {
+        int rc2 = RTPipeRead(*phPipeR, szTmp, sizeof(szTmp), &cbRead);
+        if (RT_SUCCESS(rc2) && cbRead)
+        {
+            /* Resize the buffer. */
+            if (*poffCur + cbRead >= *pcbAllocated)
+            {
+                if (*pcbAllocated >= _1G)
+                {
+                    RTPollSetRemove(hPollSet, idPollSet);
+                    rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
+                    *phPipeR = NIL_RTPIPE;
+                    return RT_SUCCESS(rc) ? VERR_TOO_MUCH_DATA : rc;
+                }
+
+                size_t cbNew = *pcbAllocated ? *pcbAllocated * 2 : sizeof(szTmp) + 1;
+                Assert(*poffCur + cbRead < cbNew);
+                rc2 = RTStrRealloc(ppszBuffer, cbNew);
+                if (RT_FAILURE(rc2))
+                {
+                    RTPollSetRemove(hPollSet, idPollSet);
+                    rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
+                    *phPipeR = NIL_RTPIPE;
+                    return RT_SUCCESS(rc) ? rc2 : rc;
+                }
+                *pcbAllocated = cbNew;
+            }
+
+            /* Append the new data, terminating it. */
+            memcpy(*ppszBuffer + *poffCur, szTmp, cbRead);
+            *poffCur += cbRead;
+            (*ppszBuffer)[*poffCur] = '\0';
+
+            /* Check for null terminators in the string. */
+            if (RT_SUCCESS(rc) && memchr(szTmp, '\0', cbRead))
+                rc = VERR_NO_TRANSLATION;
+
+            /* If we read a full buffer, try read some more. */
+            if (RT_SUCCESS(rc) && cbRead == sizeof(szTmp))
+                continue;
+        }
+        else if (rc2 != VINF_TRY_AGAIN)
+        {
+            if (RT_FAILURE(rc) && rc2 != VERR_BROKEN_PIPE)
+                rc = rc2;
+            RTPollSetRemove(hPollSet, idPollSet);
+            rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
+            *phPipeR = NIL_RTPIPE;
+        }
+        return rc;
+    }
+}
+
+/** @name RTPROCEXEC_FLAGS_XXX - flags for RTProcExec and RTProcExecToString.
+ * @{ */
+/** Redirect /dev/null to standard input. */
+#define RTPROCEXEC_FLAGS_STDIN_NULL             RT_BIT_32(0)
+/** Redirect standard output to /dev/null. */
+#define RTPROCEXEC_FLAGS_STDOUT_NULL            RT_BIT_32(1)
+/** Redirect standard error to /dev/null. */
+#define RTPROCEXEC_FLAGS_STDERR_NULL            RT_BIT_32(2)
+/** Redirect all standard output to /dev/null as well as directing /dev/null
+ * to standard input. */
+#define RTPROCEXEC_FLAGS_STD_NULL               (  RTPROCEXEC_FLAGS_STDIN_NULL \
+                                                 | RTPROCEXEC_FLAGS_STDOUT_NULL \
+                                                 | RTPROCEXEC_FLAGS_STDERR_NULL)
+/** Mask containing the valid flags. */
+#define RTPROCEXEC_FLAGS_VALID_MASK             UINT32_C(0x00000007)
+/** @} */
+
+/**
+ * Runs a process, collecting the standard output and/or standard error.
+ *
+ *
+ * @returns IPRT status code
+ * @retval  VERR_NO_TRANSLATION if the output of the program isn't valid UTF-8
+ *          or contains a nul character.
+ * @retval  VERR_TOO_MUCH_DATA if the process produced too much data.
+ *
+ * @param   pszExec     Executable image to use to create the child process.
+ * @param   papszArgs   Pointer to an array of arguments to the child.  The
+ *                      array terminated by an entry containing NULL.
+ * @param   hEnv        Handle to the environment block for the child.
+ * @param   fFlags      A combination of RTPROCEXEC_FLAGS_XXX.  The @a
+ *                      ppszStdOut and @a ppszStdErr parameters takes precedence
+ *                      over redirection flags.
+ * @param   pStatus     Where to return the status on success.
+ * @param   ppszStdOut  Where to return the text written to standard output. If
+ *                      NULL then standard output will not be collected and go
+ *                      to the standard output handle of the process.
+ *                      Free with RTStrFree, regardless of return status.
+ * @param   ppszStdErr  Where to return the text written to standard error. If
+ *                      NULL then standard output will not be collected and go
+ *                      to the standard error handle of the process.
+ *                      Free with RTStrFree, regardless of return status.
+ */
+int RTProcExecToString(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
+                       PRTPROCSTATUS pStatus, char **ppszStdOut, char **ppszStdErr)
+{
+    int rc2;
+
+    /*
+     * Clear output arguments (no returning failure here, simply crash!).
+     */
+    AssertPtr(pStatus);
+    pStatus->enmReason = RTPROCEXITREASON_ABEND;
+    pStatus->iStatus   = RTEXITCODE_FAILURE;
+    AssertPtrNull(ppszStdOut);
+    if (ppszStdOut)
+        *ppszStdOut = NULL;
+    AssertPtrNull(ppszStdOut);
+    if (ppszStdErr)
+        *ppszStdErr = NULL;
+
+    /*
+     * Check input arguments.
+     */
+    AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
+
+    /*
+     * Do we need a standard input bitbucket?
+     */
+    int         rc = VINF_SUCCESS;
+    PRTHANDLE   phChildStdIn = NULL;
+    RTHANDLE    hChildStdIn;
+    hChildStdIn.enmType = RTHANDLETYPE_FILE;
+    hChildStdIn.u.hFile = NIL_RTFILE;
+    if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
+    {
+        phChildStdIn = &hChildStdIn;
+        rc = RTFileOpenBitBucket(&hChildStdIn.u.hFile, RTFILE_O_READ);
+    }
+
+    /*
+     * Create the output pipes / bitbuckets.
+     */
+    RTPIPE      hPipeStdOutR  = NIL_RTPIPE;
+    PRTHANDLE   phChildStdOut = NULL;
+    RTHANDLE    hChildStdOut;
+    hChildStdOut.enmType = RTHANDLETYPE_PIPE;
+    hChildStdOut.u.hPipe = NIL_RTPIPE;
+    if (ppszStdOut && RT_SUCCESS(rc))
+    {
+        phChildStdOut = &hChildStdOut;
+        rc = RTPipeCreate(&hPipeStdOutR, &hChildStdOut.u.hPipe, 0 /*fFlags*/);
+    }
+    else if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
+    {
+        phChildStdOut = &hChildStdOut;
+        hChildStdOut.enmType = RTHANDLETYPE_FILE;
+        hChildStdOut.u.hFile = NIL_RTFILE;
+        rc = RTFileOpenBitBucket(&hChildStdOut.u.hFile, RTFILE_O_WRITE);
+    }
+
+    RTPIPE      hPipeStdErrR  = NIL_RTPIPE;
+    PRTHANDLE   phChildStdErr = NULL;
+    RTHANDLE    hChildStdErr;
+    hChildStdErr.enmType = RTHANDLETYPE_PIPE;
+    hChildStdErr.u.hPipe = NIL_RTPIPE;
+    if (ppszStdErr && RT_SUCCESS(rc))
+    {
+        phChildStdErr = &hChildStdErr;
+        rc = RTPipeCreate(&hPipeStdErrR, &hChildStdErr.u.hPipe, 0 /*fFlags*/);
+    }
+    else if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
+    {
+        phChildStdErr = &hChildStdErr;
+        hChildStdErr.enmType = RTHANDLETYPE_FILE;
+        hChildStdErr.u.hFile = NIL_RTFILE;
+        rc = RTFileOpenBitBucket(&hChildStdErr.u.hFile, RTFILE_O_WRITE);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        RTPOLLSET hPollSet;
+        rc = RTPollSetCreate(&hPollSet);
+        if (RT_SUCCESS(rc))
+        {
+            if (hPipeStdOutR != NIL_RTPIPE && RT_SUCCESS(rc))
+                rc = RTPollSetAddPipe(hPollSet, hPipeStdOutR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, 1);
+            if (hPipeStdErrR != NIL_RTPIPE)
+                rc = RTPollSetAddPipe(hPollSet, hPipeStdErrR, RTPOLL_EVT_READ | RTPOLL_EVT_ERROR, 2);
+        }
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Create the process.
+             */
+            RTPROCESS hProc;
+            rc = RTProcCreateEx(pszExec,
+                                papszArgs,
+                                hEnv,
+                                0 /*fFlags*/,
+                                NULL /*phStdIn*/,
+                                phChildStdOut,
+                                phChildStdErr,
+                                NULL /*pszAsUser*/,
+                                NULL /*pszPassword*/,
+                                NULL /*pvExtraData*/,
+                                &hProc);
+            rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
+            rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
+
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Process output and wait for the process to finish.
+                 */
+                size_t cbStdOut  = 0;
+                size_t offStdOut = 0;
+                size_t cbStdErr  = 0;
+                size_t offStdErr = 0;
+                for (;;)
+                {
+                    if (hPipeStdOutR != NIL_RTPIPE)
+                        rc = rtProcProcessOutput(rc, &hPipeStdOutR, &cbStdOut, &offStdOut, ppszStdOut, hPollSet, 1);
+                    if (hPipeStdErrR != NIL_RTPIPE)
+                        rc = rtProcProcessOutput(rc, &hPipeStdErrR, &cbStdErr, &offStdErr, ppszStdErr, hPollSet, 2);
+                    if (hPipeStdOutR == NIL_RTPIPE && hPipeStdErrR == NIL_RTPIPE)
+                        break;
+
+                    if (hProc != NIL_RTPROCESS)
+                    {
+                        rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_NOBLOCK, pStatus);
+                        if (rc2 != VERR_PROCESS_RUNNING)
+                        {
+                            if (RT_FAILURE(rc2))
+                                rc = rc2;
+                            hProc = NIL_RTPROCESS;
+                        }
+                    }
+
+                    rc2 = RTPoll(hPollSet, 10000, NULL, NULL);
+                    Assert(RT_SUCCESS(rc2) || rc2 == VERR_TIMEOUT);
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    if (   (ppszStdOut && *ppszStdOut && !RTStrIsValidEncoding(*ppszStdOut))
+                        || (ppszStdErr && *ppszStdErr && !RTStrIsValidEncoding(*ppszStdErr)) )
+                        rc = VERR_NO_TRANSLATION;
+                }
+
+                /*
+                 * No more output, just wait for it to finish.
+                 */
+                if (hProc != NIL_RTPROCESS)
+                {
+                    rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
+                    if (RT_FAILURE(rc2))
+                        rc = rc2;
+                }
+            }
+            RTPollSetDestroy(hPollSet);
+        }
+    }
+
+    rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
+    rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
+    rc2 = RTHandleClose(&hChildStdIn);  AssertRC(rc2);
+    rc2 = RTPipeClose(hPipeStdErrR);    AssertRC(rc2);
+    rc2 = RTPipeClose(hPipeStdOutR);    AssertRC(rc2);
+    return rc;
+}
+
+
+/**
+ * Runs a process, waiting for it to complete.
+ *
+ * @returns IPRT status code
+ *
+ * @param   pszExec     Executable image to use to create the child process.
+ * @param   papszArgs   Pointer to an array of arguments to the child.  The
+ *                      array terminated by an entry containing NULL.
+ * @param   hEnv        Handle to the environment block for the child.
+ * @param   fFlags      A combination of RTPROCEXEC_FLAGS_XXX.
+ * @param   pStatus     Where to return the status on success.
+ */
+int RTProcExec(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
+               PRTPROCSTATUS pStatus)
+{
+    int rc;
+
+    /*
+     * Clear output argument (no returning failure here, simply crash!).
+     */
+    AssertPtr(pStatus);
+    pStatus->enmReason = RTPROCEXITREASON_ABEND;
+    pStatus->iStatus   = RTEXITCODE_FAILURE;
+
+    /*
+     * Check input arguments.
+     */
+    AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
+
+    /*
+     * Set up /dev/null redirections.
+     */
+    PRTHANDLE   aph[3] = { NULL, NULL, NULL };
+    RTHANDLE    ah[3];
+    for (uint32_t i = 0; i < 3; i++)
+    {
+        ah[i].enmType = RTHANDLETYPE_FILE;
+        ah[i].u.hFile = NIL_RTFILE;
+    }
+    rc = VINF_SUCCESS;
+    if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
+    {
+        aph[0] = &ah[0];
+        rc = RTFileOpenBitBucket(&ah[0].u.hFile, RTFILE_O_READ);
+    }
+    if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
+    {
+        aph[1] = &ah[1];
+        rc = RTFileOpenBitBucket(&ah[1].u.hFile, RTFILE_O_WRITE);
+    }
+    if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
+    {
+        aph[2] = &ah[2];
+        rc = RTFileOpenBitBucket(&ah[2].u.hFile, RTFILE_O_WRITE);
+    }
+
+    /*
+     * Create the process.
+     */
+    RTPROCESS hProc = NIL_RTPROCESS;
+    if (RT_SUCCESS(rc))
+        rc = RTProcCreateEx(pszExec,
+                            papszArgs,
+                            hEnv,
+                            0 /*fFlags*/,
+                            aph[0],
+                            aph[1],
+                            aph[2],
+                            NULL /*pszAsUser*/,
+                            NULL /*pszPassword*/,
+                            NULL /*pvExtraData*/,
+                            &hProc);
+
+    for (uint32_t i = 0; i < 3; i++)
+        RTFileClose(ah[i].u.hFile);
+
+    if (RT_SUCCESS(rc))
+        rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
+    return rc;
+}
+
+
+
+/**
+ * Executes SVN and gets the output.
+ *
+ * Standard error is suppressed.
+ *
+ * @returns VINF_SUCCESS if the command executed successfully.
+ * @param   pState              The rewrite state to work on.  Can be NULL.
+ * @param   papszArgs           The SVN argument.
+ * @param   fNormalFailureOk    Whether normal failure is ok.
+ * @param   ppszStdOut          Where to return the output on success.
+ */
+static int scmSvnRunAndGetOutput(PSCMRWSTATE pState, const char **papszArgs, bool fNormalFailureOk, char **ppszStdOut)
+{
+    *ppszStdOut = NULL;
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    scmSvnFlushClientContextAndPool();
+#endif
+
+    char *pszCmdLine = NULL;
+    int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
+    if (RT_FAILURE(rc))
+        return rc;
+    ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
+
+    RTPROCSTATUS Status;
+    rc = RTProcExecToString(g_szSvnPath, papszArgs, RTENV_DEFAULT,
+                            RTPROCEXEC_FLAGS_STD_NULL, &Status, ppszStdOut, NULL);
+
+    if (    RT_SUCCESS(rc)
+        &&  (   Status.enmReason != RTPROCEXITREASON_NORMAL
+             || Status.iStatus != 0) )
+    {
+        if (fNormalFailureOk || Status.enmReason != RTPROCEXITREASON_NORMAL)
+            RTMsgError("%s: %s -> %s %u\n",
+                       pState ? pState->pszFilename : "<NONE>", pszCmdLine,
+                       Status.enmReason == RTPROCEXITREASON_NORMAL   ? "exit code"
+                       : Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
+                       : Status.enmReason == RTPROCEXITREASON_ABEND  ? "abnormal end"
+                       : "abducted by alien",
+                       Status.iStatus);
+        rc = VERR_GENERAL_FAILURE;
+    }
+    else if (RT_FAILURE(rc))
+    {
+        if (pState)
+            RTMsgError("%s: executing: %s => %Rrc\n", pState->pszFilename, pszCmdLine, rc);
+        else
+            RTMsgError("executing: %s => %Rrc\n", pszCmdLine, rc);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        RTStrFree(*ppszStdOut);
+        *ppszStdOut = NULL;
+    }
+    RTStrFree(pszCmdLine);
+    return rc;
+}
+
+
+/**
+ * Executes SVN.
+ *
+ * Standard error and standard output is suppressed.
+ *
+ * @returns VINF_SUCCESS if the command executed successfully.
+ * @param   pState              The rewrite state to work on.
+ * @param   papszArgs           The SVN argument.
+ * @param   fNormalFailureOk    Whether normal failure is ok.
+ */
+static int scmSvnRun(PSCMRWSTATE pState, const char **papszArgs, bool fNormalFailureOk)
+{
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    scmSvnFlushClientContextAndPool();
+#endif
+
+    char *pszCmdLine = NULL;
+    int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
+    if (RT_FAILURE(rc))
+        return rc;
+    ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
+
+    /* Lazy bird uses RTProcExec. */
+    RTPROCSTATUS Status;
+    rc = RTProcExec(g_szSvnPath, papszArgs, RTENV_DEFAULT, RTPROCEXEC_FLAGS_STD_NULL, &Status);
+
+    if (    RT_SUCCESS(rc)
+        &&  (   Status.enmReason != RTPROCEXITREASON_NORMAL
+             || Status.iStatus != 0) )
+    {
+        if (fNormalFailureOk || Status.enmReason != RTPROCEXITREASON_NORMAL)
+            RTMsgError("%s: %s -> %s %u\n",
+                       pState->pszFilename,
+                       pszCmdLine,
+                       Status.enmReason == RTPROCEXITREASON_NORMAL   ? "exit code"
+                       : Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
+                       : Status.enmReason == RTPROCEXITREASON_ABEND  ? "abnormal end"
+                       : "abducted by alien",
+                       Status.iStatus);
+        rc = VERR_GENERAL_FAILURE;
+    }
+    else if (RT_FAILURE(rc))
+        RTMsgError("%s: %s -> %Rrc\n", pState->pszFilename, pszCmdLine, rc);
+
+    RTStrFree(pszCmdLine);
+    return rc;
+}
+
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+/**
+ * Attempts to resolve the necessary subversion and apache portable runtime APIs
+ * we require dynamically.
+ *
+ * Will set all global function pointers and g_fSvnFunctionPointersValid to true
+ * on success.
+ */
+static void scmSvnTryResolveFunctions(void)
+{
+    char szPath[RTPATH_MAX];
+    int rc = RTStrCopy(szPath, sizeof(szPath), g_szSvnPath);
+    if (RT_SUCCESS(rc))
+    {
+        RTPathStripFilename(szPath);
+        char *pszEndPath = strchr(szPath, '\0');
+# ifdef RT_OS_WINDOWS
+        RTPathChangeToDosSlashes(szPath, false);
+# endif
+
+        /*
+         * Try various prefixes/suffxies/locations.
+         */
+        static struct
+        {
+            const char *pszPrefix;
+            const char *pszSuffix;
+        } const s_aVariations[] =
+        {
+# ifdef RT_OS_WINDOWS
+            { "SlikSvn-lib", "-1.dll" },    /* SlikSVN */
+            { "lib", "-1.dll" },            /* Win32Svn,CollabNet,++ */
+# elif defined(RT_OS_DARWIN)
+            { "../lib/lib", "-1.dylib" },
+# else
+            { "../lib/lib", ".so" },
+            { "../lib/lib", "-1.so" },
+#  if ARCH_BITS == 32
+            { "../lib32/lib", ".so" },
+            { "../lib32/lib", "-1.so" },
+#  else
+            { "../lib64/lib", ".so" },
+            { "../lib64/lib", "-1.so" },
+#   ifdef RT_OS_SOLARIS
+            { "../lib/svn/amd64/lib", ".so" },
+            { "../lib/svn/amd64/lib", "-1.so" },
+            { "../apr/1.6/lib/amd64/lib", ".so" },
+            { "../apr/1.6/lib/amd64/lib", "-1.so" },
+#   endif
+#  endif
+#  ifdef RT_ARCH_X86
+            { "../lib/i386-linux-gnu/lib", ".so" },
+            { "../lib/i386-linux-gnu/lib", "-1.so" },
+#  elif defined(RT_ARCH_AMD64)
+            { "../lib/x86_64-linux-gnu/lib", ".so" },
+            { "../lib/x86_64-linux-gnu/lib", "-1.so" },
+#  endif
+# endif
+        };
+        for (unsigned iVar = 0; iVar < RT_ELEMENTS(s_aVariations); iVar++)
+        {
+            /*
+             * Try load the svn_client library ...
+             */
+            static const char * const s_apszLibraries[]   = { "svn_client", "svn_subr",   "apr" };
+            RTLDRMOD ahMods[RT_ELEMENTS(s_apszLibraries)] = { NIL_RTLDRMOD, NIL_RTLDRMOD, NIL_RTLDRMOD };
+
+            rc = VINF_SUCCESS;
+            unsigned iLib;
+            for (iLib = 0; iLib < RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc); iLib++)
+            {
+                static const char * const s_apszSuffixes[] = { "", ".0", ".1" };
+                for (unsigned iSuff = 0; iSuff < RT_ELEMENTS(s_apszSuffixes); iSuff++)
+                {
+                    *pszEndPath = '\0';
+                    rc = RTPathAppend(szPath, sizeof(szPath), s_aVariations[iVar].pszPrefix);
+                    if (RT_SUCCESS(rc))
+                        rc = RTStrCat(szPath, sizeof(szPath), s_apszLibraries[iLib]);
+                    if (RT_SUCCESS(rc))
+                        rc = RTStrCat(szPath, sizeof(szPath), s_aVariations[iVar].pszSuffix);
+                    if (RT_SUCCESS(rc))
+                        rc = RTStrCat(szPath, sizeof(szPath), s_apszSuffixes[iSuff]);
+                    if (RT_SUCCESS(rc))
+                    {
+# ifdef RT_OS_WINDOWS
+                        RTPathChangeToDosSlashes(pszEndPath, false);
+# endif
+                        rc = RTLdrLoadEx(szPath, &ahMods[iLib], RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR , NULL);
+                        if (RT_SUCCESS(rc))
+                        {
+                            RTMEM_WILL_LEAK(ahMods[iLib]);
+                            break;
+                        }
+                    }
+                }
+# ifdef RT_OS_SOLARIS
+                /*
+                 * HACK: Solaris may keep libapr.so separately from svn, so do a separate search for it.
+                 */
+                /** @todo It would make a lot more sense to use the dlfcn.h machinery to figure
+                 *        out which libapr*.so* file was loaded into the process together with
+                 *        the two svn libraries and get a dlopen handle for it.  We risk ending
+                 *        up with the completely wrong libapr here! */
+                if (iLib == RT_ELEMENTS(s_apszLibraries) - 1 && RT_FAILURE(rc))
+                {
+                    ahMods[iLib] = NIL_RTLDRMOD;
+                    for (unsigned iVar2 = 0; iVar2 < RT_ELEMENTS(s_aVariations) && ahMods[iLib] == NIL_RTLDRMOD; iVar2++)
+                        for (unsigned iSuff2 = 0; iSuff2 < RT_ELEMENTS(s_apszSuffixes) && ahMods[iLib] == NIL_RTLDRMOD; iSuff2++)
+                        {
+                            *pszEndPath = '\0';
+                            rc = RTPathAppend(szPath, sizeof(szPath), s_aVariations[iVar2].pszPrefix);
+                            if (RT_SUCCESS(rc))
+                                rc = RTStrCat(szPath, sizeof(szPath), s_apszLibraries[iLib]);
+                            if (RT_SUCCESS(rc))
+                                rc = RTStrCat(szPath, sizeof(szPath), s_aVariations[iVar2].pszSuffix);
+                            if (RT_SUCCESS(rc))
+                                rc = RTStrCat(szPath, sizeof(szPath), s_apszSuffixes[iSuff2]);
+                            if (RT_SUCCESS(rc))
+                                rc = RTLdrLoadEx(szPath, &ahMods[iLib], RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR, NULL);
+                            if (RT_SUCCESS(rc))
+                                RTMEM_WILL_LEAK(ahMods[iLib]);
+                            else
+                                ahMods[iLib] = NIL_RTLDRMOD;
+                        }
+                }
+# endif /* RT_OS_SOLARIS */
+            }
+            if (iLib == RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc))
+            {
+                static const struct
+                {
+                    unsigned    iLib;
+                    const char *pszSymbol;
+                    uintptr_t  *ppfn;   /**< The nothrow attrib of PFNRT goes down the wrong way with Clang 11, thus uintptr_t. */
+                } s_aSymbols[] =
+                {
+                    { 2, "apr_initialize",              (uintptr_t *)&g_pfnAprInitialize },
+                    { 2, "apr_hash_first",              (uintptr_t *)&g_pfnAprHashFirst },
+                    { 2, "apr_hash_next",               (uintptr_t *)&g_pfnAprHashNext },
+                    { 2, "apr_hash_this_val",           (uintptr_t *)&g_pfnAprHashThisVal },
+                    { 1, "svn_pool_create_ex",          (uintptr_t *)&g_pfnSvnPoolCreateEx },
+                    { 2, "apr_pool_clear",              (uintptr_t *)&g_pfnAprPoolClear },
+                    { 2, "apr_pool_destroy",            (uintptr_t *)&g_pfnAprPoolDestroy },
+                    { 0, "svn_client_create_context",   (uintptr_t *)&g_pfnSvnClientCreateContext },
+                    { 0, "svn_client_propget4",         (uintptr_t *)&g_pfnSvnClientPropGet4 },
+                };
+                for (unsigned i = 0; i < RT_ELEMENTS(s_aSymbols); i++)
+                {
+                    rc = RTLdrGetSymbol(ahMods[s_aSymbols[i].iLib], s_aSymbols[i].pszSymbol,
+                                        (void **)(uintptr_t)s_aSymbols[i].ppfn);
+                    if (RT_FAILURE(rc))
+                    {
+                        ScmVerbose(NULL, 0, "Failed to resolve '%s' in '%s'",
+                                   s_aSymbols[i].pszSymbol, s_apszLibraries[s_aSymbols[i].iLib]);
+                        break;
+                    }
+                }
+                if (RT_SUCCESS(rc))
+                {
+                    apr_status_t rcApr = g_pfnAprInitialize();
+                    if (rcApr == 0)
+                    {
+                        ScmVerbose(NULL, 1, "Found subversion APIs.\n");
+                        g_fSvnFunctionPointersValid = true;
+                    }
+                    else
+                    {
+                        ScmVerbose(NULL, 0, "apr_initialize failed: %#x (%d)\n", rcApr, rcApr);
+                        AssertMsgFailed(("%#x (%d)\n", rc, rc));
+                    }
+                    return;
+                }
+            }
+
+            while (iLib-- > 0)
+                RTLdrClose(ahMods[iLib]);
+        }
+    }
+}
+#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
+
+
+/**
+ * Finds the svn binary, updating g_szSvnPath and g_enmSvnVersion.
+ */
+static void scmSvnFindSvnBinary(PSCMRWSTATE pState)
+{
+    /* Already been called? */
+    if (g_szSvnPath[0] != '\0')
+        return;
+
+    /*
+     * Locate it.
+     */
+    /** @todo code page fun... */
+#ifdef RT_OS_WINDOWS
+    const char *pszEnvVar = RTEnvGet("Path");
+#else
+    const char *pszEnvVar = RTEnvGet("PATH");
+#endif
+    if (pszEnvVar)
+    {
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+        int rc = RTPathTraverseList(pszEnvVar, ';', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
+#else
+        int rc = RTPathTraverseList(pszEnvVar, ':', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
+#endif
+        if (RT_FAILURE(rc))
+            strcpy(g_szSvnPath, "svn");
+    }
+    else
+        strcpy(g_szSvnPath, "svn");
+
+    /*
+     * Check the version.
+     */
+    const char *apszArgs[] = { g_szSvnPath, "--version", "--quiet", NULL };
+    char *pszVersion;
+    int rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszVersion);
+    if (RT_SUCCESS(rc))
+    {
+        char *pszStripped = RTStrStrip(pszVersion);
+        if (RTStrVersionCompare(pszStripped, "1.8") >= 0)
+            g_enmSvnVersion = kScmSvnVersion_1_8;
+        else if (RTStrVersionCompare(pszStripped, "1.7") >= 0)
+            g_enmSvnVersion = kScmSvnVersion_1_7;
+        else if (RTStrVersionCompare(pszStripped, "1.6") >= 0)
+            g_enmSvnVersion = kScmSvnVersion_1_6;
+        else
+            g_enmSvnVersion = kScmSvnVersion_Ancient;
+        RTStrFree(pszVersion);
+    }
+    else
+        g_enmSvnVersion = kScmSvnVersion_Ancient;
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    /*
+     * If we got version 1.8 or later, try see if we can locate a few of the
+     * simpler SVN APIs.
+     */
+    g_fSvnFunctionPointersValid = false;
+    if (g_enmSvnVersion >= kScmSvnVersion_1_8)
+        scmSvnTryResolveFunctions();
+#endif
+}
+
+
+/**
+ * Construct a dot svn filename for the file being rewritten.
+ *
+ * @returns IPRT status code.
+ * @param   pState              The rewrite state (for the name).
+ * @param   pszDir              The directory, including ".svn/".
+ * @param   pszSuff             The filename suffix.
+ * @param   pszDst              The output buffer.  RTPATH_MAX in size.
+ */
+static int scmSvnConstructName(PSCMRWSTATE pState, const char *pszDir, const char *pszSuff, char *pszDst)
+{
+    strcpy(pszDst, pState->pszFilename); /* ASSUMES sizeof(szBuf) <= sizeof(szPath) */
+    RTPathStripFilename(pszDst);
+
+    int rc = RTPathAppend(pszDst, RTPATH_MAX, pszDir);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTPathAppend(pszDst, RTPATH_MAX, RTPathFilename(pState->pszFilename));
+        if (RT_SUCCESS(rc))
+        {
+            size_t cchDst  = strlen(pszDst);
+            size_t cchSuff = strlen(pszSuff);
+            if (cchDst + cchSuff < RTPATH_MAX)
+            {
+                memcpy(&pszDst[cchDst], pszSuff, cchSuff + 1);
+                return VINF_SUCCESS;
+            }
+            else
+                rc = VERR_BUFFER_OVERFLOW;
+        }
+    }
+    return rc;
+}
+
+/**
+ * Interprets the specified string as decimal numbers.
+ *
+ * @returns true if parsed successfully, false if not.
+ * @param   pch                 The string (not terminated).
+ * @param   cch                 The string length.
+ * @param   pu                  Where to return the value.
+ */
+static bool scmSvnReadNumber(const char *pch, size_t cch, size_t *pu)
+{
+    size_t u = 0;
+    while (cch-- > 0)
+    {
+        char ch = *pch++;
+        if (ch < '0' || ch > '9')
+            return false;
+        u *= 10;
+        u += ch - '0';
+    }
+    *pu = u;
+    return true;
+}
+
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+
+/**
+ * Wrapper around RTPathAbs.
+ * @returns Same as RTPathAbs.
+ * @param   pszPath             The relative path.
+ * @param   pszAbsPath          Where to return the absolute path.
+ * @param   cbAbsPath           Size of the @a pszAbsPath buffer.
+ */
+static int scmSvnAbsPath(const char *pszPath, char *pszAbsPath, size_t cbAbsPath)
+{
+    int rc = RTPathAbs(pszPath, pszAbsPath, cbAbsPath);
+# if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
+    if (RT_SUCCESS(rc))
+    {
+        RTPathChangeToUnixSlashes(pszAbsPath, true /*fForce*/);
+        /* To avoid: svn: E235000: In file '..\..\..\subversion\libsvn_client\prop_commands.c' line 796: assertion failed (svn_dirent_is_absolute(target)) */
+        if (pszAbsPath[1] == ':')
+            pszAbsPath[0] = RT_C_TO_UPPER(pszAbsPath[0]);
+    }
+# endif
+    return rc;
+}
+
+
+/**
+ * Gets a client context and pool.
+ *
+ * This implements caching.
+ *
+ * @returns IPRT status code.
+ * @param   ppCtx               Where to return the context
+ * @param   ppPool              Where to return the pool.
+ */
+static int scmSvnGetClientContextAndPool(svn_client_ctx_t **ppCtx, apr_pool_t **ppPool)
+{
+    /*
+     * Use cached if present.
+     */
+    if (g_pSvnClientCtx && g_pSvnPool)
+    {
+        g_cSvnClientCtxUsed++;
+        *ppCtx  = g_pSvnClientCtx;
+        *ppPool = g_pSvnPool;
+        return VINF_SUCCESS;
+    }
+    Assert(!g_pSvnClientCtx);
+    Assert(!g_pSvnPool);
+
+    /*
+     * Create new pool and context.
+     */
+    apr_pool_t *pPool = g_pfnSvnPoolCreateEx(NULL, NULL);
+    if (pPool)
+    {
+        svn_client_ctx_t *pCtx = NULL;
+        svn_error_t *pErr = g_pfnSvnClientCreateContext(&pCtx, pPool);
+        if (!pErr)
+        {
+            g_cSvnClientCtxUsed = 1;
+            g_pSvnClientCtx     = *ppCtx  = pCtx;
+            g_pSvnPool          = *ppPool = pPool;
+            return VINF_SUCCESS;
+        }
+        g_pfnAprPoolDestroy(pPool);
+    }
+
+    *ppCtx  = NULL;
+    *ppPool = NULL;
+    return VERR_GENERAL_FAILURE;
+}
+
+
+/**
+ * Puts back a client context and pool after use.
+ *
+ * @param   pCtx                The context.
+ * @param   pPool               The pool.
+ * @param   fFlush              Whether to flush it.
+ */
+static void scmSvnPutClientContextAndPool(svn_client_ctx_t *pCtx, apr_pool_t *pPool, bool fFlush)
+{
+    if (fFlush || g_cSvnClientCtxUsed > 4096) /* Disable this to force new context every time. */
+    {
+        g_pfnAprPoolDestroy(pPool);
+        g_pSvnPool = NULL;
+        g_pSvnClientCtx = NULL;
+    }
+    RT_NOREF(pCtx, fFlush);
+}
+
+
+/**
+ * Flushes the cached client context and pool
+ */
+static void scmSvnFlushClientContextAndPool(void)
+{
+    if (g_pSvnPool)
+        scmSvnPutClientContextAndPool(g_pSvnClientCtx, g_pSvnPool, true /*fFlush*/);
+    Assert(!g_pSvnPool);
+}
+
+
+/**
+ * Checks if @a pszPath exists in the current WC.
+ *
+ * @returns true, false or -1. In the latter case, please use the fallback.
+ * @param   pszPath         Path to the object that should be investigated.
+ */
+static int scmSvnIsObjectInWorkingCopy(const char *pszPath)
+{
+    /* svn_client_propget4 and later requires absolute target path. */
+    char szAbsPath[RTPATH_MAX];
+    int  rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
+    if (RT_SUCCESS(rc))
+    {
+        apr_pool_t *pPool;
+        svn_client_ctx_t *pCtx = NULL;
+        rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
+        if (RT_SUCCESS(rc))
+        {
+            /* Make the call. */
+            apr_hash_t         *pHash = NULL;
+            svn_opt_revision_t  Rev;
+            RT_ZERO(Rev);
+            Rev.kind          = svn_opt_revision_working;
+            Rev.value.number  = -1L;
+            svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, "svn:no-such-property", szAbsPath, &Rev, &Rev,
+                                                       NULL /*pActualRev*/, svn_depth_empty, NULL /*pChangeList*/,
+                                                       pCtx, pPool, pPool);
+            if (!pErr)
+                rc = true;
+            else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
+                rc = false;
+
+            scmSvnPutClientContextAndPool(pCtx, pPool, false);
+        }
+    }
+    return rc;
+}
+
+#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
+
+
+/**
+ * Checks if the file we're operating on is part of a SVN working copy.
+ *
+ * @returns true if it is, false if it isn't or we cannot tell.
+ * @param   pState      The rewrite state to work on.  Will use the
+ *                      fIsInSvnWorkingCopy member for caching the result.
+ */
+bool ScmSvnIsInWorkingCopy(PSCMRWSTATE pState)
+{
+    /*
+     * We don't ask SVN twice as that's expensive.
+     */
+    if (pState->fIsInSvnWorkingCopy != 0)
+        return pState->fIsInSvnWorkingCopy > 0;
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    if (g_fSvnFunctionPointersValid)
+    {
+        int rc = scmSvnIsObjectInWorkingCopy(pState->pszFilename);
+        if (rc == (int)true || rc == (int)false)
+        {
+            pState->fIsInSvnWorkingCopy = rc == (int)true ? 1 : -1;
+            return rc == (int)true;
+        }
+    }
+
+    /* Fallback: */
+#endif
+    if (g_enmSvnVersion < kScmSvnVersion_1_7)
+    {
+        /*
+         * Hack: check if the .svn/text-base/<file>.svn-base file exists.
+         */
+        char szPath[RTPATH_MAX];
+        int rc = scmSvnConstructName(pState, ".svn/text-base/", ".svn-base", szPath);
+        if (RT_SUCCESS(rc))
+        {
+            if (RTFileExists(szPath))
+            {
+                pState->fIsInSvnWorkingCopy = 1;
+                return true;
+            }
+        }
+    }
+    else
+    {
+        const char *apszArgs[] = { g_szSvnPath, "proplist", pState->pszFilename, NULL };
+        char       *pszValue;
+        int rc = scmSvnRunAndGetOutput(pState, apszArgs, true, &pszValue);
+        if (RT_SUCCESS(rc))
+        {
+            RTStrFree(pszValue);
+            pState->fIsInSvnWorkingCopy = 1;
+            return true;
+        }
+    }
+    pState->fIsInSvnWorkingCopy = -1;
+    return false;
+}
+
+
+/**
+ * Checks if the specified directory is part of a SVN working copy.
+ *
+ * @returns true if it is, false if it isn't or we cannot tell.
+ * @param   pszDir              The directory in question.
+ */
+bool ScmSvnIsDirInWorkingCopy(const char *pszDir)
+{
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    if (g_fSvnFunctionPointersValid)
+    {
+        int rc = scmSvnIsObjectInWorkingCopy(pszDir);
+        if (rc == (int)true || rc == (int)false)
+            return rc == (int)true;
+    }
+
+    /* Fallback: */
+#endif
+    if (g_enmSvnVersion < kScmSvnVersion_1_7)
+    {
+        /*
+         * Hack: check if the .svn/ dir exists.
+         */
+        char szPath[RTPATH_MAX];
+        int rc = RTPathJoin(szPath, sizeof(szPath), pszDir, ".svn");
+        if (RT_SUCCESS(rc))
+            return RTDirExists(szPath);
+    }
+    else
+    {
+        const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pszDir, NULL };
+        char       *pszValue;
+        int rc = scmSvnRunAndGetOutput(NULL, apszArgs, true, &pszValue);
+        if (RT_SUCCESS(rc))
+        {
+            RTStrFree(pszValue);
+            return true;
+        }
+    }
+    return false;
+}
+
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+/**
+ * Checks if @a pszPath exists in the current WC.
+ *
+ * @returns IPRT status code - VERR_NOT_SUPPORT if fallback should be attempted.
+ * @param   pszPath         Path to the object that should be investigated.
+ * @param   pszProperty     The property name.
+ * @param   ppszValue       Where to return the property value. Optional.
+ */
+static int scmSvnQueryPropertyUsingApi(const char *pszPath, const char *pszProperty, char **ppszValue)
+{
+    /* svn_client_propget4 and later requires absolute target path. */
+    char szAbsPath[RTPATH_MAX];
+    int  rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
+    if (RT_SUCCESS(rc))
+    {
+        apr_pool_t *pPool;
+        svn_client_ctx_t *pCtx = NULL;
+        rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
+        if (RT_SUCCESS(rc))
+        {
+            /* Make the call. */
+            apr_hash_t         *pHash = NULL;
+            svn_opt_revision_t  Rev;
+            RT_ZERO(Rev);
+            Rev.kind          = svn_opt_revision_working;
+            Rev.value.number  = -1L;
+            svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, pszProperty, szAbsPath, &Rev, &Rev,
+                                                       NULL /*pActualRev*/, svn_depth_empty, NULL /*pChangeList*/,
+                                                       pCtx, pPool, pPool);
+            if (!pErr)
+            {
+                /* Get the first value, if any. */
+                rc = VERR_NOT_FOUND;
+                apr_hash_index_t *pHashIdx = g_pfnAprHashFirst(pPool, pHash);
+                if (pHashIdx)
+                {
+                    const char **ppszFirst = (const char **)g_pfnAprHashThisVal(pHashIdx);
+                    if (ppszFirst && *ppszFirst)
+                    {
+                        if (ppszValue)
+                            rc = RTStrDupEx(ppszValue, *ppszFirst);
+                        else
+                            rc = VINF_SUCCESS;
+                    }
+                }
+            }
+            else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
+                rc = VERR_INVALID_STATE;
+            else
+                rc = VERR_GENERAL_FAILURE;
+
+            scmSvnPutClientContextAndPool(pCtx, pPool, false);
+        }
+    }
+    return rc;
+}
+#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
+
+
+/**
+ * Queries the value of an SVN property.
+ *
+ * This will automatically adjust for scheduled changes.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_STATE if not a SVN WC file.
+ * @retval  VERR_NOT_FOUND if the property wasn't found.
+ * @param   pState              The rewrite state to work on.
+ * @param   pszName             The property name.
+ * @param   ppszValue           Where to return the property value.  Free this
+ *                              using RTStrFree.  Optional.
+ */
+int ScmSvnQueryProperty(PSCMRWSTATE pState, const char *pszName, char **ppszValue)
+{
+    int rc;
+
+    /*
+     * Look it up in the scheduled changes.
+     */
+    size_t i = pState->cSvnPropChanges;
+    while (i-- > 0)
+        if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
+        {
+            const char *pszValue = pState->paSvnPropChanges[i].pszValue;
+            if (!pszValue)
+                return VERR_NOT_FOUND;
+            if (ppszValue)
+                return RTStrDupEx(ppszValue, pszValue);
+            return VINF_SUCCESS;
+        }
+
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    if (g_fSvnFunctionPointersValid)
+    {
+        rc = scmSvnQueryPropertyUsingApi(pState->pszFilename, pszName, ppszValue);
+        if (rc != VERR_NOT_SUPPORTED)
+            return rc;
+        /* Fallback: */
+    }
+#endif
+
+    if (g_enmSvnVersion < kScmSvnVersion_1_7)
+    {
+        /*
+         * Hack: Read the .svn/props/<file>.svn-work file exists.
+         */
+        char szPath[RTPATH_MAX];
+        rc = scmSvnConstructName(pState, ".svn/props/", ".svn-work", szPath);
+        if (RT_SUCCESS(rc) && !RTFileExists(szPath))
+            rc = scmSvnConstructName(pState, ".svn/prop-base/", ".svn-base", szPath);
+        if (RT_SUCCESS(rc))
+        {
+            SCMSTREAM Stream;
+            rc = ScmStreamInitForReading(&Stream, szPath);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * The current format is K len\n<name>\nV len\n<value>\n" ... END.
+                 */
+                rc = VERR_NOT_FOUND;
+                size_t const    cchName = strlen(pszName);
+                SCMEOL          enmEol;
+                size_t          cchLine;
+                const char     *pchLine;
+                while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
+                {
+                    /*
+                     * Parse the 'K num' / 'END' line.
+                     */
+                    if (   cchLine == 3
+                        && !memcmp(pchLine, "END", 3))
+                        break;
+                    size_t cchKey;
+                    if (   cchLine < 3
+                        || pchLine[0] != 'K'
+                        || pchLine[1] != ' '
+                        || !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchKey)
+                        || cchKey == 0
+                        || cchKey > 4096)
+                    {
+                        RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
+                        rc = VERR_PARSE_ERROR;
+                        break;
+                    }
+
+                    /*
+                     * Match the key and skip to the value line.  Don't bother with
+                     * names containing EOL markers.
+                     */
+                    size_t const offKey = ScmStreamTell(&Stream);
+                    bool fMatch = cchName == cchKey;
+                    if (fMatch)
+                    {
+                        pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
+                        if (!pchLine)
+                            break;
+                        fMatch = cchLine == cchName
+                              && !memcmp(pchLine, pszName, cchName);
+                    }
+
+                    if (RT_FAILURE(ScmStreamSeekAbsolute(&Stream, offKey + cchKey)))
+                        break;
+                    if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
+                        break;
+
+                    /*
+                     * Read and Parse the 'V num' line.
+                     */
+                    pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
+                    if (!pchLine)
+                        break;
+                    size_t cchValue;
+                    if (   cchLine < 3
+                        || pchLine[0] != 'V'
+                        || pchLine[1] != ' '
+                        || !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchValue)
+                        || cchValue > _1M)
+                    {
+                        RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
+                        rc = VERR_PARSE_ERROR;
+                        break;
+                    }
+
+                    /*
+                     * If we have a match, allocate a return buffer and read the
+                     * value into it.  Otherwise skip this value and continue
+                     * searching.
+                     */
+                    if (fMatch)
+                    {
+                        if (!ppszValue)
+                            rc = VINF_SUCCESS;
+                        else
+                        {
+                            char *pszValue;
+                            rc = RTStrAllocEx(&pszValue, cchValue + 1);
+                            if (RT_SUCCESS(rc))
+                            {
+                                rc = ScmStreamRead(&Stream, pszValue, cchValue);
+                                if (RT_SUCCESS(rc))
+                                    *ppszValue = pszValue;
+                                else
+                                    RTStrFree(pszValue);
+                            }
+                        }
+                        break;
+                    }
+
+                    if (RT_FAILURE(ScmStreamSeekRelative(&Stream, cchValue)))
+                        break;
+                    if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
+                        break;
+                }
+
+                if (RT_FAILURE(ScmStreamGetStatus(&Stream)))
+                {
+                    rc = ScmStreamGetStatus(&Stream);
+                    RTMsgError("%s: stream error %Rrc\n", szPath, rc);
+                }
+                ScmStreamDelete(&Stream);
+            }
+        }
+
+        if (rc == VERR_FILE_NOT_FOUND)
+            rc = VERR_NOT_FOUND;
+    }
+    else
+    {
+        const char *apszArgs[] = { g_szSvnPath, "propget", "--strict", pszName, pState->pszFilename, NULL };
+        char       *pszValue;
+        rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszValue);
+        if (RT_SUCCESS(rc))
+        {
+            if (pszValue && *pszValue)
+            {
+                if (ppszValue)
+                {
+                    *ppszValue = pszValue;
+                    pszValue = NULL;
+                }
+            }
+            else
+                rc = VERR_NOT_FOUND;
+            RTStrFree(pszValue);
+        }
+    }
+    return rc;
+}
+
+
+/**
+ * Queries the value of an SVN property on the parent dir/whatever.
+ *
+ * This will not adjust for scheduled changes to the parent!
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_STATE if not a SVN WC file.
+ * @retval  VERR_NOT_FOUND if the property wasn't found.
+ * @param   pState              The rewrite state to work on.
+ * @param   pszName             The property name.
+ * @param   ppszValue           Where to return the property value.  Free this
+ *                              using RTStrFree.  Optional.
+ */
+int ScmSvnQueryParentProperty(PSCMRWSTATE pState, const char *pszName, char **ppszValue)
+{
+    /*
+     * Strip the filename and use ScmSvnQueryProperty.
+     */
+    char szPath[RTPATH_MAX];
+    int rc = RTStrCopy(szPath, sizeof(szPath), pState->pszFilename);
+    if (RT_SUCCESS(rc))
+    {
+        RTPathStripFilename(szPath);
+        SCMRWSTATE ParentState;
+        ParentState.pszFilename         = szPath;
+        ParentState.fFirst              = false;
+        ParentState.fNeedsManualRepair  = false;
+        ParentState.fIsInSvnWorkingCopy = true;
+        ParentState.cSvnPropChanges     = 0;
+        ParentState.paSvnPropChanges    = NULL;
+        ParentState.rc                  = VINF_SUCCESS;
+        rc = ScmSvnQueryProperty(&ParentState, pszName, ppszValue);
+        if (RT_SUCCESS(rc))
+            rc = ParentState.rc;
+    }
+    return rc;
+}
+
+
+/**
+ * Schedules the setting of a property.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_STATE if not a SVN WC file.
+ * @param   pState              The rewrite state to work on.
+ * @param   pszName             The name of the property to set.
+ * @param   pszValue            The value.  NULL means deleting it.
+ */
+int ScmSvnSetProperty(PSCMRWSTATE pState, const char *pszName, const char *pszValue)
+{
+    /*
+     * Update any existing entry first.
+     */
+    size_t i = pState->cSvnPropChanges;
+    while (i-- > 0)
+        if (!strcmp(pState->paSvnPropChanges[i].pszName,  pszName))
+        {
+            if (!pszValue)
+            {
+                RTStrFree(pState->paSvnPropChanges[i].pszValue);
+                pState->paSvnPropChanges[i].pszValue = NULL;
+            }
+            else
+            {
+                char *pszCopy;
+                int rc = RTStrDupEx(&pszCopy, pszValue);
+                if (RT_FAILURE(rc))
+                    return rc;
+                pState->paSvnPropChanges[i].pszValue = pszCopy;
+            }
+            return VINF_SUCCESS;
+        }
+
+    /*
+     * Insert a new entry.
+     */
+    i = pState->cSvnPropChanges;
+    if ((i % 32) == 0)
+    {
+        void *pvNew = RTMemRealloc(pState->paSvnPropChanges, (i + 32) * sizeof(SCMSVNPROP));
+        if (!pvNew)
+            return VERR_NO_MEMORY;
+        pState->paSvnPropChanges = (PSCMSVNPROP)pvNew;
+    }
+
+    pState->paSvnPropChanges[i].pszName  = RTStrDup(pszName);
+    pState->paSvnPropChanges[i].pszValue = pszValue ? RTStrDup(pszValue) : NULL;
+    if (   pState->paSvnPropChanges[i].pszName
+        && (pState->paSvnPropChanges[i].pszValue || !pszValue) )
+        pState->cSvnPropChanges = i + 1;
+    else
+    {
+        RTStrFree(pState->paSvnPropChanges[i].pszName);
+        pState->paSvnPropChanges[i].pszName = NULL;
+        RTStrFree(pState->paSvnPropChanges[i].pszValue);
+        pState->paSvnPropChanges[i].pszValue = NULL;
+        return VERR_NO_MEMORY;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Schedules a property deletion.
+ *
+ * @returns IPRT status code.
+ * @param   pState              The rewrite state to work on.
+ * @param   pszName             The name of the property to delete.
+ */
+int ScmSvnDelProperty(PSCMRWSTATE pState, const char *pszName)
+{
+    return ScmSvnSetProperty(pState, pszName, NULL);
+}
+
+
+/**
+ * Applies any SVN property changes to the work copy of the file.
+ *
+ * @returns IPRT status code.
+ * @param   pState              The rewrite state which SVN property changes
+ *                              should be applied.
+ */
+int ScmSvnDisplayChanges(PSCMRWSTATE pState)
+{
+    size_t i = pState->cSvnPropChanges;
+    while (i-- > 0)
+    {
+        const char *pszName  = pState->paSvnPropChanges[i].pszName;
+        const char *pszValue = pState->paSvnPropChanges[i].pszValue;
+        if (pszValue)
+            ScmVerbose(pState, 0, "svn propset '%s' '%s' %s\n", pszName, pszValue, pState->pszFilename);
+        else
+            ScmVerbose(pState, 0, "svn propdel '%s' %s\n", pszName, pState->pszFilename);
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Applies any SVN property changes to the work copy of the file.
+ *
+ * @returns IPRT status code.
+ * @param   pState              The rewrite state which SVN property changes
+ *                              should be applied.
+ */
+int ScmSvnApplyChanges(PSCMRWSTATE pState)
+{
+#ifdef SCM_WITH_LATER
+    if (0)
+    {
+        return ...;
+    }
+
+    /* Fallback: */
+#endif
+
+    /*
+     * Iterate thru the changes and apply them by starting the svn client.
+     */
+    for (size_t i = 0; i < pState->cSvnPropChanges; i++)
+    {
+        const char *apszArgv[6];
+        apszArgv[0] = g_szSvnPath;
+        apszArgv[1] = pState->paSvnPropChanges[i].pszValue ? "propset" : "propdel";
+        apszArgv[2] = pState->paSvnPropChanges[i].pszName;
+        int iArg = 3;
+        if (pState->paSvnPropChanges[i].pszValue)
+            apszArgv[iArg++] = pState->paSvnPropChanges[i].pszValue;
+        apszArgv[iArg++] = pState->pszFilename;
+        apszArgv[iArg++] = NULL;
+
+        int rc = scmSvnRun(pState, apszArgv, false);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Initializes the subversion interface.
+ */
+void ScmSvnInit(void)
+{
+    scmSvnFindSvnBinary(NULL);
+}
+
+
+void ScmSvnTerm(void)
+{
+#ifdef SCM_WITH_DYNAMIC_LIB_SVN
+    scmSvnFlushClientContextAndPool();
+#endif
+}
diff --git a/src/bldprogs/solgcc/.scm-settings b/src/bldprogs/solgcc/.scm-settings
new file mode 100644
index 00000000..04f23d1c
--- /dev/null
+++ b/src/bldprogs/solgcc/.scm-settings
@@ -0,0 +1,29 @@
+# $Id: .scm-settings $
+## @file
+# Source code massager settings for solgcc
+#
+
+#
+# Copyright (C) 2017-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# 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, in version 3 of the
+# License.
+#
+# 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 <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+/config/*: --external-copyright --no-fix-header-guards
+
diff --git a/src/bldprogs/solgcc/config/i386/sol2-gas.h b/src/bldprogs/solgcc/config/i386/sol2-gas.h
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/bldprogs/solgcc/config/i386/sol2-gas.h
diff --git a/src/bldprogs/solgcc/config/usegas.h b/src/bldprogs/solgcc/config/usegas.h
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/bldprogs/solgcc/config/usegas.h
diff --git a/src/bldprogs/test-gccplugin-2.c b/src/bldprogs/test-gccplugin-2.c
new file mode 100644
index 00000000..15ad61d2
--- /dev/null
+++ b/src/bldprogs/test-gccplugin-2.c
@@ -0,0 +1,57 @@
+/* $Id: test-gccplugin-2.c $ */
+/** @file
+ * Compiler plugin testcase \#2.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+/* Only valid stuff in this one. */
+extern void MyIprtPrintf(const char *pszFormat, ...) __attribute__((__iprt_format__(1,2)));
+extern void foo(const char *pszFormat, ...);
+
+extern unsigned long long g_ull;
+
+typedef unsigned long long RTGCPHYS;
+extern RTGCPHYS g_GCPhys;
+
+typedef RTGCPHYS *PRTGCPHYS;
+extern PRTGCPHYS  g_pGCPhys;
+
+#include <stdarg.h>
+
+void foo(const char *pszFormat, ...)
+{
+    MyIprtPrintf("%s %RX64 %RGp %p %RGp", "foobar", g_ull, g_GCPhys, g_pGCPhys, *g_pGCPhys);
+    MyIprtPrintf("%RX32 %d %s\n", 10, 42, "string");
+    MyIprtPrintf("%u %.8Rhxs %d\n", 10, &g_ull, 42);
+    MyIprtPrintf("%u %.8RhxD %d\n", 10, &g_ull, 42);
+    {
+        va_list va;
+        int iValue;
+        va_start(va, pszFormat);
+        iValue = va_arg(va, int);
+        va_end(va);
+        MyIprtPrintf("%u\n", iValue);
+    }
+}
+
diff --git a/src/bldprogs/test-gccplugin-3.c b/src/bldprogs/test-gccplugin-3.c
new file mode 100644
index 00000000..cc982560
--- /dev/null
+++ b/src/bldprogs/test-gccplugin-3.c
@@ -0,0 +1,47 @@
+/* $Id: test-gccplugin-3.c $ */
+/** @file
+ * Compiler plugin testcase \#3.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+/* Only valid stuff in this one. */
+#if defined(__i386__) || defined(_M_IX86) || defined(__X86__)
+# define RTCALL __attribute__((__cdecl__,__regparm__(0)))
+#else
+# define RTCALL
+#endif
+typedef struct HELPERS
+{
+    void (RTCALL * pfnPrintf)(struct HELPERS *pHlp, const char *pszFormat, ...)
+        __attribute__((__iprt_format__(2, 3)));
+} HELPERS;
+
+extern void foo(struct HELPERS *pHlp);
+
+
+void foo(struct HELPERS *pHlp)
+{
+    pHlp->pfnPrintf(pHlp, "%36 %#x %#x", "string", 42, 42); /// @todo missing 's', need to detect this.
+}
+
diff --git a/src/bldprogs/test-gccplugin.c b/src/bldprogs/test-gccplugin.c
new file mode 100644
index 00000000..e121fa71
--- /dev/null
+++ b/src/bldprogs/test-gccplugin.c
@@ -0,0 +1,36 @@
+/* $Id: test-gccplugin.c $ */
+/** @file
+ * Compiler plugin testcase \#2.
+ */
+
+/*
+ * Copyright (C) 2010-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+extern void MyIprtPrintf(const char *pszFormat, ...) __attribute__((__iprt_format__(1,2)));
+extern void foo(void);
+
+void foo(void)
+{
+    MyIprtPrintf(0);
+    MyIprtPrintf("%RX32 %d %s\n", 10, 42, "string");
+}
+