Changeset 76506 in vbox

Timestamp:

Dec 30, 2018 3:41:21 AM (6 years ago)

Author:

vboxsync

Message:

scm: Header guard massaging for adding #pragma once. bugref:9344

Location:

trunk/src/bldprogs

Files:

• VBoxTpG.cpp (modified) (1 diff)
• scm.cpp (modified) (8 diffs)
• scm.h (modified) (3 diffs)
• scmrw.cpp (modified) (7 diffs)
• scmstream.cpp (modified) (1 diff)

trunk/src/bldprogs/VBoxTpG.cpp

@@ -969 +969 @@
                     "#ifndef %s\n"
                     "#define %s\n"
+                    "#ifndef RT_WITHOUT_PRAGMA_ONCE\n"
+                    "# pragma once\n"
+                    "#endif\n"
                     "\n"
                     "#include <VBox/VBoxTpG.h>\n"

trunk/src/bldprogs/scm.cpp

@@ -75 +75 @@
     SCMOPT_FIX_FLOWER_BOX_MARKERS,
     SCMOPT_NO_FIX_FLOWER_BOX_MARKERS,
+    SCMOPT_FIX_HEADER_GUARDS,
+    SCMOPT_NO_FIX_HEADER_GUARDS,
     SCMOPT_FIX_TODOS,
     SCMOPT_NO_FIX_TODOS,
@@ -175 +177 @@
     /* .fFixFlowerBoxMarkers = */                   true,
     /* .cMinBlankLinesBeforeFlowerBoxMakers = */    2,
+    /* .fFixHeaderGuards = */                       false, /** @todo fFixHeaderGuards = true */
     /* .fFixTodos = */                              true,
     /* .fFixErrH = */                               true,
@@ -215 +218 @@
     { "--fix-flower-box-markers",           SCMOPT_FIX_FLOWER_BOX_MARKERS,          RTGETOPT_REQ_NOTHING },
     { "--no-fix-flower-box-markers",        SCMOPT_NO_FIX_FLOWER_BOX_MARKERS,       RTGETOPT_REQ_NOTHING },
+    { "--fix-header-guards",                SCMOPT_FIX_HEADER_GUARDS,               RTGETOPT_REQ_NOTHING },
+    { "--no-fix-header-guards",             SCMOPT_NO_FIX_HEADER_GUARDS,            RTGETOPT_REQ_NOTHING },
     { "--fix-todos",                        SCMOPT_FIX_TODOS,                       RTGETOPT_REQ_NOTHING },
     { "--no-fix-todos",                     SCMOPT_NO_FIX_TODOS,                    RTGETOPT_REQ_NOTHING },
@@ -289 +294 @@
 SCM_REWRITER_CFG(g_Makefile_kmk,                    "makefile-kmk",                 rewrite_Makefile_kmk);
 SCM_REWRITER_CFG(g_FixFlowerBoxMarkers,             "fix-flower-boxes",             rewrite_FixFlowerBoxMarkers);
+SCM_REWRITER_CFG(g_FixHeaderGuards,                 "fix-header-guard",             rewrite_FixHeaderGuards);
 SCM_REWRITER_CFG(g_Fix_C_and_CPP_Todos,             "fix-c-todos",                  rewrite_Fix_C_and_CPP_Todos);
 SCM_REWRITER_CFG(g_Fix_Err_H,                       "fix-err-h",                    rewrite_Fix_Err_H);
@@ -318 +324 @@
     &g_Makefile_kmk,
     &g_FixFlowerBoxMarkers,
+    &g_FixHeaderGuards,
     &g_Fix_C_and_CPP_Todos,
     &g_Fix_Err_H,
@@ -380 +387 @@
     &g_SvnSyncProcess,
     &g_Copyright_CstyleComment,
+    /// @todo &g_FixFlowerBoxMarkers,
+    &g_FixHeaderGuards,
     &g_C_and_CPP
 };
@@ -1004 +1013 @@
         case SCMOPT_NO_FIX_FLOWER_BOX_MARKERS:
             pSettings->fFixFlowerBoxMarkers = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_FIX_HEADER_GUARDS:
+            pSettings->fFixHeaderGuards = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_FIX_HEADER_GUARDS:
+            pSettings->fFixHeaderGuards = false;
             return VINF_SUCCESS;
 
@@ -2674 +2690 @@
             case SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS: RTPrintf("      Default: %u\n", g_Defaults.cMinBlankLinesBeforeFlowerBoxMakers); break;
 
+            case SCMOPT_FIX_HEADER_GUARDS:
+                RTPrintf("      Fix header guards and #pragma once.  Default: %RTbool\n", g_Defaults.fFixHeaderGuards);
+                break;
             case SCMOPT_FIX_TODOS:
                 RTPrintf("      Fix @todo statements so doxygen sees them.  Default: %RTbool\n", g_Defaults.fFixTodos);

trunk/src/bldprogs/scm.h

@@ -187 +187 @@
  * @sa      vbcppIsCIdentifierChar
  */
