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