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

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

1 files changed, 3613 insertions, 0 deletions

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;
+}
+