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