VirtualBox

Changeset 69166 in vbox for trunk/src/bldprogs


Ignore:
Timestamp:
Oct 23, 2017 3:43:33 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
118477
Message:

scm: License and copyright updating.

Location:
trunk/src/bldprogs
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bldprogs/Makefile.kmk

    r69111 r69166  
    4040        scmdiff.cpp \
    4141        scmrw.cpp \
     42       scmparser.cpp \
    4243        scmstream.cpp \
    4344        scmsubversion.cpp

  • trunk/src/bldprogs/scm.cpp

    r69110 r69166  
    7777    SCMOPT_FIX_TODOS,
    7878    SCMOPT_NO_FIX_TODOS,
     79    SCMOPT_UPDATE_COPYRIGHT_YEAR,
     80    SCMOPT_NO_UPDATE_COPYRIGHT_YEAR,
     81    SCMOPT_NO_UPDATE_LICENSE,
     82    SCMOPT_LICENSE_OSE_GPL,
     83    SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL,
     84    SCMOPT_LICENSE_LGPL,
     85    SCMOPT_LICENSE_MIT,
    7986    SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS,
    8087    SCMOPT_ONLY_SVN_DIRS,
    … …  
    129136static bool         g_fDiffIgnoreTrailingWS = false;
    130137static int          g_iVerbosity            = 2;//99; //0;
     138uint32_t            g_uYear                 = 0; /**< The current year. */
    131139
    132140/** The global settings. */
    … …  
    142150    /* .cMinBlankLinesBeforeFlowerBoxMakers = */    2,
    143151    /* .fFixTodos = */                              true,
     152    /* .fUpdateCopyrightYear = */                   false,
     153    /* .enmUpdateLicense = */                       kScmLicense_OseGpl,
    144154    /* .fOnlySvnFiles = */                          false,
    145155    /* .fOnlySvnDirs = */                           false,
    … …  
    169179    { "--strip-trailing-lines",             SCMOPT_STRIP_TRAILING_LINES,            RTGETOPT_REQ_NOTHING },
    170180    { "--strip-no-trailing-lines",          SCMOPT_NO_STRIP_TRAILING_LINES,         RTGETOPT_REQ_NOTHING },
    171     { "--min-blank-lines-before-flower-box-makers", SCMOPT_FIX_FLOWER_BOX_MARKERS,  RTGETOPT_REQ_UINT8 },
     181    { "--min-blank-lines-before-flower-box-makers", SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS,  RTGETOPT_REQ_UINT8 },
    172182    { "--fix-flower-box-markers",           SCMOPT_FIX_FLOWER_BOX_MARKERS,          RTGETOPT_REQ_NOTHING },
    173183    { "--no-fix-flower-box-markers",        SCMOPT_NO_FIX_FLOWER_BOX_MARKERS,       RTGETOPT_REQ_NOTHING },
    174184    { "--fix-todos",                        SCMOPT_FIX_TODOS,                       RTGETOPT_REQ_NOTHING },
    175185    { "--no-fix-todos",                     SCMOPT_NO_FIX_TODOS,                    RTGETOPT_REQ_NOTHING },
     186    { "--update-copyright-year",            SCMOPT_UPDATE_COPYRIGHT_YEAR,           RTGETOPT_REQ_NOTHING },
     187    { "--no-update-copyright-year",         SCMOPT_NO_UPDATE_COPYRIGHT_YEAR,        RTGETOPT_REQ_NOTHING },
     188    { "--no-update-license",                SCMOPT_NO_UPDATE_LICENSE,               RTGETOPT_REQ_NOTHING },
     189    { "--license-ose-gpl",                  SCMOPT_LICENSE_OSE_GPL,                 RTGETOPT_REQ_NOTHING },
     190    { "--license-ose-dual",                 SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL,       RTGETOPT_REQ_NOTHING },
     191    { "--license-lgpl",                     SCMOPT_LICENSE_LGPL,                    RTGETOPT_REQ_NOTHING },
     192    { "--license-mit",                      SCMOPT_LICENSE_MIT,                     RTGETOPT_REQ_NOTHING },
    176193    { "--only-svn-dirs",                    SCMOPT_ONLY_SVN_DIRS,                   RTGETOPT_REQ_NOTHING },
    177194    { "--not-only-svn-dirs",                SCMOPT_NOT_ONLY_SVN_DIRS,               RTGETOPT_REQ_NOTHING },
    … …  
    207224    rewrite_SvnNoExecutable,
    208225    rewrite_SvnKeywords,
     226    rewrite_Copyright_HashComment,
    209227    rewrite_Makefile_kmk
    210228};
    … …  
    218236    rewrite_SvnNoExecutable,
    219237    rewrite_SvnKeywords,
     238    rewrite_Copyright_CstyleComment,
    220239    rewrite_FixFlowerBoxMarkers,
    221240    rewrite_Fix_C_and_CPP_Todos,
    … …  
    230249    rewrite_AdjustTrailingLines,
    231250    rewrite_SvnNoExecutable,
     251    rewrite_Copyright_CstyleComment,
    232252    rewrite_C_and_CPP
    233253};
    … …  
    240260    rewrite_AdjustTrailingLines,
    241261    rewrite_SvnNoExecutable,
    242     rewrite_SvnKeywords
     262    rewrite_SvnKeywords,
     263    rewrite_Copyright_CstyleComment,
    243264};
    244265
    … …  
    250271    rewrite_AdjustTrailingLines,
    251272    rewrite_SvnNoExecutable,
    252     rewrite_SvnKeywords
     273    rewrite_SvnKeywords,
     274    rewrite_Copyright_SemicolonComment,
    253275};
    254276
    … …  
    257279    rewrite_ForceLF,
    258280    rewrite_ExpandTabs,
    259     rewrite_StripTrailingBlanks
     281    rewrite_StripTrailingBlanks,
     282    rewrite_Copyright_HashComment,
    260283};
    261284
    … …  
    264287    rewrite_ForceCRLF,
    265288    rewrite_ExpandTabs,
    266     rewrite_StripTrailingBlanks
     289    rewrite_StripTrailingBlanks,
     290    rewrite_Copyright_RemComment,
    267291};
    268292
    … …  
    271295    rewrite_ForceLF,
    272296    rewrite_ExpandTabs,
    273     rewrite_StripTrailingBlanks
     297    rewrite_StripTrailingBlanks,
     298    rewrite_Copyright_HashComment,
    274299};
    275300
    … …  
    280305    rewrite_StripTrailingBlanks,
    281306    rewrite_AdjustTrailingLines,
    282     rewrite_SvnKeywords
     307    rewrite_SvnKeywords,
     308    rewrite_Copyright_PythonComment,
    283309};
    284310
    … …  
    438464        case SCMOPT_NO_FIX_FLOWER_BOX_MARKERS:
    439465            pSettings->fFixFlowerBoxMarkers = false;
     466            return VINF_SUCCESS;
     467
     468        case SCMOPT_UPDATE_COPYRIGHT_YEAR:
     469            pSettings->fUpdateCopyrightYear = true;
     470            return VINF_SUCCESS;
     471        case SCMOPT_NO_UPDATE_COPYRIGHT_YEAR:
     472            pSettings->fUpdateCopyrightYear = false;
     473            return VINF_SUCCESS;
     474
     475        case SCMOPT_NO_UPDATE_LICENSE:
     476            pSettings->enmUpdateLicense = kScmLicense_LeaveAlone;
     477            return VINF_SUCCESS;
     478        case SCMOPT_LICENSE_OSE_GPL:
     479            pSettings->enmUpdateLicense = kScmLicense_OseGpl;
     480            return VINF_SUCCESS;
     481        case SCMOPT_LICENSE_OSE_DUAL_GPL_CDDL:
     482            pSettings->enmUpdateLicense = kScmLicense_OseDualGplCddl;
     483            return VINF_SUCCESS;
     484        case SCMOPT_LICENSE_LGPL:
     485            pSettings->enmUpdateLicense = kScmLicense_Lgpl;
     486            return VINF_SUCCESS;
     487        case SCMOPT_LICENSE_MIT:
     488            pSettings->enmUpdateLicense = kScmLicense_Mit;
    440489            return VINF_SUCCESS;
    441490
    … …  
    10551104        }
    10561105    }
     1106}
     1107
     1108
     1109/**
     1110 * Prints an error message.
     1111 *
     1112 * @returns false
     1113 * @param   pState              The rewrite state.  Optional.
     1114 * @param   rc                  The error code.
     1115 * @param   pszFormat           The message format string.
     1116 * @param   ...                 Format arguments.
     1117 */
     1118bool ScmError(PSCMRWSTATE pState, int rc, const char *pszFormat, ...)
     1119{
     1120    if (RT_SUCCESS(pState->rc))
     1121        pState->rc = rc;
     1122
     1123    if (!pState->fFirst)
     1124    {
     1125        RTPrintf("%s: info: --= Rewriting '%s' =--\n", g_szProgName, pState->pszFilename);
     1126        pState->fFirst = true;
     1127    }
     1128    va_list va;
     1129    va_start(va, pszFormat);
     1130    RTPrintf("%s: error: %s: %N", g_szProgName, pState->pszFilename, pszFormat, &va);
     1131    va_end(va);
     1132
     1133    return false;
    10571134}
    10581135
    … …  
    11581235                    for (size_t iRw = 0; iRw < pCfg->cRewriters; iRw++)
    11591236                    {
     1237                        pState->rc = VINF_SUCCESS;
    11601238                        bool fRc = pCfg->papfnRewriter[iRw](pState, pIn, pOut, pBaseSettings);
     1239                        if (RT_FAILURE(pState->rc))
     1240                            break;
    11611241                        if (fRc)
    11621242                        {
    … …  
    11661246                            fModified = true;
    11671247                        }
     1248
    11681249                        ScmStreamRewindForReading(pIn);
    11691250                        ScmStreamRewindForWriting(pOut);
    11701251                    }
    11711252
    1172                     rc = ScmStreamGetStatus(&Stream1);
    1173                     if (RT_SUCCESS(rc))
    1174                         rc = ScmStreamGetStatus(&Stream2);
    1175                     if (RT_SUCCESS(rc))
    1176                         rc = ScmStreamGetStatus(&Stream3);
     1253                    rc = pState->rc;
    11771254                    if (RT_SUCCESS(rc))
    11781255                    {
    1179                         /*
    1180                          * If rewritten, write it back to disk.
    1181                          */
    1182                         if (fModified)
     1256                        rc = ScmStreamGetStatus(&Stream1);
     1257                        if (RT_SUCCESS(rc))
     1258                            rc = ScmStreamGetStatus(&Stream2);
     1259                        if (RT_SUCCESS(rc))
     1260                            rc = ScmStreamGetStatus(&Stream3);
     1261                        if (RT_SUCCESS(rc))
    11831262                        {
    1184                             if (!g_fDryRun)
     1263                            /*
     1264                             * If rewritten, write it back to disk.
     1265                             */
     1266                            if (fModified)
    11851267                            {
    1186                                 ScmVerbose(pState, 1, "writing modified file to \"%s%s\"\n", pszFilename, g_pszChangedSuff);
    1187                                 rc = ScmStreamWriteToFile(pIn, "%s%s", pszFilename, g_pszChangedSuff);
    1188                                 if (RT_FAILURE(rc))
    1189                                     RTMsgError("Error writing '%s%s': %Rrc\n", pszFilename, g_pszChangedSuff, rc);
     1268                                if (!g_fDryRun)
     1269                                {
     1270                                    ScmVerbose(pState, 1, "writing modified file to \"%s%s\"\n", pszFilename, g_pszChangedSuff);
     1271                                    rc = ScmStreamWriteToFile(pIn, "%s%s", pszFilename, g_pszChangedSuff);
     1272                                    if (RT_FAILURE(rc))
     1273                                        RTMsgError("Error writing '%s%s': %Rrc\n", pszFilename, g_pszChangedSuff, rc);
     1274                                }
     1275                                else
     1276                                {
     1277                                    ScmVerbose(pState, 1, NULL);
     1278                                    ScmDiffStreams(pszFilename, &Stream1, pIn, g_fDiffIgnoreEol,
     1279                                                   g_fDiffIgnoreLeadingWS, g_fDiffIgnoreTrailingWS, g_fDiffSpecialChars,
     1280                                                   pBaseSettings->cchTab, g_pStdOut);
     1281                                    ScmVerbose(pState, 2, "would have modified the file \"%s%s\"\n",
     1282                                               pszFilename, g_pszChangedSuff);
     1283                                }
    11901284                            }
    1191                             else
     1285
     1286                            /*
     1287                             * If pending SVN property changes, apply them.
     1288                             */
     1289                            if (pState->cSvnPropChanges && RT_SUCCESS(rc))
    11921290                            {
    1193                                 ScmVerbose(pState, 1, NULL);
    1194                                 ScmDiffStreams(pszFilename, &Stream1, pIn, g_fDiffIgnoreEol, g_fDiffIgnoreLeadingWS,
    1195                                                g_fDiffIgnoreTrailingWS, g_fDiffSpecialChars, pBaseSettings->cchTab, g_pStdOut);
    1196                                 ScmVerbose(pState, 2, "would have modified the file \"%s%s\"\n", pszFilename, g_pszChangedSuff);
     1291                                if (!g_fDryRun)
     1292                                {
     1293                                    rc = ScmSvnApplyChanges(pState);
     1294                                    if (RT_FAILURE(rc))
     1295                                        RTMsgError("%s: failed to apply SVN property changes (%Rrc)\n", pszFilename, rc);
     1296                                }
     1297                                else
     1298                                    ScmSvnDisplayChanges(pState);
    11971299                            }
     1300
     1301                            if (!fModified && !pState->cSvnPropChanges)
     1302                                ScmVerbose(pState, 3, "no change\n", pszFilename);
    11981303                        }
    1199 
    1200                         /*
    1201                          * If pending SVN property changes, apply them.
    1202                          */
    1203                         if (pState->cSvnPropChanges && RT_SUCCESS(rc))
    1204                         {
    1205                             if (!g_fDryRun)
    1206                             {
    1207                                 rc = ScmSvnApplyChanges(pState);
    1208                                 if (RT_FAILURE(rc))
    1209                                     RTMsgError("%s: failed to apply SVN property changes (%Rrc)\n", pszFilename, rc);
    1210                             }
    1211                             else
    1212                                 ScmSvnDisplayChanges(pState);
    1213                         }
    1214 
    1215                         if (!fModified && !pState->cSvnPropChanges)
    1216                             ScmVerbose(pState, 3, "no change\n", pszFilename);
     1304                        else
     1305                            RTMsgError("%s: stream error %Rrc\n", pszFilename, rc);
    12171306                    }
    1218                     else
    1219                         RTMsgError("%s: stream error %Rrc\n", pszFilename, rc);
    12201307                    ScmStreamDelete(&Stream3);
    12211308                }
    … …  
    12621349        State.cSvnPropChanges  = 0;
    12631350        State.paSvnPropChanges = NULL;
     1351        State.rc               = VINF_SUCCESS;
    12641352
    12651353        rc = scmProcessFileInner(&State, pszFilename, pszBasename, cchBasename, &Base);
    … …  
    15031591    for (size_t i = 0; i < cOpts; i++)
    15041592    {
    1505         bool fAdvanceTwo = false;
     1593        size_t cExtraAdvance = 0;
    15061594        if ((paOpts[i].fFlags & RTGETOPT_REQ_MASK) == RTGETOPT_REQ_NOTHING)
    15071595        {
    1508             fAdvanceTwo = i + 1 < cOpts
    1509                        && (   strstr(paOpts[i+1].pszLong, "-no-") != NULL
    1510                            || strstr(paOpts[i+1].pszLong, "-not-") != NULL
    1511                            || strstr(paOpts[i+1].pszLong, "-dont-") != NULL
    1512                            || (paOpts[i].iShort == 'q' && paOpts[i+1].iShort == 'v')
    1513                            || (paOpts[i].iShort == 'd' && paOpts[i+1].iShort == 'D')
    1514                           );
    1515             if (fAdvanceTwo)
     1596            cExtraAdvance = i + 1 < cOpts
     1597                         && (   strstr(paOpts[i+1].pszLong, "-no-") != NULL
     1598                             || strstr(paOpts[i+1].pszLong, "-not-") != NULL
     1599                             || strstr(paOpts[i+1].pszLong, "-dont-") != NULL
     1600                             || (paOpts[i].iShort == 'q' && paOpts[i+1].iShort == 'v')
     1601                             || (paOpts[i].iShort == 'd' && paOpts[i+1].iShort == 'D')
     1602                            );
     1603            if (cExtraAdvance)
    15161604                RTPrintf("  %s, %s\n", paOpts[i].pszLong, paOpts[i + 1].pszLong);
     1605            else if (paOpts[i].iShort != SCMOPT_NO_UPDATE_LICENSE)
     1606                RTPrintf("  %s\n", paOpts[i].pszLong);
    15171607            else
    1518                 RTPrintf("  %s\n", paOpts[i].pszLong);
     1608            {
     1609                RTPrintf("  %s,\n"
     1610                         "  %s,\n"
     1611                         "  %s,\n"
     1612                         "  %s,\n"
     1613                         "  %s\n",
     1614                         paOpts[i].pszLong,
     1615                         paOpts[i + 1].pszLong,
     1616                         paOpts[i + 2].pszLong,
     1617                         paOpts[i + 3].pszLong,
     1618                         paOpts[i + 4].pszLong);
     1619                cExtraAdvance = 4;
     1620            }
    15191621        }
    15201622        else if ((paOpts[i].fFlags & RTGETOPT_REQ_MASK) == RTGETOPT_REQ_STRING)
    … …  
    15431645            case SCMOPT_STRIP_TRAILING_LINES:   RTPrintf("      Default: %RTbool\n", g_Defaults.fStripTrailingLines); break;
    15441646            case SCMOPT_FIX_FLOWER_BOX_MARKERS: RTPrintf("      Default: %RTbool\n", g_Defaults.fFixFlowerBoxMarkers); break;
    1545             case SCMOPT_FIX_TODOS:              RTPrintf("      Default: %RTbool\n", g_Defaults.fFixTodos); break;
    15461647            case SCMOPT_MIN_BLANK_LINES_BEFORE_FLOWER_BOX_MARKERS: RTPrintf("      Default: %u\n", g_Defaults.cMinBlankLinesBeforeFlowerBoxMakers); break;
     1648
     1649            case SCMOPT_FIX_TODOS:
     1650                RTPrintf("      Fix @todo statements so doxygen sees them.  Default: %RTbool\n", g_Defaults.fFixTodos);
     1651                break;
     1652            case SCMOPT_UPDATE_COPYRIGHT_YEAR:
     1653                RTPrintf("      Update the copyright year.  Default: %RTbool\n", g_Defaults.fUpdateCopyrightYear);
     1654                break;
     1655            case SCMOPT_NO_UPDATE_LICENSE:
     1656                RTPrintf("      License selection.  Default: --license-ose-gpl\n");
     1657                break;
     1658
    15471659            case SCMOPT_ONLY_SVN_DIRS:          RTPrintf("      Default: %RTbool\n", g_Defaults.fOnlySvnDirs); break;
    15481660            case SCMOPT_ONLY_SVN_FILES:         RTPrintf("      Default: %RTbool\n", g_Defaults.fOnlySvnFiles); break;
    … …  
    15571669            default: AssertMsgFailed(("i=%d %d %s\n", i, paOpts[i].iShort, paOpts[i].pszLong));
    15581670        }
    1559         i += fAdvanceTwo;
     1671        i += cExtraAdvance;
    15601672    }
    15611673
    … …  
    15671679    if (RT_FAILURE(rc))
    15681680        return 1;
     1681
     1682    /*
     1683     * Init the current year.
     1684     */
     1685    RTTIMESPEC  Now;
     1686    RTTIME      Time;
     1687    RTTimeExplode(&Time, RTTimeNow(&Now));
     1688    g_uYear = Time.i32Year;
    15691689
    15701690    /*

  • trunk/src/bldprogs/scm.h

    r63559 r69166  
    6262
    6363
     64/** @name Code Parsing
     65 * @{  */
     66
     67/**
     68 * Comment style.
     69 */
     70typedef enum SCMCOMMENTSTYLE
     71{
     72    kScmCommentStyle_Invalid = 0,
     73    kScmCommentStyle_C,
     74    kScmCommentStyle_Hash,
     75    kScmCommentStyle_Python,    /**< Same as hash, except for copyright/license. */
     76    kScmCommentStyle_Semicolon,
     77    kScmCommentStyle_Rem_Upper,
     78    kScmCommentStyle_Rem_Lower,
     79    kScmCommentStyle_Rem_Camel,
     80    kScmCommentStyle_End
     81} SCMCOMMENTSTYLE;
     82
     83/**
     84 * Comment types.
     85 */
     86typedef enum SCMCOMMENTTYPE
     87{
     88    kScmCommentType_Invalid = 0,                /**< Customary invalid zero value. */
     89    kScmCommentType_Line,                       /**< Line comment. */
     90    kScmCommentType_Line_JavaDoc,               /**< Line comment, JavaDoc style. */
     91    kScmCommentType_Line_JavaDoc_After,         /**< Line comment, JavaDoc after-member style. */
     92    kScmCommentType_Line_Qt,                    /**< Line comment, JavaDoc style. */
     93    kScmCommentType_Line_Qt_After,              /**< Line comment, JavaDoc after-member style. */
     94    kScmCommentType_MultiLine,                  /**< Multi-line comment (e.g. ansi C).  */
     95    kScmCommentType_MultiLine_JavaDoc,          /**< Multi-line comment, JavaDoc style.  */
     96    kScmCommentType_MultiLine_JavaDoc_After,    /**< Multi-line comment, JavaDoc after-member style.  */
     97    kScmCommentType_MultiLine_Qt,               /**< Multi-line comment, Qt style.  */
     98    kScmCommentType_MultiLine_Qt_After,         /**< Multi-line comment, Qt after-member style.  */
     99    kScmCommentType_DocString,                  /**< Triple quoted python doc string. */
     100    kScmCommentType_End                         /**< Customary exclusive end value. */
     101} SCMCOMMENTTYPE;
     102
     103
     104/**
     105 * Comment information.
     106 */
     107typedef struct SCMCOMMENTINFO
     108{
     109    /** Comment type. */
     110    SCMCOMMENTTYPE  enmType;
     111    /** Start line number  (0-based). */
     112    uint32_t        iLineStart;
     113    /** Start line offset (0-based). */
     114    uint32_t        offStart;
     115    /** End line number  (0-based). */
     116    uint32_t        iLineEnd;
     117    /** End line offset  (0-based). */
     118    uint32_t        offEnd;
     119    /** Number of blank lines before the body (@a pszBody). */
     120    uint32_t        cBlankLinesBefore;
     121    /** Number of blank lines after the body (@a pszBody + @a cchBody). */
     122    uint32_t        cBlankLinesAfter;
     123    /** @todo add min/max indent. Raw length. Etc. */
     124} SCMCOMMENTINFO;
     125/** Pointer to comment info. */
     126typedef SCMCOMMENTINFO *PSCMCOMMENTINFO;
     127/** Pointer to const comment info. */
     128typedef SCMCOMMENTINFO const *PCSCMCOMMENTINFO;
     129
     130
     131/**
     132 * Comment enumeration callback function.
     133 *
     134 * @returns IPRT style status code.  Failures causes immediate return.  While an
     135 *          informational status code is saved (first one) and returned later.
     136 * @param   pInfo           Additional comment info.
     137 * @param   pszBody         The comment body.  This is somewhat stripped.
     138 * @param   cchBody         The comment body length.
     139 * @param   pvUser          User callback argument.
     140 */
     141typedef DECLCALLBACK(int) FNSCMCOMMENTENUMERATOR(PCSCMCOMMENTINFO pInfo, const char *pszBody, size_t cchBody, void *pvUser);
     142/** Poiter to a omment enumeration callback function. */
     143typedef FNSCMCOMMENTENUMERATOR *PFNSCMCOMMENTENUMERATOR;
     144
     145int ScmEnumerateComments(PSCMSTREAM pIn, SCMCOMMENTSTYLE enmCommentStyle, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser);
     146
     147/** @} */
     148
     149
    64150/** @name Rewriters
    65151 * @{ */
    … …  
    79165    /** Pointer to an array of SVN property changes. */
    80166    struct SCMSVNPROP  *paSvnPropChanges;
     167    /** For error propagation. */
     168    int32_t             rc;
    81169} SCMRWSTATE;
    82170
    … …  
    104192FNSCMREWRITER rewrite_SvnNoExecutable;
    105193FNSCMREWRITER rewrite_SvnKeywords;
     194FNSCMREWRITER rewrite_Copyright_CstyleComment;
     195FNSCMREWRITER rewrite_Copyright_HashComment;
     196FNSCMREWRITER rewrite_Copyright_PythonComment;
     197FNSCMREWRITER rewrite_Copyright_RemComment;
     198FNSCMREWRITER rewrite_Copyright_SemicolonComment;
    106199FNSCMREWRITER rewrite_Makefile_kup;
    107200FNSCMREWRITER rewrite_Makefile_kmk;
    … …  
    132225
    133226
     227/** License update options. */
     228typedef enum SCMLICENSE
     229{
     230    kScmLicense_LeaveAlone = 0,     /**< Leave it alone. */
     231    kScmLicense_OseGpl,             /**< VBox OSE GPL if public. */
     232    kScmLicense_OseDualGplCddl,     /**< VBox OSE dual GPL & CDDL if public. */
     233    kScmLicense_Lgpl,               /**< LGPL if public. */
     234    kScmLicense_Mit,                /**< MIT if public. */
     235    kScmLicense_End
     236} SCMLICENSE;
     237
    134238/**
    135239 * Source Code Massager Settings.
    … …  
    151255    /** Whether to fix C/C++ todos. */
    152256    bool            fFixTodos;
     257
     258    /** Update the copyright year. */
     259    bool            fUpdateCopyrightYear;
     260    /** How to update the license. */
     261    SCMLICENSE      enmUpdateLicense;
    153262
    154263    /** Only process files that are part of a SVN working copy. */
    … …  
    230339
    231340
    232 void ScmVerbose(PSCMRWSTATE pState, int iLevel, const char *pszFormat, ...);
     341void ScmVerbose(PSCMRWSTATE pState, int iLevel, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
     342bool ScmError(PSCMRWSTATE pState, int rc, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
    233343
    234344extern const char g_szTabSpaces[16+1];
    235345extern const char g_szAsterisks[255+1];
    236346extern const char g_szSpaces[255+1];
     347extern uint32_t g_uYear;
    237348
    238349RT_C_DECLS_END

  • trunk/src/bldprogs/scmrw.cpp

    r63568 r69166  
    3939
    4040
     41/*********************************************************************************************************************************
     42*   Structures and Typedefs                                                                                                      *
     43*********************************************************************************************************************************/
     44/** License types. */
     45typedef enum SCMLICENSETYPE
     46{
     47    kScmLicenseType_Invalid = 0,
     48    kScmLicenseType_OseGpl,
     49    kScmLicenseType_OseDualGplCddl,
     50    kScmLicenseType_VBoxLgpl,
     51    kScmLicenseType_Mit,
     52    kScmLicenseType_Confidential
     53} SCMLICENSETYPE;
     54
     55/** A license. */
     56typedef struct SCMLICENSETEXT
     57{
     58    /** The license type. */
     59    SCMLICENSETYPE  enmType;
     60    /** The license option. */
     61    SCMLICENSE      enmOpt;
     62    /** The license text.   */
     63    const char     *psz;
     64    /** The license text length. */
     65    size_t          cch;
     66} SCMLICENSETEXT;
     67/** Pointer to a license. */
     68typedef SCMLICENSETEXT const *PCSCMLICENSETEXT;
     69
     70/**
     71 * Copyright + license rewriter state.
     72 */
     73typedef struct SCMCOPYRIGHTINFO
     74{
     75    /** State. */
     76    PSCMRWSTATE         pState;                 /**< input */
     77    /** The comment style (neede for C/C++). */
     78    SCMCOMMENTSTYLE     enmCommentStyle;        /**< input */
     79
     80    /** @name Common info
     81     * @{ */
     82    uint32_t            iLineComment;
     83    uint32_t            cLinesComment;          /**< This excludes any external license lines. */
     84    /** @} */
     85
     86    /** @name Copyright info
     87     * @{ */
     88    uint32_t            iLineCopyright;
     89    uint32_t            uFirstYear;
     90    uint32_t            uLastYear;
     91    bool                fWellFormedCopyright;
     92    bool                fUpToDateCopyright;
     93    /** @} */
     94
     95    /** @name License info
     96     * @{ */
     97    bool                fOpenSource;            /**< input */
     98    PCSCMLICENSETEXT    pExpectedLicense;       /**< input */
     99    PCSCMLICENSETEXT    paLicenses;             /**< input */
     100    SCMLICENSE          enmLicenceOpt;          /**< input */
     101    uint32_t            iLineLicense;
     102    uint32_t            cLinesLicense;
     103    PCSCMLICENSETEXT    pCurrentLicense;
     104    bool                fIsCorrectLicense;
     105    bool                fWellFormedLicense;
     106    bool                fExternalLicense;
     107    /** @} */
     108
     109} SCMCOPYRIGHTINFO;
     110typedef SCMCOPYRIGHTINFO *PSCMCOPYRIGHTINFO;
     111
     112
     113/*********************************************************************************************************************************
     114*   Global Variables                                                                                                             *
     115*********************************************************************************************************************************/
     116/** --license-ose-gpl */
     117static const char g_szVBoxOseGpl[] =
     118    "This file is part of VirtualBox Open Source Edition (OSE), as\n"
     119    "available from http://www.virtualbox.org. This file is free software;\n"
     120    "you can redistribute it and/or modify it under the terms of the GNU\n"
     121    "General Public License (GPL) as published by the Free Software\n"
     122    "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
     123    "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
     124    "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n";
     125
     126/** --license-ose-dual */
     127static const char g_szVBoxOseDualGplCddl[] =
     128    "This file is part of VirtualBox Open Source Edition (OSE), as\n"
     129    "available from http://www.virtualbox.org. This file is free software;\n"
     130    "you can redistribute it and/or modify it under the terms of the GNU\n"
     131    "General Public License (GPL) as published by the Free Software\n"
     132    "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
     133    "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
     134    "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
     135    "\n"
     136    "The contents of this file may alternatively be used under the terms\n"
     137    "of the Common Development and Distribution License Version 1.0\n"
     138    "(CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
     139    "VirtualBox OSE distribution, in which case the provisions of the\n"
     140    "CDDL are applicable instead of those of the GPL.\n"
     141    "\n"
     142    "You may elect to license modified versions of this file under the\n"
     143    "terms and conditions of either the GPL or the CDDL or both.\n";
     144
     145/** --license-lgpl */
     146static const char g_szVBoxLgpl[] =
     147    "This file is part of a free software library; you can redistribute\n"
     148    "it and/or modify it under the terms of the GNU Lesser General\n"
     149    "Public License version 2.1 as published by the Free Software\n"
     150    "Foundation and shipped in the \"COPYING\" file with this library.\n"
     151    "The library is distributed in the hope that it will be useful,\n"
     152    "but WITHOUT ANY WARRANTY of any kind.\n"
     153    "\n"
     154    "Oracle LGPL Disclaimer: For the avoidance of doubt, except that if\n"
     155    "any license choice other than GPL or LGPL is available it will\n"
     156    "apply instead, Oracle elects to use only the Lesser General Public\n"
     157    "License version 2.1 (LGPLv2) at this time for any software where\n"
     158    "a choice of LGPL license versions is made available with the\n"
     159    "language indicating that LGPLv2 or any later version may be used,\n"
     160    "or where a choice of which version of the LGPL is applied is\n"
     161    "otherwise unspecified.\n";
     162
     163/** --license-mit
     164 * @note This isn't detectable as VirtualBox or Oracle specific.  */
     165static const char g_szMit[] =
     166    "Permission is hereby granted, free of charge, to any person\n"
     167    "obtaining a copy of this software and associated documentation\n"
     168    "files (the \"Software\"), to deal in the Software without\n"
     169    "restriction, including without limitation the rights to use,\n"
     170    "copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
     171    "copies of the Software, and to permit persons to whom the\n"
     172    "Software is furnished to do so, subject to the following\n"
     173    "conditions:\n"
     174    "\n"
     175    "The above copyright notice and this permission notice shall be\n"
     176    "included in all copies or substantial portions of the Software.\n"
     177    "\n"
     178    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
     179    "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n"
     180    "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
     181    "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n"
     182    "HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n"
     183    "WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
     184    "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
     185    "OTHER DEALINGS IN THE SOFTWARE.\n";
     186
     187/** Oracle confidential. */
     188static const char g_szOracleConfidential[] =
     189    "Oracle Corporation confidential\n"
     190    "All rights reserved\n";
     191
     192/** Licenses to detect when --license-mit isn't used. */
     193static const SCMLICENSETEXT g_aLicenses[] =
     194{
     195    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseGpl)},
     196    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
     197    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
     198    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
     199    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
     200};
     201
     202/** Licenses to detect when --license-mit _is_ used. */
     203static const SCMLICENSETEXT g_aLicensesWithMit[] =
     204{
     205    { kScmLicenseType_OseGpl,           kScmLicense_OseGpl,         RT_STR_TUPLE(g_szVBoxOseGpl)},
     206    { kScmLicenseType_OseDualGplCddl,   kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
     207    { kScmLicenseType_VBoxLgpl,         kScmLicense_Lgpl,           RT_STR_TUPLE(g_szVBoxLgpl)},
     208    { kScmLicenseType_Mit,              kScmLicense_Mit,            RT_STR_TUPLE(g_szMit) },
     209    { kScmLicenseType_Confidential,     kScmLicense_End,            RT_STR_TUPLE(g_szOracleConfidential) },
     210    { kScmLicenseType_Invalid,          kScmLicense_End,            NULL, 0 },
     211};
     212
     213/** Copyright holder. */
     214static const char g_szCopyrightHolder[] = "Oracle Corporation";
     215
     216
     217/** Copyright+license comment start for each SCMCOMMENTSTYLE. */
     218static RTSTRTUPLE const g_aCopyrightCommentStart[] =
     219{
     220    RT_STR_TUPLE("<invalid> "),
     221    RT_STR_TUPLE("/*"),
     222    RT_STR_TUPLE("#"),
     223    RT_STR_TUPLE("\"\"\""),
     224    RT_STR_TUPLE(";"),
     225    RT_STR_TUPLE("REM"),
     226    RT_STR_TUPLE("rem"),
     227    RT_STR_TUPLE("Rem"),
     228    RT_STR_TUPLE("<end>"),
     229};
     230
     231/** Copyright+license line prefix for each SCMCOMMENTSTYLE. */
     232static RTSTRTUPLE const g_aCopyrightCommentPrefix[] =
     233{
     234    RT_STR_TUPLE("<invalid> "),
     235    RT_STR_TUPLE(" * "),
     236    RT_STR_TUPLE("# "),
     237    RT_STR_TUPLE(""),
     238    RT_STR_TUPLE("; "),
     239    RT_STR_TUPLE("REM "),
     240    RT_STR_TUPLE("rem "),
     241    RT_STR_TUPLE("Rem "),
     242    RT_STR_TUPLE("<end>"),
     243};
     244
     245/** Copyright+license empty line for each SCMCOMMENTSTYLE. */
     246static RTSTRTUPLE const g_aCopyrightCommentEmpty[] =
     247{
     248    RT_STR_TUPLE("<invalid>"),
     249    RT_STR_TUPLE(" *"),
     250    RT_STR_TUPLE("#"),
     251    RT_STR_TUPLE(""),
     252    RT_STR_TUPLE(";"),
     253    RT_STR_TUPLE("REM"),
     254    RT_STR_TUPLE("rem"),
     255    RT_STR_TUPLE("Rem"),
     256    RT_STR_TUPLE("<end>"),
     257};
     258
     259/** Copyright+license end of comment for each SCMCOMMENTSTYLE. */
     260static RTSTRTUPLE const g_aCopyrightCommentEnd[] =
     261{
     262    RT_STR_TUPLE("<invalid> "),
     263    RT_STR_TUPLE(" */"),
     264    RT_STR_TUPLE("#"),
     265    RT_STR_TUPLE("\"\"\""),
     266    RT_STR_TUPLE(";"),
     267    RT_STR_TUPLE("REM"),
     268    RT_STR_TUPLE("rem"),
     269    RT_STR_TUPLE("Rem"),
     270    RT_STR_TUPLE("<end>"),
     271};
     272
     273
     274/**
     275 * Figures out the predominant casing of the "REM" keyword in a batch file.
     276 *
     277 * @returns Predominant comment style.
     278 * @param   pIn         The file to scan.  Will be rewound.
     279 */
     280static SCMCOMMENTSTYLE determinBatchFileCommentStyle(PSCMSTREAM pIn)
     281{
     282    /*
     283     * Figure out whether it's using upper or lower case REM comments before
     284     * doing the work.
     285     */
     286    uint32_t    cUpper = 0;
     287    uint32_t    cLower = 0;
     288    uint32_t    cCamel = 0;
     289    SCMEOL      enmEol;
     290    size_t      cchLine;
     291    const char *pchLine;
     292    while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
     293    {
     294        while (   cchLine > 2
     295               && RT_C_IS_SPACE(*pchLine))
     296        {
     297            pchLine++;
     298            cchLine--;
     299        }
     300        if (   (   cchLine > 3
     301                && RT_C_IS_SPACE(pchLine[2]))
     302            || cchLine == 3)
     303        {
     304            if (   pchLine[0] == 'R'
     305                && pchLine[1] == 'E'
     306                && pchLine[2] == 'M')
     307                cUpper++;
     308            else if (   pchLine[0] == 'r'
     309                     && pchLine[1] == 'e'
     310                     && pchLine[2] == 'm')
     311                cLower++;
     312            else if (   pchLine[0] == 'R'
     313                     && pchLine[1] == 'e'
     314                     && pchLine[2] == 'm')
     315                cCamel++;
     316        }
     317    }
     318
     319    ScmStreamRewindForReading(pIn);
     320
     321    if (cLower >= cUpper && cLower >= cCamel)
     322        return kScmCommentStyle_Rem_Lower;
     323    if (cCamel >= cLower && cCamel >= cUpper)
     324        return kScmCommentStyle_Rem_Camel;
     325    return kScmCommentStyle_Rem_Upper;
     326}
     327
     328
    41329/**
    42330 * Worker for isBlankLine.
    … …  
    229517            int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
    230518            if (RT_FAILURE(rc2))
    231                 RTMsgError("ScmSvnSetProperty: %Rrc\n", rc2); /** @todo propagate the error somehow... */
     519                ScmError(pState, rc2, "ScmSvnSetProperty: %Rrc\n", rc2);
    232520        }
    233521        if (RT_SUCCESS(rc))
    … …  
    374662        rc = ScmSvnDelProperty(pState, "svn:executable");
    375663        if (RT_FAILURE(rc))
    376             RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
     664            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
    377665    }
    378666    return false;
    … …  
    412700            rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
    413701            if (RT_FAILURE(rc))
    414                 RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
     702                ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
    415703        }
    416704        else
    417             RTMsgError("RTStrAppend: %Rrc\n", rc); /** @todo error propagation here.. */
     705            ScmError(pState, rc, "RTStrAppend: %Rrc\n", rc);
    418706        RTStrFree(pszKeywords);
    419707    }
    … …  
    423711        rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
    424712        if (RT_FAILURE(rc))
    425             RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
     713            ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
    426714    }
    427715    else if (RT_SUCCESS(rc))
    … …  
    430718    return false;
    431719}
     720
     721
     722/**
     723 * Compares two strings word-by-word, ignoring spaces, punctuation and case.
     724 *
     725 * Assumes ASCII strings.
     726 *
     727 * @returns true if they match, false if not.
     728 * @param   psz1        The first string.  This is typically the known one.
     729 * @param   psz2        The second string.  This is typically the unknown one,
     730 *                      which is why we return a next pointer for this one.
     731 * @param   ppsz2Next   Where to return the next part of the 2nd string.  If
     732 *                      this is NULL, the whole string must match.
     733 */
     734static bool IsEqualWordByWordIgnoreCase(const char *psz1, const char *psz2, const char **ppsz2Next)
     735{
     736    for (;;)
     737    {
     738        /* Try compare raw strings first. */
     739        char ch1 = *psz1;
     740        char ch2 = *psz2;
     741        if (   ch1 == ch2
     742            || RT_C_TO_LOWER(ch1) == RT_C_TO_LOWER(ch2))
     743        {
     744            if (ch1)
     745            {
     746                psz1++;
     747                psz2++;
     748            }
     749            else
     750                return true;
     751        }
     752        else
     753        {
     754            /* Try skip spaces an punctuation. */
     755            while (   RT_C_IS_SPACE(ch1)
     756                   || RT_C_IS_PUNCT(ch1))
     757                ch1 = *++psz1;
     758
     759            if (ch1 == '\0' && ppsz2Next)
     760            {
     761                *ppsz2Next = psz2;
     762                return true;
     763            }
     764
     765            while (   RT_C_IS_SPACE(ch2)
     766                   || RT_C_IS_PUNCT(ch2))
     767                ch2 = *++psz2;
     768
     769            if (   ch1 != ch2
     770                && RT_C_TO_LOWER(ch1) != RT_C_TO_LOWER(ch2))
     771                return false;
     772        }
     773    }
     774}
     775
     776
     777/**
     778 * Counts the number of lines in the given substring.
     779 *
     780 * @returns The number of lines.
     781 * @param   psz          The start of the substring.
     782 * @param   cch          The length of the substring.
     783 */
     784static uint32_t CountLinesInSubstring(const char *psz, size_t cch)
     785{
     786    uint32_t cLines = 0;
     787    for (;;)
     788    {
     789        const char *pszEol = (const char *)memchr(psz, '\n', cch);
     790        if (pszEol)
     791            cLines++;
     792        else
     793            return cLines + (*psz != '\0');
     794        cch -= pszEol + 1 - psz;
     795        if (!cch)
     796            return cLines;
     797        psz  = pszEol + 1;
     798    }
     799}
     800
     801
     802/**
     803 * Comment parser callback for locating copyright and license.
     804 */
     805static DECLCALLBACK(int)
     806rewrite_Copyright_CommentCallback(PCSCMCOMMENTINFO pInfo, const char *pszBody, size_t cchBody, void *pvUser)
     807{
     808    PSCMCOPYRIGHTINFO pState = (PSCMCOPYRIGHTINFO)pvUser;
     809    Assert(strlen(pszBody) == cchBody);
     810    //RTPrintf("--- comment at %u, type %u ---\n%s\n--- end ---\n", pInfo->iLineStart, pInfo->enmType, pszBody);
     811    ScmVerbose(pState->pState, 2,
     812               "--- comment at %u col %u, %u lines, type %u, %u lines before body, %u lines after body\n",
     813               pInfo->iLineStart, pInfo->offStart, pInfo->iLineEnd - pInfo->iLineStart + 1, pInfo->enmType,
     814               pInfo->cBlankLinesBefore, pInfo->cBlankLinesAfter);
     815
     816    uint32_t iLine = pInfo->iLineStart + pInfo->cBlankLinesBefore;
     817
     818    /*
     819     * Since the license statement is typically prefaced by a copyright line.
     820     */
     821    bool     fFoundCopyright = false;
     822    uint32_t cBlankLinesAfterCopyright = 0;
     823    if (   pState->iLineCopyright == UINT32_MAX
     824        && cchBody > sizeof("Copyright") + sizeof(g_szCopyrightHolder)
     825        && RTStrNICmp(pszBody, RT_STR_TUPLE("copyright")) == 0)
     826    {
     827        const char *pszNextLine = (const char *)memchr(pszBody, '\n', cchBody);
     828
     829        /* Oracle copyright? */
     830        const char *pszEnd  = pszNextLine ? pszNextLine : &pszBody[cchBody];
     831        while (RT_C_IS_SPACE(pszEnd[-1]))
     832            pszEnd--;
     833        if (   (pszEnd - pszBody) > sizeof(g_szCopyrightHolder)
     834            && RTStrNICmp(pszEnd - sizeof(g_szCopyrightHolder) + 1, RT_STR_TUPLE(g_szCopyrightHolder)) == 0)
     835        {
     836            /* Parse out the year(s). */
     837            const char *psz = pszBody + sizeof("copyright");
     838            while ((uintptr_t)psz < (uintptr_t)pszEnd && !RT_C_IS_DIGIT(*psz))
     839                psz++;
     840            if (RT_C_IS_DIGIT(*psz))
     841            {
     842                char *pszNext;
     843                int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &pState->uFirstYear);
     844                if (   RT_SUCCESS(rc)
     845                    && rc != VWRN_NUMBER_TOO_BIG
     846                    && rc != VWRN_NEGATIVE_UNSIGNED)
     847                {
     848                    if (   pState->uFirstYear < 1975
     849                        || pState->uFirstYear > 3000)
     850                    {
     851                        ScmError(pState->pState, VERR_OUT_OF_RANGE, "Copyright year is out of range: %u ('%.*s')\n",
     852                                 pState->uFirstYear, pszEnd - pszBody, pszBody);
     853                        pState->uFirstYear = UINT32_MAX;
     854                    }
     855
     856                    while (RT_C_IS_SPACE(*pszNext))
     857                        pszNext++;
     858                    if (*pszNext == '-')
     859                    {
     860                        do
     861                            pszNext++;
     862                        while (RT_C_IS_SPACE(*pszNext));
     863                        rc = RTStrToUInt32Ex(pszNext, &pszNext, 10, &pState->uLastYear);
     864                        if (   RT_SUCCESS(rc)
     865                            && rc != VWRN_NUMBER_TOO_BIG
     866                            && rc != VWRN_NEGATIVE_UNSIGNED)
     867                        {
     868                            if (   pState->uLastYear < 1975
     869                                || pState->uLastYear > 3000)
     870                            {
     871                                ScmError(pState->pState, VERR_OUT_OF_RANGE, "Second copyright year is out of range: %u ('%.*s')\n",
     872                                         pState->uLastYear, pszEnd - pszBody, pszBody);
     873                                pState->uLastYear = UINT32_MAX;
     874                            }
     875                            else if (pState->uFirstYear > pState->uLastYear)
     876                            {
     877                                RTMsgWarning("Copyright years switched(?): '%.*s'\n", pszEnd - pszBody, pszBody);
     878                                uint32_t iTmp = pState->uLastYear;
     879                                pState->uLastYear = pState->uFirstYear;
     880                                pState->uFirstYear = iTmp;
     881                            }
     882                        }
     883                        else
     884                        {
     885                            pState->uLastYear = UINT32_MAX;
     886                            ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
     887                                     "Failed to parse second copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
     888                        }
     889                    }
     890                    else if (*pszNext != g_szCopyrightHolder[0])
     891                        ScmError(pState->pState, VERR_PARSE_ERROR,
     892                                 "Failed to parse copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
     893                    else
     894                        pState->uLastYear = pState->uFirstYear;
     895                }
     896                else
     897                {
     898                    pState->uFirstYear = UINT32_MAX;
     899                    ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
     900                             "Failed to parse copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
     901                }
     902            }
     903
     904            /* The copyright comment must come before the license. */
     905            if (pState->iLineLicense != UINT32_MAX)
     906                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright (line %u) must come before the license (line %u)!\n",
     907                         iLine, pState->iLineLicense);
     908
     909            /* In C/C++ code, this must be a multiline comment.  While in python it
     910               must be a */
     911            if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
     912                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a multiline comment (no doxygen stuff)\n");
     913            else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
     914                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a doc-string\n");
     915
     916            /* The copyright must be followed by the license. */
     917            if (!pszNextLine)
     918                ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
     919
     920            /* Quit if we've flagged a failure. */
     921            if (RT_FAILURE(pState->pState->rc))
     922                return VERR_CALLBACK_RETURN;
     923
     924            /* Check if it's well formed and up to date. */
     925            char   szWellFormed[256];
     926            size_t cchWellFormed;
     927            if (pState->uFirstYear == pState->uLastYear)
     928                cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u %s",
     929                                            pState->uFirstYear, g_szCopyrightHolder);
     930            else
     931                cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u-%u %s",
     932                                            pState->uFirstYear, pState->uLastYear, g_szCopyrightHolder);
     933            pState->fWellFormedCopyright = cchWellFormed == (uintptr_t)(pszEnd - pszBody)
     934                                        && memcmp(pszBody, szWellFormed, cchWellFormed) == 0;
     935            pState->fUpToDateCopyright   = pState->uLastYear == g_uYear;
     936            pState->iLineCopyright       = iLine;
     937
     938            /* If there wasn't exactly one blank line before the comment, trigger a rewrite. */
     939            if (pInfo->cBlankLinesBefore != 1)
     940                pState->fWellFormedCopyright = false;
     941
     942            /* If the comment doesn't start in column 1, trigger rewrite. */
     943            if (pInfo->offStart != 0)
     944            {
     945                pState->fWellFormedCopyright = false;
     946                /** @todo check that there isn't any code preceeding the comment. */
     947            }
     948
     949            fFoundCopyright = true;
     950            ScmVerbose(pState->pState, 2, "oracle copyright %u-%u: up-to-date=%RTbool well-formed=%RTbool\n",
     951                       pState->uFirstYear, pState->uLastYear, pState->fUpToDateCopyright, pState->fWellFormedCopyright);
     952        }
     953        else
     954            ScmVerbose(pState->pState, 2, "not oracle copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
     955
     956        if (!pszNextLine)
     957            return VINF_SUCCESS;
     958
     959        /* Skip the copyright line and any blank lines following it. */
     960        cchBody -= pszNextLine - pszBody + 1;
     961        pszBody  = pszNextLine + 1;
     962        iLine   += 1;
     963        while (*pszBody == '\n')
     964        {
     965            pszBody++;
     966            cchBody--;
     967            iLine++;
     968            cBlankLinesAfterCopyright++;
     969        }
     970    }
     971
     972    /*
     973     * Now try match against the license texts if we haven't already found it.
     974     */
     975    if (pState->iLineLicense == UINT32_MAX)
     976    {
     977        for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
     978        {
     979            const char *pszNext;
     980            if (   pCur->cch - 1 <= cchBody
     981                && IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
     982            {
     983                while (   RT_C_IS_SPACE(*pszNext)
     984                       || (RT_C_IS_PUNCT(*pszNext) && *pszNext != '-'))
     985                    pszNext++;
     986
     987                uint32_t cDashes = 0;
     988                while (*pszNext == '-')
     989                    cDashes++, pszNext++;
     990                bool fExternal = cDashes > 10;
     991
     992                if (   *pszNext == '\0'
     993                    || fExternal)
     994                {
     995                    /* In C/C++ code, this must be a multiline comment.  While in python it
     996                       must be a */
     997                    if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
     998                        ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a multiline comment (no doxygen stuff)\n");
     999                    else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
     1000                        ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a doc-string\n");
     1001
     1002                    /* Quit if we've flagged a failure. */
     1003                    if (RT_FAILURE(pState->pState->rc))
     1004                        return VERR_CALLBACK_RETURN;
     1005
     1006                    /* Record it. */
     1007                    pState->iLineLicense        = iLine;
     1008                    pState->cLinesLicense       = CountLinesInSubstring(pszBody, pszNext - pszBody);
     1009                    pState->pCurrentLicense     = pCur;
     1010                    pState->fExternalLicense    = fExternal;
     1011                    pState->fIsCorrectLicense   = pState->fOpenSource
     1012                                                ? pCur->enmOpt == pState->enmLicenceOpt
     1013                                                : pCur->enmType == kScmLicenseType_Confidential;
     1014                    pState->fWellFormedLicense  = memcmp(pszBody, pCur->psz, pCur->cch - 1) == 0;
     1015
     1016                    /* If there was more than one blank line between the copyright and the
     1017                       license text, extend the license text area and force a rewrite of it. */
     1018                    if (cBlankLinesAfterCopyright > 1)
     1019                    {
     1020                        pState->iLineLicense -= cBlankLinesAfterCopyright - 1;
     1021                        pState->cLinesLicense += cBlankLinesAfterCopyright - 1;
     1022                        pState->fWellFormedLicense = false;
     1023                    }
     1024
     1025                    /* If there was more than one blank line after the license, trigger a rewrite. */
     1026                    if (!fExternal && pInfo->cBlankLinesAfter != 1)
     1027                        pState->fWellFormedLicense = false;
     1028
     1029                    /** @todo Check that the last comment line doesn't have any code on it. */
     1030                    /** @todo Check that column 2 contains '*' for C/C++ files. */
     1031
     1032                    ScmVerbose(pState->pState, 2,
     1033                               "Found license %d/%d at %u..%u: is-correct=%RTbool well-formed=%RTbool external-part=%RTbool open-source=%RTbool\n",
     1034                               pCur->enmType, pCur->enmOpt, pState->iLineLicense, pState->iLineLicense + pState->cLinesLicense,
     1035                               pState->fIsCorrectLicense, pState->fWellFormedLicense,
     1036                               pState->fExternalLicense, pState->fOpenSource);
     1037
     1038                    if (fFoundCopyright)
     1039                    {
     1040                        pState->iLineComment  = pInfo->iLineStart;
     1041                        pState->cLinesComment = (fExternal ? pState->iLineLicense + pState->cLinesLicense : pInfo->iLineEnd + 1)
     1042                                              - pInfo->iLineStart;
     1043                    }
     1044                    else
     1045                        ScmError(pState->pState, VERR_WRONG_ORDER, "License should be preceeded by the copyright!\n");
     1046                    if (pState->iLineCopyright != UINT32_MAX)
     1047                        return VERR_CALLBACK_RETURN;
     1048                    break;
     1049                }
     1050            }
     1051        }
     1052    }
     1053
     1054    if (fFoundCopyright)
     1055        ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
     1056    return VINF_SUCCESS;
     1057}
     1058
     1059
     1060/**
     1061 * Updates the copyright year and/or license text.
     1062 *
     1063 * @returns true if modifications were made, false if not.
     1064 * @param   pState              The rewriter state.
     1065 * @param   pIn                 The input stream.
     1066 * @param   pOut                The output stream.
     1067 * @param   pSettings           The settings.
     1068 * @param   enmCommentStyle     The comment style used by the file.
     1069 */
     1070static bool rewrite_Copyright_Common(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
     1071                                     SCMCOMMENTSTYLE enmCommentStyle)
     1072{
     1073    if (   !pSettings->fUpdateCopyrightYear
     1074        && pSettings->enmUpdateLicense == kScmLicense_LeaveAlone)
     1075        return false;
     1076
     1077    /*
     1078     * Try locate the relevant comments.
     1079     */
     1080    SCMCOPYRIGHTINFO Info =
     1081    {
     1082        /*.pState = */                  pState,
     1083        /*.enmCommentStyle = */         enmCommentStyle,
     1084
     1085        /*.iLineComment = */            UINT32_MAX,
     1086        /*.cLinesComment = */           0,
     1087
     1088        /*.iLineCopyright = */          UINT32_MAX,
     1089        /*.uFirstYear = */              UINT32_MAX,
     1090        /*.uLastYear = */               UINT32_MAX,
     1091        /*.fWellFormedCopyright = */    false,
     1092        /*.fUpToDateCopyright = */      false,
     1093
     1094        /*.fOpenSource = */             true,
     1095        /*.pExpectedLicense = */        NULL,
     1096        /*.paLicenses = */              pSettings->enmUpdateLicense != kScmLicense_Mit ? &g_aLicenses[0] : &g_aLicensesWithMit[0],
     1097        /*.enmLicenceOpt = */           pSettings->enmUpdateLicense,
     1098        /*.iLineLicense = */            UINT32_MAX,
     1099        /*.cLinesLicense = */           0,
     1100        /*.pCurrentLicense = */         NULL,
     1101        /*.fIsCorrectLicense = */       false,
     1102        /*.fWellFormedLicense = */      false,
     1103        /*.fExternalLicense = */        false,
     1104    };
     1105
     1106    /* Figure Info.fOpenSource and the desired license: */
     1107    char *pszSyncProcess;
     1108    int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
     1109    if (RT_SUCCESS(rc))
     1110    {
     1111        Info.fOpenSource = strcmp(RTStrStrip(pszSyncProcess), "export") == 0;
     1112        RTStrFree(pszSyncProcess);
     1113    }
     1114    else if (rc == VERR_NOT_FOUND)
     1115        Info.fOpenSource = false;
     1116    else
     1117        return ScmError(pState, rc, "ScmSvnQueryProperty(svn:sync-process): %Rrc\n", rc);
     1118
     1119    Info.pExpectedLicense = Info.paLicenses;
     1120    if (Info.fOpenSource)
     1121        while (Info.pExpectedLicense->enmOpt != pSettings->enmUpdateLicense)
     1122            Info.pExpectedLicense++;
     1123    else
     1124        while (Info.pExpectedLicense->enmType != kScmLicenseType_Confidential)
     1125            Info.pExpectedLicense++;
     1126
     1127    /* Scan the comments. */
     1128    rc = ScmEnumerateComments(pIn, enmCommentStyle, rewrite_Copyright_CommentCallback, &Info);
     1129    if (   (rc == VERR_CALLBACK_RETURN || RT_SUCCESS(rc))
     1130        && RT_SUCCESS(pState->rc))
     1131    {
     1132        if (Info.iLineCopyright == UINT32_MAX)
     1133            ScmError(pState, VERR_NOT_FOUND, "Missing copyright!\n");
     1134        else if (Info.iLineLicense == UINT32_MAX)
     1135            ScmError(pState, VERR_NOT_FOUND, "Missing license!\n");
     1136        else
     1137        {
     1138            /*
     1139             * Do we need to make any changes?
     1140             */
     1141            bool fUpdateCopyright = !Info.fWellFormedCopyright
     1142                                 || (!Info.fUpToDateCopyright && pSettings->fUpdateCopyrightYear);
     1143            bool fUpdateLicense   = Info.enmLicenceOpt != kScmLicense_LeaveAlone
     1144                                 && (   !Info.fWellFormedLicense
     1145                                     || !Info.fIsCorrectLicense);
     1146            if (fUpdateCopyright || fUpdateLicense)
     1147            {
     1148                Assert(Info.iLineComment != UINT32_MAX);
     1149                Assert(Info.cLinesComment > 0);
     1150
     1151                /*
     1152                 * Okay, do the work.
     1153                 */
     1154                ScmStreamRewindForReading(pIn);
     1155
     1156                if (pSettings->fUpdateCopyrightYear)
     1157                    Info.uLastYear = g_uYear;
     1158
     1159                uint32_t    iLine = 0;
     1160                SCMEOL      enmEol;
     1161                size_t      cchLine;
     1162                const char *pchLine;
     1163                while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
     1164                {
     1165                    if (iLine == Info.iLineComment)
     1166                    {
     1167                        /* Leading blank line. */
     1168                        ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
     1169                                         g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
     1170
     1171                        /* Write the copyright comment line. */
     1172                        ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
     1173                                       g_aCopyrightCommentPrefix[enmCommentStyle].cch);
     1174
     1175                        char   szCopyright[256];
     1176                        size_t cchCopyright;
     1177                        if (Info.uFirstYear == Info.uLastYear)
     1178                            cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u %s",
     1179                                                       Info.uFirstYear, g_szCopyrightHolder);
     1180                        else
     1181                            cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u-%u %s",
     1182                                                       Info.uFirstYear, Info.uLastYear, g_szCopyrightHolder);
     1183
     1184                        ScmStreamWrite(pOut, szCopyright, cchCopyright);
     1185                        ScmStreamPutEol(pOut, enmEol);
     1186
     1187                        /* Blank line separating the two. */
     1188                        ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
     1189                                         g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
     1190
     1191                        /* Write the license text. */
     1192                        Assert(Info.pExpectedLicense->psz[Info.pExpectedLicense->cch - 1] == '\n');
     1193                        Assert(Info.pExpectedLicense->psz[Info.pExpectedLicense->cch - 2] != '\n');
     1194                        const char *psz = Info.pExpectedLicense->psz;
     1195                        do
     1196                        {
     1197                            const char *pszEol = strchr(psz, '\n');
     1198                            if (pszEol != psz)
     1199                            {
     1200                                ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
     1201                                               g_aCopyrightCommentPrefix[enmCommentStyle].cch);
     1202                                ScmStreamWrite(pOut, psz, pszEol - psz);
     1203                                ScmStreamPutEol(pOut, enmEol);
     1204                            }
     1205                            else
     1206                                ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
     1207                                                 g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
     1208                            psz = pszEol + 1;
     1209                        } while (*psz != '\0');
     1210
     1211                        /* Final comment line (picking up the stream status here). */
     1212                        if (!Info.fExternalLicense)
     1213                            rc = ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
     1214                                                  g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
     1215                        else
     1216                            rc = ScmStreamGetStatus(pOut);
     1217
     1218                        /* Skip the copyright and license text in the input file. */
     1219                        if (RT_SUCCESS(rc))
     1220                        {
     1221                            iLine = Info.iLineComment + Info.cLinesComment;
     1222                            rc = ScmStreamSeekByLine(pIn, iLine);
     1223                        }
     1224                    }
     1225                    else
     1226                    {
     1227                        rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
     1228                        iLine++;
     1229                    }
     1230                    if (RT_FAILURE(rc))
     1231                        return false;
     1232                }
     1233                return true;
     1234            }
     1235        }
     1236    }
     1237    else
     1238        ScmError(pState, rc,  "ScmEnumerateComments: %Rrc\n", rc);
     1239    NOREF(pState); NOREF(pOut);
     1240    return false;
     1241}
     1242
     1243
     1244/** Copyright updater for C-style comments.   */
     1245bool rewrite_Copyright_CstyleComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
     1246{
     1247    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_C);
     1248}
     1249
     1250/** Copyright updater for hash-prefixed comments.   */
     1251bool rewrite_Copyright_HashComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
     1252{
     1253    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Hash);
     1254}
     1255
     1256/** Copyright updater for REM-prefixed comments.   */
     1257bool rewrite_Copyright_RemComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
     1258{
     1259    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, determinBatchFileCommentStyle(pIn));
     1260}
     1261
     1262/** Copyright updater for python comments.   */
     1263bool rewrite_Copyright_PythonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
     1264{
     1265    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Python);
     1266}
     1267
     1268/** Copyright updater for semicolon-prefixed comments.   */
     1269bool rewrite_Copyright_SemicolonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
     1270{
     1271    return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Semicolon);
     1272}
     1273
    4321274
    4331275/**

  • trunk/src/bldprogs/scmstream.cpp

    r62537 r69166  
    663663
    664664/**
    665  * Get a numbered line from the stream (changes the position).
    666  *
    667  * A line is always delimited by a LF character or the end of the stream.  The
    668  * delimiter is not included in returned line length, but instead returned via
    669  * the @a penmEol indicator.
     665 * Worker for ScmStreamGetLineByNo and ScmStreamGetLine.
     666 *
     667 * Works on a fully lineated stream.
    670668 *
    671669 * @returns Pointer to the first character in the line, not NULL terminated.
    … …  
    678676 * @param   penmEol             Where to return the end of line type indicator.
    679677 */
    680 const char *ScmStreamGetLineByNo(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol)
    681 {
    682     AssertReturn(!pStream->fWriteOrRead, NULL);
    683     if (RT_FAILURE(pStream->rc))
    684         return NULL;
    685 
    686     /* Make sure it's fully delineated so we can use the index. */
    687     if (RT_UNLIKELY(!pStream->fFullyLineated))
    688     {
    689         int rc = scmStreamLineate(pStream);
    690         if (RT_FAILURE(rc))
    691             return NULL;
    692     }
    693 
    694     /* End of stream? */
    695     if (RT_UNLIKELY(iLine >= pStream->cLines))
    696     {
     678DECLINLINE(const char *) scmStreamGetLineByNoCommon(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol)
     679{
     680    Assert(!pStream->fWriteOrRead);
     681    Assert(pStream->fFullyLineated);
     682
     683    /* Check stream status. */
     684    if (RT_SUCCESS(pStream->rc))
     685    {
     686        /* Not at the end of the stream yet? */
     687        if (RT_LIKELY(iLine < pStream->cLines))
     688        {
     689            /* Get the data. */
     690            const char *pchRet = &pStream->pch[pStream->paLines[iLine].off];
     691            *pcchLine          = pStream->paLines[iLine].cch;
     692            *penmEol           = pStream->paLines[iLine].enmEol;
     693
     694            /* update the stream position. */
     695            pStream->off       = pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol;
     696            pStream->iLine     = iLine + 1;
     697            return pchRet;
     698        }
    697699        pStream->off   = pStream->cb;
    698700        pStream->iLine = pStream->cLines;
    699         return NULL;
    700     }
    701 
    702     /* Get the data. */
    703     const char *pchRet = &pStream->pch[pStream->paLines[iLine].off];
    704     *pcchLine          = pStream->paLines[iLine].cch;
    705     *penmEol           = pStream->paLines[iLine].enmEol;
    706 
    707     /* update the stream position. */
    708     pStream->off       = pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol;
    709     pStream->iLine     = iLine + 1;
    710 
    711     return pchRet;
    712 }
    713 
    714 /**
    715  * Get a line from the stream.
     701    }
     702    *pcchLine = 0;
     703    *penmEol  = SCMEOL_NONE;
     704    return NULL;
     705}
     706
     707
     708/**
     709 * Get a numbered line from the stream (changes the position).
    716710 *
    717711 * A line is always delimited by a LF character or the end of the stream.  The
    … …  
    721715 * @returns Pointer to the first character in the line, not NULL terminated.
    722716 *          NULL if the end of the stream has been reached or some problem
    723  *          occurred.
     717 *          occurred (*pcchLine set to zero and *penmEol to SCMEOL_NONE).
     718 *
     719 * @param   pStream             The stream.  Must be in read mode.
     720 * @param   iLine               The line to get (0-based).
     721 * @param   pcchLine            The length.
     722 * @param   penmEol             Where to return the end of line type indicator.
     723 */
     724const char *ScmStreamGetLineByNo(PSCMSTREAM pStream, size_t iLine, size_t *pcchLine, PSCMEOL penmEol)
     725{
     726    AssertReturn(!pStream->fWriteOrRead, NULL);
     727
     728    /* Make sure it's fully delineated so we can use the index. */
     729    if (RT_LIKELY(pStream->fFullyLineated))
     730        return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
     731
     732    int rc = pStream->rc;
     733    if (RT_SUCCESS(rc))
     734    {
     735        rc = scmStreamLineate(pStream);
     736        if (RT_SUCCESS(rc))
     737            return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
     738    }
     739
     740    *pcchLine = 0;
     741    *penmEol  = SCMEOL_NONE;
     742    return NULL;
     743}
     744
     745/**
     746 * Get a line from the stream.
     747 *
     748 * A line is always delimited by a LF character or the end of the stream.  The
     749 * delimiter is not included in returned line length, but instead returned via
     750 * the @a penmEol indicator.
     751 *
     752 * @returns Pointer to the first character in the line, not NULL terminated.
     753 *          NULL if the end of the stream has been reached or some problem
     754 *          occurred (*pcchLine set to zero and *penmEol to SCMEOL_NONE).
    724755 *
    725756 * @param   pStream             The stream.  Must be in read mode.
    … …  
    729760const char *ScmStreamGetLine(PSCMSTREAM pStream, size_t *pcchLine, PSCMEOL penmEol)
    730761{
    731     if (!pStream->fFullyLineated)
    732         return scmStreamGetLineInternal(pStream, pcchLine, penmEol);
    733 
    734     size_t      offCur   = pStream->off;
    735     size_t      iCurLine = pStream->iLine;
    736     const char *pszLine  = ScmStreamGetLineByNo(pStream, iCurLine, pcchLine, penmEol);
    737     if (   pszLine
    738         && offCur > pStream->paLines[iCurLine].off)
    739     {
    740         offCur -= pStream->paLines[iCurLine].off;
    741         Assert(offCur <= pStream->paLines[iCurLine].cch + pStream->paLines[iCurLine].enmEol);
    742         if (offCur < pStream->paLines[iCurLine].cch)
    743             *pcchLine  -= offCur;
    744         else
    745             *pcchLine   = 0;
    746         pszLine        += offCur;
    747     }
    748     return pszLine;
     762    if (RT_LIKELY(pStream->fFullyLineated))
     763    {
     764        size_t      offCur   = pStream->off;
     765        size_t      iCurLine = pStream->iLine;
     766        const char *pszLine  = scmStreamGetLineByNoCommon(pStream, iCurLine, pcchLine, penmEol);
     767        if (   pszLine
     768            && offCur > pStream->paLines[iCurLine].off)
     769        {
     770            offCur -= pStream->paLines[iCurLine].off;
     771            Assert(offCur <= pStream->paLines[iCurLine].cch + pStream->paLines[iCurLine].enmEol);
     772            if (offCur < pStream->paLines[iCurLine].cch)
     773                *pcchLine  -= offCur;
     774            else
     775                *pcchLine   = 0;
     776            pszLine        += offCur;
     777        }
     778        return pszLine;
     779    }
     780    return scmStreamGetLineInternal(pStream, pcchLine, penmEol);
    749781}
    750782
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette