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