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