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