5dfc8f4d294dc4fb68613ea2ea970385b6724dc3
[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     ENTRY                   = 'entry'           ;
21     PUBLIC                  = 'public'          ;
22     PROTECTED               = 'protected'       ;
23     ENTRY                   = 'entry'           ;
24     PRIVATE                 = 'private'         ;
25     ABSTRACT                = 'abstract'        ;
26     NATIVE                  = 'native'          ;
27     FINAL                   = 'final'           ;
28     STATIC                  = 'static'          ;
29     VOLATILE                = 'volatile'        ;
30     VOID                    = 'void'            ;
31     BOOLEAN                 = 'boolean'         ;
32     CHAR                    = 'char'            ;
33     BYTE                    = 'byte'            ;
34     SHORT                   = 'short'           ;
35     INT                     = 'int'             ;
36     LONG                    = 'long'            ;
37     FLOAT                   = 'float'           ;
38     DOUBLE                  = 'double'          ;
39     TRUE                    = 'true'            ;
40     FALSE                   = 'false'           ;
41     NULL                    = 'null'            ;
42     THIS                    = 'this'            ;
43     SUPER                   = 'super'           ;
44     CHARE                   = 'chare'           ;
45     CHARE_ARRAY             = 'chare_array'     ;
46     MAINCHARE               = 'mainchare'       ;
47     INTERFACE               = 'interface'       ;
48     PACKAGE                 = 'package'         ;
49     IMPORT                  = 'import'          ;
50     CLASS                   = 'class'           ;
51     EXTENDS                 = 'extends'         ;
52     GROUP                   = 'group'           ;
53     NODEGROUP               = 'nodegroup'       ;
54     ENUM                    = 'enum'            ;
55
56     FOR                     = 'for'             ;
57     WHILE                   = 'while'           ;
58     IF                      = 'if'              ;
59     CASE                    = 'case'            ;
60     SWITCH                  = 'switch'          ;
61     RETURN                  = 'return'          ;
62     ELSE                    = 'else'            ;
63     CONTINUE                = 'continue'        ;
64     DO                      = 'do'              ;
65     DEFAULT                 = 'default'         ;
66     WHILE                   = 'while'           ;
67     THROW                   = 'throw'           ;
68     BREAK                   = 'break'           ;
69
70     NEW                     = 'new'             ;
71     BITWISE_OR              = '|'               ;
72     BITWISE_AND             = '&'               ;
73     EQUALS                  = '='               ;
74     NOT_EQUALS              = '!='              ;
75     PLUS_EQUALS             = '+='              ;
76     MINUS_EQUALS            = '-='              ;
77     TIMES_EQUALS            = '*='              ;
78     DIVIDE_EQUALS           = '/='              ;
79     AND_EQUALS              = '&='              ;
80     OR_EQUALS               = '|='              ;
81     POWER_EQUALS            = '^='              ;
82     MOD_EQUALS              = '%='              ;
83     OR                      = '||'              ;
84     AND                     = '&&'              ;
85     POWER                   = '^'               ;
86     GT                      = '>'               ;
87     LT                      = '<'               ;
88     PLUS                    = '+'               ;
89     MINUS                   = '-'               ;
90     TIMES                   = '*'               ;
91     DIVIDE                  = '/'               ;
92     MOD                     = '%'               ;
93     UNARY_PLUS              = '++'              ;
94     UNARY_MINUS             = '--'              ;
95     NOT                     = '!'               ;
96     TILDA                   = '~'               ;
97     INSTANCEOF              = 'instanceof'      ;
98
99
100     // C++ keywords that aren't used in charj. 
101     // We don't use these ourselves, but they're still reserved
102     ASM                     = 'asm'             ;
103     AUTO                    = 'auto'            ;
104     BOOL                    = 'bool'            ;
105     CONST_CAST              = 'const_cast'      ;
106     DYNAMIC_CAST            = 'dynamic_cast'    ;
107     EXPLICIT                = 'explicit'        ;
108     EXPORT                  = 'export'          ;
109     EXTERN                  = 'extern'          ;
110     FRIEND                  = 'friend'          ;
111     GOTO                    = 'goto'            ;
112     INLINE                  = 'inline'          ;
113     MUTABLE                 = 'mutable'         ;
114     NAMESPACE               = 'namespace'       ;
115     OPERATOR                = 'operator'        ;
116     REGISTER                = 'register'        ;
117     REINTERPRET_CAST        = 'reinterpret_cast';
118     SIGNED                  = 'signed'          ;
119     SIZEOF                  = 'sizeof'          ;
120     STATIC_CAST             = 'static_cast'     ;
121     STRUCT                  = 'struct'          ;
122     TEMPLATE                = 'template'        ;
123     TYPEDEF                 = 'typedef'         ;
124     TYPEID                  = 'typeid'          ;
125     TYPENAME                = 'typename'        ;
126     UNION                   = 'union'           ;
127     UNSIGNED                = 'unsigned'        ;
128     USING                   = 'using'           ;
129     VIRTUAL                 = 'virtual'         ;
130     WCHAR_T                 = 'wchar_t'         ;
131     
132     // tokens for imaginary nodes
133     ARGUMENT_LIST;
134     ARRAY_DECLARATOR;
135     ARRAY_DECLARATOR_LIST;
136     ARRAY_ELEMENT_ACCESS;
137     ARRAY_INITIALIZER;
138     BLOCK;
139     CAST_EXPR;
140     CATCH_CLAUSE_LIST;
141     CLASS_CONSTRUCTOR_CALL;
142     CLASS_INSTANCE_INITIALIZER;
143     CLASS_STATIC_INITIALIZER;
144     CLASS_TOP_LEVEL_SCOPE;
145     CONSTRUCTOR_DECL;
146     ENUM_TOP_LEVEL_SCOPE;
147     EXPR;
148     EXTENDS_BOUND_LIST;
149     EXTENDS_CLAUSE;
150     FOR_EACH;
151     FOR_EXPR;
152     FOR_UPDATE;
153     FORMAL_PARAM_LIST;
154     FORMAL_PARAM_STD_DECL;
155     FORMAL_PARAM_VARARG_DECL;
156     FUNCTION_METHOD_DECL;
157     GENERIC_TYPE_ARG_LIST;
158     GENERIC_TYPE_PARAM_LIST;
159     INTERFACE_TOP_LEVEL_SCOPE;
160     IMPLEMENTS_CLAUSE;
161     LABELED_STATEMENT;
162     LOCAL_MODIFIER_LIST;
163     CHARJ_SOURCE;
164     METHOD_CALL;
165     MODIFIER_LIST;
166     PAREN_EXPR;
167     POST_DEC;
168     POST_INC;
169     PRE_DEC;
170     PRE_INC;
171     QUALIFIED_TYPE_IDENT;
172     STATIC_ARRAY_CREATOR;
173     SUPER_CONSTRUCTOR_CALL;
174     THIS_CONSTRUCTOR_CALL;
175     TYPE;
176     SIMPLE_TYPE;
177     OBJECT_TYPE;
178     REFERENCE_TYPE;
179     POINTER_TYPE;
180     PRIMITIVE_VAR_DECLARATION;
181     OBJECT_VAR_DECLARATION;
182     VAR_DECLARATOR;
183     VAR_DECLARATOR_LIST;
184 }
185
186 @header {
187 package charj.translator;
188 }
189
190 @members {
191 }
192
193 @lexer::header {
194 package charj.translator; 
195 }
196
197 @lexer::members {
198 }
199
200 // Starting point for parsing a Charj file.
201 charjSource
202     :   compilationUnit EOF
203         ->  ^(CHARJ_SOURCE compilationUnit)
204     ;
205
206 compilationUnit
207     :   packageDeclaration? 
208         importDeclaration* 
209         typeDeclaration
210     ;
211
212 packageDeclaration
213     :   PACKAGE IDENT ('.' IDENT)+ ';'  
214         ->  ^(PACKAGE IDENT+)
215     ;
216
217 importDeclaration
218     :   IMPORT^ qualifiedIdentifier '.*'? ';'!
219     ;
220
221 typeDeclaration
222     :   classDefinition
223     |   interfaceDefinition
224     |   enumDefinition
225     |   chareDefinition
226     ;
227
228 classDefinition
229     :   PUBLIC? CLASS IDENT (EXTENDS type)? ('implements' typeList)? '{'
230             classScopeDeclaration*
231         '}' ';'?
232         -> ^(TYPE CLASS IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
233     ;
234
235 chareType
236     :   CHARE
237     |   GROUP
238     |   NODEGROUP
239     |   MAINCHARE
240     |   CHARE_ARRAY '[' ARRAY_DIMENSION ']' -> ^(CHARE_ARRAY ARRAY_DIMENSION)
241     ;
242
243 chareDefinition
244     :   PUBLIC? chareType IDENT (EXTENDS type)? ('implements' typeList)? '{'
245             classScopeDeclaration*
246         '}' ';'?
247         -> ^(TYPE chareType IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
248     ;
249
250 interfaceDefinition
251     :   'interface' IDENT (EXTENDS typeList)?  '{'
252             interfaceScopeDeclaration*
253         '}' ';'?
254         -> ^('interface' IDENT ^(EXTENDS typeList)? interfaceScopeDeclaration*)
255     ;
256
257 enumDefinition
258     :   ENUM IDENT ('implements' typeList)? '{'
259             enumConstants ','? ';' classScopeDeclaration*
260         '}' ';'?
261         -> ^(ENUM IDENT ^('implements' typeList)? enumConstants classScopeDeclaration*)
262     ;
263
264 enumConstants
265     :   enumConstant (','! enumConstant)*
266     ;
267
268 enumConstant
269     :   IDENT^ arguments?
270     ;
271
272 typeList
273     :   type (','! type)*
274     ;
275
276 classScopeDeclaration
277     :   modifierList?
278         (   genericTypeParameterList?
279             (   type IDENT formalParameterList arrayDeclaratorList? (block | ';')
280                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT
281                     formalParameterList arrayDeclaratorList? block?)
282             |   ident=IDENT formalParameterList block
283                 ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList? genericTypeParameterList? IDENT
284                         formalParameterList block)
285             )
286         |   simpleType classFieldDeclaratorList ';'
287             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType classFieldDeclaratorList)
288         |   objectType classFieldDeclaratorList ';'
289             ->  ^(OBJECT_VAR_DECLARATION modifierList? objectType classFieldDeclaratorList)
290         )
291     ;
292
293 interfaceScopeDeclaration
294     :   modifierList?
295         (   genericTypeParameterList?
296             (   type IDENT formalParameterList arrayDeclaratorList? ';'
297                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList?
298                         type IDENT formalParameterList arrayDeclaratorList?)
299             )
300         |   simpleType interfaceFieldDeclaratorList ';'
301             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType interfaceFieldDeclaratorList)
302         |   objectType interfaceFieldDeclaratorList ';'
303             ->  ^(OBJECT_VAR_DECLARATION modifierList? objectType interfaceFieldDeclaratorList)        
304         )
305     ;
306
307 classFieldDeclaratorList
308     :   classFieldDeclarator (',' classFieldDeclarator)*
309         ->  ^(VAR_DECLARATOR_LIST classFieldDeclarator+)
310     ;
311
312 classFieldDeclarator
313     :   variableDeclaratorId ('=' variableInitializer)?
314         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
315     ;
316
317 interfaceFieldDeclaratorList
318     :   interfaceFieldDeclarator (',' interfaceFieldDeclarator)*
319         ->  ^(VAR_DECLARATOR_LIST interfaceFieldDeclarator+)
320     ;
321
322 interfaceFieldDeclarator
323     :   variableDeclaratorId '=' variableInitializer
324         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
325     ;
326
327
328 variableDeclaratorId
329     :   IDENT^ arrayDeclaratorList?
330     ;
331
332 variableInitializer
333     :   arrayInitializer
334     |   expression
335     ;
336
337 arrayDeclarator
338     :   '[' ']'
339         ->  ARRAY_DECLARATOR
340     ;
341
342 arrayDeclaratorList
343     :   arrayDeclarator+
344         ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
345     ;
346
347 arrayInitializer
348     :   lc='{' (variableInitializer (',' variableInitializer)* ','?)? '}'
349         ->  ^(ARRAY_INITIALIZER[$lc, "ARRAY_INITIALIZER"] variableInitializer*)
350     ;
351
352 genericTypeParameterList
353     :   lt='<' genericTypeParameter (',' genericTypeParameter)* genericTypeListClosing
354         ->  ^(GENERIC_TYPE_PARAM_LIST[$lt, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
355     ;
356
357 // This hack is fairly dirty - we just bite off some angle brackets and don't
358 // actually match up opening and closing brackets.
359 genericTypeListClosing  
360     :   '>'
361     |   '>>'
362     |   '>>>'
363     |
364     ;
365
366 genericTypeParameter
367     :   IDENT bound?
368         ->  ^(IDENT bound?)
369     ;
370
371 bound
372     :   e=EXTENDS type ('&' type)*
373         ->  ^(EXTENDS_BOUND_LIST[$e, "EXTENDS_BOUND_LIST"] type+)
374     ;
375
376 modifierList
377     :   modifier+
378         ->  ^(MODIFIER_LIST modifier+)
379     ;
380
381 modifier
382     :   PUBLIC
383     |   PROTECTED
384     |   ENTRY
385     |   PRIVATE
386     |   ABSTRACT
387     |   NATIVE
388     |   localModifier
389     ;
390
391 localModifierList
392     :   localModifier+
393         -> ^(LOCAL_MODIFIER_LIST localModifier+)
394     ;
395
396 localModifier
397     :   FINAL
398     |   STATIC
399     |   VOLATILE
400     ;
401
402 type
403     :   simpleType
404     |   objectType
405     |   VOID
406     ;
407
408 simpleType
409     :   primitiveType arrayDeclaratorList?
410         ->  ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)  
411     ;
412
413 objectType
414     :   qualifiedTypeIdent arrayDeclaratorList?
415         ->  ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
416     ;
417
418 qualifiedTypeIdent
419     :   typeIdent ('.' typeIdent)*
420         ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
421     ;
422
423 typeIdent
424     :   IDENT^ genericTypeArgumentList?
425     ;
426
427 primitiveType
428     :   BOOLEAN
429     |   CHAR
430     |   BYTE
431     |   SHORT
432     |   INT
433     |   LONG
434     |   FLOAT
435     |   DOUBLE
436     ;
437
438 genericTypeArgumentList
439     :   lt='<' genericTypeArgument (',' genericTypeArgument)* genericTypeListClosing
440         ->  ^(GENERIC_TYPE_ARG_LIST[$lt, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
441     ;
442
443 genericTypeArgument
444     :   type
445     |   '?'
446     ;
447
448 qualifiedIdentList
449     :   qualifiedIdentifier (','! qualifiedIdentifier)*
450     ;
451
452 formalParameterList
453     :   lp='('
454         (   // Contains at least one standard argument declaration and optionally a variable argument declaration.
455             formalParameterStandardDecl (',' formalParameterStandardDecl)* (',' formalParameterVarArgDecl)? 
456             ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"] formalParameterStandardDecl+ formalParameterVarArgDecl?) 
457             // Contains a variable argument declaration only.
458         |   formalParameterVarArgDecl
459             ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"] formalParameterVarArgDecl) 
460             // Contains nothing.
461         |   ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"]) 
462         )
463         ')'
464     ;
465
466 formalParameterStandardDecl
467     :   localModifierList? type variableDeclaratorId
468         ->  ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
469     ;
470
471 formalParameterVarArgDecl
472     :   localModifierList? type '...' variableDeclaratorId
473         ->  ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
474     ;
475
476 qualifiedIdentifier
477     :   (   IDENT
478             ->  IDENT
479         )
480         (   '.' ident=IDENT
481             ->  ^('.' $qualifiedIdentifier $ident)
482         )*
483     ;
484
485 block
486     :   lc='{' blockStatement* '}'
487         ->  ^(BLOCK[$lc, "BLOCK"] blockStatement*)
488     |   nonBlockStatement
489         -> ^(BLOCK nonBlockStatement)
490     ;
491
492 blockStatement
493     :   localVariableDeclaration ';'!
494     |   statement
495     ;
496
497 localVariableDeclaration
498     :   localModifierList? simpleType classFieldDeclaratorList
499         ->  ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType classFieldDeclaratorList)
500     |   localModifierList? objectType classFieldDeclaratorList
501         ->  ^(OBJECT_VAR_DECLARATION localModifierList? objectType classFieldDeclaratorList)
502     ;
503
504 statement
505     :   nonBlockStatement
506     |   block
507     ;
508         
509 nonBlockStatement
510     :   'assert' expr1=expression 
511         (   ':' expr2=expression ';'
512             ->  ^('assert' $expr1 $expr2)
513         |   ';'
514             ->  ^('assert' $expr1)
515         )
516     |   IF parenthesizedExpression ifStat=block
517         (   ELSE elseStat=block
518             ->  ^(IF parenthesizedExpression $ifStat $elseStat)
519         |
520             ->  ^(IF parenthesizedExpression $ifStat)
521         )   
522     |   f=FOR '('
523         (   forInit? ';' expression? ';' expressionList? ')' block
524             -> ^($f forInit? FOR_EXPR expression? FOR_UPDATE expressionList? block)
525         |   localModifierList? type IDENT ':' expression ')' block
526             -> ^(FOR_EACH[$f, "FOR_EACH"] localModifierList? type IDENT expression block)
527         )
528     |   WHILE parenthesizedExpression block
529         ->  ^(WHILE parenthesizedExpression block)
530     |   DO block WHILE parenthesizedExpression ';'
531         ->  ^(DO block parenthesizedExpression)
532     |   SWITCH parenthesizedExpression '{' switchCaseLabel* '}'
533         ->  ^(SWITCH parenthesizedExpression switchCaseLabel*)
534     |   RETURN expression? ';'
535         ->  ^(RETURN expression?)
536     |   THROW expression ';'
537         ->  ^(THROW expression)
538     |   BREAK IDENT? ';'
539         ->  ^(BREAK IDENT?)
540     |   CONTINUE IDENT? ';'
541         ->  ^(CONTINUE IDENT?)
542     |   IDENT ':' statement
543         ->  ^(LABELED_STATEMENT IDENT statement)
544     |   'delete' qualifiedIdentifier ';'
545         -> ^('delete' qualifiedIdentifier)
546     |   'embed' STRING_LITERAL EMBED_BLOCK
547         ->  ^('embed' STRING_LITERAL EMBED_BLOCK)
548     |   expression ';'!
549     |   ';' // Preserve empty statements.
550     ;           
551         
552
553 switchCaseLabel
554     :   CASE^ expression ':'! blockStatement*
555     |   DEFAULT^ ':'! blockStatement*
556     ;
557     
558 forInit
559     :   localVariableDeclaration
560     |   expressionList
561     ;
562     
563 // EXPRESSIONS
564
565 parenthesizedExpression
566     :   lp='(' expression ')'
567         ->  ^(PAREN_EXPR[$lp, "PAREN_EXPR"] expression)
568     ;
569     
570 expressionList
571     :   expression (','! expression)*
572     ;
573
574 expression
575     :   assignmentExpression
576         ->  ^(EXPR assignmentExpression)
577     ;
578
579 assignmentExpression
580     :   conditionalExpression 
581         (   (   '='^
582             |   '+='^
583             |   '-='^
584             |   '*='^
585             |   '/='^
586             |   '&='^
587             |   '|='^
588             |   '^='^
589             |   '%='^
590             |   '<<='^
591             |   '>>='^
592             |   '>>>='^
593         ) 
594         assignmentExpression)?
595     ;
596     
597 conditionalExpression
598     :   logicalOrExpression ('?'^ assignmentExpression ':'! conditionalExpression)?
599     ;
600
601 logicalOrExpression
602     :   logicalAndExpression ('||'^ logicalAndExpression)*
603     ;
604
605 logicalAndExpression
606     :   inclusiveOrExpression ('&&'^ inclusiveOrExpression)*
607     ;
608
609 inclusiveOrExpression
610     :   exclusiveOrExpression ('|'^ exclusiveOrExpression)*
611     ;
612
613 exclusiveOrExpression
614     :   andExpression ('^'^ andExpression)*
615     ;
616
617 andExpression
618     :   equalityExpression ('&'^ equalityExpression)*
619     ;
620
621 equalityExpression
622     :   instanceOfExpression 
623         (   (   '=='^
624             |   '!='^
625             ) 
626             instanceOfExpression
627         )*
628     ;
629
630 instanceOfExpression
631     :   relationalExpression ('instanceof'^ type)?
632     ;
633
634 relationalExpression
635     :   shiftExpression 
636         (   (   '<='^
637             |   '>='^
638             |   '<'^
639             |   '>'^
640             )
641             shiftExpression
642         )*
643     ;
644     
645 shiftExpression
646     :   additiveExpression
647         (   (   '>>>'^
648             |   '>>'^
649             |   '<<'^
650             )
651             additiveExpression
652         )*
653     ;
654
655 additiveExpression
656     :   multiplicativeExpression
657         (   (   '+'^
658             |   '-'^
659             )
660             multiplicativeExpression
661         )*
662     ;
663
664 multiplicativeExpression
665     :   unaryExpression 
666         (   (   '*'^
667             |   '/'^
668             |   '%'^
669             )
670             unaryExpression
671         )*
672     ;
673     
674 unaryExpression
675     :   op='+' unaryExpression
676         ->  ^(UNARY_PLUS[$op, "UNARY_PLUS"] unaryExpression)
677     |   op='-' unaryExpression
678         ->  ^(UNARY_MINUS[$op, "UNARY_MINUS"] unaryExpression)
679     |   op='++' postfixedExpression
680         ->  ^(PRE_INC[$op, "PRE_INC"] postfixedExpression)
681     |   op='--' postfixedExpression
682         ->  ^(PRE_DEC[$op, "PRE_DEC"] postfixedExpression)
683     |   unaryExpressionNotPlusMinus
684     ;
685
686 unaryExpressionNotPlusMinus
687     :   '!' unaryExpression
688         ->  ^('!' unaryExpression)
689     |   '~' unaryExpression
690         ->  ^('~' unaryExpression)
691     |   lp='(' type ')' unaryExpression
692         ->  ^(CAST_EXPR[$lp, "CAST_EXPR"] type unaryExpression)
693     |   postfixedExpression
694     ;
695     
696 postfixedExpression
697         // At first resolve the primary expression ...
698     :   (   primaryExpression
699             ->  primaryExpression
700         )
701         // ... and than the optional things that may follow a primary
702         // expression 0 or more times.
703         (   outerDot='.'                 
704             // Note: generic type arguments are only valid for method calls,
705             // i.e. if there is an argument list
706             (   (   genericTypeArgumentList?  
707                     IDENT
708                     ->  ^($outerDot $postfixedExpression IDENT)
709                 ) 
710                 (   arguments
711                     ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentList? arguments)
712                 )?
713             |   THIS
714                 ->  ^($outerDot $postfixedExpression THIS)
715             |   s='super' arguments
716                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
717             |   (   'super' innerDot='.' IDENT
718                     ->  ^($innerDot ^($outerDot $postfixedExpression 'super') IDENT)
719                 )
720                 (   arguments
721                     ->  ^(METHOD_CALL $postfixedExpression arguments)
722                 )?
723             )
724         |   '[' expression ']'
725             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
726         )*
727         // At the end there may follow a post increment/decrement.
728         (   op='++'-> ^(POST_INC[$op, "POST_INC"] $postfixedExpression)
729         |   op='--'-> ^(POST_DEC[$op, "POST_DEC"] $postfixedExpression)
730         )?
731     ;    
732     
733 primaryExpression
734     :   parenthesizedExpression
735     |   literal
736     |   newExpression
737     |   qualifiedIdentExpression
738     |   genericTypeArgumentList 
739         (   s='super'
740             (   arguments
741                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
742             |   IDENT arguments
743                 ->  ^(METHOD_CALL ^('.' 'super' IDENT) genericTypeArgumentList arguments)
744             )
745         |   IDENT arguments
746             ->  ^(METHOD_CALL IDENT genericTypeArgumentList arguments)
747         |   t=THIS arguments
748             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
749         )
750     |   (   THIS
751             ->  THIS
752         )
753         (   arguments
754             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] arguments)
755         )?
756     |   s='super' arguments
757         ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] arguments)
758     |   (   'super' '.' IDENT
759         )
760         (   arguments
761             ->  ^(METHOD_CALL ^('.' 'super' IDENT) arguments)
762         |   ->  ^('.' 'super' IDENT)
763         )
764     ;
765     
766 qualifiedIdentExpression
767         // The qualified identifier itself is the starting point for this rule.
768     :   (   qualifiedIdentifier
769             ->  qualifiedIdentifier
770         )
771         // And now comes the stuff that may follow the qualified identifier.
772         (   arguments
773             ->  ^(METHOD_CALL qualifiedIdentifier arguments)
774         |   outerDot='.'
775             (   genericTypeArgumentList 
776                 (   s='super' arguments
777                     ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"]
778                             qualifiedIdentifier genericTypeArgumentList arguments)
779                 |   'super' innerDot='.' IDENT arguments
780                     ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier 'super') IDENT)
781                             genericTypeArgumentList arguments)
782                 |   IDENT arguments
783                     ->  ^(METHOD_CALL ^($outerDot qualifiedIdentifier IDENT) genericTypeArgumentList arguments)
784                 )
785             |   THIS
786                 ->  ^($outerDot qualifiedIdentifier THIS)
787             |   s='super' arguments
788                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
789             )
790         )?
791     ;
792
793 newExpression
794     :   n=NEW
795         (   primitiveType newArrayConstruction          // new static array of primitive type elements
796             ->  ^(STATIC_ARRAY_CREATOR[$n, "STATIC_ARRAY_CREATOR"] primitiveType newArrayConstruction)
797         |   genericTypeArgumentList? qualifiedTypeIdent
798                 newArrayConstruction                // new static array of object type reference elements
799             ->  ^(STATIC_ARRAY_CREATOR[$n, "STATIC_ARRAY_CREATOR"] genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction)
800         |   qualifiedTypeIdent arguments
801             -> ^(NEW qualifiedTypeIdent arguments)
802         )
803     ;
804     
805 newArrayConstruction
806     :   arrayDeclaratorList arrayInitializer
807     |   '['! expression ']'! ('['! expression ']'!)* arrayDeclaratorList?
808     ;
809
810 arguments
811     :   lp='(' expressionList? ')'
812         ->  ^(ARGUMENT_LIST[$lp, "ARGUMENT_LIST"] expressionList?)
813     ;
814
815 literal 
816     :   HEX_LITERAL
817     |   OCTAL_LITERAL
818     |   DECIMAL_LITERAL
819     |   FLOATING_POINT_LITERAL
820     |   CHARACTER_LITERAL
821     |   STRING_LITERAL
822     |   TRUE
823     |   FALSE
824     |   NULL
825     ;
826
827 // LEXER
828
829 HEX_LITERAL : '0' ('x'|'X') HEX_DIGIT+ INTEGER_TYPE_SUFFIX? ;
830
831 DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) INTEGER_TYPE_SUFFIX? ;
832
833 OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
834
835 ARRAY_DIMENSION :  ('1'..'6')('d'|'D') ;
836
837 fragment
838 HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
839
840 fragment
841 INTEGER_TYPE_SUFFIX : ('l'|'L') ;
842
843 FLOATING_POINT_LITERAL
844     :   ('0'..'9')+ 
845         (
846             '.' ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
847         |   EXPONENT FLOAT_TYPE_SUFFIX?
848         |   FLOAT_TYPE_SUFFIX
849         )
850     |   '.' ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
851     ;
852
853 fragment
854 EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
855
856 fragment
857 FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;
858
859 CHARACTER_LITERAL
860     :   '\'' ( ESCAPE_SEQUENCE | ~('\''|'\\') ) '\''
861     ;
862
863 STRING_LITERAL
864     :  '"' ( ESCAPE_SEQUENCE | ~('\\'|'"') )* '"'
865     ;
866
867 fragment
868 ESCAPE_SEQUENCE
869     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
870     |   UNICODE_ESCAPE
871     |   OCTAL_ESCAPE
872     ;
873
874 fragment
875 OCTAL_ESCAPE
876     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
877     |   '\\' ('0'..'7') ('0'..'7')
878     |   '\\' ('0'..'7')
879     ;
880
881 fragment
882 UNICODE_ESCAPE
883     :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
884     ;
885
886 IDENT
887     :   CHARJ_ID_START (CHARJ_ID_PART)*
888     ;
889
890 fragment
891 CHARJ_ID_START
892     :  '\u0024'
893     |  '\u0041'..'\u005a'
894     |  '\u005f'
895     |  '\u0061'..'\u007a'
896     |  '\u00c0'..'\u00d6'
897     |  '\u00d8'..'\u00f6'
898     |  '\u00f8'..'\u00ff'
899     |  '\u0100'..'\u1fff'
900     |  '\u3040'..'\u318f'
901     |  '\u3300'..'\u337f'
902     |  '\u3400'..'\u3d2d'
903     |  '\u4e00'..'\u9fff'
904     |  '\uf900'..'\ufaff'
905     ;
906
907 fragment
908 CHARJ_ID_PART
909     :  CHARJ_ID_START
910     |  '\u0030'..'\u0039'
911     ;
912
913 WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') 
914     {   
915         $channel = HIDDEN;
916     }
917     ;
918
919 fragment
920 EMBED_BLOCK
921     :   '{' ( options {greedy=false;} : EMBED_BLOCK | . )* '}'
922     ;
923
924 COMMENT
925     :   '/*' ( options {greedy=false;} : . )* '*/'
926     {   
927         $channel = HIDDEN;
928     }
929     ;
930
931 LINE_COMMENT
932     : ('//'|'#') ~('\n'|'\r')* '\r'? '\n'
933     {   
934         $channel = HIDDEN;
935     }
936     ;
937