Changeset 69166 in vbox for trunk/src/bldprogs/scmrw.cpp

Timestamp:

Oct 23, 2017 3:43:33 PM (7 years ago)

Author:

vboxsync

Message:

scm: License and copyright updating.

File:

• trunk/src/bldprogs/scmrw.cpp (modified) (6 diffs)

trunk/src/bldprogs/scmrw.cpp

@@ -39 +39 @@
 
 
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** License types. */
+typedef enum SCMLICENSETYPE
+{
+    kScmLicenseType_Invalid = 0,
+    kScmLicenseType_OseGpl,
+    kScmLicenseType_OseDualGplCddl,
+    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 */
+
+    /** @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;
+    /** @} */
+
+} SCMCOPYRIGHTINFO;
+typedef SCMCOPYRIGHTINFO *PSCMCOPYRIGHTINFO;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** --license-ose-gpl */
+static const char g_szVBoxOseGpl[] =
+    "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 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-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\" 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";
+
+/** --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";
+
+/** Oracle confidential. */
+static const char g_szOracleConfidential[] =
+    "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_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
+    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
+    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
+};
+
+/** Licenses to detect when --license-mit _is_ used. */
+static const SCMLICENSETEXT g_aLicensesWithMit[] =
+{
+    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseGpl)},
+    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
+    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
+    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMit) },
+    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
+    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
+};
+
+/** Copyright holder. */
+static const char g_szCopyrightHolder[] = "Oracle Corporation";
+
+
+/** 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("<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("<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("<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("<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 determinBatchFileCommentStyle(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;
+}
+
+
 /**
  * Worker for isBlankLine.
@@ -229 +517 @@
             int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
             if (RT_FAILURE(rc2))
-                RTMsgError("ScmSvnSetProperty: %Rrc\n", rc2); /** @todo propagate the error somehow... */
+                ScmError(pState, rc2, "ScmSvnSetProperty: %Rrc\n", rc2);
         }
         if (RT_SUCCESS(rc))
@@ -374 +662 @@
         rc = ScmSvnDelProperty(pState, "svn:executable");
         if (RT_FAILURE(rc))
-            RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
     }
     return false;
@@ -412 +700 @@
             rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
             if (RT_FAILURE(rc))
-                RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
+                ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
         }
         else
-            RTMsgError("RTStrAppend: %Rrc\n", rc); /** @todo error propagation here.. */
+            ScmError(pState, rc, "RTStrAppend: %Rrc\n", rc);
         RTStrFree(pszKeywords);
     }
@@ -423 +711 @@
         rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
         if (RT_FAILURE(rc))
-            RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
+            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
     }
     else if (RT_SUCCESS(rc))
@@ -430 +718 @@
     return false;
 }
