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