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