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