Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 585

Show
Ignore:
Timestamp:
07/24/10 17:45:29 (14 years ago)
Author:
walter
Message:

bugzilla 4077 - Bugs caused by bitwise operator precedence

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/dmd-1.x/src/expression.c

    r528 r585  
    3232#include "template.h" 
    3333#include "utf.h" 
    3434#include "enum.h" 
    3535#include "scope.h" 
    3636#include "statement.h" 
    3737#include "declaration.h" 
    3838#include "aggregate.h" 
    3939#include "import.h" 
    4040#include "id.h" 
    4141#include "dsymbol.h" 
    4242#include "module.h" 
    4343#include "attrib.h" 
    4444#include "hdrgen.h" 
    4545#include "parse.h" 
    4646 
    4747 
    4848Expression *createTypeInfoArray(Scope *sc, Expression *args[], int dim); 
    4949Expression *expandVar(int result, VarDeclaration *v); 
    5050 
    5151#define LOGSEMANTIC     0 
    52  
    53 /********************************** 
    54  * Set operator precedence for each operator. 
    55  */ 
    56  
    57 // Operator precedence - greater values are higher precedence 
    58  
    59 enum PREC 
    60 { 
    61     PREC_zero, 
    62     PREC_expr, 
    63     PREC_assign, 
    64     PREC_cond, 
    65     PREC_oror, 
    66     PREC_andand, 
    67     PREC_or, 
    68     PREC_xor, 
    69     PREC_and, 
    70     PREC_equal, 
    71     PREC_rel, 
    72     PREC_shift, 
    73     PREC_add, 
    74     PREC_mul, 
    75     PREC_unary, 
    76     PREC_primary, 
    77 }; 
    78  
    79 enum PREC precedence[TOKMAX]; 
    80  
    81 void initPrecedence() 
    82 { 
    83     precedence[TOKdotvar] = PREC_primary; 
    84     precedence[TOKimport] = PREC_primary; 
    85     precedence[TOKidentifier] = PREC_primary; 
    86     precedence[TOKthis] = PREC_primary; 
    87     precedence[TOKsuper] = PREC_primary; 
    88     precedence[TOKint64] = PREC_primary; 
    89     precedence[TOKfloat64] = PREC_primary; 
    90     precedence[TOKnull] = PREC_primary; 
    91     precedence[TOKstring] = PREC_primary; 
    92     precedence[TOKarrayliteral] = PREC_primary; 
    93     precedence[TOKtypeid] = PREC_primary; 
    94     precedence[TOKis] = PREC_primary; 
    95     precedence[TOKassert] = PREC_primary; 
    96     precedence[TOKfunction] = PREC_primary; 
    97     precedence[TOKvar] = PREC_primary; 
    98 #if DMDV2 
    99     precedence[TOKdefault] = PREC_primary; 
    100 #endif 
    101  
    102     // post 
    103     precedence[TOKdotti] = PREC_primary; 
    104     precedence[TOKdot] = PREC_primary; 
    105 //  precedence[TOKarrow] = PREC_primary; 
    106     precedence[TOKplusplus] = PREC_primary; 
    107     precedence[TOKminusminus] = PREC_primary; 
    108     precedence[TOKcall] = PREC_primary; 
    109     precedence[TOKslice] = PREC_primary; 
    110     precedence[TOKarray] = PREC_primary; 
    111  
    112     precedence[TOKaddress] = PREC_unary; 
    113     precedence[TOKstar] = PREC_unary; 
    114     precedence[TOKneg] = PREC_unary; 
    115     precedence[TOKuadd] = PREC_unary; 
    116     precedence[TOKnot] = PREC_unary; 
    117     precedence[TOKtobool] = PREC_add; 
    118     precedence[TOKtilde] = PREC_unary; 
    119     precedence[TOKdelete] = PREC_unary; 
    120     precedence[TOKnew] = PREC_unary; 
    121     precedence[TOKcast] = PREC_unary; 
    122  
    123     precedence[TOKmul] = PREC_mul; 
    124     precedence[TOKdiv] = PREC_mul; 
    125     precedence[TOKmod] = PREC_mul; 
    126  
    127     precedence[TOKadd] = PREC_add; 
    128     precedence[TOKmin] = PREC_add; 
    129     precedence[TOKcat] = PREC_add; 
    130  
    131     precedence[TOKshl] = PREC_shift; 
    132     precedence[TOKshr] = PREC_shift; 
    133     precedence[TOKushr] = PREC_shift; 
    134  
    135     precedence[TOKlt] = PREC_rel; 
    136     precedence[TOKle] = PREC_rel; 
    137     precedence[TOKgt] = PREC_rel; 
    138     precedence[TOKge] = PREC_rel; 
    139     precedence[TOKunord] = PREC_rel; 
    140     precedence[TOKlg] = PREC_rel; 
    141     precedence[TOKleg] = PREC_rel; 
    142     precedence[TOKule] = PREC_rel; 
    143     precedence[TOKul] = PREC_rel; 
    144     precedence[TOKuge] = PREC_rel; 
    145     precedence[TOKug] = PREC_rel; 
    146     precedence[TOKue] = PREC_rel; 
    147     precedence[TOKin] = PREC_rel; 
    148  
    149 #if 0 
    150     precedence[TOKequal] = PREC_equal; 
    151     precedence[TOKnotequal] = PREC_equal; 
    152     precedence[TOKidentity] = PREC_equal; 
    153     precedence[TOKnotidentity] = PREC_equal; 
    154 #else 
    155     /* Note that we changed precedence, so that < and != have the same 
    156      * precedence. This change is in the parser, too. 
    157      */ 
    158     precedence[TOKequal] = PREC_rel; 
    159     precedence[TOKnotequal] = PREC_rel; 
    160     precedence[TOKidentity] = PREC_rel; 
    161     precedence[TOKnotidentity] = PREC_rel; 
    162 #endif 
    163  
    164     precedence[TOKand] = PREC_and; 
    165  
    166     precedence[TOKxor] = PREC_xor; 
    167  
    168     precedence[TOKor] = PREC_or; 
    169  
    170     precedence[TOKandand] = PREC_andand; 
    171  
    172     precedence[TOKoror] = PREC_oror; 
    173  
    174     precedence[TOKquestion] = PREC_cond; 
    175  
    176     precedence[TOKassign] = PREC_assign; 
    177     precedence[TOKconstruct] = PREC_assign; 
    178     precedence[TOKblit] = PREC_assign; 
    179     precedence[TOKaddass] = PREC_assign; 
    180     precedence[TOKminass] = PREC_assign; 
    181     precedence[TOKcatass] = PREC_assign; 
    182     precedence[TOKmulass] = PREC_assign; 
    183     precedence[TOKdivass] = PREC_assign; 
    184     precedence[TOKmodass] = PREC_assign; 
    185     precedence[TOKshlass] = PREC_assign; 
    186     precedence[TOKshrass] = PREC_assign; 
    187     precedence[TOKushrass] = PREC_assign; 
    188     precedence[TOKandass] = PREC_assign; 
    189     precedence[TOKorass] = PREC_assign; 
    190     precedence[TOKxorass] = PREC_assign; 
    191  
    192     precedence[TOKcomma] = PREC_expr; 
    193 } 
    19452 
    19553/************************************************************* 
    19654 * Given var, we need to get the 
    19755 * right 'this' pointer if var is in an outer class, but our 
    19856 * existing 'this' pointer is in an inner class. 
    19957 * Input: 
    20058 *      e1      existing 'this' 
    20159 *      ad      struct or class we need the correct 'this' for 
    20260 *      var     the specific member of ad we're accessing 
    20361 */ 
    20462 
    20563Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, 
    20664        Expression *e1, Declaration *var) 
    20765{ 
    20866    //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars()); 
    20967 L1: 
    21068    Type *t = e1->type->toBasetype(); 
    21169    //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars()); 
    21270 
    21371    /* If e1 is not the 'this' pointer for ad 

  • branches/dmd-1.x/src/parse.c

    r514 r585  
    54395439        check(TOKrbracket); 
    54405440        t = parseDeclarator(t, NULL); 
    54415441        t = new TypeDArray(t); 
    54425442    } 
    54435443    else if (token.value == TOKlparen) 
    54445444        arguments = parseArguments(); 
    54455445#endif 
    54465446    e = new NewExp(loc, thisexp, newargs, t, arguments); 
    54475447    return e; 
    54485448} 
    54495449 
    54505450/********************************************** 
    54515451 */ 
    54525452 
    54535453void Parser::addComment(Dsymbol *s, unsigned char *blockComment) 
    54545454{ 
    54555455    s->addComment(combineComments(blockComment, token.lineComment)); 
    54565456    token.lineComment = NULL; 
    54575457} 
    54585458 
    5459  
    5460 /********************************* ***************************/ 
    5461  
     5459/********************************** 
     5460 * Set operator precedence for each operator. 
     5461 */ 
     5462 
     5463void initPrecedence() 
     5464{ 
     5465    precedence[TOKdotvar] = PREC_primary; 
     5466    precedence[TOKimport] = PREC_primary; 
     5467    precedence[TOKidentifier] = PREC_primary; 
     5468    precedence[TOKthis] = PREC_primary; 
     5469    precedence[TOKsuper] = PREC_primary; 
     5470    precedence[TOKint64] = PREC_primary; 
     5471    precedence[TOKfloat64] = PREC_primary; 
     5472    precedence[TOKnull] = PREC_primary; 
     5473    precedence[TOKstring] = PREC_primary; 
     5474    precedence[TOKarrayliteral] = PREC_primary; 
     5475    precedence[TOKtypeid] = PREC_primary; 
     5476    precedence[TOKis] = PREC_primary; 
     5477    precedence[TOKassert] = PREC_primary; 
     5478    precedence[TOKfunction] = PREC_primary; 
     5479    precedence[TOKvar] = PREC_primary; 
     5480#if DMDV2 
     5481    precedence[TOKdefault] = PREC_primary; 
     5482#endif 
     5483 
     5484    // post 
     5485    precedence[TOKdotti] = PREC_primary; 
     5486    precedence[TOKdot] = PREC_primary; 
     5487//  precedence[TOKarrow] = PREC_primary; 
     5488    precedence[TOKplusplus] = PREC_primary; 
     5489    precedence[TOKminusminus] = PREC_primary; 
     5490    precedence[TOKcall] = PREC_primary; 
     5491    precedence[TOKslice] = PREC_primary; 
     5492    precedence[TOKarray] = PREC_primary; 
     5493 
     5494    precedence[TOKaddress] = PREC_unary; 
     5495    precedence[TOKstar] = PREC_unary; 
     5496    precedence[TOKneg] = PREC_unary; 
     5497    precedence[TOKuadd] = PREC_unary; 
     5498    precedence[TOKnot] = PREC_unary; 
     5499    precedence[TOKtobool] = PREC_add; 
     5500    precedence[TOKtilde] = PREC_unary; 
     5501    precedence[TOKdelete] = PREC_unary; 
     5502    precedence[TOKnew] = PREC_unary; 
     5503    precedence[TOKcast] = PREC_unary; 
     5504 
     5505    precedence[TOKmul] = PREC_mul; 
     5506    precedence[TOKdiv] = PREC_mul; 
     5507    precedence[TOKmod] = PREC_mul; 
     5508 
     5509    precedence[TOKadd] = PREC_add; 
     5510    precedence[TOKmin] = PREC_add; 
     5511    precedence[TOKcat] = PREC_add; 
     5512 
     5513    precedence[TOKshl] = PREC_shift; 
     5514    precedence[TOKshr] = PREC_shift; 
     5515    precedence[TOKushr] = PREC_shift; 
     5516 
     5517    precedence[TOKlt] = PREC_rel; 
     5518    precedence[TOKle] = PREC_rel; 
     5519    precedence[TOKgt] = PREC_rel; 
     5520    precedence[TOKge] = PREC_rel; 
     5521    precedence[TOKunord] = PREC_rel; 
     5522    precedence[TOKlg] = PREC_rel; 
     5523    precedence[TOKleg] = PREC_rel; 
     5524    precedence[TOKule] = PREC_rel; 
     5525    precedence[TOKul] = PREC_rel; 
     5526    precedence[TOKuge] = PREC_rel; 
     5527    precedence[TOKug] = PREC_rel; 
     5528    precedence[TOKue] = PREC_rel; 
     5529    precedence[TOKin] = PREC_rel; 
     5530 
     5531#if 0 
     5532    precedence[TOKequal] = PREC_equal; 
     5533    precedence[TOKnotequal] = PREC_equal; 
     5534    precedence[TOKidentity] = PREC_equal; 
     5535    precedence[TOKnotidentity] = PREC_equal; 
     5536#else 
     5537    /* Note that we changed precedence, so that < and != have the same 
     5538     * precedence. This change is in the parser, too. 
     5539     */ 
     5540    precedence[TOKequal] = PREC_rel; 
     5541    precedence[TOKnotequal] = PREC_rel; 
     5542    precedence[TOKidentity] = PREC_rel; 
     5543    precedence[TOKnotidentity] = PREC_rel; 
     5544#endif 
     5545 
     5546    precedence[TOKand] = PREC_and; 
     5547 
     5548    precedence[TOKxor] = PREC_xor; 
     5549 
     5550    precedence[TOKor] = PREC_or; 
     5551 
     5552    precedence[TOKandand] = PREC_andand; 
     5553 
     5554    precedence[TOKoror] = PREC_oror; 
     5555 
     5556    precedence[TOKquestion] = PREC_cond; 
     5557 
     5558    precedence[TOKassign] = PREC_assign; 
     5559    precedence[TOKconstruct] = PREC_assign; 
     5560    precedence[TOKblit] = PREC_assign; 
     5561    precedence[TOKaddass] = PREC_assign; 
     5562    precedence[TOKminass] = PREC_assign; 
     5563    precedence[TOKcatass] = PREC_assign; 
     5564    precedence[TOKmulass] = PREC_assign; 
     5565    precedence[TOKdivass] = PREC_assign; 
     5566    precedence[TOKmodass] = PREC_assign; 
     5567    precedence[TOKshlass] = PREC_assign; 
     5568    precedence[TOKshrass] = PREC_assign; 
     5569    precedence[TOKushrass] = PREC_assign; 
     5570    precedence[TOKandass] = PREC_assign; 
     5571    precedence[TOKorass] = PREC_assign; 
     5572    precedence[TOKxorass] = PREC_assign; 
     5573 
     5574    precedence[TOKcomma] = PREC_expr; 
     5575} 
     5576 

  • branches/dmd-1.x/src/parse.h

    r428 r585  
    126126    Expression *parseAddExp(); 
    127127    Expression *parseShiftExp(); 
    128128    Expression *parseRelExp(); 
    129129    Expression *parseEqualExp(); 
    130130    Expression *parseCmpExp(); 
    131131    Expression *parseAndExp(); 
    132132    Expression *parseXorExp(); 
    133133    Expression *parseOrExp(); 
    134134    Expression *parseAndAndExp(); 
    135135    Expression *parseOrOrExp(); 
    136136    Expression *parseCondExp(); 
    137137    Expression *parseAssignExp(); 
    138138 
    139139    Expressions *parseArguments(); 
    140140 
    141141    Expression *parseNewExp(Expression *thisexp); 
    142142 
    143143    void addComment(Dsymbol *s, unsigned char *blockComment); 
    144144}; 
    145145 
     146// Operator precedence - greater values are higher precedence 
     147 
     148enum PREC 
     149{ 
     150    PREC_zero, 
     151    PREC_expr, 
     152    PREC_assign, 
     153    PREC_cond, 
     154    PREC_oror, 
     155    PREC_andand, 
     156    PREC_or, 
     157    PREC_xor, 
     158    PREC_and, 
     159    PREC_equal, 
     160    PREC_rel, 
     161    PREC_shift, 
     162    PREC_add, 
     163    PREC_mul, 
     164    PREC_unary, 
     165    PREC_primary, 
     166}; 
     167 
     168enum PREC precedence[TOKMAX]; 
     169 
     170void initPrecedence(); 
     171 
    146172#endif /* DMD_PARSE_H */ 

  • trunk/src/expression.c

    r555 r585  
    3232#include "template.h" 
    3333#include "utf.h" 
    3434#include "enum.h" 
    3535#include "scope.h" 
    3636#include "statement.h" 
    3737#include "declaration.h" 
    3838#include "aggregate.h" 
    3939#include "import.h" 
    4040#include "id.h" 
    4141#include "dsymbol.h" 
    4242#include "module.h" 
    4343#include "attrib.h" 
    4444#include "hdrgen.h" 
    4545#include "parse.h" 
    4646 
    4747 
    4848Expression *createTypeInfoArray(Scope *sc, Expression *args[], int dim); 
    4949Expression *expandVar(int result, VarDeclaration *v); 
    5050 
    5151#define LOGSEMANTIC     0 
    52  
    53 /********************************** 
    54  * Set operator precedence for each operator. 
    55  */ 
    56  
    57 // Operator precedence - greater values are higher precedence 
    58  
    59 enum PREC 
    60 { 
    61     PREC_zero, 
    62     PREC_expr, 
    63     PREC_assign, 
    64     PREC_cond, 
    65     PREC_oror, 
    66     PREC_andand, 
    67     PREC_or, 
    68     PREC_xor, 
    69     PREC_and, 
    70     PREC_equal, 
    71     PREC_rel, 
    72     PREC_shift, 
    73     PREC_add, 
    74     PREC_mul, 
    75     PREC_pow, 
    76     PREC_unary, 
    77     PREC_primary, 
    78 }; 
    79  
    80 enum PREC precedence[TOKMAX]; 
    81  
    82 void initPrecedence() 
    83 { 
    84     precedence[TOKdotvar] = PREC_primary; 
    85     precedence[TOKimport] = PREC_primary; 
    86     precedence[TOKidentifier] = PREC_primary; 
    87     precedence[TOKthis] = PREC_primary; 
    88     precedence[TOKsuper] = PREC_primary; 
    89     precedence[TOKint64] = PREC_primary; 
    90     precedence[TOKfloat64] = PREC_primary; 
    91     precedence[TOKnull] = PREC_primary; 
    92     precedence[TOKstring] = PREC_primary; 
    93     precedence[TOKarrayliteral] = PREC_primary; 
    94     precedence[TOKtypeid] = PREC_primary; 
    95     precedence[TOKis] = PREC_primary; 
    96     precedence[TOKassert] = PREC_primary; 
    97     precedence[TOKfunction] = PREC_primary; 
    98     precedence[TOKvar] = PREC_primary; 
    99 #if DMDV2 
    100     precedence[TOKdefault] = PREC_primary; 
    101 #endif 
    102  
    103     // post 
    104     precedence[TOKdotti] = PREC_primary; 
    105     precedence[TOKdot] = PREC_primary; 
    106 //  precedence[TOKarrow] = PREC_primary; 
    107     precedence[TOKplusplus] = PREC_primary; 
    108     precedence[TOKminusminus] = PREC_primary; 
    109     precedence[TOKpreplusplus] = PREC_primary; 
    110     precedence[TOKpreminusminus] = PREC_primary; 
    111     precedence[TOKcall] = PREC_primary; 
    112     precedence[TOKslice] = PREC_primary; 
    113     precedence[TOKarray] = PREC_primary; 
    114  
    115     precedence[TOKaddress] = PREC_unary; 
    116     precedence[TOKstar] = PREC_unary; 
    117     precedence[TOKneg] = PREC_unary; 
    118     precedence[TOKuadd] = PREC_unary; 
    119     precedence[TOKnot] = PREC_unary; 
    120     precedence[TOKtobool] = PREC_add; 
    121     precedence[TOKtilde] = PREC_unary; 
    122     precedence[TOKdelete] = PREC_unary; 
    123     precedence[TOKnew] = PREC_unary; 
    124     precedence[TOKcast] = PREC_unary; 
    125  
    126     precedence[TOKpow] = PREC_pow; 
    127  
    128     precedence[TOKmul] = PREC_mul; 
    129     precedence[TOKdiv] = PREC_mul; 
    130     precedence[TOKmod] = PREC_mul; 
    131     precedence[TOKpow] = PREC_mul; 
    132  
    133     precedence[TOKadd] = PREC_add; 
    134     precedence[TOKmin] = PREC_add; 
    135     precedence[TOKcat] = PREC_add; 
    136  
    137     precedence[TOKshl] = PREC_shift; 
    138     precedence[TOKshr] = PREC_shift; 
    139     precedence[TOKushr] = PREC_shift; 
    140  
    141     precedence[TOKlt] = PREC_rel; 
    142     precedence[TOKle] = PREC_rel; 
    143     precedence[TOKgt] = PREC_rel; 
    144     precedence[TOKge] = PREC_rel; 
    145     precedence[TOKunord] = PREC_rel; 
    146     precedence[TOKlg] = PREC_rel; 
    147     precedence[TOKleg] = PREC_rel; 
    148     precedence[TOKule] = PREC_rel; 
    149     precedence[TOKul] = PREC_rel; 
    150     precedence[TOKuge] = PREC_rel; 
    151     precedence[TOKug] = PREC_rel; 
    152     precedence[TOKue] = PREC_rel; 
    153     precedence[TOKin] = PREC_rel; 
    154  
    155 #if 0 
    156     precedence[TOKequal] = PREC_equal; 
    157     precedence[TOKnotequal] = PREC_equal; 
    158     precedence[TOKidentity] = PREC_equal; 
    159     precedence[TOKnotidentity] = PREC_equal; 
    160 #else 
    161     /* Note that we changed precedence, so that < and != have the same 
    162      * precedence. This change is in the parser, too. 
    163      */ 
    164     precedence[TOKequal] = PREC_rel; 
    165     precedence[TOKnotequal] = PREC_rel; 
    166     precedence[TOKidentity] = PREC_rel; 
    167     precedence[TOKnotidentity] = PREC_rel; 
    168 #endif 
    169  
    170     precedence[TOKand] = PREC_and; 
    171  
    172     precedence[TOKxor] = PREC_xor; 
    173  
    174     precedence[TOKor] = PREC_or; 
    175  
    176     precedence[TOKandand] = PREC_andand; 
    177  
    178     precedence[TOKoror] = PREC_oror; 
    179  
    180     precedence[TOKquestion] = PREC_cond; 
    181  
    182     precedence[TOKassign] = PREC_assign; 
    183     precedence[TOKconstruct] = PREC_assign; 
    184     precedence[TOKblit] = PREC_assign; 
    185     precedence[TOKaddass] = PREC_assign; 
    186     precedence[TOKminass] = PREC_assign; 
    187     precedence[TOKcatass] = PREC_assign; 
    188     precedence[TOKmulass] = PREC_assign; 
    189     precedence[TOKdivass] = PREC_assign; 
    190     precedence[TOKmodass] = PREC_assign; 
    191     precedence[TOKpowass] = PREC_assign; 
    192     precedence[TOKshlass] = PREC_assign; 
    193     precedence[TOKshrass] = PREC_assign; 
    194     precedence[TOKushrass] = PREC_assign; 
    195     precedence[TOKandass] = PREC_assign; 
    196     precedence[TOKorass] = PREC_assign; 
    197     precedence[TOKxorass] = PREC_assign; 
    198  
    199     precedence[TOKcomma] = PREC_expr; 
    200 } 
    20152 
    20253/************************************************************* 
    20354 * Given var, we need to get the 
    20455 * right 'this' pointer if var is in an outer class, but our 
    20556 * existing 'this' pointer is in an inner class. 
    20657 * Input: 
    20758 *      e1      existing 'this' 
    20859 *      ad      struct or class we need the correct 'this' for 
    20960 *      var     the specific member of ad we're accessing 
    21061 */ 
    21162 
    21263Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, 
    21364        Expression *e1, Declaration *var) 
    21465{ 
    21566    //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars()); 
    21667 L1: 
    21768    Type *t = e1->type->toBasetype(); 
    21869    //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars()); 
    21970 
    22071    /* If e1 is not the 'this' pointer for ad 
    …… 
    1001852        {   Expression *arg = (Expression *)arguments->data[i]; 
    1002853 
    1003854            if (i) 
    1004855                buf->writeByte(','); 
    1005856            argbuf.reset(); 
    1006857            arg->type->toCBuffer2(&argbuf, hgs, 0); 
    1007858            buf->write(&argbuf); 
    1008859        } 
    1009860    } 
    1010861} 
    1011862 
    1012863/******************************** Expression **************************/ 
    1013864 
    1014865Expression::Expression(Loc loc, enum TOK op, int size) 
    1015866    : loc(loc) 
    1016867{ 
    1017868    //printf("Expression::Expression(op = %d) this = %p\n", op, this); 
    1018869    this->loc = loc; 
    1019870    this->op = op; 
    1020871    this->size = size; 
     872    this->parens = 0; 
    1021873    type = NULL; 
    1022874} 
    1023875 
    1024876Expression *Expression::syntaxCopy() 
    1025877{ 
    1026878    //printf("Expression::syntaxCopy()\n"); 
    1027879    //dump(0); 
    1028880    return copy(); 
    1029881} 
    1030882 
    1031883/********************************* 
    1032884 * Does *not* do a deep copy. 
    1033885 */ 
    1034886 
    1035887Expression *Expression::copy() 
    1036888{ 
    1037889    Expression *e; 
    1038890    if (!size) 
    1039891    { 
    1040892#ifdef DEBUG 

  • trunk/src/expression.h

    r528 r585  
    6464Expression *build_overload(Loc loc, Scope *sc, Expression *ethis, Expression *earg, Identifier *id, Objects *targsi = NULL); 
    6565Dsymbol *search_function(ScopeDsymbol *ad, Identifier *funcid); 
    6666void inferApplyArgTypes(enum TOK op, Parameters *arguments, Expression *aggr); 
    6767void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); 
    6868void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs); 
    6969void expandTuples(Expressions *exps); 
    7070FuncDeclaration *hasThis(Scope *sc); 
    7171Expression *fromConstInitializer(int result, Expression *e); 
    7272int arrayExpressionCanThrow(Expressions *exps); 
    7373 
    7474struct IntRange 
    7575{   uinteger_t imin; 
    7676    uinteger_t imax; 
    7777}; 
    7878 
    7979struct Expression : Object 
    8080{ 
    8181    Loc loc;                    // file location 
    8282    enum TOK op;                // handy to minimize use of dynamic_cast 
    8383    Type *type;                 // !=NULL means that semantic() has been run 
    84     int size;                   // # of bytes in Expression so we can copy() it 
     84    unsigned char size;         // # of bytes in Expression so we can copy() it 
     85    unsigned char parens;       // if this is a parenthesized expression 
    8586 
    8687    Expression(Loc loc, enum TOK op, int size); 
    8788    Expression *copy(); 
    8889    virtual Expression *syntaxCopy(); 
    8990    virtual Expression *semantic(Scope *sc); 
    9091    Expression *trySemantic(Scope *sc); 
    9192 
    9293    int dyncast() { return DYNCAST_EXPRESSION; }        // kludge for template.isExpression() 
    9394 
    9495    void print(); 
    9596    char *toChars(); 
    9697    virtual void dump(int indent); 
    9798    void error(const char *format, ...); 
    9899    void warning(const char *format, ...); 
    99100    virtual void rvalue(); 
    100101 
    101102    static Expression *combine(Expression *e1, Expression *e2); 
    102103    static Expressions *arraySyntaxCopy(Expressions *exps); 
    103104 
    104105    virtual dinteger_t toInteger(); 

  • trunk/src/parse.c

    r514 r585  
    42294229} 
    42304230 
    42314231void Parser::check(enum TOK value) 
    42324232{ 
    42334233    check(loc, value); 
    42344234} 
    42354235 
    42364236void Parser::check(Loc loc, enum TOK value) 
    42374237{ 
    42384238    if (token.value != value) 
    42394239        error(loc, "found '%s' when expecting '%s'", token.toChars(), Token::toChars(value)); 
    42404240    nextToken(); 
    42414241} 
    42424242 
    42434243void Parser::check(enum TOK value, const char *string) 
    42444244{ 
    42454245    if (token.value != value) 
    42464246        error("found '%s' when expecting '%s' following %s", 
    42474247            token.toChars(), Token::toChars(value), string); 
    42484248    nextToken(); 
     4249} 
     4250 
     4251void Parser::checkParens(enum TOK value, Expression *e) 
     4252{ 
     4253    if (precedence[e->op] == PREC_rel && !e->parens) 
     4254        error(loc, "%s must be parenthesized when next to operator %s", e->toChars(), Token::toChars(value)); 
    42494255} 
    42504256 
    42514257/************************************ 
    42524258 * Determine if the scanner is sitting on the start of a declaration. 
    42534259 * Input: 
    42544260 *      needId  0       no identifier 
    42554261 *              1       identifier optional 
    42564262 *              2       must have identifier 
    42574263 * Output: 
    42584264 *      if *pt is not NULL, it is set to the ending token, which would be endtok 
    42594265 */ 
    42604266 
    42614267int Parser::isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt) 
    42624268{ 
    42634269    //printf("isDeclaration(needId = %d)\n", needId); 
    42644270    int haveId = 0; 
    42654271 
    42664272#if DMDV2 
    42674273    if ((t->value == TOKconst || 
    42684274         t->value == TOKinvariant || 
    …… 
    52295235 
    52305236        case TOKimport: 
    52315237        { 
    52325238            nextToken(); 
    52335239            check(TOKlparen, "import"); 
    52345240            e = parseAssignExp(); 
    52355241            check(TOKrparen); 
    52365242            e = new FileExp(loc, e); 
    52375243            break; 
    52385244        } 
    52395245 
    52405246        case TOKlparen: 
    52415247            if (peekPastParen(&token)->value == TOKlcurly) 
    52425248            {   // (arguments) { statements... } 
    52435249                save = TOKdelegate; 
    52445250                goto case_delegate; 
    52455251            } 
    52465252            // ( expression ) 
    52475253            nextToken(); 
    52485254            e = parseExpression(); 
     5255            e->parens = 1; 
    52495256            check(loc, TOKrparen); 
    52505257            break; 
    52515258 
    52525259        case TOKlbracket: 
    52535260        {   /* Parse array literals and associative array literals: 
    52545261             *  [ value, value, value ... ] 
    52555262             *  [ key:value, key:value, key:value ... ] 
    52565263             */ 
    52575264            Expressions *values = new Expressions(); 
    52585265            Expressions *keys = NULL; 
    52595266 
    52605267            nextToken(); 
    52615268            if (token.value != TOKrbracket) 
    52625269            { 
    52635270                while (token.value != TOKeof) 
    52645271                { 
    52655272                    Expression *e = parseAssignExp(); 
    52665273                    if (token.value == TOKcolon && (keys || values->dim == 0)) 
    52675274                    {   nextToken(); 
    52685275                        if (!keys) 
    …… 
    57615768    Expression *e2; 
    57625769    Loc loc = this->loc; 
    57635770 
    57645771    e = parseAddExp(); 
    57655772    while (1) 
    57665773    { 
    57675774        switch (token.value) 
    57685775        { 
    57695776            case TOKshl:  nextToken(); e2 = parseAddExp(); e = new ShlExp(loc,e,e2);  continue; 
    57705777            case TOKshr:  nextToken(); e2 = parseAddExp(); e = new ShrExp(loc,e,e2);  continue; 
    57715778            case TOKushr: nextToken(); e2 = parseAddExp(); e = new UshrExp(loc,e,e2); continue; 
    57725779 
    57735780            default: 
    57745781                break; 
    57755782        } 
    57765783        break; 
    57775784    } 
    57785785    return e; 
    57795786} 
    57805787 
     5788#if DMDV1 
    57815789Expression *Parser::parseRelExp() 
    57825790{   Expression *e; 
    57835791    Expression *e2; 
    57845792    enum TOK op; 
    57855793    Loc loc = this->loc; 
    57865794 
    57875795    e = parseShiftExp(); 
    57885796    while (1) 
    57895797    { 
    57905798        switch (token.value) 
    57915799        { 
    57925800            case TOKlt: 
    57935801            case TOKle: 
    57945802            case TOKgt: 
    57955803            case TOKge: 
    57965804            case TOKunord: 
    57975805            case TOKlg: 
    57985806            case TOKleg: 
    57995807            case TOKule: 
    58005808            case TOKul: 
    58015809            case TOKuge: 
    58025810            case TOKug: 
    58035811            case TOKue: 
    58045812                op = token.value; 
    58055813                nextToken(); 
    58065814                e2 = parseShiftExp(); 
    58075815                e = new CmpExp(op, loc, e, e2); 
    58085816                continue; 
    58095817 
    58105818            case TOKnot:                // could be !in 
    5811 printf("test1\n"); 
    58125819                if (peekNext() == TOKin) 
    58135820                { 
    5814 printf("test2\n"); 
    58155821                    nextToken(); 
    58165822                    nextToken(); 
    58175823                    e2 = parseShiftExp(); 
    58185824                    e = new InExp(loc, e, e2); 
    58195825                    e = new NotExp(loc, e); 
    58205826                    continue; 
    58215827                } 
    58225828                break; 
    58235829 
    58245830            case TOKin: 
    58255831                nextToken(); 
    58265832                e2 = parseShiftExp(); 
    58275833                e = new InExp(loc, e, e2); 
    58285834                continue; 
    58295835 
    58305836            default: 
    58315837                break; 
    58325838        } 
    58335839        break; 
    58345840    } 
    58355841    return e; 
    58365842} 
    5837  
     5843#endif 
     5844 
     5845#if DMDV1 
    58385846Expression *Parser::parseEqualExp() 
    58395847{   Expression *e; 
    58405848    Expression *e2; 
    58415849    Token *t; 
    58425850    Loc loc = this->loc; 
    58435851 
    58445852    e = parseRelExp(); 
    58455853    while (1) 
    58465854    {   enum TOK value = token.value; 
    58475855 
    58485856        switch (value) 
    58495857        { 
    58505858            case TOKequal: 
    58515859            case TOKnotequal: 
    58525860                nextToken(); 
    58535861                e2 = parseRelExp(); 
    58545862                e = new EqualExp(value, loc, e, e2); 
    58555863                continue; 
    58565864 
    58575865            case TOKidentity: 
    …… 
    58715879                t = peek(&token); 
    58725880                if (t->value != TOKis) 
    58735881                    break; 
    58745882                nextToken(); 
    58755883                value = TOKnotidentity; 
    58765884                goto L1; 
    58775885 
    58785886            L1: 
    58795887                nextToken(); 
    58805888                e2 = parseRelExp(); 
    58815889                e = new IdentityExp(value, loc, e, e2); 
    58825890                continue; 
    58835891 
    58845892            default: 
    58855893                break; 
    58865894        } 
    58875895        break; 
    58885896    } 
    58895897    return e; 
    58905898} 
     5899#endif 
    58915900 
    58925901Expression *Parser::parseCmpExp() 
    58935902{   Expression *e; 
    58945903    Expression *e2; 
    58955904    Token *t; 
    58965905    Loc loc = this->loc; 
    58975906 
    58985907    e = parseShiftExp(); 
    58995908    enum TOK op = token.value; 
    59005909 
    59015910    switch (op) 
    59025911    { 
    59035912        case TOKequal: 
    59045913        case TOKnotequal: 
    59055914            nextToken(); 
    59065915            e2 = parseShiftExp(); 
    59075916            e = new EqualExp(op, loc, e, e2); 
    59085917            break; 
    59095918 
    59105919        case TOKis: 
    …… 
    59485957        case TOKug: 
    59495958        case TOKue: 
    59505959            nextToken(); 
    59515960            e2 = parseShiftExp(); 
    59525961            e = new CmpExp(op, loc, e, e2); 
    59535962            break; 
    59545963 
    59555964        case TOKin: 
    59565965            nextToken(); 
    59575966            e2 = parseShiftExp(); 
    59585967            e = new InExp(loc, e, e2); 
    59595968            break; 
    59605969 
    59615970        default: 
    59625971            break; 
    59635972    } 
    59645973    return e; 
    59655974} 
    59665975 
    59675976Expression *Parser::parseAndExp() 
    5968 {   Expression *e; 
    5969     Expression *e2; 
     5977{ 
    59705978    Loc loc = this->loc; 
    59715979 
    5972     if (global.params.Dversion == 1) 
    5973     { 
    5974         e = parseEqualExp(); 
    5975         while (token.value == TOKand) 
    5976         { 
    5977             nextToken(); 
    5978             e2 = parseEqualExp(); 
    5979             e = new AndExp(loc,e,e2); 
    5980             loc = this->loc; 
    5981         } 
    5982     } 
    5983     else 
    5984     { 
    5985         e = parseCmpExp(); 
    5986         while (token.value == TOKand) 
    5987         { 
    5988             nextToken(); 
    5989             e2 = parseCmpExp(); 
    5990             e = new AndExp(loc,e,e2); 
    5991             loc = this->loc; 
    5992         } 
     5980    Expression *e = parseCmpExp(); 
     5981    while (token.value == TOKand) 
     5982    { 
     5983        checkParens(TOKand, e); 
     5984        nextToken(); 
     5985        Expression *e2 = parseCmpExp(); 
     5986        checkParens(TOKand, e2); 
     5987        e = new AndExp(loc,e,e2); 
     5988        loc = this->loc; 
    59935989    } 
    59945990    return e; 
    59955991} 
    59965992 
    59975993Expression *Parser::parseXorExp() 
    5998 {   Expression *e; 
    5999     Expression *e2; 
     5994{ 
    60005995    Loc loc = this->loc; 
    60015996 
    6002     e = parseAndExp(); 
     5997    Expression *e = parseAndExp(); 
    60035998    while (token.value == TOKxor) 
    60045999    { 
     6000        checkParens(TOKxor, e); 
    60056001        nextToken(); 
    6006         e2 = parseAndExp(); 
     6002        Expression *e2 = parseAndExp(); 
     6003        checkParens(TOKxor, e2); 
    60076004        e = new XorExp(loc, e, e2); 
    60086005    } 
    60096006    return e; 
    60106007} 
    60116008 
    60126009Expression *Parser::parseOrExp() 
    6013 {   Expression *e; 
    6014     Expression *e2; 
     6010{ 
    60156011    Loc loc = this->loc; 
    60166012 
    6017     e = parseXorExp(); 
     6013    Expression *e = parseXorExp(); 
    60186014    while (token.value == TOKor) 
    60196015    { 
     6016        checkParens(TOKor, e); 
    60206017        nextToken(); 
    6021         e2 = parseXorExp(); 
     6018        Expression *e2 = parseXorExp(); 
     6019        checkParens(TOKor, e2); 
    60226020        e = new OrExp(loc, e, e2); 
    60236021    } 
    60246022    return e; 
    60256023} 
    60266024 
    60276025Expression *Parser::parseAndAndExp() 
    60286026{   Expression *e; 
    60296027    Expression *e2; 
    60306028    Loc loc = this->loc; 
    60316029 
    60326030    e = parseOrExp(); 
    60336031    while (token.value == TOKandand) 
    60346032    { 
    60356033        nextToken(); 
    60366034        e2 = parseOrExp(); 
    60376035        e = new AndAndExp(loc, e, e2); 
    60386036    } 
    60396037    return e; 
    60406038} 
    60416039 
    …… 
    62416239        t = new TypeDArray(tsa->next); 
    62426240    } 
    62436241    else if (token.value == TOKlparen) 
    62446242    { 
    62456243        arguments = parseArguments(); 
    62466244    } 
    62476245    e = new NewExp(loc, thisexp, newargs, t, arguments); 
    62486246    return e; 
    62496247} 
    62506248 
    62516249/********************************************** 
    62526250 */ 
    62536251 
    62546252void Parser::addComment(Dsymbol *s, unsigned char *blockComment) 
    62556253{ 
    62566254    s->addComment(combineComments(blockComment, token.lineComment)); 
    62576255    token.lineComment = NULL; 
    62586256} 
    62596257 
    62606258 
    6261 /********************************* ***************************/ 
    6262  
     6259/********************************** 
     6260 * Set operator precedence for each operator. 
     6261 */ 
     6262 
     6263enum PREC precedence[TOKMAX]; 
     6264 
     6265void initPrecedence() 
     6266{ 
     6267    precedence[TOKdotvar] = PREC_primary; 
     6268    precedence[TOKimport] = PREC_primary; 
     6269    precedence[TOKidentifier] = PREC_primary; 
     6270    precedence[TOKthis] = PREC_primary; 
     6271    precedence[TOKsuper] = PREC_primary; 
     6272    precedence[TOKint64] = PREC_primary; 
     6273    precedence[TOKfloat64] = PREC_primary; 
     6274    precedence[TOKnull] = PREC_primary; 
     6275    precedence[TOKstring] = PREC_primary; 
     6276    precedence[TOKarrayliteral] = PREC_primary; 
     6277    precedence[TOKtypeid] = PREC_primary; 
     6278    precedence[TOKis] = PREC_primary; 
     6279    precedence[TOKassert] = PREC_primary; 
     6280    precedence[TOKfunction] = PREC_primary; 
     6281    precedence[TOKvar] = PREC_primary; 
     6282#if DMDV2 
     6283    precedence[TOKdefault] = PREC_primary; 
     6284#endif 
     6285 
     6286    // post 
     6287    precedence[TOKdotti] = PREC_primary; 
     6288    precedence[TOKdot] = PREC_primary; 
     6289//  precedence[TOKarrow] = PREC_primary; 
     6290    precedence[TOKplusplus] = PREC_primary; 
     6291    precedence[TOKminusminus] = PREC_primary; 
     6292    precedence[TOKpreplusplus] = PREC_primary; 
     6293    precedence[TOKpreminusminus] = PREC_primary; 
     6294    precedence[TOKcall] = PREC_primary; 
     6295    precedence[TOKslice] = PREC_primary; 
     6296    precedence[TOKarray] = PREC_primary; 
     6297 
     6298    precedence[TOKaddress] = PREC_unary; 
     6299    precedence[TOKstar] = PREC_unary; 
     6300    precedence[TOKneg] = PREC_unary; 
     6301    precedence[TOKuadd] = PREC_unary; 
     6302    precedence[TOKnot] = PREC_unary; 
     6303    precedence[TOKtobool] = PREC_add; 
     6304    precedence[TOKtilde] = PREC_unary; 
     6305    precedence[TOKdelete] = PREC_unary; 
     6306    precedence[TOKnew] = PREC_unary; 
     6307    precedence[TOKcast] = PREC_unary; 
     6308 
     6309    precedence[TOKpow] = PREC_pow; 
     6310 
     6311    precedence[TOKmul] = PREC_mul; 
     6312    precedence[TOKdiv] = PREC_mul; 
     6313    precedence[TOKmod] = PREC_mul; 
     6314    precedence[TOKpow] = PREC_mul; 
     6315 
     6316    precedence[TOKadd] = PREC_add; 
     6317    precedence[TOKmin] = PREC_add; 
     6318    precedence[TOKcat] = PREC_add; 
     6319 
     6320    precedence[TOKshl] = PREC_shift; 
     6321    precedence[TOKshr] = PREC_shift; 
     6322    precedence[TOKushr] = PREC_shift; 
     6323 
     6324    precedence[TOKlt] = PREC_rel; 
     6325    precedence[TOKle] = PREC_rel; 
     6326    precedence[TOKgt] = PREC_rel; 
     6327    precedence[TOKge] = PREC_rel; 
     6328    precedence[TOKunord] = PREC_rel; 
     6329    precedence[TOKlg] = PREC_rel; 
     6330    precedence[TOKleg] = PREC_rel; 
     6331    precedence[TOKule] = PREC_rel; 
     6332    precedence[TOKul] = PREC_rel; 
     6333    precedence[TOKuge] = PREC_rel; 
     6334    precedence[TOKug] = PREC_rel; 
     6335    precedence[TOKue] = PREC_rel; 
     6336    precedence[TOKin] = PREC_rel; 
     6337 
     6338#if 0 
     6339    precedence[TOKequal] = PREC_equal; 
     6340    precedence[TOKnotequal] = PREC_equal; 
     6341    precedence[TOKidentity] = PREC_equal; 
     6342    precedence[TOKnotidentity] = PREC_equal; 
     6343#else 
     6344    /* Note that we changed precedence, so that < and != have the same 
     6345     * precedence. This change is in the parser, too. 
     6346     */ 
     6347    precedence[TOKequal] = PREC_rel; 
     6348    precedence[TOKnotequal] = PREC_rel; 
     6349    precedence[TOKidentity] = PREC_rel; 
     6350    precedence[TOKnotidentity] = PREC_rel; 
     6351#endif 
     6352 
     6353    precedence[TOKand] = PREC_and; 
     6354 
     6355    precedence[TOKxor] = PREC_xor; 
     6356 
     6357    precedence[TOKor] = PREC_or; 
     6358 
     6359    precedence[TOKandand] = PREC_andand; 
     6360 
     6361    precedence[TOKoror] = PREC_oror; 
     6362 
     6363    precedence[TOKquestion] = PREC_cond; 
     6364 
     6365    precedence[TOKassign] = PREC_assign; 
     6366    precedence[TOKconstruct] = PREC_assign; 
     6367    precedence[TOKblit] = PREC_assign; 
     6368    precedence[TOKaddass] = PREC_assign; 
     6369    precedence[TOKminass] = PREC_assign; 
     6370    precedence[TOKcatass] = PREC_assign; 
     6371    precedence[TOKmulass] = PREC_assign; 
     6372    precedence[TOKdivass] = PREC_assign; 
     6373    precedence[TOKmodass] = PREC_assign; 
     6374    precedence[TOKpowass] = PREC_assign; 
     6375    precedence[TOKshlass] = PREC_assign; 
     6376    precedence[TOKshrass] = PREC_assign; 
     6377    precedence[TOKushrass] = PREC_assign; 
     6378    precedence[TOKandass] = PREC_assign; 
     6379    precedence[TOKorass] = PREC_assign; 
     6380    precedence[TOKxorass] = PREC_assign; 
     6381 
     6382    precedence[TOKcomma] = PREC_expr; 
     6383} 
     6384 
     6385 

  • trunk/src/parse.h

    r428 r585  
    9999    UnitTestDeclaration *parseUnitTest(); 
    100100    NewDeclaration *parseNew(); 
    101101    DeleteDeclaration *parseDelete(); 
    102102    Parameters *parseParameters(int *pvarargs); 
    103103    EnumDeclaration *parseEnum(); 
    104104    Dsymbol *parseAggregate(); 
    105105    BaseClasses *parseBaseClasses(); 
    106106    Import *parseImport(Dsymbols *decldefs, int isstatic); 
    107107    Type *parseType(Identifier **pident = NULL, TemplateParameters **tpl = NULL); 
    108108    Type *parseBasicType(); 
    109109    Type *parseBasicType2(Type *t); 
    110110    Type *parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl = NULL); 
    111111    Dsymbols *parseDeclarations(StorageClass storage_class); 
    112112    void parseContracts(FuncDeclaration *f); 
    113113    Statement *parseStatement(int flags); 
    114114    Initializer *parseInitializer(); 
    115115    Expression *parseDefaultInitExp(); 
    116116    void check(Loc loc, enum TOK value); 
    117117    void check(enum TOK value); 
    118118    void check(enum TOK value, const char *string); 
     119    void checkParens(enum TOK value, Expression *e); 
    119120    int isDeclaration(Token *t, int needId, enum TOK endtok, Token **pt); 
    120121    int isBasicType(Token **pt); 
    121122    int isDeclarator(Token **pt, int *haveId, enum TOK endtok); 
    122123    int isParameters(Token **pt); 
    123124    int isExpression(Token **pt); 
    124125    int isTemplateInstance(Token *t, Token **pt); 
    125126    int skipParens(Token *t, Token **pt); 
    126127 
    127128    Expression *parseExpression(); 
    128129    Expression *parsePrimaryExp(); 
    129130    Expression *parseUnaryExp(); 
    130131    Expression *parsePostExp(Expression *e); 
    131132    Expression *parseMulExp(); 
    132133    Expression *parseAddExp(); 
    133134    Expression *parseShiftExp(); 
     135#if DMDV1 
    134136    Expression *parseRelExp(); 
    135137    Expression *parseEqualExp(); 
     138#endif 
    136139    Expression *parseCmpExp(); 
    137140    Expression *parseAndExp(); 
    138141    Expression *parseXorExp(); 
    139142    Expression *parseOrExp(); 
    140143    Expression *parseAndAndExp(); 
    141144    Expression *parseOrOrExp(); 
    142145    Expression *parseCondExp(); 
    143146    Expression *parseAssignExp(); 
    144147 
    145148    Expressions *parseArguments(); 
    146149 
    147150    Expression *parseNewExp(Expression *thisexp); 
    148151 
    149152    void addComment(Dsymbol *s, unsigned char *blockComment); 
    150153}; 
    151154 
     155// Operator precedence - greater values are higher precedence 
     156 
     157enum PREC 
     158{ 
     159    PREC_zero, 
     160    PREC_expr, 
     161    PREC_assign, 
     162    PREC_cond, 
     163    PREC_oror, 
     164    PREC_andand, 
     165    PREC_or, 
     166    PREC_xor, 
     167    PREC_and, 
     168    PREC_equal, 
     169    PREC_rel, 
     170    PREC_shift, 
     171    PREC_add, 
     172    PREC_mul, 
     173    PREC_pow, 
     174    PREC_unary, 
     175    PREC_primary, 
     176}; 
     177 
     178extern enum PREC precedence[TOKMAX]; 
     179 
     180void initPrecedence(); 
     181 
    152182#endif /* DMD_PARSE_H */