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