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