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