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