Changeset 76551 in vbox

Timestamp:

Dec 31, 2018 5:09:06 AM (6 years ago)

Author:

vboxsync

Message:

scm: More work on header guard massaging (not active yet).

Location:

trunk/src/bldprogs

Files:

• scm.cpp (modified) (9 diffs)
• scm.h (modified) (1 diff)
• scmrw.cpp (modified) (9 diffs)
• scmstream.cpp (modified) (3 diffs)

trunk/src/bldprogs/scm.cpp

@@ -79 +79 @@
     SCMOPT_PRAGMA_ONCE,
     SCMOPT_NO_PRAGMA_ONCE,
+    SCMOPT_ENDIF_GUARD_COMMENT,
+    SCMOPT_NO_ENDIF_GUARD_COMMENT,
+    SCMOPT_GUARD_PREFIX,
+    SCMOPT_GUARD_RELATIVE_TO_DIR,
     SCMOPT_FIX_TODOS,
     SCMOPT_NO_FIX_TODOS,
@@ -181 +185 @@
     /* .fFixHeaderGuards = */                       true,
     /* .fPragmaOnce = */                            true,
+    /* .fEndifGuardComment = */                     true,
+    /* .pszGuardPrefix = */                         (char *)"VBOX_INCLUDED_",
+    /* .pszGuardRelativeToDir = */                  NULL,
     /* .fFixTodos = */                              true,
     /* .fFixErrH = */                               true,
@@ -225 +232 @@
     { "--pragma-once",                      SCMOPT_PRAGMA_ONCE,                     RTGETOPT_REQ_NOTHING },
     { "--no-pragma-once",                   SCMOPT_NO_PRAGMA_ONCE,                  RTGETOPT_REQ_NOTHING },
+    { "--endif-guard-comment",              SCMOPT_ENDIF_GUARD_COMMENT,             RTGETOPT_REQ_NOTHING },
+    { "--no-endif-guard-comment",           SCMOPT_NO_ENDIF_GUARD_COMMENT,          RTGETOPT_REQ_NOTHING },
+    { "--guard-prefix",                     SCMOPT_GUARD_PREFIX,                    RTGETOPT_REQ_STRING },
+    { "--guard-relative-to-dir",            SCMOPT_GUARD_RELATIVE_TO_DIR,           RTGETOPT_REQ_STRING },
     { "--fix-todos",                        SCMOPT_FIX_TODOS,                       RTGETOPT_REQ_NOTHING },
     { "--no-fix-todos",                     SCMOPT_NO_FIX_TODOS,                    RTGETOPT_REQ_NOTHING },
@@ -886 +897 @@
             if (RT_SUCCESS(rc))
             {
-                if (!pSrc->fFreeTreatAs)
-                    return VINF_SUCCESS;
-
-                pSettings->pTreatAs = scmCfgEntryDup(pSrc->pTreatAs);
-                if (pSettings->pTreatAs)
-                    return VINF_SUCCESS;
-
-                RTStrFree(pSettings->pszFilterOutDirs);
+                rc = RTStrDupEx(&pSettings->pszGuardPrefix, pSrc->pszGuardPrefix);
+                if (RT_SUCCESS(rc))
+                {
+                    if (pSrc->pszGuardRelativeToDir)
+                        rc = RTStrDupEx(&pSettings->pszGuardRelativeToDir, pSrc->pszGuardRelativeToDir);
+                    if (RT_SUCCESS(rc))
+                    {
+
+                        if (!pSrc->fFreeTreatAs)
+                            return VINF_SUCCESS;
+
+                        pSettings->pTreatAs = scmCfgEntryDup(pSrc->pTreatAs);
+                        if (pSettings->pTreatAs)
+                            return VINF_SUCCESS;
+
+                        RTStrFree(pSettings->pszGuardRelativeToDir);
+                    }
+                    RTStrFree(pSettings->pszGuardPrefix);
+                }
             }
             RTStrFree(pSettings->pszFilterOutFiles);
@@ -900 +922 @@
     }
 
+    pSettings->pszGuardRelativeToDir = NULL;
+    pSettings->pszGuardPrefix = NULL;
     pSettings->pszFilterFiles = NULL;
     pSettings->pszFilterOutFiles = NULL;
@@ -930 +954 @@
         pSettings->cchTab = UINT8_MAX;
 
