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