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