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