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