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