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