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