+
+
+/**
+ * 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
+                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))
+                return false;
+        }
+    }
+}
+
+
+/**
+ * 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, 2,
+               "--- 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);
+
+    uint32_t iLine = pInfo->iLineStart + pInfo->cBlankLinesBefore;
+
+    /*
+     * Since the license statement is typically prefaced by a copyright line.
+     */
+    bool     fFoundCopyright = false;
+    uint32_t cBlankLinesAfterCopyright = 0;
+    if (   pState->iLineCopyright == UINT32_MAX
+        && cchBody > sizeof("Copyright") + sizeof(g_szCopyrightHolder)
+        && 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 (   (pszEnd - pszBody) > sizeof(g_szCopyrightHolder)
+            && RTStrNICmp(pszEnd - sizeof(g_szCopyrightHolder) + 1, RT_STR_TUPLE(g_szCopyrightHolder)) == 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)
+                    {
+                        ScmError(pState->pState, VERR_OUT_OF_RANGE, "Copyright year is out of range: %u ('%.*s')\n",
+                                 pState->uFirstYear, pszEnd - pszBody, pszBody);
+                        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)
+                            {
+                                ScmError(pState->pState, VERR_OUT_OF_RANGE, "Second copyright year is out of range: %u ('%.*s')\n",
+                                         pState->uLastYear, pszEnd - pszBody, pszBody);
+                                pState->uLastYear = UINT32_MAX;
+                            }
+                            else if (pState->uFirstYear > pState->uLastYear)
+                            {
+                                RTMsgWarning("Copyright years switched(?): '%.*s'\n", pszEnd - pszBody, pszBody);
+                                uint32_t iTmp = pState->uLastYear;
+                                pState->uLastYear = pState->uFirstYear;
+                                pState->uFirstYear = iTmp;
+                            }
+                        }
+                        else
+                        {
+                            pState->uLastYear = UINT32_MAX;
+                            ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
+                                     "Failed to parse second copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
+                        }
+                    }
+                    else if (*pszNext != g_szCopyrightHolder[0])
+                        ScmError(pState->pState, VERR_PARSE_ERROR,
+                                 "Failed to parse copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
+                    else
+                        pState->uLastYear = pState->uFirstYear;
+                }
+                else
+                {
+                    pState->uFirstYear = UINT32_MAX;
+                    ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
+                             "Failed to parse copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
+                }
+            }
+
+            /* 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->fWellFormedCopyright = cchWellFormed == (uintptr_t)(pszEnd - pszBody)
+                                        && memcmp(pszBody, szWellFormed, cchWellFormed) == 0;
+            pState->fUpToDateCopyright   = pState->uLastYear == g_uYear;
+            pState->iLineCopyright       = iLine;
+
+            /* If there wasn't exactly one blank line before the comment, trigger a rewrite. */
+            if (pInfo->cBlankLinesBefore != 1)
+                pState->fWellFormedCopyright = false;
+
+            /* If the comment doesn't start in column 1, trigger rewrite. */
+            if (pInfo->offStart != 0)
+            {
+                pState->fWellFormedCopyright = false;
+                /** @todo check that there isn't any code preceeding the comment. */
+            }
+
+            fFoundCopyright = true;
+            ScmVerbose(pState->pState, 2, "oracle copyright %u-%u: up-to-date=%RTbool well-formed=%RTbool\n",
+                       pState->uFirstYear, pState->uLastYear, pState->fUpToDateCopyright, pState->fWellFormedCopyright);
+        }
+        else
+            ScmVerbose(pState->pState, 2, "not oracle copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
+
+        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++;
+        }
+    }
+
+    /*
+     * Now try match against the license texts if we haven't already found it.
+     */
+    if (pState->iLineLicense == UINT32_MAX)
+    {
+        for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
+        {
+            const char *pszNext;
+            if (   pCur->cch - 1 <= cchBody
+                && 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 */
+                    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);
+                    pState->pCurrentLicense     = pCur;
+                    pState->fExternalLicense    = fExternal;
+                    pState->fIsCorrectLicense   = pState->fOpenSource
+                                                ? pCur->enmOpt == pState->enmLicenceOpt
+                                                : pCur->enmType == kScmLicenseType_Confidential;
+                    pState->fWellFormedLicense  = memcmp(pszBody, pCur->psz, pCur->cch - 1) == 0;
+
+                    /* 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)
+                    {
+                        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)
+                        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, 2,
+                               "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");
+                    if (pState->iLineCopyright != UINT32_MAX)
+                        return VERR_CALLBACK_RETURN;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (fFoundCopyright)
+        ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Updates the copyright year and/or license text.
+ *
+ * @returns true if modifications were made, false if not.
+ * @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 bool rewrite_Copyright_Common(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
+                                     SCMCOMMENTSTYLE enmCommentStyle)
+{
+    if (   !pSettings->fUpdateCopyrightYear
+        && pSettings->enmUpdateLicense == kScmLicense_LeaveAlone)
+        return false;
+
+    /*
+     * Try locate the relevant comments.
+     */
+    SCMCOPYRIGHTINFO Info =
+    {
+        /*.pState = */                  pState,
+        /*.enmCommentStyle = */         enmCommentStyle,
+
+        /*.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 ? &g_aLicenses[0] : &g_aLicensesWithMit[0],
+        /*.enmLicenceOpt = */           pSettings->enmUpdateLicense,
+        /*.iLineLicense = */            UINT32_MAX,
+        /*.cLinesLicense = */           0,
+        /*.pCurrentLicense = */         NULL,
+        /*.fIsCorrectLicense = */       false,
+        /*.fWellFormedLicense = */      false,
+        /*.fExternalLicense = */        false,
+    };
+
+    /* 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)
+        while (Info.pExpectedLicense->enmOpt != pSettings->enmUpdateLicense)
+            Info.pExpectedLicense++;
+    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))
+    {
+        if (Info.iLineCopyright == UINT32_MAX)
+            ScmError(pState, VERR_NOT_FOUND, "Missing copyright!\n");
+        else if (Info.iLineLicense == UINT32_MAX)
+            ScmError(pState, VERR_NOT_FOUND, "Missing license!\n");
+        else
+        {
+            /*
+             * Do we need to make any changes?
+             */
+            bool fUpdateCopyright = !Info.fWellFormedCopyright
+                                 || (!Info.fUpToDateCopyright && pSettings->fUpdateCopyrightYear);
+            bool fUpdateLicense   = Info.enmLicenceOpt != kScmLicense_LeaveAlone
+                                 && (   !Info.fWellFormedLicense
+                                     || !Info.fIsCorrectLicense);
+            if (fUpdateCopyright || fUpdateLicense)
+            {
+                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)
+                    {
+                        /* Leading blank line. */
+                        ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
+                                         g_aCopyrightCommentStart[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);
+
+                        /* Blank line separating the two. */
+                        ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
+                                         g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
+
+                        /* Write the license text. */
+                        Assert(Info.pExpectedLicense->psz[Info.pExpectedLicense->cch - 1] == '\n');
+                        Assert(Info.pExpectedLicense->psz[Info.pExpectedLicense->cch - 2] != '\n');
+                        const char *psz = Info.pExpectedLicense->psz;
+                        do
+                        {
+                            const char *pszEol = strchr(psz, '\n');
+                            if (pszEol != psz)
+                            {
+                                ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
+                                               g_aCopyrightCommentPrefix[enmCommentStyle].cch);
+                                ScmStreamWrite(pOut, psz, pszEol - psz);
+                                ScmStreamPutEol(pOut, enmEol);
+                            }
+                            else
+                                ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
+                                                 g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
+                            psz = pszEol + 1;
+                        } while (*psz != '\0');
+
+                        /* Final comment line (picking up the stream status here). */
+                        if (!Info.fExternalLicense)
+                            rc = ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
+                                                  g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
+                        else
+                            rc = ScmStreamGetStatus(pOut);
+
+                        /* Skip the copyright and license text in the input file. */
+                        if (RT_SUCCESS(rc))
+                        {
+                            iLine = Info.iLineComment + Info.cLinesComment;
+                            rc = ScmStreamSeekByLine(pIn, iLine);
+                        }
+                    }
+                    else
+                    {
+                        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+                        iLine++;
+                    }
+                    if (RT_FAILURE(rc))
+                        return false;
+                }
+                return true;
+            }
+        }
+    }
+    else
+        ScmError(pState, rc,  "ScmEnumerateComments: %Rrc\n", rc);
+    NOREF(pState); NOREF(pOut);
+    return false;
+}
+
+
+/** Copyright updater for C-style comments.   */
+bool 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.   */
+bool 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.   */
+bool rewrite_Copyright_RemComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, determinBatchFileCommentStyle(pIn));
+}
+
+/** Copyright updater for python comments.   */
+bool 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.   */
+bool rewrite_Copyright_SemicolonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Semicolon);
+}
+
 
 /**