表达式语法文件 for Antlr

使用AntlrWorks编写了以下Expr.g语法文件，考虑到便与后期遍历树构造节点方便，添加了一些虚Token，例如BINARY。
 语法文件内容如下：

  1  grammar Expr;
  2 
  3  options {
  4    output = AST;
  5    ASTLabelType = CommonTree;
  6    //  language=CSharp;
  7  }
  8 
  9  tokens {
 10        CALL;
 11      INDEX;
 12      BINARY;
 13      UNARY;
 14      CONST;
 15      VAR;
 16      FIELD;
 17  }
 18 
 19  expr 
 20      :    logicalOrExpr
 21      ;
 22 
 23  logicalOrExpr 
 24      :    (logicalAndExpr -> logicalAndExpr) (OR b = logicalAndExpr  ->   ^ (BINARY OR $logicalOrExpr $b)) *
 25      ;
 26                          
 27  logicalAndExpr 
 28      :    (equalityExpr -> equalityExpr) (AND b = equalityExpr  ->   ^ (BINARY AND $logicalAndExpr $b)) *   
 29      ;   
 30                           
 31  equalityExpr 
 32      :    (relationalExpr -> relationalExpr) ((a = EQUALS | a = NOTEQUALS) b = relationalExpr  ->   ^ (BINARY $a $equalityExpr $b)) *
 33      ;
 34      
 35  relationalExpr 
 36      :    (additiveExpr  ->  additiveExpr) ((a = LT | a = LTEQ | a = GT | a = GTEQ) b = additiveExpr  ->   ^ (BINARY $a $relationalExpr $b)) ?  
 37      ;
 38    
 39  additiveExpr 
 40      :    (multiplyExpr ->  multiplyExpr) ((a = PLUS | a = MINUS) b = multiplyExpr  ->   ^ (BINARY $a $additiveExpr $b)) *
 41        ;
 42 
 43  multiplyExpr 
 44        :    (powExpr -> powExpr) ((a = MUL | a = DIV | a = MOD) b = powExpr  ->^ (BINARY $a $multiplyExpr $b)) *  
 45         ;
 46     
 47  powExpr 
 48         :    (unaryExpr  -> unaryExpr) (POWER b = unaryExpr  ->   ^ (BINARY POWER $powExpr $b)) ?  
 49         ;   
 50 
 51  unaryExpr 
 52      :      (a = PLUS  |  a = MINUS  |  a = NOT) unaryExpr  ->   ^ (UNARY $a unaryExpr)      
 53       |       memberExpr 
 54      ;
 55         
 56  memberExpr 
 57         :    basicExpr ^  (memberAccessExpr | indexerExpr) *  
 58         ;
 59 
 60  basicExpr 
 61      :    constant  |   varExpr  |  methodExpr  |  parenExpr;       
 62         
 63  parenExpr 
 64         :    LPAREN expr  RPAREN  ->  expr
 65         ; 
 66         
 67  constant  
 68        :      (a = INTEGER_LITERAL  |  a = DECIMAL_LITERAL  |  a = DATETIME_LITERAL  |  a = STRING_LITERAL  |  a = BOOL_LITERAL)  ->   ^ (CONST $a)
 69         ;    
 70         
 71  memberAccessExpr 
 72      :     ' . ' !  memberFunctionExpr
 73      ;
 74 
 75  memberFunctionExpr 
 76      :    fieldPropertyExpr  ->   ^ (FIELD fieldPropertyExpr)  |  methodExpr
 77      ;
 78      
 79  fieldPropertyExpr 
 80      :    IDENTIFIER
 81      ;    
 82      
 83  varExpr    
 84      :    IDENTIFIER  ->   ^ (VAR IDENTIFIER)
 85      ;
 86  methodExpr    
 87      :    IDENTIFIER LPAREN (argument (COMMA argument) * ) ?  RPAREN  ->   ^ (CALL IDENTIFIER argument * )
 88      ;
 89          
 90  indexerExpr 
 91      :    LBRACKET argument (COMMA argument) *  RBRACKET  ->   ^ (INDEX argument + )
 92      ;
 93      
 94  argument 
 95        :     expr 
 96        ;   
 97 
 98     
 99  AND    
100      :     ' and '
101      ;
102      
103  OR    
104      :      ' or '
105      ;
106 
107  NOT    
108      :      ' not '
109      ;
110 
111  COMMA     
112      :      ' , '   
113      ;
114 
115  PLUS    
116      :      ' + '   
117      ;
118      
119  MINUS    
120      :      ' - '
121      ;
122      
123  MUL    
124      :      ' * '   
125      ;
126      
127  DIV    
128      :      ' / '   
129      ;
130      
131  MOD    
132      :      ' % '
133      ;
134      
135  POWER    
136      :      ' ^ '
137      ;
138      
139  EQUALS    :     ' = ' ;
140      
141  NOTEQUALS 
142      :     ' != '   |   ' <> ' ;
143      
144  LT    :     ' < ' ;
145  LTEQ    :     ' <= ' ;
146  GT    :     ' > ' ;
147  GTEQ    :     ' >= ' ;
148 
149  LPAREN
150      :     ' ( '
151      ;
152      
153  RPAREN    :     ' ) '
154      ;
155 
156  LBRACKET
157      :     ' [ '
158      ;
159 
160  RBRACKET
161      :     ' ] '
162      ;
163      
164  DATETIME_LITERAL
165      :      ' \ ''  STRING_LITERAL  ' \ ''
166      ;
167 
168  STRING_LITERAL    
169      :     ' " '  ( ~ ' " ' ) *   ' " '     
170      ;
171 
172  BOOL_LITERAL
173      :     ' true ' | ' True ' | ' false ' | ' False '
174      ;
175 
176  IDENTIFIER
177      :    LETTER (LETTER | Digit) *
178      ;
179      
180  fragment
181  LETTER    
182      :     ' A ' .. ' Z ' | ' a ' .. ' z ' | ' _ '
183      ;
184 
185  DECIMAL_LITERAL
186      :       (INTEGER_LITERAL) ?   ' . '  Digit *  Exponent ?  
187      ;
188 
189  fragment
190  Exponent 
191      :     ( ' e ' | ' E ' ) INTEGER_LITERAL
192      ;
193 
194  INTEGER_LITERAL 
195      :     Digit +  
196      ;    
197 
198  fragment
199  Digit    
200      :     ' 0 ' .. ' 9 '
201      ;
202 
203          
204 
205  /*  Ignore white spaces  */     
206  WS    
207      :  ( '   ' | ' \r ' | ' \t ' | ' \u000C ' | ' \n ' ) {$channel = HIDDEN;}
208      ;
209 

在AntlrWorks调试以下语句：2-3+IIF(true=false, ds.b[1].id+bb, pp())
解析后的AST为：