217f73044e0c8f979f62654821b31ee5ade8d6fc
[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     ENTRY_CONSTRUCTOR_DECL;
237 }
238
239 @header {
240 package charj.translator;
241 }
242
243 @members {
244 }
245
246 @lexer::header {
247 package charj.translator; 
248 }
249
250 @lexer::members {
251 }
252
253 // Starting point for parsing a Charj file.
254 charjSource
255     :   compilationUnit EOF
256         ->  ^(CHARJ_SOURCE compilationUnit)
257     ;
258
259 compilationUnit
260     :   packageDeclaration? 
261         topLevelDeclaration+ 
262     ;
263
264 topLevelDeclaration
265     :   importDeclaration
266     |   readonlyDeclaration
267     |   typeDeclaration
268     ;
269
270 packageDeclaration
271     :   PACKAGE IDENT (DOT IDENT)* ';'
272         ->  ^(PACKAGE IDENT+)
273     ;
274
275 importDeclaration
276     :   IMPORT^ qualifiedIdentifier '.*'? ';'!
277     ;
278
279 readonlyDeclaration
280     :   READONLY^ localVariableDeclaration ';'!
281     ;
282
283 typeDeclaration
284     :   classDefinition
285     |   templateDeclaration
286     |   interfaceDefinition
287     |   enumDefinition
288     |   chareDefinition
289     ;
290
291 templateList
292     : 'class'! IDENT (','! 'class'! IDENT)*
293     ;
294
295 templateDeclaration
296     : 'template' '<' templateList '>' classDefinition
297         -> ^('template' templateList classDefinition)
298     ;
299
300 classDefinition
301     :   PUBLIC? CLASS IDENT (EXTENDS type)? ('implements' typeList)? '{'
302       classScopeDeclaration* '}' ';'?
303         -> ^(TYPE CLASS IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
304     ;
305
306 chareType
307     :   CHARE
308     |   GROUP
309     |   NODEGROUP
310     |   MAINCHARE
311     |   CHARE_ARRAY '[' ARRAY_DIMENSION ']' -> ^(CHARE_ARRAY ARRAY_DIMENSION)
312     ;
313
314 chareDefinition
315     :   PUBLIC? chareType IDENT (EXTENDS type)? ('implements' typeList)? '{'
316             classScopeDeclaration*
317         '}' ';'?
318         -> ^(TYPE chareType IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
319     ;
320
321 interfaceDefinition
322     :   'interface' IDENT (EXTENDS typeList)?  '{'
323             interfaceScopeDeclaration*
324         '}' ';'?
325         -> ^('interface' IDENT ^(EXTENDS typeList)? interfaceScopeDeclaration*)
326     ;
327
328 enumDefinition
329     :   ENUM IDENT ('implements' typeList)? '{'
330             enumConstants ','? ';' classScopeDeclaration*
331         '}' ';'?
332         -> ^(ENUM IDENT ^('implements' typeList)? enumConstants classScopeDeclaration*)
333     ;
334
335 enumConstants
336     :   enumConstant (','! enumConstant)*
337     ;
338
339 enumConstant
340     :   IDENT^ arguments?
341     ;
342
343 typeList
344     :   type (','! type)*
345     ;
346
347 classScopeDeclaration
348     :   modifierList?
349         (   genericTypeParameterList?
350             (   type IDENT formalParameterList (';' | block)
351                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT
352                     formalParameterList block?)
353             |   ident=IDENT formalParameterList block
354                 ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList? genericTypeParameterList? IDENT
355                         formalParameterList block)
356             )
357         |   type IDENT formalParameterList divconBlock
358             ->  ^(DIVCON_METHOD_DECL modifierList? type IDENT formalParameterList divconBlock)
359         |   simpleType classFieldDeclaratorList ';'
360             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType classFieldDeclaratorList)
361         |   objectType classFieldDeclaratorList ';'
362             ->  ^(OBJECT_VAR_DECLARATION modifierList? objectType classFieldDeclaratorList)
363         )
364     ;
365
366 interfaceScopeDeclaration
367     :   modifierList?
368         (   genericTypeParameterList?
369             (   type IDENT formalParameterList ';'
370                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList?
371                         type IDENT formalParameterList)
372             )
373         |   simpleType interfaceFieldDeclaratorList ';'
374             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType interfaceFieldDeclaratorList)
375         |   objectType interfaceFieldDeclaratorList ';'
376             ->  ^(OBJECT_VAR_DECLARATION modifierList? objectType interfaceFieldDeclaratorList)        
377         )
378     ;
379
380 classFieldDeclaratorList
381     :   classFieldDeclarator (',' classFieldDeclarator)*
382         ->  ^(VAR_DECLARATOR_LIST classFieldDeclarator+)
383     ;
384
385 classFieldDeclarator
386     :   variableDeclaratorId (ASSIGNMENT variableInitializer)?
387         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
388     ;
389
390 interfaceFieldDeclaratorList
391     :   interfaceFieldDeclarator (',' interfaceFieldDeclarator)*
392         ->  ^(VAR_DECLARATOR_LIST interfaceFieldDeclarator+)
393     ;
394
395 interfaceFieldDeclarator
396     :   variableDeclaratorId ASSIGNMENT variableInitializer
397         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
398     ;
399
400 variableDeclaratorId
401     :   IDENT^ domainExpression?
402     ;
403
404 variableInitializer
405     :   arrayInitializer
406     |   expression
407     ;
408
409 arrayInitializer
410     :   lc='{' (variableInitializer (',' variableInitializer)* ','?)? '}'
411         ->  ^(ARRAY_INITIALIZER[$lc, "ARRAY_INITIALIZER"] variableInitializer*)
412     ;
413
414 templateArg
415     : genericTypeArgument
416     | literal
417     ;
418
419 templateArgList
420     :   templateArg (','! templateArg)*
421     ;
422
423 templateInstantiation
424     :    '<' templateArgList '>'
425         -> ^(TEMPLATE_INST templateArgList)
426     |    '<' templateInstantiation '>'
427         -> ^(TEMPLATE_INST templateInstantiation)
428     ;
429
430 genericTypeParameterList
431     :   lt='<' genericTypeParameter (',' genericTypeParameter)* genericTypeListClosing
432         ->  ^(GENERIC_TYPE_PARAM_LIST[$lt, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
433     ;
434
435 // This hack is fairly dirty - we just bite off some angle brackets and don't
436 // actually match up opening and closing brackets.
437 genericTypeListClosing  
438     :   '>'
439     |   '>>'
440     |   '>>>'
441     |
442     ;
443
444 genericTypeParameter
445     :   IDENT bound?
446         ->  ^(IDENT bound?)
447     ;
448
449 bound
450     :   e=EXTENDS type ('&' type)*
451         ->  ^(EXTENDS_BOUND_LIST[$e, "EXTENDS_BOUND_LIST"] type+)
452     ;
453
454 modifierList
455     :   modifier+
456         ->  ^(MODIFIER_LIST modifier+)
457     ;
458
459 modifier
460     :   PUBLIC
461     |   PROTECTED
462     |   ENTRY
463     |   SDAGENTRY
464     |   TRACED
465     |   PRIVATE
466     |   ABSTRACT
467     |   NATIVE
468     |   localModifier
469     ;
470
471 localModifierList
472     :   localModifier+
473         -> ^(LOCAL_MODIFIER_LIST localModifier+)
474     ;
475
476 localModifier
477     :   FINAL
478     |   STATIC
479     |   VOLATILE
480     ;
481
482 type
483     :   simpleType
484     |   objectType
485     |   VOID
486     ;
487
488 constructorType
489     :   qualifiedTypeIdent AT domainExpression?
490         ->  ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
491     |   qualifiedTypeIdent domainExpression?
492         ->  ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
493     ;
494
495 simpleType
496     :   primitiveType domainExpression?
497         ->  ^(SIMPLE_TYPE primitiveType domainExpression?)  
498     ;
499
500 objectType
501     :   qualifiedTypeIdent AT domainExpression?
502         ->  ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
503     |   qualifiedTypeIdent domainExpression?
504         ->  ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
505     ;
506
507 qualifiedTypeIdent
508     :   typeIdent (DOT typeIdent)*
509         ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
510     ;
511
512 typeIdent
513     :   IDENT^ templateInstantiation?
514     ;
515
516 primitiveType
517     :   BOOLEAN
518     |   CHAR
519     |   BYTE
520     |   SHORT
521     |   INT
522     |   LONG
523     |   FLOAT
524     |   DOUBLE
525     ;
526
527 /*genericTypeArgumentList
528     :   lt='<' genericTypeArgument (',' genericTypeArgument)* genericTypeListClosing
529         ->  ^(GENERIC_TYPE_ARG_LIST[$lt, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
530     ;*/
531
532 genericTypeArgument
533     :   type
534     |   '?'
535     ;
536
537 qualifiedIdentList
538     :   qualifiedIdentifier (','! qualifiedIdentifier)*
539     ;
540
541 formalParameterList
542     :   lp='('
543         (   // Contains at least one standard argument declaration and optionally a variable argument declaration.
544             formalParameterStandardDecl (',' formalParameterStandardDecl)* (',' formalParameterVarArgDecl)? 
545             ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"] formalParameterStandardDecl+ formalParameterVarArgDecl?) 
546             // Contains a variable argument declaration only.
547         |   formalParameterVarArgDecl
548             ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"] formalParameterVarArgDecl) 
549             // Contains nothing.
550         |   ->  ^(FORMAL_PARAM_LIST[$lp, "FORMAL_PARAM_LIST"]) 
551         )
552         ')'
553     ;
554
555 formalParameterStandardDecl
556     :   localModifierList? type variableDeclaratorId
557         ->  ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
558     ;
559
560 formalParameterVarArgDecl
561     :   localModifierList? type '...' variableDeclaratorId
562         ->  ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
563     ;
564
565 qualifiedIdentifier
566     :   (   IDENT
567             ->  IDENT
568         )
569         (   DOT ident=IDENT
570             ->  ^(DOT $qualifiedIdentifier $ident)
571         )*
572     ;
573
574 block
575     :   lc='{' blockStatement* '}'
576         ->  ^(BLOCK[$lc, "BLOCK"] blockStatement*)
577     |   nonBlockStatement
578         -> ^(BLOCK nonBlockStatement)
579     ;
580
581 blockStatement
582     :   localVariableDeclaration ';'!
583     |   statement
584     ;
585
586 localVariableDeclaration
587     :   localModifierList? simpleType classFieldDeclaratorList
588         ->  ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType classFieldDeclaratorList)
589     |   localModifierList? objectType classFieldDeclaratorList
590         ->  ^(OBJECT_VAR_DECLARATION localModifierList? objectType classFieldDeclaratorList)
591     ;
592
593 statement
594     :   nonBlockStatement
595     |   sdagStatement
596     |   block
597     ;
598
599 sdagStatement
600     :   OVERLAP block
601         -> ^(OVERLAP block)
602     |   WHEN (IDENT ('[' expression ']')? formalParameterList)* block
603         -> ^(WHEN (IDENT expression? formalParameterList)* block)
604     ;
605
606 divconBlock
607     :   divconExpr
608         ->  ^(DIVCON_BLOCK divconExpr)
609     ;
610
611 divconAssignment
612     :   IDENT '=' expression
613         -> ^(LET_ASSIGNMENT IDENT expression)
614     ;
615
616 divconAssignmentList
617     :   divconAssignment (','! divconAssignment)*
618     ;
619
620 divconExpr
621     :   IF parenthesizedExpression ifExpr=divconExpr
622         (   ELSE elseExpr=divconExpr
623             ->  ^(IF parenthesizedExpression $ifExpr $elseExpr)
624         |
625             ->  ^(IF parenthesizedExpression $ifExpr)
626         )
627     |   LET ^divconAssignmentList IN divconExpr
628     |   expression ';'!
629     |   '{'! divconExpr '}'!
630     ;
631
632 nonBlockStatement
633     :   'assert' expr1=expression 
634         (   ':' expr2=expression ';'
635             ->  ^('assert' $expr1 $expr2)
636         |   ';'
637             ->  ^('assert' $expr1)
638         )
639     |   IF parenthesizedExpression ifStat=block
640         (   ELSE elseStat=block
641             ->  ^(IF parenthesizedExpression $ifStat $elseStat)
642         |
643             ->  ^(IF parenthesizedExpression $ifStat)
644         )   
645     |   f=FOR '('
646         (   forInit? ';' expression? ';' expressionList? ')' block
647             -> ^($f forInit? FOR_EXPR expression? FOR_UPDATE expressionList? block)
648         |   localModifierList? type IDENT ':' expression ')' block
649             -> ^(FOR_EACH[$f, "FOR_EACH"] localModifierList? type IDENT expression block)
650         )
651     |   WHILE parenthesizedExpression block
652         ->  ^(WHILE parenthesizedExpression block)
653     |   DO block WHILE parenthesizedExpression ';'
654         ->  ^(DO block parenthesizedExpression)
655     |   SWITCH parenthesizedExpression '{' switchCaseLabel* '}'
656         ->  ^(SWITCH parenthesizedExpression switchCaseLabel*)
657     |   RETURN expression? ';'
658         ->  ^(RETURN expression?)
659     |   THROW expression ';'
660         ->  ^(THROW expression)
661     |   BREAK IDENT? ';'
662         ->  ^(BREAK IDENT?)
663     |   CONTINUE IDENT? ';'
664         ->  ^(CONTINUE IDENT?)
665     |   IDENT ':' statement
666         ->  ^(LABELED_STATEMENT IDENT statement)
667     |   'delete' expression ';'
668         -> ^('delete' expression)
669     |   'embed' STRING_LITERAL EMBED_BLOCK
670         ->  ^('embed' STRING_LITERAL EMBED_BLOCK)
671     |   expression ';'!
672     |   ';' // Preserve empty statements.
673     |   PRINT '(' (expression (',' expression)*)* ')' ';'
674         ->  ^(PRINT expression*)
675     |   PRINTLN '(' (expression (',' expression)*)* ')' ';'
676         ->  ^(PRINTLN expression*)
677     |   EXIT '(' expression? ')' ';'
678         ->  ^(EXIT expression?)
679     |   EXITALL '(' ')' ';'
680         ->  EXITALL
681     ;           
682         
683
684 switchCaseLabel
685     :   CASE^ expression ':'! blockStatement*
686     |   DEFAULT^ ':'! blockStatement*
687     ;
688     
689 forInit
690     :   localVariableDeclaration
691     |   expressionList
692     ;
693     
694 // EXPRESSIONS
695
696 parenthesizedExpression
697     :   lp='(' expression ')'
698         ->  ^(PAREN_EXPR[$lp, "PAREN_EXPR"] expression)
699     ;
700     
701 rangeItem
702     :   DECIMAL_LITERAL
703     |   IDENT
704     ;
705
706 rangeExpression
707     :   rangeItem
708         -> ^(RANGE_EXPRESSION rangeItem)
709     |   rangeItem ':' rangeItem
710         -> ^(RANGE_EXPRESSION rangeItem rangeItem)
711     |   rangeItem ':' rangeItem ':' rangeItem
712         -> ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
713     ;
714
715 rangeList
716     :   rangeExpression (','! rangeExpression)*
717     ;
718
719 domainExpression
720     :   '[' rangeList ']'
721         -> ^(DOMAIN_EXPRESSION rangeList)
722     ;
723
724 expressionList
725     :   expression (','! expression)*
726     ;
727
728 expression
729     :   assignmentExpression
730         ->  ^(EXPR assignmentExpression)
731     ;
732
733 assignmentExpression
734     :   conditionalExpression 
735         (   (   ASSIGNMENT^
736             |   '+='^
737             |   '-='^
738             |   '*='^
739             |   '/='^
740             |   '&='^
741             |   '|='^
742             |   '^='^
743             |   '%='^
744             |   '<<='^
745             |   '>>='^
746             |   '>>>='^
747         ) 
748         assignmentExpression)?
749     ;
750     
751 conditionalExpression
752     :   logicalOrExpression ('?'^ assignmentExpression ':'! conditionalExpression)?
753     ;
754
755 logicalOrExpression
756     :   logicalAndExpression ('||'^ logicalAndExpression)*
757     ;
758
759 logicalAndExpression
760     :   inclusiveOrExpression ('&&'^ inclusiveOrExpression)*
761     ;
762
763 inclusiveOrExpression
764     :   exclusiveOrExpression ('|'^ exclusiveOrExpression)*
765     ;
766
767 exclusiveOrExpression
768     :   andExpression ('^'^ andExpression)*
769     ;
770
771 andExpression
772     :   equalityExpression ('&'^ equalityExpression)*
773     ;
774
775 equalityExpression
776     :   instanceOfExpression 
777         (   (   EQUALS^
778             |   '!='^
779             ) 
780             instanceOfExpression
781         )*
782     ;
783
784 instanceOfExpression
785     :   relationalExpression ('instanceof'^ type)?
786     ;
787
788 relationalExpression
789     :   shiftExpression 
790         (   (   '<='^
791             |   '>='^
792             |   '<'^
793             |   '>'^
794             )
795             shiftExpression
796         )*
797     ;
798     
799 shiftExpression
800     :   additiveExpression
801         (   (   '>>>'^
802             |   '>>'^
803             |   '<<'^
804             )
805             additiveExpression
806         )*
807     ;
808
809 additiveExpression
810     :   multiplicativeExpression
811         (   (   '+'^
812             |   '-'^
813             )
814             multiplicativeExpression
815         )*
816     ;
817
818 multiplicativeExpression
819     :   unaryExpression 
820         (   (   '*'^
821             |   '/'^
822             |   '%'^
823             )
824             unaryExpression
825         )*
826     ;
827     
828 unaryExpression
829     :   op='+' unaryExpression
830         ->  ^(UNARY_PLUS[$op, "UNARY_PLUS"] unaryExpression)
831     |   op='-' unaryExpression
832         ->  ^(UNARY_MINUS[$op, "UNARY_MINUS"] unaryExpression)
833     |   op='++' postfixedExpression
834         ->  ^(PRE_INC[$op, "PRE_INC"] postfixedExpression)
835     |   op='--' postfixedExpression
836         ->  ^(PRE_DEC[$op, "PRE_DEC"] postfixedExpression)
837     |   unaryExpressionNotPlusMinus
838     ;
839
840 unaryExpressionNotPlusMinus
841     :   '!' unaryExpression
842         ->  ^('!' unaryExpression)
843     |   '~' unaryExpression
844         ->  ^('~' unaryExpression)
845     |   lp='(' type ')' unaryExpression
846         ->  ^(CAST_EXPR[$lp, "CAST_EXPR"] type unaryExpression)
847     |   postfixedExpression
848     ;
849     
850 postfixedExpression
851         // At first resolve the primary expression ...
852     :   (   primaryExpression
853             ->  primaryExpression
854         )
855         // ... and than the optional things that may follow a primary expression 0 or more times.
856         (   outerDot=DOT                 
857             // Note: generic type arguments are only valid for method calls,
858             // i.e. if there is an argument list
859             (   (   templateInstantiation?  
860                     IDENT
861                     ->  ^($outerDot $postfixedExpression IDENT)
862                 ) 
863                 (   arguments
864                     ->  ^(METHOD_CALL $postfixedExpression templateInstantiation? arguments)
865                 )?
866             |   THIS
867                 ->  ^($outerDot $postfixedExpression THIS)
868             |   s=SUPER arguments
869                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
870             |   (   SUPER innerDot=DOT IDENT
871                     ->  ^($innerDot ^($outerDot $postfixedExpression SUPER) IDENT)
872                 )
873                 (   arguments
874                     ->  ^(METHOD_CALL $postfixedExpression arguments)
875                 )?
876             )
877         |   (AT templateInstantiation? IDENT arguments)
878             ->  ^(ENTRY_METHOD_CALL ^(AT $postfixedExpression IDENT) templateInstantiation? arguments)
879         |   '[' expression ']'
880             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
881         |   domainExpression
882             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression domainExpression)
883         )*
884         // At the end there may follow a post increment/decrement.
885         (   op='++'-> ^(POST_INC[$op, "POST_INC"] $postfixedExpression)
886         |   op='--'-> ^(POST_DEC[$op, "POST_DEC"] $postfixedExpression)
887         )?
888     ;    
889     
890 primaryExpression
891     :   parenthesizedExpression
892     |   literal
893     |   newExpression
894     |   qualifiedIdentExpression
895     |   domainExpression
896     |   templateInstantiation
897         (   s=SUPER
898             (   arguments
899                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] templateInstantiation arguments)
900             |   IDENT arguments
901                 ->  ^(METHOD_CALL ^(DOT SUPER IDENT) templateInstantiation arguments)
902             )
903         |   IDENT arguments
904             ->  ^(METHOD_CALL IDENT templateInstantiation arguments)
905         |   t=THIS arguments
906             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] templateInstantiation arguments)
907         )
908     |   (   THIS
909             ->  THIS
910         )
911         (   arguments
912             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] arguments)
913         )?
914     |   s=SUPER arguments
915         ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] arguments)
916     |   (   SUPER DOT IDENT
917         )
918         (   arguments
919             ->  ^(METHOD_CALL ^(DOT SUPER IDENT) arguments)
920         |   ->  ^(DOT SUPER IDENT)
921         )
922     |   GETMYPE '(' ')'
923         ->  GETMYPE
924     |   GETNUMPES '(' ')'
925         ->  GETNUMPES
926     |   GETMYRANK '(' ')'
927         ->  GETMYRANK
928     |   GETMYNODE '(' ')'
929         -> GETMYNODE
930     |   GETNUMNODES '(' ')'
931         -> GETNUMNODES
932         |       THISINDEX
933         |       THISPROXY
934     ;
935     
936 qualifiedIdentExpression
937         // The qualified identifier itself is the starting point for this rule.
938     :   (   qualifiedIdentifier
939             ->  qualifiedIdentifier
940         )
941         // And now comes the stuff that may follow the qualified identifier.
942         (   arguments
943             ->  ^(METHOD_CALL qualifiedIdentifier arguments)
944         |   outerDot=DOT
945             (   templateInstantiation
946                 (   s=SUPER arguments
947                     ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"]
948                             qualifiedIdentifier templateInstantiation arguments)
949                 |   SUPER innerDot=DOT IDENT arguments
950                     ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier SUPER) IDENT)
951                             templateInstantiation arguments)
952                 |   IDENT arguments
953                     ->  ^(METHOD_CALL ^($outerDot qualifiedIdentifier IDENT) templateInstantiation arguments)
954                 )
955             |   THIS
956                 ->  ^($outerDot qualifiedIdentifier THIS)
957             |   s=SUPER arguments
958                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
959             )
960         )?
961     ;
962
963 newExpression
964     :   n=NEW
965         (
966             domainExpression arguments?
967             ->  ^(NEW_EXPRESSION arguments? domainExpression)
968         |   constructorType arguments
969             -> ^(NEW constructorType arguments)
970         )
971     ;
972     
973 /*newArrayConstruction
974     :   arrayDeclaratorList arrayInitializer
975     |   '['! expression ']'! ('['! expression ']'!)* arrayDeclaratorList?
976     ;*/
977
978 arguments
979     :   lp='(' expressionList? ')'
980         ->  ^(ARGUMENT_LIST[$lp, "ARGUMENT_LIST"] expressionList?)
981     ;
982
983 literal 
984     :   HEX_LITERAL
985     |   OCTAL_LITERAL
986     |   DECIMAL_LITERAL
987     |   FLOATING_POINT_LITERAL
988     |   CHARACTER_LITERAL
989     |   STRING_LITERAL
990     |   TRUE
991     |   FALSE
992     |   NULL
993     ;
994
995 // LEXER
996
997 HEX_LITERAL : '0' ('x'|'X') HEX_DIGIT+ INTEGER_TYPE_SUFFIX? ;
998
999 DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) INTEGER_TYPE_SUFFIX? ;
1000
1001 OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
1002
1003 ARRAY_DIMENSION :  ('1'..'6')('d'|'D') ;
1004
1005 fragment
1006 HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
1007
1008 fragment
1009 INTEGER_TYPE_SUFFIX : ('l'|'L') ;
1010
1011 FLOATING_POINT_LITERAL
1012     :   ('0'..'9')+ 
1013         (
1014             DOT ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
1015         |   EXPONENT FLOAT_TYPE_SUFFIX?
1016         |   FLOAT_TYPE_SUFFIX
1017         )
1018     |   DOT ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
1019     ;
1020
1021 fragment
1022 EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
1023
1024 fragment
1025 FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;
1026
1027 CHARACTER_LITERAL
1028     :   '\'' ( ESCAPE_SEQUENCE | ~('\''|'\\') ) '\''
1029     ;
1030
1031 STRING_LITERAL
1032     :  '"' ( ESCAPE_SEQUENCE | ~('\\'|'"') )* '"'
1033     ;
1034
1035 fragment
1036 ESCAPE_SEQUENCE
1037     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
1038     |   UNICODE_ESCAPE
1039     |   OCTAL_ESCAPE
1040     ;
1041
1042 fragment
1043 OCTAL_ESCAPE
1044     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
1045     |   '\\' ('0'..'7') ('0'..'7')
1046     |   '\\' ('0'..'7')
1047     ;
1048
1049 fragment
1050 UNICODE_ESCAPE
1051     :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1052     ;
1053
1054 IDENT
1055     :   CHARJ_ID_START (CHARJ_ID_PART)*
1056     ;
1057
1058 fragment
1059 CHARJ_ID_START
1060     :  '\u0024'
1061     |  '\u0041'..'\u005a'
1062     |  '\u005f'
1063     |  '\u0061'..'\u007a'
1064     |  '\u00c0'..'\u00d6'
1065     |  '\u00d8'..'\u00f6'
1066     |  '\u00f8'..'\u00ff'
1067     |  '\u0100'..'\u1fff'
1068     |  '\u3040'..'\u318f'
1069     |  '\u3300'..'\u337f'
1070     |  '\u3400'..'\u3d2d'
1071     |  '\u4e00'..'\u9fff'
1072     |  '\uf900'..'\ufaff'
1073     ;
1074
1075 fragment
1076 CHARJ_ID_PART
1077     :  CHARJ_ID_START
1078     |  '\u0030'..'\u0039'
1079     ;
1080
1081 WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') 
1082     {   
1083         $channel = HIDDEN;
1084     }
1085     ;
1086
1087 fragment
1088 EMBED_BLOCK
1089     :   '{' ( options {greedy=false;} : EMBED_BLOCK | . )* '}'
1090     ;
1091
1092 COMMENT
1093     :   '/*' ( options {greedy=false;} : . )* '*/'
1094     {   
1095         $channel = HIDDEN;
1096     }
1097     ;
1098
1099 LINE_COMMENT
1100     : ('//'|'#') ~('\n'|'\r')* '\r'? '\n'
1101     {   
1102         $channel = HIDDEN;
1103     }
1104     ;
1105