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