+        RTStrFree(pSettings->pszGuardPrefix);
+        RTStrFree(pSettings->pszGuardRelativeToDir);
         RTStrFree(pSettings->pszFilterFiles);
         RTStrFree(pSettings->pszFilterOutFiles);
@@ -936 +962 @@
             scmCfgEntryDelete((PSCMCFGENTRY)pSettings->pTreatAs);
 
+        pSettings->pszGuardPrefix = NULL;
+        pSettings->pszGuardRelativeToDir = NULL;
         pSettings->pszFilterOutDirs = NULL;
         pSettings->pszFilterOutFiles = NULL;
@@ -1032 +1060 @@
         case SCMOPT_NO_PRAGMA_ONCE:
             pSettings->fPragmaOnce = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_ENDIF_GUARD_COMMENT:
+            pSettings->fEndifGuardComment = true;
+            return VINF_SUCCESS;
+        case SCMOPT_NO_ENDIF_GUARD_COMMENT:
+            pSettings->fEndifGuardComment = false;
+            return VINF_SUCCESS;
+
+        case SCMOPT_GUARD_PREFIX:
+            RTStrFree(pSettings->pszGuardPrefix);
+            pSettings->pszGuardPrefix = NULL;
+            return RTStrDupEx(&pSettings->pszGuardPrefix, pValueUnion->psz);
+
+        case SCMOPT_GUARD_RELATIVE_TO_DIR:
+            RTStrFree(pSettings->pszGuardRelativeToDir);
+            pSettings->pszGuardRelativeToDir = NULL;
+            if (*pValueUnion->psz != '\0')
+            {
+                if (cchDir == 1 && *pchDir == '/')
+                {
+                    pSettings->pszGuardRelativeToDir = RTPathAbsDup(pValueUnion->psz);
+                    if (pSettings->pszGuardRelativeToDir)
+                        return VINF_SUCCESS;
+                }
+                else
+                {
+                    char *pszDir = RTStrDupN(pchDir, cchDir);
+                    if (pszDir)
+                    {
+                        pSettings->pszGuardRelativeToDir = RTPathAbsExDup(pszDir, pValueUnion->psz);
+                        RTStrFree(pszDir);
+                        if (pSettings->pszGuardRelativeToDir)
+                            return VINF_SUCCESS;
+                    }
+                }
+                RTMsgError("Failed to abspath --guard-relative-to-dir value '%s' - probably out of memory\n", pValueUnion->psz);
+                return VERR_NO_STR_MEMORY;
+            }
             return VINF_SUCCESS;
 
@@ -2708 +2775 @@
                 RTPrintf("      Whether to include #pragma once with the header guard.  Default: %RTbool\n", g_Defaults.fPragmaOnce);
                 break;
+            case SCMOPT_ENDIF_GUARD_COMMENT:
+                RTPrintf("      Put a comment on the header guard #endif or not.  Default: %RTbool\n", g_Defaults.fEndifGuardComment);
+                break;
+            case SCMOPT_GUARD_RELATIVE_TO_DIR:
+                RTPrintf("      Header guard should be normalized relative to given dir.\n"
+                         "      If empty no normalization takes place.  Default: '%s'\n", g_Defaults.pszGuardRelativeToDir);
+                break;
+            case SCMOPT_GUARD_PREFIX:
+                RTPrintf("      Prefix to use with --guard-relative-to-dir.  Default: %s\n", g_Defaults.pszGuardPrefix);
+                break;
             case SCMOPT_FIX_TODOS:
                 RTPrintf("      Fix @todo statements so doxygen sees them.  Default: %RTbool\n", g_Defaults.fFixTodos);

trunk/src/bldprogs/scm.h

@@ -338 +338 @@
     /** Whether to include a pragma once statement with the header guard. */
     bool            fPragmaOnce;
+    /** Whether to add a comment on the \#endif part of the header guard. */
+    bool            fEndifGuardComment;
+    /** The guard name prefix.   */
+    char           *pszGuardPrefix;
+    /** Header guards should be normalized using prefix and this directory.
+     * When NULL the guard identifiers found in the header is preserved. */
+    char           *pszGuardRelativeToDir;
 
     /** Whether to fix C/C++ todos. */

trunk/src/bldprogs/scmrw.cpp

@@ -2862 +2862 @@
         return false;
 
-    int rc;
-    bool fRet = false;
     RTERRINFOSTATIC ErrInfo;
