VirtualBox

Changeset 41266 in vbox for trunk/src


Ignore:
Timestamp:
May 14, 2012 7:55:04 AM (13 years ago)
Author:
vboxsync
Message:

VBoxCPP: Bug fix in vbcppExprEvaluteTree. Some cleanups.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bldprogs/VBoxCPP.cpp

    r41263 r41266  
    6969*   Structures and Typedefs                                                    *
    7070*******************************************************************************/
     71/** Pointer to the C preprocessor instance data. */
     72typedef struct VBCPP *PVBCPP;
     73
     74
    7175/**
    7276 * Variable string buffer (very simple version of SCMSTREAM).
    … …  
    169173    kMacroReScanMode_End
    170174} VBCPPMACRORESCANMODE;
     175
     176
     177/**
     178 * Expression node type.
     179 */
     180typedef enum VBCPPEXPRKIND
     181{
     182    kVBCppExprKind_Invalid = 0,
     183    kVBCppExprKind_Unary,
     184    kVBCppExprKind_Binary,
     185    kVBCppExprKind_Ternary,
     186    kVBCppExprKind_SignedValue,
     187    kVBCppExprKind_UnsignedValue,
     188    kVBCppExprKind_End
     189} VBCPPEXPRKIND;
     190
     191
     192/** Macro used for the precedence field. */
     193#define VBCPPOP_PRECEDENCE(a_iPrecedence)   ((a_iPrecedence) << 8)
     194/** Mask for getting the precedence field value. */
     195#define VBCPPOP_PRECEDENCE_MASK             0xff00
     196/** Operator associativity - Left to right. */
     197#define VBCPPOP_L2R                         (1 << 16)
     198/** Operator associativity - Right to left. */
     199#define VBCPPOP_R2L                         (2 << 16)
     200
     201/**
     202 * Unary operators.
     203 */
     204typedef enum VBCPPUNARYOP
     205{
     206    kVBCppUnaryOp_Invalid = 0,
     207    kVBCppUnaryOp_Pluss             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  5,
     208    kVBCppUnaryOp_Minus             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  6,
     209    kVBCppUnaryOp_LogicalNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  7,
     210    kVBCppUnaryOp_BitwiseNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  8,
     211    kVBCppUnaryOp_Parenthesis       = VBCPPOP_R2L | VBCPPOP_PRECEDENCE(15) |  9,
     212    kVBCppUnaryOp_End
     213} VBCPPUNARYOP;
     214
     215/**
     216 * Binary operators.
     217 */
     218typedef enum VBCPPBINARYOP
     219{
     220    kVBCppBinary_Invalid = 0,
     221    kVBCppBinary_Multiplication     = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  2,
     222    kVBCppBinary_Division           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  4,
     223    kVBCppBinary_Modulo             = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  5,
     224    kVBCppBinary_Addition           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  6,
     225    kVBCppBinary_Subtraction        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  7,
     226    kVBCppBinary_LeftShift          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  8,
     227    kVBCppBinary_RightShift         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  9,
     228    kVBCppBinary_LessThan           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 10,
     229    kVBCppBinary_LessThanOrEqual    = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 11,
     230    kVBCppBinary_GreaterThan        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 12,
     231    kVBCppBinary_GreaterThanOrEqual = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 13,
     232    kVBCppBinary_EqualTo            = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 14,
     233    kVBCppBinary_NotEqualTo         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 15,
     234    kVBCppBinary_BitwiseAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(10) | 16,
     235    kVBCppBinary_BitwiseXor         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(11) | 17,
     236    kVBCppBinary_BitwiseOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(12) | 18,
     237    kVBCppBinary_LogicalAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(13) | 19,
     238    kVBCppBinary_LogicalOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(14) | 20,
     239    kVBCppBinary_End
     240} VBCPPBINARYOP;
     241
     242/** The precedence of the ternary operator (expr ? true : false). */
     243#define VBCPPTERNAROP_PRECEDENCE   VBCPPOP_PRECEDENCE(16)
     244
     245
     246/** Pointer to an expression parsing node. */
     247typedef struct VBCPPEXPR *PVBCPPEXPR;
     248/**
     249 * Expression parsing node.
     250 */
     251typedef struct VBCPPEXPR
     252{
     253    /** Parent expression. */
     254    PVBCPPEXPR          pParent;
     255    /** Whether the expression is complete or not. */
     256    bool                fComplete;
     257    /** The kind of expression. */
     258    VBCPPEXPRKIND       enmKind;
     259    /** Kind specific content. */
     260    union
     261    {
     262        /** kVBCppExprKind_Unary */
     263        struct
     264        {
     265            VBCPPUNARYOP    enmOperator;
     266            PVBCPPEXPR      pArg;
     267        } Unary;
     268
     269        /** kVBCppExprKind_Binary */
     270        struct
     271        {
     272            VBCPPBINARYOP   enmOperator;
     273            PVBCPPEXPR      pLeft;
     274            PVBCPPEXPR      pRight;
     275        } Binary;
     276
     277        /** kVBCppExprKind_Ternary */
     278        struct
     279        {
     280            PVBCPPEXPR      pExpr;
     281            PVBCPPEXPR      pTrue;
     282            PVBCPPEXPR      pFalse;
     283        } Ternary;
     284
     285        /** kVBCppExprKind_SignedValue */
     286        struct
     287        {
     288            int64_t         s64;
     289        } SignedValue;
     290
     291        /** kVBCppExprKind_UnsignedValue */
     292        struct
     293        {
     294            uint64_t        u64;
     295        } UnsignedValue;
     296    } u;
     297} VBCPPEXPR;
     298
     299
     300/**
     301 * Operator return statuses.
     302 */
     303typedef enum VBCPPEXPRRET
     304{
     305    kExprRet_Error = -1,
     306    kExprRet_Ok = 0,
     307    kExprRet_UnaryOperator,
     308    kExprRet_Value,
     309    kExprRet_EndOfExpr,
     310    kExprRet_End
     311} VBCPPEXPRRET;
     312
     313/**
     314 * Expression parser context.
     315 */
     316typedef struct VBCPPEXPRPARSER
     317{
     318    /** The current expression posistion. */
     319    const char         *pszCur;
     320    /** The root node. */
     321    PVBCPPEXPR          pRoot;
     322    /** The current expression node. */
     323    PVBCPPEXPR          pCur;
     324    /** Where to insert the next expression. */
     325    PVBCPPEXPR         *ppCur;
     326    /** The expression. */
     327    const char         *pszExpr;
     328    /** The number of undefined macros we've encountered while parsing. */
     329    size_t              cUndefined;
     330    /** Pointer to the C preprocessor instance. */
     331    PVBCPP              pThis;
     332} VBCPPEXPRPARSER;
     333/** Pointer to an expression parser context. */
     334typedef VBCPPEXPRPARSER *PVBCPPEXPRPARSER;
    171335
    172336
    … …  
    349513    bool                fStrmOutputValid;
    350514} VBCPP;
    351 /** Pointer to the C preprocessor instance data. */
    352 typedef VBCPP *PVBCPP;
    353515
    354516
    … …  
    470632
    471633
     634/**
     635 * Initializes a string buffer.
     636 *
     637 * @param   pStrBuf             The buffer structure to initialize.
     638 * @param   pThis               The C preprocessor instance.
     639 */
    472640static void vbcppStrBufInit(PVBCPPSTRBUF pStrBuf, PVBCPP pThis)
    473641{
    … …  
    479647
    480648
     649/**
     650 * Deletes a string buffer.
     651 *
     652 * @param   pStrBuf             Pointer to the string buffer.
     653 */
    481654static void vbcppStrBufDelete(PVBCPPSTRBUF pStrBuf)
    482655{
    … …  
    486659
    487660
     661/**
     662 * Ensures that sufficient bufferspace is available, growing the buffer if
     663 * necessary.
     664 *
     665 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     666 * @param   pStrBuf             Pointer to the string buffer.
     667 * @param   cbMin               The minimum buffer size.
     668 */
    488669static RTEXITCODE vbcppStrBufGrow(PVBCPPSTRBUF pStrBuf, size_t cbMin)
    489670{
    … …  
    504685
    505686
     687/**
     688 * Appends a substring.
     689 *
     690 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     691 * @param   pStrBuf             Pointer to the string buffer.
     692 * @param   pchSrc              Pointer to the first character in the substring.
     693 * @param   cchSrc              The length of the substring.
     694 */
    506695static RTEXITCODE vbcppStrBufAppendN(PVBCPPSTRBUF pStrBuf, const char *pchSrc, size_t cchSrc)
    507696{
    … …  
    523712
    524713
     714/**
     715 * Appends a character.
     716 *
     717 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     718 * @param   pStrBuf             Pointer to the string buffer.
     719 * @param   ch                  The charater to append.
     720 */
    525721static RTEXITCODE vbcppStrBufAppendCh(PVBCPPSTRBUF pStrBuf, char ch)
    526722{
    … …  
    541737
    542738
     739/**
     740 * Appends a string to the buffer.
     741 *
     742 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     743 * @param   pStrBuf             Pointer to the string buffer.
     744 * @param   psz                 The string to append.
     745 */
    543746static RTEXITCODE vbcppStrBufAppend(PVBCPPSTRBUF pStrBuf, const char *psz)
    544747{
    … …  
    547750
    548751
     752/**
     753 * Gets the last char in the buffer.
     754 *
     755 * @returns Last character, 0 if empty.
     756 * @param   pStrBuf             Pointer to the string buffer.
     757 */
    549758static char vbcppStrBufLastCh(PVBCPPSTRBUF pStrBuf)
    550759{
    … …  
    638847}
    639848
    640 
     849#if 0
    641850
    642851/**
    … …  
    7941003}
    7951004
     1005#endif
     1006
     1007
    7961008
    7971009
    … …  
    11171329    return rcExit;
    11181330}
    1119 
    11201331
    11211332
    … …  
    12611472 * Processes a single quoted constant.
    12621473 *
    1263  * Must not replace any C-words in strings.
     1474 * Must not replace any C-words in character constants.
    12641475 *
    12651476 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
    … …  
    12971508/**
    12981509 * Processes a integer or floating point number constant.
     1510 *
     1511 * Must not replace the type suffix.
    12991512 *
    13001513 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
    … …  
    14711684    return UINT32_MAX;
    14721685}
    1473 
    1474 
    14751686
    14761687
    … …  
    30203231
    30213232
    3022 typedef enum VBCPPEXPRKIND
    3023 {
    3024     kVBCppExprKind_Invalid = 0,
    3025     kVBCppExprKind_Unary,
    3026     kVBCppExprKind_Binary,
    3027     kVBCppExprKind_Ternary,
    3028     kVBCppExprKind_SignedValue,
    3029     kVBCppExprKind_UnsignedValue,
    3030     kVBCppExprKind_End
    3031 } VBCPPEXPRKIND;
    3032 
    3033 #define VBCPPOP_PRECEDENCE(a_iPrecedence)   ((a_iPrecedence) << 8)
    3034 #define VBCPPOP_PRECEDENCE_MASK             0xff00
    3035 #define VBCPPOP_L2R                         (1 << 16)
    3036 #define VBCPPOP_R2L                         (2 << 16)
    3037 
    3038 typedef enum VBCPPUNARYOP
    3039 {
    3040     kVBCppUnaryOp_Invalid = 0,
    3041     kVBCppUnaryOp_Pluss             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  5,
    3042     kVBCppUnaryOp_Minus             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  6,
    3043     kVBCppUnaryOp_LogicalNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  7,
    3044     kVBCppUnaryOp_BitwiseNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  8,
    3045     kVBCppUnaryOp_Parenthesis       = VBCPPOP_R2L | VBCPPOP_PRECEDENCE(15) |  9,
    3046     kVBCppUnaryOp_End
    3047 } VBCPPUNARYOP;
    3048 
    3049 typedef enum VBCPPBINARYOP
    3050 {
    3051     kVBCppBinary_Invalid = 0,
    3052 //    kVBCppBinary_SizeOf             = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 3) |  1,
    3053     kVBCppBinary_Multiplication     = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  2,
    3054     kVBCppBinary_Division           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  4,
    3055     kVBCppBinary_Modulo             = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  5,
    3056     kVBCppBinary_Addition           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  6,
    3057     kVBCppBinary_Subtraction        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  7,
    3058     kVBCppBinary_LeftShift          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  8,
    3059     kVBCppBinary_RightShift         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  9,
    3060     kVBCppBinary_LessThan           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 10,
    3061     kVBCppBinary_LessThanOrEqual    = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 11,
    3062     kVBCppBinary_GreaterThan        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 12,
    3063     kVBCppBinary_GreaterThanOrEqual = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 13,
    3064     kVBCppBinary_EqualTo            = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 14,
    3065     kVBCppBinary_NotEqualTo         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 15,
    3066     kVBCppBinary_BitwiseAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(10) | 16,
    3067     kVBCppBinary_BitwiseXor         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(11) | 17,
    3068     kVBCppBinary_BitwiseOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(12) | 18,
    3069     kVBCppBinary_LogicalAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(13) | 19,
    3070     kVBCppBinary_LogicalOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(14) | 20,
    3071     kVBCppBinary_End
    3072 } VBCPPBINARYOP;
    3073 
    3074 /** The precedence of the ternary operator (expr ? true : false). */
    3075 #define VBCPPTERNAROP_PRECEDENCE   VBCPPOP_PRECEDENCE(16)
    3076 
    3077 
    3078 typedef struct VBCPPEXPR *PVBCPPEXPR;
    3079 
    3080 /**
    3081  * Expression parsing structure.
    3082  */
    3083 typedef struct VBCPPEXPR
    3084 {
    3085     /** Parent expression. */
    3086     PVBCPPEXPR          pParent;
    3087     /** Whether the expression is complete or not. */
    3088     bool                fComplete;
    3089     /** The kind of expression. */
    3090     VBCPPEXPRKIND       enmKind;
    3091     /** Content specific. */
    3092     union
    3093     {
    3094         struct
    3095         {
    3096             VBCPPUNARYOP    enmOperator;
    3097             PVBCPPEXPR      pArg;
    3098         } Unary;
    3099 
    3100         struct
    3101         {
    3102             VBCPPBINARYOP   enmOperator;
    3103             PVBCPPEXPR      pLeft;
    3104             PVBCPPEXPR      pRight;
    3105         } Binary;
    3106 
    3107         struct
    3108         {
    3109             PVBCPPEXPR      pExpr;
    3110             PVBCPPEXPR      pTrue;
    3111             PVBCPPEXPR      pFalse;
    3112         } Ternary;
    3113 
    3114         struct
    3115         {
    3116             int64_t         s64;
    3117         } SignedValue;
    3118 
    3119         struct
    3120         {
    3121             uint64_t        u64;
    3122         } UnsignedValue;
    3123 
    3124     } u;
    3125 } VBCPPEXPR;
    3126 
    3127 
    3128 
    3129 /**
    3130  * Operator return statuses.
    3131  */
    3132 typedef enum VBCPPEXPRRET
    3133 {
    3134     kExprRet_Error = -1,
    3135     kExprRet_Ok = 0,
    3136     kExprRet_UnaryOperator,
    3137     kExprRet_Value,
    3138     kExprRet_EndOfExpr,
    3139     kExprRet_End
    3140 } VBCPPEXPRRET;
    3141 
    3142 /**
    3143  * Expression parser context.
    3144  */
    3145 typedef struct VBCPPEXPRPARSER
    3146 {
    3147     /** The current expression posistion. */
    3148     const char         *pszCur;
    3149     /** The root node. */
    3150     PVBCPPEXPR          pRoot;
    3151     /** The current expression node. */
    3152     PVBCPPEXPR          pCur;
    3153     /** Where to insert the next expression. */
    3154     PVBCPPEXPR         *ppCur;
    3155     /** The expression. */
    3156     const char         *pszExpr;
    3157     /** The number of undefined macros we've encountered while parsing. */
    3158     size_t              cUndefined;
    3159     /** Pointer to the C preprocessor instance. */
    3160     PVBCPP              pThis;
    3161 } VBCPPEXPRPARSER;
    3162 /** Pointer to an expression parser context. */
    3163 typedef VBCPPEXPRPARSER *PVBCPPEXPRPARSER;
    3164 
    3165 
    31663233/**
    31673234 * Recursively destroys the expression tree.
    … …  
    31993266
    32003267
    3201 static VBCPPEXPRRET vbcppExprParserError(PVBCPPEXPRPARSER pParser, const char *pszMsg, ...)
     3268/**
     3269 * Report error during expression parsing.
     3270 *
     3271 * @returns kExprRet_Error
     3272 * @param   pParser             The parser instance.
     3273 * @param   pszMsg              The error message.
     3274 * @param   ...                 Format arguments.
     3275 */
     3276static VBCPPEXPRRET vbcppExprParseError(PVBCPPEXPRPARSER pParser, const char *pszMsg, ...)
    32023277{
    32033278    va_list va;
    … …  
    32093284
    32103285
     3286/**
     3287 * Skip white space.
     3288 *
     3289 * @param   pParser             The parser instance.
     3290 */
    32113291static void vbcppExprParseSkipWhiteSpace(PVBCPPEXPRPARSER pParser)
    32123292{
    … …  
    32163296
    32173297
     3298/**
     3299 * Allocate a new
     3300 *
     3301 * @returns Pointer to the node. NULL+msg on failure.
     3302 * @param   pParser             The parser instance.
     3303 */
    32183304static PVBCPPEXPR vbcppExprParseAllocNode(PVBCPPEXPRPARSER pParser)
    32193305{
    32203306    PVBCPPEXPR pExpr = (PVBCPPEXPR)RTMemAllocZ(sizeof(*pExpr));
     3307    if (!pExpr)
     3308        vbcppExprParseError(pParser, "out of memory (expression node)");
    32213309    return pExpr;
    32223310}
    32233311
    32243312
    3225 static VBCPPEXPRRET vbcppExprParserBinaryOrEoeOrRparen(PVBCPPEXPRPARSER pParser)
     3313/**
     3314 * Looks for right parentheses and/or end of expression.
     3315 *
     3316 * @returns Expression status.
     3317 * @retval  kExprRet_Ok
     3318 * @retval  kExprRet_Error with msg.
     3319 * @retval  kExprRet_EndOfExpr
     3320 * @param   pParser             The parser instance.
     3321 */
     3322static VBCPPEXPRRET vbcppExprParseMaybeRParenOrEoe(PVBCPPEXPRPARSER pParser)
    32263323{
    32273324    Assert(!pParser->ppCur);
    3228 
    3229     /*
    3230      * Right parenthesis closes
    3231      */
    3232     char ch;
    32333325    for (;;)
    32343326    {
    32353327        vbcppExprParseSkipWhiteSpace(pParser);
    3236         ch = *pParser->pszCur;
     3328        char ch = *pParser->pszCur;
    32373329        if (ch == '\0')
    32383330            return kExprRet_EndOfExpr;
    … …  
    32533345                    break;
    32543346                case kVBCppExprKind_Unary:
    3255                     AssertReturn(pCur->u.Unary.pArg, vbcppExprParserError(pParser, "internal error"));
     3347                    AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
    32563348                    pCur->fComplete = true;
    32573349                    break;
    32583350                case kVBCppExprKind_Binary:
    3259                     AssertReturn(pCur->u.Binary.pLeft, vbcppExprParserError(pParser, "internal error"));
    3260                     AssertReturn(pCur->u.Binary.pRight, vbcppExprParserError(pParser, "internal error"));
     3351                    AssertReturn(pCur->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
     3352                    AssertReturn(pCur->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
    32613353                    pCur->fComplete = true;
    32623354                    break;
    32633355                case kVBCppExprKind_Ternary:
    32643356#if 1 /** @todo Check out the ternary operator implementation. */
    3265                     return vbcppExprParserError(pParser, "The ternary operator is not implemented");
     3357                    return vbcppExprParseError(pParser, "The ternary operator is not implemented");
    32663358#else
    32673359                    Assert(pCur->u.Ternary.pExpr);
    32683360                    if (!pCur->u.Ternary.pTrue)
    3269                         return vbcppExprParserError(pParser, "?!?!?");
     3361                        return vbcppExprParseError(pParser, "?!?!?");
    32703362                    if (!pCur->u.Ternary.pFalse)
    3271                         return vbcppExprParserError(pParser, "?!?!?!?");
     3363                        return vbcppExprParseError(pParser, "?!?!?!?");
    32723364                    pCur->fComplete = true;
    32733365#endif
    32743366                    break;
    32753367                default:
    3276                     return vbcppExprParserError(pParser, "Internal error (enmKind=%d)", pCur->enmKind);
     3368                    return vbcppExprParseError(pParser, "Internal error (enmKind=%d)", pCur->enmKind);
    32773369            }
    32783370            pCur = pCur->pParent;
    32793371        }
    32803372        if (!pCur)
    3281             return vbcppExprParserError(pParser, "Right parenthesis without a left one");
     3373            return vbcppExprParseError(pParser, "Right parenthesis without a left one");
    32823374        pCur->fComplete = true;
    32833375
    … …  
    32863378               && pCur->pParent)
    32873379        {
    3288             AssertReturn(pCur->u.Unary.pArg, vbcppExprParserError(pParser, "internal error"));
     3380            AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
    32893381            pCur->fComplete = true;
    32903382            pCur = pCur->pParent;
    … …  
    32923384    }
    32933385
     3386    return kExprRet_Ok;
     3387}
     3388
     3389
     3390/**
     3391 * Parses an binary operator.
     3392 *
     3393 * @returns Expression status.
     3394 * @retval  kExprRet_Ok
     3395 * @retval  kExprRet_Error with msg.
     3396 * @param   pParser             The parser instance.
     3397 */
     3398static VBCPPEXPRRET vbcppExprParseBinaryOperator(PVBCPPEXPRPARSER pParser)
     3399{
    32943400    /*
    32953401     * Binary or ternary operator should follow now.
    32963402     */
    32973403    VBCPPBINARYOP enmOp;
     3404    char ch = *pParser->pszCur;
    32983405    switch (ch)
    32993406    {
    33003407        case '*':
    33013408            if (pParser->pszCur[1] == '=')
    3302                 return vbcppExprParserError(pParser, "The assignment by product operator is not valid in a preprocessor expression");
     3409                return vbcppExprParseError(pParser, "The assignment by product operator is not valid in a preprocessor expression");
    33033410            enmOp = kVBCppBinary_Multiplication;
    33043411            break;
    33053412        case '/':
    33063413            if (pParser->pszCur[1] == '=')
    3307                 return vbcppExprParserError(pParser, "The assignment by quotient operator is not valid in a preprocessor expression");
     3414                return vbcppExprParseError(pParser, "The assignment by quotient operator is not valid in a preprocessor expression");
    33083415            enmOp = kVBCppBinary_Division;
    33093416            break;
    33103417        case '%':
    33113418            if (pParser->pszCur[1] == '=')
    3312                 return vbcppExprParserError(pParser, "The assignment by remainder operator is not valid in a preprocessor expression");
     3419                return vbcppExprParseError(pParser, "The assignment by remainder operator is not valid in a preprocessor expression");
    33133420            enmOp = kVBCppBinary_Modulo;
    33143421            break;
    33153422        case '+':
    33163423            if (pParser->pszCur[1] == '=')
    3317                 return vbcppExprParserError(pParser, "The assignment by sum operator is not valid in a preprocessor expression");
     3424                return vbcppExprParseError(pParser, "The assignment by sum operator is not valid in a preprocessor expression");
    33183425            enmOp = kVBCppBinary_Addition;
    33193426            break;
    33203427        case '-':
    33213428            if (pParser->pszCur[1] == '=')
    3322                 return vbcppExprParserError(pParser, "The assignment by difference operator is not valid in a preprocessor expression");
     3429                return vbcppExprParseError(pParser, "The assignment by difference operator is not valid in a preprocessor expression");
    33233430            enmOp = kVBCppBinary_Subtraction;
    33243431            break;
    … …  
    33343441                pParser->pszCur++;
    33353442                if (pParser->pszCur[1] == '=')
    3336                     return vbcppExprParserError(pParser, "The assignment by bitwise left shift operator is not valid in a preprocessor expression");
     3443                    return vbcppExprParseError(pParser, "The assignment by bitwise left shift operator is not valid in a preprocessor expression");
    33373444                enmOp = kVBCppBinary_LeftShift;
    33383445            }
    … …  
    33493456                pParser->pszCur++;
    33503457                if (pParser->pszCur[1] == '=')
    3351                     return vbcppExprParserError(pParser, "The assignment by bitwise right shift operator is not valid in a preprocessor expression");
     3458                    return vbcppExprParseError(pParser, "The assignment by bitwise right shift operator is not valid in a preprocessor expression");
    33523459                enmOp = kVBCppBinary_LeftShift;
    33533460            }
    … …  
    33553462        case '=':
    33563463            if (pParser->pszCur[1] != '=')
    3357                 return vbcppExprParserError(pParser, "The assignment operator is not valid in a preprocessor expression");
     3464                return vbcppExprParseError(pParser, "The assignment operator is not valid in a preprocessor expression");
    33583465            pParser->pszCur++;
    33593466            enmOp = kVBCppBinary_EqualTo;
    … …  
    33623469        case '!':
    33633470            if (pParser->pszCur[1] != '=')
    3364                 return vbcppExprParserError(pParser, "Expected binary operator, found the unary operator logical NOT");
     3471                return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator logical NOT");
    33653472            pParser->pszCur++;
    33663473            enmOp = kVBCppBinary_NotEqualTo;
    … …  
    33693476        case '&':
    33703477            if (pParser->pszCur[1] == '=')
    3371                 return vbcppExprParserError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
     3478                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
    33723479            if (pParser->pszCur[1] == '&')
    33733480            {
    … …  
    33803487        case '^':
    33813488            if (pParser->pszCur[1] == '=')
    3382                 return vbcppExprParserError(pParser, "The assignment by bitwise XOR operator is not valid in a preprocessor expression");
     3489                return vbcppExprParseError(pParser, "The assignment by bitwise XOR operator is not valid in a preprocessor expression");
    33833490            enmOp = kVBCppBinary_BitwiseXor;
    33843491            break;
    33853492        case '|':
    33863493            if (pParser->pszCur[1] == '=')
    3387                 return vbcppExprParserError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
     3494                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
    33883495            if (pParser->pszCur[1] == '|')
    33893496            {
    … …  
    33953502            break;
    33963503        case '~':
    3397             return vbcppExprParserError(pParser, "Expected binary operator, found the unary operator bitwise NOT");
     3504            return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator bitwise NOT");
    33983505
    33993506        case ':':
    34003507        case '?':
    3401             return vbcppExprParserError(pParser, "The ternary operator is not yet implemented");
     3508            return vbcppExprParseError(pParser, "The ternary operator is not yet implemented");
    34023509
    34033510        default:
    3404             return vbcppExprParserError(pParser, "Expected binary operator, found '%.20s'", pParser->pszCur);
     3511            return vbcppExprParseError(pParser, "Expected binary operator, found '%.20s'", pParser->pszCur);
    34053512    }
    34063513    pParser->pszCur++;
    … …  
    34333540                break;
    34343541            }
    3435             AssertReturn(pParent->u.Unary.pArg, vbcppExprParserError(pParser, "internal error"));
     3542            AssertReturn(pParent->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
    34363543            pParent->fComplete = true;
    34373544        }
    34383545        else if (pParent->enmKind == kVBCppExprKind_Binary)
    34393546        {
    3440             AssertReturn(pParent->u.Binary.pLeft, vbcppExprParserError(pParser, "internal error"));
    3441             AssertReturn(pParent->u.Binary.pRight, vbcppExprParserError(pParser, "internal error"));
     3547            AssertReturn(pParent->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
     3548            AssertReturn(pParent->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
    34423549            if ((pParent->u.Binary.enmOperator & VBCPPOP_PRECEDENCE_MASK) >= (enmOp & VBCPPOP_PRECEDENCE_MASK))
    34433550            {
    3444                 AssertReturn(pChild, vbcppExprParserError(pParser, "internal error"));
     3551                AssertReturn(pChild, vbcppExprParseError(pParser, "internal error"));
    34453552
    34463553                if (pParent->u.Binary.pRight == pChild)
    … …  
    34483555                else
    34493556                    ppPlace = &pParent->u.Binary.pLeft;
    3450                 AssertReturn(*ppPlace == pChild, vbcppExprParserError(pParser, "internal error"));
     3557                AssertReturn(*ppPlace == pChild, vbcppExprParseError(pParser, "internal error"));
    34513558                break;
    34523559            }
    … …  
    34553562        else if (pParent->enmKind == kVBCppExprKind_Ternary)
    34563563        {
    3457             return vbcppExprParserError(pParser, "The ternary operator is not implemented");
     3564            return vbcppExprParseError(pParser, "The ternary operator is not implemented");
    34583565        }
    34593566        else
    34603567            AssertReturn(   pParent->enmKind == kVBCppExprKind_SignedValue
    34613568                         || pParent->enmKind == kVBCppExprKind_UnsignedValue,
    3462                          vbcppExprParserError(pParser, "internal error"));
     3569                         vbcppExprParseError(pParser, "internal error"));
    34633570
    34643571        /* Up on level */
    … …  
    34893596
    34903597
     3598/**
     3599 * Deals with right paretheses or/and end of expression, looks for binary
     3600 * operators.
     3601 *
     3602 * @returns Expression status.
     3603 * @retval  kExprRet_Ok if binary operator was found processed.
     3604 * @retval  kExprRet_Error with msg.
     3605 * @retval  kExprRet_EndOfExpr
     3606 * @param   pParser             The parser instance.
     3607 */
     3608static VBCPPEXPRRET vbcppExprParseBinaryOrEoeOrRparen(PVBCPPEXPRPARSER pParser)
     3609{
     3610    VBCPPEXPRRET enmRet = vbcppExprParseMaybeRParenOrEoe(pParser);
     3611    if (enmRet != kExprRet_Ok)
     3612        return enmRet;
     3613    return vbcppExprParseBinaryOperator(pParser);
     3614}
     3615
     3616
     3617/**
     3618 * Parses an identifier in the expression, replacing it by 0.
     3619 *
     3620 * All known identifiers has already been replaced by their macro values, so
     3621 * what's left are unknown macros.  These are replaced by 0.
     3622 *
     3623 * @returns Expression status.
     3624 * @retval  kExprRet_Value
     3625 * @retval  kExprRet_Error with msg.
     3626 * @param   pParser             The parser instance.
     3627 */
    34913628static VBCPPEXPRRET vbcppExprParseIdentifier(PVBCPPEXPRPARSER pParser)
    34923629{
     3630/** @todo don't increment if it's an actively undefined macro. Need to revise
     3631 *        the expression related code wrt selective preprocessing. */
    34933632    pParser->cUndefined++;
    34943633
    … …  
    35183657    vbcppExprParseSkipWhiteSpace(pParser);
    35193658    if (*pParser->pszCur == '(')
    3520         return vbcppExprParserError(pParser, "Unknown unary operator '%.*s'", cchMacro, pszMacro);
    3521 
     3659        return vbcppExprParseError(pParser, "Unknown unary operator '%.*s'", cchMacro, pszMacro);
    35223660
    35233661    return kExprRet_Value;
    3524 
    3525 }
    3526 
    3527 
     3662}
     3663
     3664
     3665/**
     3666 * Parses an numeric constant in the expression.
     3667 *
     3668 * @returns Expression status.
     3669 * @retval  kExprRet_Value
     3670 * @retval  kExprRet_Error with msg.
     3671 * @param   pParser             The parser instance.
     3672 */
    35283673static VBCPPEXPRRET vbcppExprParseNumber(PVBCPPEXPRPARSER pParser)
    35293674{
    … …  
    35383683        ch2 = *++pParser->pszCur;
    35393684        if (!RT_C_IS_XDIGIT(ch2))
    3540             return vbcppExprParserError(pParser, "Expected hex digit following '0x'");
     3685            return vbcppExprParseError(pParser, "Expected hex digit following '0x'");
    35413686        int rc = RTStrToUInt64Ex(pParser->pszCur, &pszNext, 16, &u64);
    35423687        if (   RT_FAILURE(rc)
    35433688            || rc == VWRN_NUMBER_TOO_BIG)
    3544             return vbcppExprParserError(pParser, "Invalid hex value '%.20s...' (%Rrc)", pParser->pszCur, rc);
     3689            return vbcppExprParseError(pParser, "Invalid hex value '%.20s...' (%Rrc)", pParser->pszCur, rc);
    35453690        fSigned = false;
    35463691    }
    … …  
    35503695        if (   RT_FAILURE(rc)
    35513696            || rc == VWRN_NUMBER_TOO_BIG)
    3552             return vbcppExprParserError(pParser, "Invalid octal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
     3697            return vbcppExprParseError(pParser, "Invalid octal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
    35533698        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
    35543699    }
    … …  
    35583703        if (   RT_FAILURE(rc)
    35593704            || rc == VWRN_NUMBER_TOO_BIG)
    3560             return vbcppExprParserError(pParser, "Invalid decimal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
     3705            return vbcppExprParseError(pParser, "Invalid decimal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
    35613706        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
    35623707    }
    … …  
    35843729            fSigned = false;
    35853730        else
    3586             return vbcppExprParserError(pParser, "Invalid number suffix '%.*s'", cchSuffix, pszNext);
     3731            return vbcppExprParseError(pParser, "Invalid number suffix '%.*s'", cchSuffix, pszNext);
    35873732
    35883733        pszNext += cchSuffix;
    … …  
    36163761
    36173762
     3763/**
     3764 * Parses an character constant in the expression.
     3765 *
     3766 * @returns Expression status.
     3767 * @retval  kExprRet_Value
     3768 * @retval  kExprRet_Error with msg.
     3769 * @param   pParser             The parser instance.
     3770 */
    36183771static VBCPPEXPRRET vbcppExprParseCharacterConstant(PVBCPPEXPRPARSER pParser)
    36193772{
    … …  
    36213774    char ch2 = *pParser->pszCur++;
    36223775    if (ch2 == '\'')
    3623         return vbcppExprParserError(pParser, "Empty character constant");
     3776        return vbcppExprParseError(pParser, "Empty character constant");
    36243777    int64_t s64;
    36253778    if (ch2 == '\\')
    … …  
    36333786            case 't': s64 = 0x09; break;
    36343787            default:
    3635                 return vbcppExprParserError(pParser, "Escape character '%c' is not implemented", ch2);
     3788                return vbcppExprParseError(pParser, "Escape character '%c' is not implemented", ch2);
    36363789        }
    36373790    }
    … …  
    36393792        s64 = ch2;
    36403793    if (*pParser->pszCur != '\'')
    3641         return vbcppExprParserError(pParser, "Character constant contains more than one character");
     3794        return vbcppExprParseError(pParser, "Character constant contains more than one character");
    36423795
    36433796    /* Create a signed value node. */
    … …  
    36593812
    36603813
    3661 static VBCPPEXPRRET vbcppExprParseUnaryOrValueOrEoe(PVBCPPEXPRPARSER pParser)
     3814/**
     3815 * Parses a unary operator or a value.
     3816 *
     3817 * @returns Expression status.
     3818 * @retval  kExprRet_Value if value was found and processed.
     3819 * @retval  kExprRet_UnaryOperator if an unary operator was found and processed.
     3820 * @retval  kExprRet_Error with msg.
     3821 * @param   pParser             The parser instance.
     3822 */
     3823static VBCPPEXPRRET vbcppExprParseUnaryOrValue(PVBCPPEXPRPARSER pParser)
    36623824{
    36633825    vbcppExprParseSkipWhiteSpace(pParser);
    36643826    char ch = *pParser->pszCur;
    36653827    if (ch == '\0')
    3666         return vbcppExprParserError(pParser, "Premature end of expression");
     3828        return vbcppExprParseError(pParser, "Premature end of expression");
    36673829
    36683830    /*
    … …  
    36743836        return vbcppExprParseNumber(pParser);
    36753837    if (ch == '"')
    3676         return vbcppExprParserError(pParser, "String litteral");
     3838        return vbcppExprParseError(pParser, "String litteral");
    36773839    if (vbcppIsCIdentifierLeadChar(ch))
    36783840        return vbcppExprParseIdentifier(pParser);
    … …  
    36863848        enmOperator = kVBCppUnaryOp_Pluss;
    36873849        if (pParser->pszCur[1] == '+')
    3688             return vbcppExprParserError(pParser, "The prefix increment operator is not valid in a preprocessor expression");
     3850            return vbcppExprParseError(pParser, "The prefix increment operator is not valid in a preprocessor expression");
    36893851    }
    36903852    else if (ch == '-')
    … …  
    36923854        enmOperator = kVBCppUnaryOp_Minus;
    36933855        if (pParser->pszCur[1] == '-')
    3694             return vbcppExprParserError(pParser, "The prefix decrement operator is not valid in a preprocessor expression");
     3856            return vbcppExprParseError(pParser, "The prefix decrement operator is not valid in a preprocessor expression");
    36953857    }
    36963858    else if (ch == '!')
    … …  
    37013863        enmOperator = kVBCppUnaryOp_Parenthesis;
    37023864    else
    3703         return vbcppExprParserError(pParser, "Unknown token '%.*s'", 32, pParser->pszCur - 1);
     3865        return vbcppExprParseError(pParser, "Unknown token '%.*s'", 32, pParser->pszCur - 1);
    37043866    pParser->pszCur++;
    37053867
    … …  
    37233885
    37243886
    3725 
     3887/**
     3888 * Parses an expanded preprocessor expression.
     3889 *
     3890 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     3891 * @param   pThis               The C preprocessor instance.
     3892 * @param   pszExpr             The expression to parse.
     3893 * @param   cchExpr             The length of the expression in case we need it.
     3894 * @param   ppExprTree          Where to return the parse tree.
     3895 * @param   pcUndefined         Where to return the number of unknown undefined
     3896 *                              macros.  Optional.
     3897 */
    37263898static RTEXITCODE vbcppExprParse(PVBCPP pThis, char *pszExpr, size_t cchExpr, PVBCPPEXPR *ppExprTree, size_t *pcUndefined)
    37273899{
    37283900    RTEXITCODE rcExit = RTEXITCODE_FAILURE;
     3901    NOREF(cchExpr);
    37293902
    37303903    /*
    … …  
    37503923         */
    37513924        do
    3752             enmRet = vbcppExprParseUnaryOrValueOrEoe(&Parser);
     3925            enmRet = vbcppExprParseUnaryOrValue(&Parser);
    37533926        while (enmRet == kExprRet_UnaryOperator);
    37543927        if (enmRet == kExprRet_Error)
    37553928            break;
    3756         AssertBreakStmt(enmRet == kExprRet_Value, enmRet = vbcppExprParserError(&Parser, "Expected value (enmRet=%d)", enmRet));
     3929        AssertBreakStmt(enmRet == kExprRet_Value, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
    37573930
    37583931        /*
    37593932         * Non-unary operator, right parenthesis or end of expression is up next.
    37603933         */
    3761         enmRet = vbcppExprParserBinaryOrEoeOrRparen(&Parser);
     3934        enmRet = vbcppExprParseBinaryOrEoeOrRparen(&Parser);
    37623935        if (enmRet == kExprRet_Error)
    37633936            break;
    … …  
    37683941            break;
    37693942        }
    3770         AssertBreakStmt(enmRet == kExprRet_Ok, enmRet = vbcppExprParserError(&Parser, "Expected value (enmRet=%d)", enmRet));
     3943        AssertBreakStmt(enmRet == kExprRet_Ok, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
    37713944    }
    37723945
    … …  
    37843957
    37853958
     3959/**
     3960 * Checks if an expression value value is evaluates to @c true or @c false.
     3961 *
     3962 * @returns @c true or @c false.
     3963 * @param   pExpr               The value expression.
     3964 */
    37863965static bool vbcppExprIsExprTrue(PVBCPPEXPR pExpr)
    37873966{
    37883967    Assert(pExpr->enmKind == kVBCppExprKind_SignedValue || pExpr->enmKind == kVBCppExprKind_UnsignedValue);
     3968
    37893969    return pExpr->enmKind == kVBCppExprKind_SignedValue
    37903970         ? pExpr->u.SignedValue.s64   != 0
    … …  
    37933973
    37943974
     3975/**
     3976 * Evalutes a parse (sub-)tree.
     3977 *
     3978 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
     3979 * @param   pThis               The C preprocessor instance.
     3980 * @param   pRoot               The root of the parse (sub-)tree.
     3981 * @param   pResult             Where to store the result value.
     3982 */
    37953983static RTEXITCODE vbcppExprEvaluteTree(PVBCPP pThis, PVBCPPEXPR pRoot, PVBCPPEXPR pResult)
    37963984{
    … …  
    38654053            /* Evalute the right side. */
    38664054            VBCPPEXPR Result2;
    3867             rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pLeft, &Result2);
     4055            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pRight, &Result2);
    38684056            if (rcExit != RTEXITCODE_SUCCESS)
    38694057                return rcExit;
    … …  
    40444232static RTEXITCODE vbcppExprEval(PVBCPP pThis, char *pszExpr, size_t cchExpr, size_t cReplacements, VBCPPEVAL *penmResult)
    40454233{
    4046     //Assert(strlen(pszExpr) == cchExpr);
     4234    Assert(strlen(pszExpr) == cchExpr);
    40474235    size_t      cUndefined;
    40484236    PVBCPPEXPR  pExprTree;
    … …  
    41994387        }
    42004388        else if (ch == '\r' || ch == '\n')
    4201         {
    42024389            break; /* done */
    4203         }
    4204         else if (RT_C_IS_SPACE(ch) && RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf)))
     4390        else if (   RT_C_IS_SPACE(ch)
     4391                 && (   RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf))
     4392                     || vbcppStrBufLastCh(pStrBuf) == '\0') )
    42054393        {
    42064394            unsigned ch2 = ScmStreamGetCh(pStrmInput);
    42074395            Assert(ch == ch2);
     4396            rcExit = RTEXITCODE_SUCCESS;
    42084397        }
    42094398        else
    … …  
    42174406            {
    42184407                ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
     4408                rcExit = RTEXITCODE_SUCCESS;
    42194409            }
    42204410            else
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