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