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