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