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