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