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