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