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