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