-DECLINLINE(bool) scmIsCIdentifierChar(char ch)
+DECLINLINE(bool) ScmIsCIdentifierChar(char ch)
 {
     return RT_C_IS_ALNUM(ch)
@@ -260 +260 @@
 FNSCMREWRITER rewrite_Fix_C_and_CPP_Todos;
 FNSCMREWRITER rewrite_Fix_Err_H;
+FNSCMREWRITER rewrite_FixHeaderGuards;
 FNSCMREWRITER rewrite_C_and_CPP;
 
@@ -330 +331 @@
     /** The minimum number of blank lines we want before flowerbox markers. */
     uint8_t         cMinBlankLinesBeforeFlowerBoxMakers;
+
+    /** Whether to fix C/C++ header guards and \#pragma once directives. */
+    bool            fFixHeaderGuards;
 
     /** Whether to fix C/C++ todos. */

trunk/src/bldprogs/scmrw.cpp

@@ -2406 +2406 @@
 
 
-
 /**
  * Tries to parse a C/C++ preprocessor include directive.
@@ -2469 +2468 @@
                         return chFirst == '"' ? kScmIncludeDir_Quoted : kScmIncludeDir_Bracketed;
                     }
-                    ScmError(pState,  VERR_PARSE_ERROR, "Unbalanced #include filename %s: %.*s\n",
+                    ScmError(pState, VERR_PARSE_ERROR, "Unbalanced #include filename %s: %.*s\n",
                              chFirst == '"' ? "quotes" : "brackets" , cchLine, pchLine);
                 }
@@ -2477 +2476 @@
                     size_t cchFilename = 1;
                     while (   cchFilename < cchLine
-                           && scmIsCIdentifierChar(pchLine[cchFilename]))
+                           && ScmIsCIdentifierChar(pchLine[cchFilename]))
                         cchFilename++;
                     if (ppchFilename)
@@ -2486 +2485 @@
                 }
                 else
-                    ScmError(pState,  VERR_PARSE_ERROR, "Malformed #include filename part: %.*s\n", cchLine, pchLine);
+                    ScmError(pState, VERR_PARSE_ERROR, "Malformed #include filename part: %.*s\n", cchLine, pchLine);
             }
             else
-                ScmError(pState,  VERR_PARSE_ERROR, "Missing #include filename!\n");
+                ScmError(pState, VERR_PARSE_ERROR, "Missing #include filename!\n");
         }
     }
@@ -2659 +2658 @@
                 if (    pchHit[4] == '_'
                     && (   pchHit == pchLine
-                        || !scmIsCIdentifierChar(pchHit[-1]))
+                        || !ScmIsCIdentifierChar(pchHit[-1]))
                     && (   (pchHit[1] == 'E' && pchHit[2] == 'R' && pchHit[3] == 'R')
                         || (pchHit[1] == 'W' && pchHit[2] == 'R' && pchHit[3] == 'N')
@@ -2665 +2664 @@
                 {
                     size_t cchIdentifier = 5;
-                    while (cchIdentifier < cchLeftHit && scmIsCIdentifierChar(pchHit[cchIdentifier]))
+                    while (cchIdentifier < cchLeftHit && ScmIsCIdentifierChar(pchHit[cchIdentifier]))
                         cchIdentifier++;
                     ScmVerbose(pState, 4, "--- status code at %u col %zu: %.*s\n",
@@ -2751 +2750 @@
 }
 
+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 true if modifications were made, false if not.
+ * @param   pIn                 The input stream.
+ * @param   pOut                The output stream.
+ * @param   pSettings           The settings.
+ */
+bool rewrite_FixHeaderGuards(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
+{
+    if (!pSettings->fFixHeaderGuards)
+        return false;
+
+    int rc;
+    bool fRet = false;
+    RTERRINFOSTATIC ErrInfo;
+
+    /*
+     * 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.
+     */
+    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 },
+                };
+                RTSTRTUPLE Guard;
+                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, 2, "line %u: #ifndef %.*s\n", ScmStreamTellLine(pIn) - 1, 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;
+
+                /*
+                 * 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 false;
+                break;
+            }
+        }
+
+        if (!isBlankLine(pchLine, cchLine))
+        {
+            while (cBlankLines-- > 0)
+                ScmStreamPutEol(pOut, enmEol);
+            cBlankLines = 0;
+            rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+            if (RT_FAILURE(rc))
+                return false;
+        }
+        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"),                   0, 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");
+    }
+    else
+    {
+        rc = ScmStreamSeekByLine(pIn, iPragmaOnce);
+        if (RT_FAILURE(rc))
+            return ScmError(pState, rc, "seek error\n");
+        fRet = true;
+        ScmVerbose(pState, 2, "Missing #pragma once\n");
+    }
+
+    /*
+     * Write the pragma once stuff.
+     */
+    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 false;
+
+    /*
+     * Copy the rest of the file and remove pragma once statements, while
+     * looking for the last #endif in the file.
+     */
+    size_t iEndIf = 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") < 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") < cchLine && !memcmp(&pchLine[off], RT_STR_TUPLE("endif")))
+                    iEndIf = ScmStreamTellLine(pOut);
+            }
+        }
+
+        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
+        if (RT_FAILURE(rc))
+            return false;
+    }
+
+    /*
+     * Check out the last endif, making sure it's well formed and make sure it has the
+     * right kind of comment following it.
+     */
+    /** @todo \#endif */
+
+    return fRet;
+}
+
+
 /**
  * Rewrite a C/C++ source or header file.

trunk/src/bldprogs/scmstream.cpp

@@ -241 +241 @@
     pStream->fFullyLineated = true;
     pStream->rc             = VINF_SUCCESS;
+
+    /* Initialize the first line with a zero length so ScmStreamWrite won't misbehave. */
+    if (pStream->cLinesAllocated == 0)
+        scmStreamGrowLines(pStream, 1);
+    if (pStream->cLinesAllocated > 0)
+    {
+        pStream->paLines[0].off    = 0;
+        pStream->paLines[0].cch    = 0;
+        pStream->paLines[0].enmEol = SCMEOL_NONE;
+    }
 }