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