VirtualBox

Changeset 41226 in vbox


Ignore:
Timestamp:
May 9, 2012 8:32:08 PM (13 years ago)
Author:
vboxsync
Message:

Working on simple function expansion for R3PTRYPE and friends.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bldprogs/VBoxCPP.cpp

    r41217 r41226  
    109109typedef VBCPPDEF *PVBCPPDEF;
    110110
    111 
    112 /**
    113  * Expansion context.
    114  */
    115 typedef struct VBCPPCTX
    116 {
    117     /** The next context on the stack. */
    118     struct VBCPPCTX    *pUp;
    119     /** The define being expanded. */
    120     PVBCPPDEF           pDef;
    121     /** Arguments. */
    122     struct VBCPPCTXARG
    123     {
    124         /** The value. */
    125         const char *pchValue;
    126         /** The value length. */
    127         const char *cchValue;
    128     }                   aArgs[1];
    129 } VBCPPCTX;
    130 /** Pointer to an define expansion context. */
    131 typedef VBCPPCTX *PVBCPPCTX;
    132111
    133112/**
    … …  
    279258     * should expand. */
    280259    VBCPP_BITMAP_TYPE   bmDefined[VBCPP_BITMAP_SIZE];
    281     /** Indicates whether a C-word might need argument expansion.
    282      * The bitmap is indexed by C-word lead character.  Bits that are set
    283      * indicates that the lead character is used in an argument of an currently
    284      * expanding  \#define. */
    285     VBCPP_BITMAP_TYPE   bmArgs[VBCPP_BITMAP_SIZE];
    286 
    287     /** Expansion context stack. */
    288     PVBCPPCTX           pExpStack;
    289     /** The current expansion stack depth. */
    290     uint32_t            cExpStackDepth;
    291260
    292261    /** The current depth of the conditional stack. */
    … …  
    324293*   Internal Functions                                                         *
    325294*******************************************************************************/
    326 static PVBCPPDEF vbcppDefineLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine);
    327 
     295static PVBCPPDEF    vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine);
     296static RTEXITCODE   vbcppMacroExpandFunctionLike(PVBCPP pThis, PVBCPPDEF pMacro, PSCMSTREAM pStrmInput, char **ppszExpansion);
     297static RTEXITCODE   vbcppMacroExpandObjectLike(PVBCPP pThis, PVBCPPDEF pMacro, PSCMSTREAM pStrmInput, char **ppszExpansion);
    328298
    329299
    … …  
    726696    }
    727697    return ScmStreamTell(pStrmInput);
     698}
     699
     700
     701/**
     702 * Looks for a left parenthesis in the input stream.
     703 *
     704 * Used during macro expansion.  Will ignore comments, newlines and other
     705 * whitespace.
     706 *
     707 * @retval  true if found. The stream position at opening parenthesis.
     708 * @retval  false if not found. The stream position is unchanged.
     709 *
     710 * @param   pThis               The C preprocessor instance.
     711 * @param   pStrmInput          The input stream.
     712 */
     713static bool vbcppInputLookForLeftParenthesis(PVBCPP pThis, PSCMSTREAM pStrmInput)
     714{
     715    size_t offSaved = ScmStreamTell(pStrmInput);
     716    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
     717    unsigned ch = ScmStreamPeekCh(pStrmInput);
     718    if (ch == '(')
     719        return true;
     720
     721    int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
     722    AssertFatalRC(rc);
     723    return false;
    728724}
    729725
    … …  
    901897 * @param   pStrmInput          The input stream.
    902898 */
    903 static RTEXITCODE vbcppProcessDoubleQuotedString(PVBCPP pThis, PSCMSTREAM pStrmInput)
     899static RTEXITCODE vbcppProcessStringLitteral(PVBCPP pThis, PSCMSTREAM pStrmInput)
    904900{
    905901    RTEXITCODE rcExit = vbcppOutputCh(pThis, '"');
    … …  
    938934 * @param   pStrmInput          The input stream.
    939935 */
    940 static RTEXITCODE vbcppProcessSingledQuotedString(PVBCPP pThis, PSCMSTREAM pStrmInput)
     936static RTEXITCODE vbcppProcessCharacterConstant(PVBCPP pThis, PSCMSTREAM pStrmInput)
    941937{
    942938    RTEXITCODE rcExit = vbcppOutputCh(pThis, '\'');
    … …  
    967963
    968964/**
    969  * Processes a C word, possibly replacing it with a definition.
     965 * Processes a integer or floating point number constant.
     966 *
     967 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     968 * @param   pThis               The C preprocessor instance.
     969 * @param   pStrmInput          The input stream.
     970 * @param   chFirst             The first character.
     971 */
     972static RTEXITCODE vbcppProcessNumber(PVBCPP pThis, PSCMSTREAM pStrmInput, char chFirst)
     973{
     974    RTEXITCODE rcExit = vbcppOutputCh(pThis, chFirst);
     975
     976    unsigned ch;
     977    while (   rcExit == RTEXITCODE_SUCCESS
     978           && (ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
     979    {
     980        if (   !vbcppIsCIdentifierChar(ch)
     981            && ch != '.')
     982            break;
     983
     984        unsigned ch2 = ScmStreamGetCh(pStrmInput);
     985        AssertBreakStmt(ch2 == ch, rcExit = vbcppError(pThis, "internal error"));
     986        rcExit = vbcppOutputCh(pThis, ch);
     987    }
     988
     989    return rcExit;
     990}
     991
     992
     993/**
     994 * Processes a identifier, possibly replacing it with a definition.
    970995 *
    971996 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
    … …  
    974999 * @param   ch                  The first character.
    9751000 */
    976 static RTEXITCODE vbcppProcessCWord(PVBCPP pThis, PSCMSTREAM pStrmInput, char ch)
    977 {
     1001static RTEXITCODE vbcppProcessIdentifier(PVBCPP pThis, PSCMSTREAM pStrmInput, char ch)
     1002{
     1003    int         rc     = VINF_SUCCESS;
    9781004    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
    9791005    size_t      cchDefine;
    … …  
    9811007    AssertReturn(pchDefine, vbcppError(pThis, "Internal error in ScmStreamCGetWordM1"));
    9821008
    983 
    9841009    /*
    9851010     * Does this look like a define we know?
    9861011     */
    987     PVBCPPDEF pDef = vbcppDefineLookup(pThis, pchDefine, cchDefine);
    988     if (pDef)
    989     {
    990         if (!pDef->fFunction)
    991         {
    992 #if 0 /** @todo proper expansion! */
    993             vbcppDefineExpandSimple(pThis, pDef, )
    994 #else
    995             int rc = ScmStreamWrite(&pThis->StrmOutput, pDef->szValue, pDef->cchValue);
     1012    PVBCPPDEF pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
     1013    if (   pMacro
     1014        && (   !pMacro->fFunction
     1015            || vbcppInputLookForLeftParenthesis(pThis, pStrmInput)) )
     1016    {
     1017        char *pszExpansion = NULL;
     1018        if (!pMacro->fFunction)
     1019            rcExit = vbcppMacroExpandObjectLike(pThis, pMacro, pStrmInput, &pszExpansion);
     1020        else
     1021            rcExit = vbcppMacroExpandFunctionLike(pThis, pMacro, pStrmInput, &pszExpansion);
     1022        if (rcExit == RTEXITCODE_SUCCESS)
     1023        {
     1024            rc = ScmStreamWrite(&pThis->StrmOutput, pszExpansion, strlen(pszExpansion));
    9961025            if (RT_FAILURE(rc))
    9971026                rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
    998 #endif
    999         }
    1000         else
    1001             rcExit = vbcppError(pThis, "Expanding function macros is not implemented\n");
     1027            RTMemFree(pszExpansion);
     1028        }
    10021029    }
    10031030    else
    10041031    {
    10051032        /*
    1006          * Not a define, just output the text unchanged.
     1033         * Not a macro or a function-macro name match but no invocation, just
     1034         * output the text unchanged.
    10071035         */
    1008         int rc = ScmStreamWrite(&pThis->StrmOutput, pchDefine, cchDefine);
     1036        rc = ScmStreamWrite(&pThis->StrmOutput, pchDefine, cchDefine);
    10091037        if (RT_FAILURE(rc))
    10101038            rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
    … …  
    10221050 *
    10231051 *
    1024  * D E F I N E S
    1025  * D E F I N E S
    1026  * D E F I N E S
    1027  * D E F I N E S
    1028  * D E F I N E S
     1052 * D E F I N E S   /   M A C R O S
     1053 * D E F I N E S   /   M A C R O S
     1054 * D E F I N E S   /   M A C R O S
     1055 * D E F I N E S   /   M A C R O S
     1056 * D E F I N E S   /   M A C R O S
    10291057 *
    10301058 *
    … …  
    10411069 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
    10421070 */
    1043 static bool vbcppDefineExists(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
     1071static bool vbcppMacroExists(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
    10441072{
    10451073    return cchDefine > 0
    … …  
    10581086 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
    10591087 */
    1060 static PVBCPPDEF vbcppDefineLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
     1088static PVBCPPDEF vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
    10611089{
    10621090    if (!cchDefine)
    … …  
    10681096
    10691097
     1098
     1099static RTEXITCODE vbcppMacroExpandObjectLike(PVBCPP pThis, PVBCPPDEF pMacro, PSCMSTREAM pStrmInput, char **ppszExpansion)
     1100{
     1101    *ppszExpansion = RTStrDup(pMacro->szValue);
     1102    if (!*ppszExpansion)
     1103        return vbcppError(pThis, "out of memory");
     1104    return RTEXITCODE_SUCCESS;
     1105}
     1106
     1107
     1108static RTEXITCODE vbcppMacroExpandFunctionLike(PVBCPP pThis, PVBCPPDEF pMacro, PSCMSTREAM pStrmInput, char **ppszExpansion)
     1109{
     1110    *ppszExpansion = NULL;
     1111    return vbcppError(pThis, "Expansion of function like macros is not yet supported");
     1112}
     1113
     1114
     1115
    10701116/**
    10711117 * Frees a define.
    … …  
    10751121 * @param   pvUser              Unused.
    10761122 */
    1077 static DECLCALLBACK(int) vbcppFreeDefine(PRTSTRSPACECORE pStr, void *pvUser)
     1123static DECLCALLBACK(int) vbcppMacroFree(PRTSTRSPACECORE pStr, void *pvUser)
    10781124{
    10791125    RTMemFree(pStr);
    … …  
    10931139 *                              preprocessing run it will evaluate to undefined.
    10941140 */
    1095 static RTEXITCODE vbcppDefineUndef(PVBCPP pThis, const char *pszDefine, size_t cchDefine, bool fExplicitUndef)
     1141static RTEXITCODE vbcppMacroUndef(PVBCPP pThis, const char *pszDefine, size_t cchDefine, bool fExplicitUndef)
    10961142{
    10971143    PRTSTRSPACECORE pHit = RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
    … …  
    10991145    {
    11001146        RTStrSpaceRemove(&pThis->StrSpace, pHit->pszString);
    1101         vbcppFreeDefine(pHit, NULL);
     1147        vbcppMacroFree(pHit, NULL);
    11021148    }
    11031149
    … …  
    11271173 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
    11281174 * @param   pThis               The C preprocessor instance.
    1129  * @param   pDef                The define to insert.
    1130  */
    1131 static RTEXITCODE vbcppDefineInsert(PVBCPP pThis, PVBCPPDEF pDef)
     1175 * @param   pMacro              The define to insert.
     1176 */
     1177static RTEXITCODE vbcppMacroInsert(PVBCPP pThis, PVBCPPDEF pMacro)
    11321178{
    11331179    /*
    11341180     * Reject illegal macro names.
    11351181     */
    1136     if (!strcmp(pDef->Core.pszString, "defined"))
    1137     {
    1138         RTEXITCODE rcExit = vbcppError(pThis, "Cannot use '%s' as a macro name", pDef->Core.pszString);
    1139         vbcppFreeDefine(&pDef->Core, NULL);
     1182    if (!strcmp(pMacro->Core.pszString, "defined"))
     1183    {
     1184        RTEXITCODE rcExit = vbcppError(pThis, "Cannot use '%s' as a macro name", pMacro->Core.pszString);
     1185        vbcppMacroFree(&pMacro->Core, NULL);
    11401186        return rcExit;
    11411187    }
    … …  
    11451191     */
    11461192    if (   !pThis->fRespectSourceDefines
    1147         && !pDef->fCmdLine)
     1193        && !pMacro->fCmdLine)
    11481194    {
    11491195        /* Ignore*/
    1150         vbcppFreeDefine(&pDef->Core, NULL);
     1196        vbcppMacroFree(&pMacro->Core, NULL);
    11511197        return RTEXITCODE_SUCCESS;
    11521198    }
    … …  
    11551201     * Insert it and update the lead character hint bitmap.
    11561202     */
    1157     if (RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core))
    1158         VBCPP_BITMAP_SET(pThis->bmDefined, *pDef->Core.pszString);
     1203    if (RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core))
     1204        VBCPP_BITMAP_SET(pThis->bmDefined, *pMacro->Core.pszString);
    11591205    else
    11601206    {
    … …  
    11631209         * line take precendece.
    11641210         */
    1165         PVBCPPDEF pOld = (PVBCPPDEF)RTStrSpaceGet(&pThis->StrSpace, pDef->Core.pszString); Assert(pOld);
     1211        PVBCPPDEF pOld = (PVBCPPDEF)RTStrSpaceGet(&pThis->StrSpace, pMacro->Core.pszString); Assert(pOld);
    11661212        if (   pThis->fAllowRedefiningCmdLineDefines
    1167             || pDef->fCmdLine == pOld->fCmdLine)
    1168         {
    1169             if (pDef->fCmdLine)
    1170                 RTMsgWarning("Redefining '%s'\n", pDef->Core.pszString);
     1213            || pMacro->fCmdLine == pOld->fCmdLine)
     1214        {
     1215            if (pMacro->fCmdLine)
     1216                RTMsgWarning("Redefining '%s'", pMacro->Core.pszString);
    11711217
    11721218            RTStrSpaceRemove(&pThis->StrSpace, pOld->Core.pszString);
    1173             vbcppFreeDefine(&pOld->Core, NULL);
    1174 
    1175             bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core);
     1219            vbcppMacroFree(&pOld->Core, NULL);
     1220
     1221            bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core);
    11761222            Assert(fRc);
    11771223        }
    11781224        else
    11791225        {
    1180             RTMsgWarning("Ignoring redefinition of '%s'\n", pDef->Core.pszString);
    1181             vbcppFreeDefine(&pDef->Core, NULL);
     1226            RTMsgWarning("Ignoring redefinition of '%s'", pMacro->Core.pszString);
     1227            vbcppMacroFree(&pMacro->Core, NULL);
    11821228        }
    11831229    }
    … …  
    12001246 * @param   fCmdLine            Set if originating on the command line.
    12011247 */
    1202 static RTEXITCODE vbcppDefineAddFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
    1203                                    const char *pszParams, size_t cchParams,
    1204                                    const char *pszValue, size_t cchValue,
    1205                                    bool fCmdLine)
     1248static RTEXITCODE vbcppMacroAddFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
     1249                                  const char *pszParams, size_t cchParams,
     1250                                  const char *pszValue, size_t cchValue,
     1251                                  bool fCmdLine)
    12061252
    12071253{
    … …  
    12531299                    + sizeof(const char *) * cArgs;
    12541300    cbDef = RT_ALIGN_Z(cbDef, sizeof(const char *));
    1255     PVBCPPDEF pDef  = (PVBCPPDEF)RTMemAlloc(cbDef);
    1256     if (!pDef)
     1301    PVBCPPDEF pMacro  = (PVBCPPDEF)RTMemAlloc(cbDef);
     1302    if (!pMacro)
    12571303        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
    12581304
    1259     char *pszDst = &pDef->szValue[cchValue + 1];
    1260     pDef->Core.pszString = pszDst;
     1305    char *pszDst = &pMacro->szValue[cchValue + 1];
     1306    pMacro->Core.pszString = pszDst;
    12611307    memcpy(pszDst, pszDefine, cchDefine);
    12621308    pszDst += cchDefine;
    12631309    *pszDst++ = '\0';
    1264     pDef->fFunction = true;
    1265     pDef->fVarArg   = false;
    1266     pDef->fCmdLine  = fCmdLine;
    1267     pDef->cArgs     = cArgs;
    1268     pDef->papszArgs = (const char **)((uintptr_t)pDef + cbDef - sizeof(const char *) * cArgs);
    1269     VBCPP_BITMAP_EMPTY(pDef->bmArgs);
    1270     pDef->cchValue  = cchValue;
    1271     memcpy(pDef->szValue, pszValue, cchValue);
    1272     pDef->szValue[cchValue] = '\0';
     1310    pMacro->fFunction = true;
     1311    pMacro->fVarArg   = false;
     1312    pMacro->fCmdLine  = fCmdLine;
     1313    pMacro->cArgs     = cArgs;
     1314    pMacro->papszArgs = (const char **)((uintptr_t)pMacro + cbDef - sizeof(const char *) * cArgs);
     1315    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
     1316    pMacro->cchValue  = cchValue;
     1317    memcpy(pMacro->szValue, pszValue, cchValue);
     1318    pMacro->szValue[cchValue] = '\0';
    12731319
    12741320    /*
    … …  
    12941340
    12951341        /* Found and argument. First character is already validated. */
    1296         pDef->papszArgs[iArg] = pszDst;
     1342        pMacro->papszArgs[iArg] = pszDst;
    12971343        do
    12981344        {
    … …  
    13031349        iArg++;
    13041350    }
    1305     Assert((uintptr_t)pszDst <= (uintptr_t)pDef->papszArgs);
    1306 
    1307     return vbcppDefineInsert(pThis, pDef);
     1351    Assert((uintptr_t)pszDst <= (uintptr_t)pMacro->papszArgs);
     1352
     1353    return vbcppMacroInsert(pThis, pMacro);
    13081354}
    13091355
    … …  
    13211367 * @param   fCmdLine            Set if originating on the command line.
    13221368 */
    1323 static RTEXITCODE vbcppDefineAdd(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
    1324                                  const char *pszValue, size_t cchValue, bool fCmdLine)
     1369static RTEXITCODE vbcppMacroAdd(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
     1370                                const char *pszValue, size_t cchValue, bool fCmdLine)
    13251371{
    13261372    /*
    … …  
    13571403        pszParams++;
    13581404        cchParams -= 2;
    1359         return vbcppDefineAddFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue, fCmdLine);
     1405        return vbcppMacroAddFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue, fCmdLine);
    13601406    }
    13611407
    … …  
    13661412        return RTEXITCODE_FAILURE;
    13671413
    1368     PVBCPPDEF pDef = (PVBCPPDEF)RTMemAlloc(RT_OFFSETOF(VBCPPDEF, szValue[cchValue + 1 + cchDefine + 1]));
    1369     if (!pDef)
     1414    PVBCPPDEF pMacro = (PVBCPPDEF)RTMemAlloc(RT_OFFSETOF(VBCPPDEF, szValue[cchValue + 1 + cchDefine + 1]));
     1415    if (!pMacro)
    13701416        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
    13711417
    1372     pDef->Core.pszString = &pDef->szValue[cchValue + 1];
    1373     memcpy((char *)pDef->Core.pszString, pszDefine, cchDefine);
    1374     ((char *)pDef->Core.pszString)[cchDefine] = '\0';
    1375     pDef->fFunction = false;
    1376     pDef->fVarArg   = false;
    1377     pDef->fCmdLine  = fCmdLine;
    1378     pDef->cArgs     = 0;
    1379     pDef->papszArgs = NULL;
    1380     VBCPP_BITMAP_EMPTY(pDef->bmArgs);
    1381     pDef->cchValue  = cchValue;
    1382     memcpy(pDef->szValue, pszValue, cchValue);
    1383     pDef->szValue[cchValue] = '\0';
    1384 
    1385     return vbcppDefineInsert(pThis, pDef);
     1418    pMacro->Core.pszString = &pMacro->szValue[cchValue + 1];
     1419    memcpy((char *)pMacro->Core.pszString, pszDefine, cchDefine);
     1420    ((char *)pMacro->Core.pszString)[cchDefine] = '\0';
     1421    pMacro->fFunction = false;
     1422    pMacro->fVarArg   = false;
     1423    pMacro->fCmdLine  = fCmdLine;
     1424    pMacro->cArgs     = 0;
     1425    pMacro->papszArgs = NULL;
     1426    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
     1427    pMacro->cchValue  = cchValue;
     1428    memcpy(pMacro->szValue, pszValue, cchValue);
     1429    pMacro->szValue[cchValue] = '\0';
     1430
     1431    return vbcppMacroInsert(pThis, pMacro);
    13861432}
    13871433
    … …  
    13961442 *                              started (for pass thru).
    13971443 */
    1398 static RTEXITCODE vbcppProcessDefine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     1444static RTEXITCODE vbcppDirectiveDefine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    13991445{
    14001446    /*
    … …  
    14661512                 */
    14671513                if (pchParams)
    1468                     rcExit = vbcppDefineAddFn(pThis, pchDefine, cchDefine, pchParams, cchParams, pchValue, cchValue, false);
     1514                    rcExit = vbcppMacroAddFn(pThis, pchDefine, cchDefine, pchParams, cchParams, pchValue, cchValue, false);
    14691515                else
    1470                     rcExit = vbcppDefineAdd(pThis, pchDefine, cchDefine, pchValue, cchValue, false);
     1516                    rcExit = vbcppMacroAdd(pThis, pchDefine, cchDefine, pchValue, cchValue, false);
    14711517
    14721518                /*
    … …  
    15061552 *                              started (for pass thru).
    15071553 */
    1508 static RTEXITCODE vbcppProcessUndef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     1554static RTEXITCODE vbcppDirectiveUndef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    15091555{
    15101556    return vbcppError(pThis, "Not implemented %s", __FUNCTION__);
    … …  
    17701816
    17711817            /* Does it exist?  Will save a whole lot of trouble if it doesn't. */
    1772             PVBCPPDEF pDef = vbcppDefineLookup(pThis, &pszExpr[offIdentifier], cchIdentifier);
    1773             if (pDef)
     1818            PVBCPPDEF pMacro = vbcppMacroLookup(pThis, &pszExpr[offIdentifier], cchIdentifier);
     1819            if (pMacro)
    17741820            {
    17751821                /* Skip white space and check for parenthesis. */
    … …  
    17871833                {
    17881834                    /* Expand simple define if found. */
    1789                     if (pDef->cchValue + 2 < cchIdentifier)
     1835                    if (pMacro->cchValue + 2 < cchIdentifier)
    17901836                    {
    1791                         size_t offDelta = cchIdentifier - pDef->cchValue - 2;
     1837                        size_t offDelta = cchIdentifier - pMacro->cchValue - 2;
    17921838                        memmove(&pszExpr[offIdentifier], &pszExpr[offIdentifier + offDelta],
    17931839                                cchExpr - offIdentifier - offDelta + 1); /* Lazy bird is moving too much! */
    17941840                        cchExpr -= offDelta;
    17951841                    }
    1796                     else if (pDef->cchValue + 2 > cchIdentifier)
     1842                    else if (pMacro->cchValue + 2 > cchIdentifier)
    17971843                    {
    1798                         size_t offDelta = pDef->cchValue + 2 - cchIdentifier;
     1844                        size_t offDelta = pMacro->cchValue + 2 - cchIdentifier;
    17991845                        if (cchExpr + offDelta + 1 > cbExprAlloc)
    18001846                        {
    … …  
    18191865                       standard compliant this is... */
    18201866                    pszExpr[offIdentifier] = ' ';
    1821                     memcpy(&pszExpr[offIdentifier + 1], pDef->szValue, pDef->cchValue);
    1822                     pszExpr[offIdentifier + 1 + pDef->cchValue] = ' ';
     1867                    memcpy(&pszExpr[offIdentifier + 1], pMacro->szValue, pMacro->cchValue);
     1868                    pszExpr[offIdentifier + 1 + pMacro->cchValue] = ' ';
    18231869
    18241870                    /* Restart parsing at the inserted macro. */
    … …  
    19351981 * @param   enmKind             The kind of directive we're processing.
    19361982 */
    1937 static RTEXITCODE vbcppProcessIfOrElif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
     1983static RTEXITCODE vbcppDirectiveIfOrElif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
    19381984                                       VBCPPCONDKIND enmKind)
    19391985{
    … …  
    20362082 *                              started (for pass thru).
    20372083 */
    2038 static RTEXITCODE vbcppProcessIfDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2084static RTEXITCODE vbcppDirectiveIfDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    20392085{
    20402086    /*
    … …  
    20552101                 */
    20562102                VBCPPEVAL enmEval;
    2057                 if (vbcppDefineExists(pThis, pchDefine, cchDefine))
     2103                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
    20582104                    enmEval = kVBCppEval_True;
    20592105                else if (   !pThis->fUndecidedConditionals
    … …  
    20822128 *                              started (for pass thru).
    20832129 */
    2084 static RTEXITCODE vbcppProcessIfNDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2130static RTEXITCODE vbcppDirectiveIfNDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    20852131{
    20862132    /*
    … …  
    21012147                 */
    21022148                VBCPPEVAL enmEval;
    2103                 if (vbcppDefineExists(pThis, pchDefine, cchDefine))
     2149                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
    21042150                    enmEval = kVBCppEval_False;
    21052151                else if (   !pThis->fUndecidedConditionals
    … …  
    21282174 *                              started (for pass thru).
    21292175 */
    2130 static RTEXITCODE vbcppProcessElse(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2176static RTEXITCODE vbcppDirectiveElse(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    21312177{
    21322178    /*
    … …  
    21912237 *                              started (for pass thru).
    21922238 */
    2193 static RTEXITCODE vbcppProcessEndif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2239static RTEXITCODE vbcppDirectiveEndif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    21942240{
    21952241    /*
    … …  
    22822328 *                              started (for pass thru).
    22832329 */
    2284 static RTEXITCODE vbcppProcessInclude(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2330static RTEXITCODE vbcppDirectiveInclude(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    22852331{
    22862332    /*
    … …  
    23892435 *                              started (for pass thru).
    23902436 */
    2391 static RTEXITCODE vbcppProcessPragma(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2437static RTEXITCODE vbcppDirectivePragma(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    23922438{
    23932439    /*
    … …  
    24412487
    24422488/**
    2443  * Processes a abbreviated line number directive.
     2489 * Processes an error directive.
    24442490 *
    24452491 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
    … …  
    24492495 *                              started (for pass thru).
    24502496 */
    2451 static RTEXITCODE vbcppProcessLineNo(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2497static RTEXITCODE vbcppDirectiveError(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
     2498{
     2499    return vbcppError(pThis, "Hit an #error");
     2500}
     2501
     2502
     2503/**
     2504 * Processes a abbreviated line number directive.
     2505 *
     2506 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     2507 * @param   pThis               The C preprocessor instance.
     2508 * @param   pStrmInput          The input stream.
     2509 * @param   offStart            The stream position where the directive
     2510 *                              started (for pass thru).
     2511 */
     2512static RTEXITCODE vbcppDirectiveLineNo(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
    24522513{
    24532514    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
    … …  
    24622523 * @param   pStrmInput          The input stream.
    24632524 */
    2464 static RTEXITCODE vbcppProcessLineNoShort(PVBCPP pThis, PSCMSTREAM pStrmInput)
     2525static RTEXITCODE vbcppDirectiveLineNoShort(PVBCPP pThis, PSCMSTREAM pStrmInput)
    24652526{
    24662527    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
    … …  
    24902551#define IS_DIRECTIVE(a_sz) ( sizeof(a_sz) - 1 == cchDirective && strncmp(pchDirective, a_sz, sizeof(a_sz) - 1) == 0)
    24912552        if (IS_DIRECTIVE("if"))
    2492             rcExit = vbcppProcessIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_If);
     2553            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_If);
    24932554        else if (IS_DIRECTIVE("elif"))
    2494             rcExit = vbcppProcessIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_ElIf);
     2555            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_ElIf);
    24952556        else if (IS_DIRECTIVE("ifdef"))
    2496             rcExit = vbcppProcessIfDef(pThis, pStrmInput, offStart);
     2557            rcExit = vbcppDirectiveIfDef(pThis, pStrmInput, offStart);
    24972558        else if (IS_DIRECTIVE("ifndef"))
    2498             rcExit = vbcppProcessIfNDef(pThis, pStrmInput, offStart);
     2559            rcExit = vbcppDirectiveIfNDef(pThis, pStrmInput, offStart);
    24992560        else if (IS_DIRECTIVE("else"))
    2500             rcExit = vbcppProcessElse(pThis, pStrmInput, offStart);
     2561            rcExit = vbcppDirectiveElse(pThis, pStrmInput, offStart);
    25012562        else if (IS_DIRECTIVE("endif"))
    2502             rcExit = vbcppProcessEndif(pThis, pStrmInput, offStart);
     2563            rcExit = vbcppDirectiveEndif(pThis, pStrmInput, offStart);
    25032564        else if (!pThis->fIf0Mode)
    25042565        {
    25052566            if (IS_DIRECTIVE("include"))
    2506                 rcExit = vbcppProcessInclude(pThis, pStrmInput, offStart);
     2567                rcExit = vbcppDirectiveInclude(pThis, pStrmInput, offStart);
    25072568            else if (IS_DIRECTIVE("define"))
    2508                 rcExit = vbcppProcessDefine(pThis, pStrmInput, offStart);
     2569                rcExit = vbcppDirectiveDefine(pThis, pStrmInput, offStart);
    25092570            else if (IS_DIRECTIVE("undef"))
    2510                 rcExit = vbcppProcessUndef(pThis, pStrmInput, offStart);
     2571                rcExit = vbcppDirectiveUndef(pThis, pStrmInput, offStart);
    25112572            else if (IS_DIRECTIVE("pragma"))
    2512                 rcExit = vbcppProcessPragma(pThis, pStrmInput, offStart);
     2573                rcExit = vbcppDirectivePragma(pThis, pStrmInput, offStart);
     2574            else if (IS_DIRECTIVE("error"))
     2575                rcExit = vbcppDirectiveError(pThis, pStrmInput, offStart);
    25132576            else if (IS_DIRECTIVE("line"))
    2514                 rcExit = vbcppProcessLineNo(pThis, pStrmInput, offStart);
     2577                rcExit = vbcppDirectiveLineNo(pThis, pStrmInput, offStart);
    25152578            else
    25162579                rcExit = vbcppError(pThis, "Unknown preprocessor directive '#%.*s'", cchDirective, pchDirective);
    … …  
    25232586        unsigned ch = ScmStreamPeekCh(pStrmInput);
    25242587        if (RT_C_IS_DIGIT(ch))
    2525             rcExit = vbcppProcessLineNoShort(pThis, pStrmInput);
     2588            rcExit = vbcppDirectiveLineNoShort(pThis, pStrmInput);
    25262589        else
    25272590            rcExit = vbcppError(pThis, "Malformed preprocessor directive");
    … …  
    26052668                {
    26062669                    if (ch == '"')
    2607                         rcExit = vbcppProcessDoubleQuotedString(pThis, pStrmInput);
     2670                        rcExit = vbcppProcessStringLitteral(pThis, pStrmInput);
    26082671                    else if (ch == '\'')
    2609                         rcExit = vbcppProcessSingledQuotedString(pThis, pStrmInput);
     2672                        rcExit = vbcppProcessCharacterConstant(pThis, pStrmInput);
    26102673                    else if (vbcppIsCIdentifierLeadChar(ch))
    2611                         rcExit = vbcppProcessCWord(pThis, pStrmInput, ch);
     2674                        rcExit = vbcppProcessIdentifier(pThis, pStrmInput, ch);
     2675                    else if (RT_C_IS_DIGIT(ch))
     2676                        rcExit = vbcppProcessNumber(pThis, pStrmInput, ch);
    26122677                    else
    26132678                        rcExit = vbcppOutputCh(pThis, ch);
    … …  
    27842849                const char *pszEqual = strchr(ValueUnion.psz, '=');
    27852850                if (pszEqual)
    2786                     rcExit = vbcppDefineAdd(pThis, ValueUnion.psz, pszEqual - ValueUnion.psz, pszEqual + 1, RTSTR_MAX, true);
     2851                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, pszEqual - ValueUnion.psz, pszEqual + 1, RTSTR_MAX, true);
    27872852                else
    2788                     rcExit = vbcppDefineAdd(pThis, ValueUnion.psz, RTSTR_MAX, "1", 1, true);
     2853                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, RTSTR_MAX, "1", 1, true);
    27892854                if (rcExit != RTEXITCODE_SUCCESS)
    27902855                    return rcExit;
    … …  
    27992864
    28002865            case 'U':
    2801                 rcExit = vbcppDefineUndef(pThis, ValueUnion.psz, RTSTR_MAX, true);
     2866                rcExit = vbcppMacroUndef(pThis, ValueUnion.psz, RTSTR_MAX, true);
    28022867                break;
    28032868
    … …  
    28812946    ScmStreamDelete(&pThis->StrmOutput);
    28822947
    2883     RTStrSpaceDestroy(&pThis->StrSpace, vbcppFreeDefine, NULL);
     2948    RTStrSpaceDestroy(&pThis->StrSpace, vbcppMacroFree, NULL);
    28842949    pThis->StrSpace = NULL;
    28852950
    … …  
    29082973    pThis->StrSpace         = NULL;
    29092974    pThis->UndefStrSpace    = NULL;
    2910     pThis->pExpStack        = NULL;
    2911     pThis->cExpStackDepth   = 0;
    29122975    pThis->cCondStackDepth  = 0;
    29132976    pThis->pCondStack       = NULL;
    … …  
    29162979    pThis->fMaybePreprocessorLine = true;
    29172980    VBCPP_BITMAP_EMPTY(pThis->bmDefined);
    2918     VBCPP_BITMAP_EMPTY(pThis->bmArgs);
    29192981    pThis->cCondStackDepth  = 0;
    29202982    pThis->pInputStack      = NULL;
Note: See TracChangeset for help on using the changeset viewer.

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