overhaul of statement codegen
[charm.git] / src / langs / charj / src / charj / translator / Charj.g
1 /**
2  * ANTLR (v3) grammar for the Charj Language
3  *
4  * The other .g files are tree parsers that can read and modify an AST 
5  * using the output of this grammar.
6  */
7
8
9 grammar Charj;
10
11 options {
12     backtrack = true; 
13     memoize = true;
14     output = AST;
15     ASTLabelType = CharjAST;
16 }
17
18 tokens {
19
20     // operators and other special chars
21     
22     AND                     = '&'               ;
23     AND_ASSIGN              = '&='              ;
24     ASSIGN                  = '='               ;
25     AT                      = '@'               ;
26     BIT_SHIFT_RIGHT         = '>>>'             ;
27     BIT_SHIFT_RIGHT_ASSIGN  = '>>>='            ;
28     COLON                   = ':'               ;
29     COMMA                   = ','               ;
30     DEC                     = '--'              ;
31     DIV                     = '/'               ;
32     DIV_ASSIGN              = '/='              ;
33     DOT                     = '.'               ;
34     DOTSTAR                 = '.*'              ;
35     ELLIPSIS                = '...'             ;
36     EQUAL                   = '=='              ;
37     GREATER_OR_EQUAL        = '>='              ;
38     GREATER_THAN            = '>'               ;
39     INC                     = '++'              ;
40     LBRACK                  = '['               ;
41     LCURLY                  = '{'               ;
42     LESS_OR_EQUAL           = '<='              ;
43     LESS_THAN               = '<'               ;
44     LOGICAL_AND             = '&&'              ;
45     LOGICAL_NOT             = '!'               ;
46     LOGICAL_OR              = '||'              ;
47     LPAREN                  = '('               ;
48     MINUS                   = '-'               ;
49     MINUS_ASSIGN            = '-='              ;
50     MOD                     = '%'               ;
51     MOD_ASSIGN              = '%='              ;
52     NOT                     = '~'               ;
53     NOT_EQUAL               = '!='              ;
54     OR                      = '|'               ;
55     OR_ASSIGN               = '|='              ;
56     PLUS                    = '+'               ;
57     PLUS_ASSIGN             = '+='              ;
58     QUESTION                = '?'               ;
59     RBRACK                  = ']'               ;
60     RCURLY                  = '}'               ;
61     RPAREN                  = ')'               ;
62     SEMI                    = ';'               ;
63     SHIFT_LEFT              = '<<'              ;
64     SHIFT_LEFT_ASSIGN       = '<<='             ;
65     SHIFT_RIGHT             = '>>'              ;
66     SHIFT_RIGHT_ASSIGN      = '>>='             ;
67     STAR                    = '*'               ;
68     STAR_ASSIGN             = '*='              ;
69     XOR                     = '^'               ;
70     XOR_ASSIGN              = '^='              ;
71
72     // Charj-specific operators
73     DOUBLE_LCURLY           = '{{'              ;
74     DOUBLE_RCURLY           = '}}'              ;
75
76     // Keywords common to Java and Charj
77     
78     ABSTRACT                = 'abstract'        ;
79     ASSERT                  = 'assert'          ;
80     BOOLEAN                 = 'boolean'         ;
81     BREAK                   = 'break'           ;
82     BYTE                    = 'byte'            ;
83     CASE                    = 'case'            ;
84     CATCH                   = 'catch'           ;
85     CHAR                    = 'char'            ;
86     CLASS                   = 'class'           ;
87     CONTINUE                = 'continue'        ;
88     DEFAULT                 = 'default'         ;
89     DELETE                  = 'delete'          ;
90     DO                      = 'do'              ;
91     DOUBLE                  = 'double'          ;
92     ELSE                    = 'else'            ;
93     ENUM                    = 'enum'            ;
94     EXTENDS                 = 'extends'         ;
95     FALSE                   = 'false'           ;
96     FINAL                   = 'final'           ;
97     FINALLY                 = 'finally'         ;
98     FLOAT                   = 'float'           ;
99     FOR                     = 'for'             ;
100     IF                      = 'if'              ;
101     IMPLEMENTS              = 'implements'      ;
102     INSTANCEOF              = 'instanceof'      ;
103     INTERFACE               = 'interface'       ;
104     IMPORT                  = 'import'          ;
105     INT                     = 'int'             ;
106     LONG                    = 'long'            ;
107     NATIVE                  = 'native'          ;
108     NEW                     = 'new'             ;
109     NULL                    = 'null'            ;
110     PACKAGE                 = 'package'         ;
111     PRIVATE                 = 'private'         ;
112     PROTECTED               = 'protected'       ;
113     PUBLIC                  = 'public'          ;
114     RETURN                  = 'return'          ;
115     SHORT                   = 'short'           ;
116     STATIC                  = 'static'          ;
117     SUPER                   = 'super'           ;
118     SWITCH                  = 'switch'          ;
119     SYNCHRONIZED            = 'synchronized'    ;
120     THIS                    = 'this'            ;
121     THROW                   = 'throw'           ;
122     THROWS                  = 'throws'          ;
123     TRANSIENT               = 'transient'       ;
124     TRUE                    = 'true'            ;
125     TRY                     = 'try'             ;
126     VOID                    = 'void'            ;
127     VOLATILE                = 'volatile'        ;
128     WHILE                   = 'while'           ;
129
130     // Charj-specific keywords
131     EMBED                   = 'embed'           ;
132     ENTRY                   = 'entry'           ;
133
134     // C++ keywords that aren't used in charj. 
135     // We don't use these ourselves, but they're still reserved
136     ASM                     = 'asm'             ;
137     AUTO                    = 'auto'            ;
138     BOOL                    = 'bool'            ;
139     CONST_CAST              = 'const_cast'      ;
140     DYNAMIC_CAST            = 'dynamic_cast'    ;
141     EXPLICIT                = 'explicit'        ;
142     EXPORT                  = 'export'          ;
143     EXTERN                  = 'extern'          ;
144     FRIEND                  = 'friend'          ;
145     GOTO                    = 'goto'            ;
146     INLINE                  = 'inline'          ;
147     MUTABLE                 = 'mutable'         ;
148     NAMESPACE               = 'namespace'       ;
149     OPERATOR                = 'operator'        ;
150     REGISTER                = 'register'        ;
151     REINTERPRET_CAST        = 'reinterpret_cast';
152     SIGNED                  = 'signed'          ;
153     SIZEOF                  = 'sizeof'          ;
154     STATIC_CAST             = 'static_cast'     ;
155     STRUCT                  = 'struct'          ;
156     TEMPLATE                = 'template'        ;
157     TYPEDEF                 = 'typedef'         ;
158     TYPEID                  = 'typeid'          ;
159     TYPENAME                = 'typename'        ;
160     UNION                   = 'union'           ;
161     UNSIGNED                = 'unsigned'        ;
162     USING                   = 'using'           ;
163     VIRTUAL                 = 'virtual'         ;
164     WCHAR_T                 = 'wchar_t'         ;
165     
166     // tokens for imaginary nodes
167     ARGUMENT_LIST;
168     ARRAY_DECLARATOR;
169     ARRAY_DECLARATOR_LIST;
170     ARRAY_ELEMENT_ACCESS;
171     ARRAY_INITIALIZER;
172     BLOCK_SCOPE;
173     CAST_EXPR;
174     CATCH_CLAUSE_LIST;
175     CLASS_CONSTRUCTOR_CALL;
176     CLASS_INSTANCE_INITIALIZER;
177     CLASS_STATIC_INITIALIZER;
178     CLASS_TOP_LEVEL_SCOPE;
179     CONSTRUCTOR_DECL;
180     ENUM_TOP_LEVEL_SCOPE;
181     EXPR;
182     EXTENDS_BOUND_LIST;
183     EXTENDS_CLAUSE;
184     FOR_CONDITION;
185     FOR_EACH;
186     FOR_INIT;
187     FOR_UPDATE;
188     FORMAL_PARAM_LIST;
189     FORMAL_PARAM_STD_DECL;
190     FORMAL_PARAM_VARARG_DECL;
191     FUNCTION_METHOD_DECL;
192     GENERIC_TYPE_ARG_LIST;
193     GENERIC_TYPE_PARAM_LIST;
194     INTERFACE_TOP_LEVEL_SCOPE;
195     IMPLEMENTS_CLAUSE;
196     LABELED_STATEMENT;
197     LOCAL_MODIFIER_LIST;
198     CHARJ_SOURCE;
199     METHOD_CALL;
200     MODIFIER_LIST;
201     PARENTESIZED_EXPR;
202     POST_DEC;
203     POST_INC;
204     PRE_DEC;
205     PRE_INC;
206     QUALIFIED_TYPE_IDENT;
207     STATIC_ARRAY_CREATOR;
208     SUPER_CONSTRUCTOR_CALL;
209     SWITCH_BLOCK_LABEL_LIST;
210     THIS_CONSTRUCTOR_CALL;
211     THROWS_CLAUSE;
212     TYPE;
213     UNARY_MINUS;
214     UNARY_PLUS;
215     PRIMITIVE_VAR_DECLARATION;
216     OBJECT_VAR_DECLARATION;
217     VAR_DECLARATOR;
218     VAR_DECLARATOR_LIST;
219     VOID_METHOD_DECL;
220 }
221
222 @header {
223 package charj.translator;
224 }
225
226 @members {
227 }
228
229 @lexer::header {
230 package charj.translator; 
231 }
232
233 @lexer::members {
234 }
235
236 // Starting point for parsing a Charj file.
237 charjSource
238     :   compilationUnit
239         ->  ^(CHARJ_SOURCE compilationUnit)
240     ;
241
242 compilationUnit
243     :   packageDeclaration? 
244         importDeclaration* 
245         typeDecls
246         //typeDecls*
247     ;
248
249 typeDecls
250     :   typeDeclaration
251     |   SEMI!
252     ;
253
254 packageDeclaration
255     :   PACKAGE^ qualifiedIdentifier SEMI!  
256     ;
257     
258 importDeclaration
259     :   IMPORT^ STATIC? qualifiedIdentifier DOTSTAR? SEMI!
260     ;
261     
262 typeDeclaration
263     :   modifierList!
264         (   classTypeDeclaration[$modifierList.tree]
265         |   interfaceTypeDeclaration[$modifierList.tree]
266         |   enumTypeDeclaration[$modifierList.tree]
267         )
268     ;
269     
270 classTypeDeclaration[CharjAST modifiers]
271     :   CLASS IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody
272         ->  ^(CLASS {$modifiers} IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody)
273     ;
274     
275 classExtendsClause
276     :   EXTENDS type
277         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] type)
278     ;   
279     
280 interfaceExtendsClause
281     :   EXTENDS typeList
282         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] typeList)
283     ;   
284     
285 implementsClause
286     :   IMPLEMENTS typeList
287         ->  ^(IMPLEMENTS_CLAUSE[$IMPLEMENTS, "IMPLEMENTS_CLAUSE"] typeList)
288     ;
289         
290 genericTypeParameterList
291     :   LESS_THAN genericTypeParameter (COMMA genericTypeParameter)* genericTypeListClosing
292         ->  ^(GENERIC_TYPE_PARAM_LIST[$LESS_THAN, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
293     ;
294
295 genericTypeListClosing  // This 'trick' is fairly dirty - if there's some time a better solution should 
296                         // be found to resolve the problem with nested generic type parameter lists 
297                         // (i.e. <T1 extends AnyType<T2>> for generic type parameters or <T1<T2>> for 
298                         // generic type arguments etc). 
299     :   GREATER_THAN
300     |   SHIFT_RIGHT
301     |   BIT_SHIFT_RIGHT
302     |
303     ;
304
305 genericTypeParameter
306     :   IDENT bound?
307         ->  ^(IDENT bound?)
308     ;
309         
310 bound
311     :   EXTENDS type (AND type)*
312         ->  ^(EXTENDS_BOUND_LIST[$EXTENDS, "EXTENDS_BOUND_LIST"] type+)
313     ;
314
315 enumTypeDeclaration[CharjAST modifiers]
316     :   ENUM IDENT implementsClause? enumBody
317         ->  ^(ENUM {$modifiers} IDENT implementsClause? enumBody)
318     ;
319     
320 enumBody
321     :   LCURLY enumScopeDeclarations RCURLY
322         ->  ^(ENUM_TOP_LEVEL_SCOPE[$LCURLY, "ENUM_TOP_LEVEL_SCOPE"] enumScopeDeclarations)
323     ;
324
325 enumScopeDeclarations
326     :   enumConstants (COMMA!)? enumClassScopeDeclarations?
327     ;
328
329 enumClassScopeDeclarations
330     :   SEMI classScopeDeclarations*
331         ->  ^(CLASS_TOP_LEVEL_SCOPE[$SEMI, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
332     ;
333
334 enumConstants
335     :   enumConstant (COMMA! enumConstant)*
336     ;
337     
338 enumConstant
339     :   IDENT^ arguments? classBody?
340     ;
341     
342 interfaceTypeDeclaration[CharjAST modifiers]
343     :   INTERFACE IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody
344         ->  ^(INTERFACE {$modifiers} IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody)
345     ;
346     
347 typeList
348     :   type (COMMA! type)*
349     ;
350     
351 classBody
352     :   LCURLY classScopeDeclarations* RCURLY
353         ->  ^(CLASS_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
354     ;
355     
356 interfaceBody
357     :   LCURLY interfaceScopeDeclarations* RCURLY
358         ->  ^(INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] interfaceScopeDeclarations*)
359     ;
360
361 classScopeDeclarations
362     :   block
363         ->  ^(CLASS_INSTANCE_INITIALIZER block)
364     |   STATIC block
365         ->  ^(CLASS_STATIC_INITIALIZER[$STATIC, "CLASS_STATIC_INITIALIZER"] block)
366     |   modifierList
367         (   genericTypeParameterList?
368             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? (block | SEMI)
369                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
370             |   VOID IDENT formalParameterList throwsClause? (block | SEMI)
371                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
372             |   ident=IDENT formalParameterList throwsClause? block
373                 ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block)
374             )
375         |   simpleType classFieldDeclaratorList SEMI
376             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType classFieldDeclaratorList)
377         |   objectType classFieldDeclaratorList SEMI
378             ->  ^(OBJECT_VAR_DECLARATION modifierList objectType classFieldDeclaratorList)
379         )
380     |   typeDeclaration
381     |   SEMI!
382     ;
383             
384 interfaceScopeDeclarations
385     :   modifierList
386         (   genericTypeParameterList?
387             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? SEMI
388                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
389             |   VOID IDENT formalParameterList throwsClause? SEMI
390                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
391             )
392         |   simpleType interfaceFieldDeclaratorList SEMI
393             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType interfaceFieldDeclaratorList)
394         |   objectType interfaceFieldDeclaratorList SEMI
395             ->  ^(OBJECT_VAR_DECLARATION modifierList objectType interfaceFieldDeclaratorList)        
396         )
397     |   typeDeclaration
398     |   SEMI!
399     ;
400
401 classFieldDeclaratorList
402     :   classFieldDeclarator (COMMA classFieldDeclarator)*
403         ->  ^(VAR_DECLARATOR_LIST classFieldDeclarator+)
404     ;
405
406 classFieldDeclarator
407     :   variableDeclaratorId (ASSIGN variableInitializer)?
408         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
409     ;
410     
411 interfaceFieldDeclaratorList
412     :   interfaceFieldDeclarator (COMMA interfaceFieldDeclarator)*
413         ->  ^(VAR_DECLARATOR_LIST interfaceFieldDeclarator+)
414     ;
415
416 interfaceFieldDeclarator
417     :   variableDeclaratorId ASSIGN variableInitializer
418         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
419     ;
420     
421 variableDeclaratorId
422     :   IDENT^ arrayDeclaratorList?
423     ;
424
425 variableInitializer
426     :   arrayInitializer
427     |   expression
428     ;
429
430 arrayDeclarator
431     :   LBRACK RBRACK
432         ->  ^(ARRAY_DECLARATOR)
433     ;
434
435 arrayDeclaratorList
436     :   arrayDeclarator+
437         ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
438     ;
439     
440 arrayInitializer
441     :   LCURLY (variableInitializer (COMMA variableInitializer)* COMMA?)? RCURLY
442         ->  ^(ARRAY_INITIALIZER[$LCURLY, "ARRAY_INITIALIZER"] variableInitializer*)
443     ;
444
445 throwsClause
446     :   THROWS qualifiedIdentList
447         ->  ^(THROWS_CLAUSE[$THROWS, "THROWS_CLAUSE"] qualifiedIdentList)
448     ;
449
450 modifierList
451     :   modifier*   
452         ->  ^(MODIFIER_LIST modifier*)
453     ;
454
455 modifier
456     :   PUBLIC
457     |   PROTECTED
458     |   ENTRY
459     |   PRIVATE
460     |   STATIC
461     |   ABSTRACT
462     |   NATIVE
463     |   SYNCHRONIZED
464     |   TRANSIENT
465     |   VOLATILE
466     |   localModifier
467     ;
468
469 localModifierList
470     :   localModifier*
471         -> ^(LOCAL_MODIFIER_LIST localModifier*)
472     ;
473     
474 localModifier
475     :   FINAL
476     ;
477
478 type
479     :   simpleType
480     |   objectType
481     ;
482
483 simpleType // including static arrays of simple type elements
484     :   primitiveType arrayDeclaratorList?
485         ->  ^(TYPE primitiveType arrayDeclaratorList?)  
486     ;
487     
488 objectType // including static arrays of object type reference elements
489     :   qualifiedTypeIdent arrayDeclaratorList?
490         ->  ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
491     ;
492
493 objectTypeSimplified
494     :   qualifiedTypeIdentSimplified arrayDeclaratorList?
495         ->  ^(TYPE qualifiedTypeIdentSimplified arrayDeclaratorList?)
496     ;
497
498 qualifiedTypeIdent
499     :   typeIdent (DOT typeIdent)*
500         ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
501     ;
502
503 qualifiedTypeIdentSimplified
504     :   typeIdentSimplified (DOT typeIdentSimplified)*
505         ->  ^(QUALIFIED_TYPE_IDENT typeIdentSimplified+) 
506     ;
507
508 typeIdent
509     :   IDENT^ genericTypeArgumentList?
510     ;
511
512 typeIdentSimplified
513     :   IDENT^ genericTypeArgumentListSimplified?
514     ;
515
516 primitiveType
517     :   BOOLEAN
518     |   CHAR
519     |   BYTE
520     |   SHORT
521     |   INT
522     |   LONG
523     |   FLOAT
524     |   DOUBLE
525     ;
526
527 genericTypeArgumentList
528     :   LESS_THAN genericTypeArgument (COMMA genericTypeArgument)* genericTypeListClosing
529         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
530     ;
531
532 genericTypeArgument
533     :   type
534     |   QUESTION genericWildcardBoundType?
535         ->  ^(QUESTION genericWildcardBoundType?)
536     ;
537     
538 genericWildcardBoundType
539     :   (EXTENDS | SUPER)^ type
540     ;
541
542 genericTypeArgumentListSimplified
543     :   LESS_THAN genericTypeArgumentSimplified (COMMA genericTypeArgumentSimplified)* genericTypeListClosing
544         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgumentSimplified+)
545     ;
546     
547 genericTypeArgumentSimplified
548     :   type
549     |   QUESTION
550     ;
551     
552 qualifiedIdentList
553     :   qualifiedIdentifier (COMMA! qualifiedIdentifier)*
554     ;
555     
556 formalParameterList
557     :   LPAREN 
558         (   // Contains at least one standard argument declaration and optionally a variable argument declaration.
559             formalParameterStandardDecl (COMMA formalParameterStandardDecl)* (COMMA formalParameterVarArgDecl)? 
560             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterStandardDecl+ formalParameterVarArgDecl?) 
561             // Contains a variable argument declaration only.
562         |   formalParameterVarArgDecl
563             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterVarArgDecl) 
564             // Contains nothing.
565         |   ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"]) 
566         )
567         RPAREN
568     ;
569     
570 formalParameterStandardDecl
571     :   localModifierList type variableDeclaratorId
572         ->  ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
573     ;
574     
575 formalParameterVarArgDecl
576     :   localModifierList type ELLIPSIS variableDeclaratorId
577         ->  ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
578     ;
579     
580 qualifiedIdentifier
581     :   (   IDENT
582             ->  IDENT
583         )
584         (   DOT ident=IDENT
585             ->  ^(DOT $qualifiedIdentifier $ident)
586         )*
587     ;
588     
589 block
590     :   LCURLY blockStatement* RCURLY
591         ->  ^(BLOCK_SCOPE[$LCURLY, "BLOCK_SCOPE"] blockStatement*)
592     ;
593
594 blockStatement
595     :   localVariableDeclaration SEMI!
596     |   typeDeclaration
597     |   statement
598     ;
599     
600 localVariableDeclaration
601     :   localModifierList simpleType classFieldDeclaratorList
602         ->  ^(PRIMITIVE_VAR_DECLARATION localModifierList simpleType classFieldDeclaratorList)
603     |   localModifierList objectType classFieldDeclaratorList
604         ->  ^(OBJECT_VAR_DECLARATION localModifierList objectType classFieldDeclaratorList)
605     ;
606     
607         
608 statement
609     :   block
610     |   ASSERT expr1=expression 
611         (   COLON expr2=expression SEMI
612             ->  ^(ASSERT $expr1 $expr2)
613         |   SEMI
614             ->  ^(ASSERT $expr1)
615         )
616     |   IF parenthesizedExpression ifStat=statement 
617         (   ELSE elseStat=statement
618             ->  ^(IF parenthesizedExpression $ifStat $elseStat)
619         |
620             ->  ^(IF parenthesizedExpression $ifStat)
621         )   
622     |   FOR LPAREN 
623         (   forInit SEMI forCondition SEMI forUpdater RPAREN statement
624             ->  ^(FOR forInit forCondition forUpdater statement) 
625         |   localModifierList type IDENT COLON expression RPAREN statement
626             ->  ^(FOR_EACH[$FOR, "FOR_EACH"] localModifierList type IDENT expression statement)
627         ) 
628     |   WHILE parenthesizedExpression statement
629         ->  ^(WHILE parenthesizedExpression statement)
630     |   DO statement WHILE parenthesizedExpression SEMI
631         ->  ^(DO statement parenthesizedExpression)
632     |   TRY block (catches finallyClause? | finallyClause)
633         ->  ^(TRY block catches? finallyClause?)
634     |   SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY
635         ->  ^(SWITCH parenthesizedExpression switchBlockLabels)
636     |   SYNCHRONIZED parenthesizedExpression block
637         ->  ^(SYNCHRONIZED parenthesizedExpression block)
638     |   RETURN expression? SEMI
639         ->  ^(RETURN expression?)
640     |   THROW expression SEMI
641         ->  ^(THROW expression)
642     |   BREAK IDENT? SEMI
643         ->  ^(BREAK IDENT?)
644     |   CONTINUE IDENT? SEMI
645         ->  ^(CONTINUE IDENT?)
646     |   IDENT COLON statement
647         ->  ^(LABELED_STATEMENT IDENT statement)
648     |   EMBED STRING_LITERAL EMBED_BLOCK
649         ->  ^(EMBED STRING_LITERAL EMBED_BLOCK)
650     |   expression SEMI!
651     |   SEMI // Preserve empty statements.
652     ;           
653         
654 catches
655     :   catchClause+
656         ->  ^(CATCH_CLAUSE_LIST catchClause+)
657     ;
658     
659 catchClause
660     :   CATCH^ LPAREN! formalParameterStandardDecl RPAREN! block
661     ;
662
663 finallyClause
664     :   FINALLY block
665         ->  block
666     ;
667
668 switchBlockLabels
669     :   switchCaseLabels
670         ->  ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabels)
671     ;
672     
673 switchCaseLabels
674     :   switchCaseLabel*
675     ;
676         
677 switchCaseLabel
678     :   CASE^ expression COLON! blockStatement*
679     |   DEFAULT^ COLON! blockStatement*
680     ;
681     
682 forInit
683     :   localVariableDeclaration
684         ->  ^(FOR_INIT localVariableDeclaration)
685     |   expressionList
686         ->  ^(FOR_INIT expressionList)
687     |
688         ->  ^(FOR_INIT)
689     ;
690     
691 forCondition
692     :   expression?
693         ->  ^(FOR_CONDITION expression?)
694     ;
695     
696 forUpdater
697     :   expressionList?
698         ->  ^(FOR_UPDATE expressionList?)
699     ;
700
701 // EXPRESSIONS
702
703 parenthesizedExpression
704     :   LPAREN expression RPAREN
705         ->  ^(PARENTESIZED_EXPR[$LPAREN, "PARENTESIZED_EXPR"] expression)
706     ;
707     
708 expressionList
709     :   expression (COMMA! expression)*
710     ;
711
712 expression
713     :   assignmentExpression
714         ->  ^(EXPR assignmentExpression)
715     ;
716
717 assignmentExpression
718     :   conditionalExpression 
719         (   (   ASSIGN^
720             |   PLUS_ASSIGN^
721             |   MINUS_ASSIGN^
722             |   STAR_ASSIGN^
723             |   DIV_ASSIGN^
724             |   AND_ASSIGN^
725             |   OR_ASSIGN^
726             |   XOR_ASSIGN^
727             |   MOD_ASSIGN^
728             |   SHIFT_LEFT_ASSIGN^
729             |   SHIFT_RIGHT_ASSIGN^
730             |   BIT_SHIFT_RIGHT_ASSIGN^
731         ) 
732         assignmentExpression)?
733     ;
734     
735 conditionalExpression
736     :   logicalOrExpression (QUESTION^ assignmentExpression COLON! conditionalExpression)?
737     ;
738
739 logicalOrExpression
740     :   logicalAndExpression (LOGICAL_OR^ logicalAndExpression)*
741     ;
742
743 logicalAndExpression
744     :   inclusiveOrExpression (LOGICAL_AND^ inclusiveOrExpression)*
745     ;
746
747 inclusiveOrExpression
748     :   exclusiveOrExpression (OR^ exclusiveOrExpression)*
749     ;
750
751 exclusiveOrExpression
752     :   andExpression (XOR^ andExpression)*
753     ;
754
755 andExpression
756     :   equalityExpression (AND^ equalityExpression)*
757     ;
758
759 equalityExpression
760     :   instanceOfExpression 
761         (   (   EQUAL^
762             |   NOT_EQUAL^
763             ) 
764             instanceOfExpression
765         )*
766     ;
767
768 instanceOfExpression
769     :   relationalExpression (INSTANCEOF^ type)?
770     ;
771
772 relationalExpression
773     :   shiftExpression 
774         (   (   LESS_OR_EQUAL^
775             |   GREATER_OR_EQUAL^
776             |   LESS_THAN^
777             |   GREATER_THAN^
778             )
779             shiftExpression
780         )*
781     ;
782     
783 shiftExpression
784     :   additiveExpression
785         (   (   BIT_SHIFT_RIGHT^
786             |   SHIFT_RIGHT^
787             |   SHIFT_LEFT^
788             )
789             additiveExpression
790         )*
791     ;
792
793 additiveExpression
794     :   multiplicativeExpression
795         (   (   PLUS^
796             |   MINUS^
797             )
798             multiplicativeExpression
799         )*
800     ;
801
802 multiplicativeExpression
803     :   unaryExpression 
804         (   (   STAR^
805             |   DIV^
806             |   MOD^
807             )
808             unaryExpression
809         )*
810     ;
811     
812 unaryExpression
813     :   PLUS unaryExpression
814         ->  ^(UNARY_PLUS[$PLUS, "UNARY_PLUS"] unaryExpression)
815     |   MINUS unaryExpression
816         ->  ^(UNARY_MINUS[$MINUS, "UNARY_MINUS"] unaryExpression)
817     |   INC postfixedExpression
818         ->  ^(PRE_INC[$INC, "PRE_INC"] postfixedExpression)
819     |   DEC postfixedExpression
820         ->  ^(PRE_DEC[$DEC, "PRE_DEC"] postfixedExpression)
821     |   unaryExpressionNotPlusMinus
822     ;
823
824 unaryExpressionNotPlusMinus
825     :   NOT unaryExpression
826         ->  ^(NOT unaryExpression)
827     |   LOGICAL_NOT unaryExpression
828         ->  ^(LOGICAL_NOT unaryExpression)
829     |   LPAREN type RPAREN unaryExpression
830         ->  ^(CAST_EXPR[$LPAREN, "CAST_EXPR"] type unaryExpression)
831     |   postfixedExpression
832     ;
833     
834 postfixedExpression
835         // At first resolve the primary expression ...
836     :   (   primaryExpression
837             ->  primaryExpression
838         )
839         // ... and than the optional things that may follow a primary
840         // expression 0 or more times.
841         (   outerDot=DOT                            
842             // Note: generic type arguments are only valid for method calls,
843             // i.e. if there is an argument list
844             (   (   genericTypeArgumentListSimplified?  
845                     IDENT
846                     ->  ^(DOT $postfixedExpression IDENT)
847                 ) 
848                 (   arguments
849                     ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentListSimplified? arguments)
850                 )?
851             |   THIS
852                 ->  ^(DOT $postfixedExpression THIS)
853             |   Super=SUPER arguments
854                 ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
855             |   (   SUPER innerDot=DOT IDENT
856                     ->  ^($innerDot ^($outerDot $postfixedExpression SUPER) IDENT)
857                 )
858                 (   arguments
859                     ->  ^(METHOD_CALL $postfixedExpression arguments)
860                 )?
861             |   innerNewExpression
862                 ->  ^(DOT $postfixedExpression innerNewExpression)
863             )
864         |   LBRACK expression RBRACK
865             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
866         )*
867         // At the end there may follow a post increment/decrement.
868         (   INC -> ^(POST_INC[$INC, "POST_INC"] $postfixedExpression)
869         |   DEC -> ^(POST_DEC[$DEC, "POST_DEC"] $postfixedExpression)
870         )?
871     ;    
872     
873 primaryExpression
874     :   parenthesizedExpression
875     |   literal
876     |   newExpression
877     |   qualifiedIdentExpression
878     |   genericTypeArgumentListSimplified 
879         (   SUPER
880             (   arguments
881                 ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
882             |   DOT IDENT arguments
883                 ->  ^(METHOD_CALL ^(DOT SUPER IDENT) genericTypeArgumentListSimplified arguments)
884             )
885         |   IDENT arguments
886             ->  ^(METHOD_CALL IDENT genericTypeArgumentListSimplified arguments)
887         |   THIS arguments
888             ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
889         )
890     |   (   THIS
891             ->  THIS
892         )
893         (   arguments
894             ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] arguments)
895         )?
896     |   SUPER arguments
897         ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] arguments)
898     |   (   SUPER DOT IDENT
899         )
900         (   arguments
901             ->  ^(METHOD_CALL ^(DOT SUPER IDENT) arguments)
902         |   ->  ^(DOT SUPER IDENT)
903         )
904     |   (   primitiveType
905             ->  primitiveType
906         )
907         (   arrayDeclarator
908             ->  ^(arrayDeclarator $primaryExpression)   
909         )* 
910         DOT CLASS
911         ->  ^(DOT $primaryExpression CLASS)
912     |   VOID DOT CLASS
913         ->  ^(DOT VOID CLASS)
914     ;
915     
916 qualifiedIdentExpression
917         // The qualified identifier itself is the starting point for this rule.
918     :   (   qualifiedIdentifier
919             ->  qualifiedIdentifier
920         )
921         // And now comes the stuff that may follow the qualified identifier.
922         (   (   arrayDeclarator
923                 ->  ^(arrayDeclarator $qualifiedIdentExpression)
924             )+ 
925             (   DOT CLASS
926                 ->  ^(DOT $qualifiedIdentExpression CLASS)
927             )
928         |   arguments
929             ->  ^(METHOD_CALL qualifiedIdentifier arguments)
930         |   outerDot=DOT
931             (   CLASS
932                 ->  ^(DOT qualifiedIdentifier CLASS)
933             |   genericTypeArgumentListSimplified 
934                 (   Super=SUPER arguments
935                     ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"]
936                             qualifiedIdentifier genericTypeArgumentListSimplified arguments)
937                 |   SUPER innerDot=DOT IDENT arguments
938                     ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier SUPER) IDENT)
939                             genericTypeArgumentListSimplified arguments)
940                 |   IDENT arguments
941                     ->  ^(METHOD_CALL ^(DOT qualifiedIdentifier IDENT) genericTypeArgumentListSimplified arguments)
942                 )
943             |   THIS
944                 ->  ^(DOT qualifiedIdentifier THIS)
945             |   Super=SUPER arguments
946                 ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
947             |   innerNewExpression
948                 ->  ^(DOT qualifiedIdentifier innerNewExpression)
949             )
950         )?
951     ;
952
953 newExpression
954     :   NEW  
955             (   primitiveType newArrayConstruction      // new static array of primitive type elements
956                 ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] primitiveType newArrayConstruction
957             )
958     |   genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified
959             (   newArrayConstruction                // new static array of object type reference elements
960                 ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] 
961                     genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified newArrayConstruction
962             )
963     |   arguments classBody?                // new object type via constructor invocation
964                 ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? 
965                     qualifiedTypeIdentSimplified arguments classBody?)
966             )
967         )
968     ;
969     
970 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
971     :   NEW genericTypeArgumentListSimplified? IDENT arguments classBody?
972         ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? IDENT arguments classBody?)
973     ;
974
975 newArrayConstruction
976     :   arrayDeclaratorList arrayInitializer
977     |   LBRACK! expression RBRACK! (LBRACK! expression RBRACK!)* arrayDeclaratorList?
978     ;
979
980 arguments
981     :   LPAREN expressionList? RPAREN
982         ->  ^(ARGUMENT_LIST[$LPAREN, "ARGUMENT_LIST"] expressionList?)
983     ;
984
985 literal 
986     :   HEX_LITERAL
987     |   OCTAL_LITERAL
988     |   DECIMAL_LITERAL
989     |   FLOATING_POINT_LITERAL
990     |   CHARACTER_LITERAL
991     |   STRING_LITERAL
992     |   TRUE
993     |   FALSE
994     |   NULL
995     ;
996
997 // LEXER
998
999 HEX_LITERAL : '0' ('x'|'X') HEX_DIGIT+ INTEGER_TYPE_SUFFIX? ;
1000
1001 DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) INTEGER_TYPE_SUFFIX? ;
1002
1003 OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
1004
1005 fragment
1006 HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
1007
1008 fragment
1009 INTEGER_TYPE_SUFFIX : ('l'|'L') ;
1010
1011 FLOATING_POINT_LITERAL
1012     :   ('0'..'9')+ 
1013         (
1014             DOT ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
1015         |   EXPONENT FLOAT_TYPE_SUFFIX?
1016         |   FLOAT_TYPE_SUFFIX
1017         )
1018     |   DOT ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
1019     ;
1020
1021 fragment
1022 EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
1023
1024 fragment
1025 FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;
1026
1027 CHARACTER_LITERAL
1028     :   '\'' ( ESCAPE_SEQUENCE | ~('\''|'\\') ) '\''
1029     ;
1030
1031 STRING_LITERAL
1032     :  '"' ( ESCAPE_SEQUENCE | ~('\\'|'"') )* '"'
1033     ;
1034
1035 fragment
1036 ESCAPE_SEQUENCE
1037     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
1038     |   UNICODE_ESCAPE
1039     |   OCTAL_ESCAPE
1040     ;
1041
1042 fragment
1043 OCTAL_ESCAPE
1044     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
1045     |   '\\' ('0'..'7') ('0'..'7')
1046     |   '\\' ('0'..'7')
1047     ;
1048
1049 fragment
1050 UNICODE_ESCAPE
1051     :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1052     ;
1053
1054 IDENT
1055     :   CHARJ_ID_START (CHARJ_ID_PART)*
1056     ;
1057
1058 fragment
1059 CHARJ_ID_START
1060     :  '\u0024'
1061     |  '\u0041'..'\u005a'
1062     |  '\u005f'
1063     |  '\u0061'..'\u007a'
1064     |  '\u00c0'..'\u00d6'
1065     |  '\u00d8'..'\u00f6'
1066     |  '\u00f8'..'\u00ff'
1067     |  '\u0100'..'\u1fff'
1068     |  '\u3040'..'\u318f'
1069     |  '\u3300'..'\u337f'
1070     |  '\u3400'..'\u3d2d'
1071     |  '\u4e00'..'\u9fff'
1072     |  '\uf900'..'\ufaff'
1073     ;
1074
1075 fragment
1076 CHARJ_ID_PART
1077     :  CHARJ_ID_START
1078     |  '\u0030'..'\u0039'
1079     ;
1080
1081 WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') 
1082     {   
1083         $channel = HIDDEN;
1084     }
1085     ;
1086
1087 EMBED_BLOCK
1088     :   DOUBLE_LCURLY
1089         ( options {greedy=false;} : . )* 
1090         DOUBLE_RCURLY 
1091     ;
1092
1093 COMMENT
1094     :   '/*' ( options {greedy=false;} : . )* '*/'
1095     {   
1096         $channel = HIDDEN;
1097     }
1098     ;
1099
1100 LINE_COMMENT
1101     : '//' ~('\n'|'\r')* '\r'? '\n'
1102     {   
1103         $channel = HIDDEN;
1104     }
1105     ;