+    char            szNormalized[168];
+    size_t          cchNormalized;
+    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);
+        rc = RTPathCalcRelative(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized,
+                                pSettings->pszGuardRelativeToDir, 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++;
+        }
+    }
 
     /*
@@ -2872 +2898 @@
      * and will be upset if this isn't the case.
      */
+    RTSTRTUPLE  Guard       = { NULL, 0 };
     uint32_t    cBlankLines = 0;
     SCMEOL      enmEol;
@@ -2895 +2922 @@
                     { RT_STR_TUPLE(""),                 0, true, false },
                 };
-                RTSTRTUPLE Guard;
                 rc = ScmMatchWords(pchLine, cchLine, s_aIfndefGuard, RT_ELEMENTS(s_aIfndefGuard),
                                    NULL /*poffNext*/, &Guard, RTErrInfoInitStatic(&ErrInfo));
@@ -2902 +2928 @@
                                     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);
+                ScmVerbose(pState, 3, "line %u in %s: #ifndef %.*s\n",
+                           ScmStreamTellLine(pIn) - 1, pState->pszFilename, Guard.cch, Guard.psz);
 
                 /* #define xxxx */
@@ -2924 +2951 @@
                 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')
+                {
+                    fRet = Guard.cch != cchNormalized || memcmp(Guard.psz, szNormalized, cchNormalized) != 0;
+                    Guard.psz = szNormalized;
+                    Guard.cch = cchNormalized;
+                }
+
                 /*
                  * Write guard, making sure we've got a single blank line preceeding it.
@@ -3046 +3084 @@
      * looking for the last #endif in the file.
      */
-    size_t iEndIf = 0;
+    size_t iEndIfIn = 0;
+    size_t iEndIfOut = 0;
     while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
     {
@@ -3059 +3098 @@
                     off++;
                 /* #pragma once */
-                if (off + sizeof("pragma") < cchLine && !memcmp(&pchLine[off], RT_STR_TUPLE("pragma")))
+                if (   off + sizeof("pragma") - 1 <= cchLine
+                    && !memcmp(&pchLine[off], RT_STR_TUPLE("pragma")))
                 {
                     rc = ScmMatchWords(pchLine, cchLine, s_aPragmaOnce, RT_ELEMENTS(s_aPragmaOnce),
@@ -3070 +3110 @@
                 }
                 /* #endif */
-                else if (off + sizeof("endif") < cchLine && !memcmp(&pchLine[off], RT_STR_TUPLE("endif")))
-                    iEndIf = ScmStreamTellLine(pOut);
+                else if (   off + sizeof("endif") - 1 <= cchLine
+                         && !memcmp(&pchLine[off], RT_STR_TUPLE("endif")))
+                {
+                    iEndIfIn  = ScmStreamTellLine(pIn) - 1;
+                    iEndIfOut = ScmStreamTellLine(pOut);
+                }
             }
         }
@@ -3084 +3128 @@
      * right kind of comment following it.
      */
-    /** @todo \#endif */
+#if 0
+    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 false;
+    rc = ScmStreamSeekByLine(pOut, iEndIfOut);
+    if (RT_FAILURE(rc))
+        return false;
+
+    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 false;
+
+    /* 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 false;
+    }
+#else
+    RT_NOREF(iEndIfOut, iEndIfIn);
+#endif
 
     return fRet;

trunk/src/bldprogs/scmstream.cpp

@@ -629 +629 @@
 int ScmStreamSeekByLine(PSCMSTREAM pStream, size_t iLine)
 {
-    AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
     if (RT_FAILURE(pStream->rc))
         return pStream->rc;
@@ -636 +635 @@
     if (RT_UNLIKELY(!pStream->fFullyLineated))
     {
+        AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
         int rc = scmStreamLineate(pStream);
         if (RT_FAILURE(rc))
@@ -644 +644 @@
     if (iLine < pStream->cLines)
     {
+        pStream->iLine = iLine;
         pStream->off   = pStream->paLines[iLine].off;
-        pStream->iLine = iLine;
+        if (pStream->fWriteOrRead)
+        {
+            pStream->cb     = pStream->paLines[iLine].off;
+            pStream->cLines = iLine;
+            pStream->paLines[iLine].cch    = 0;
+            pStream->paLines[iLine].enmEol = SCMEOL_NONE;
+        }
     }
     else
     {
+        AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
         pStream->off   = pStream->cb;
         pStream->iLine = pStream->cLines;