Add grammar for SDAG 'when' and 'overlap' statements
[charm.git] / src / langs / charj / src / charj / translator / CharjASTModifier.g
1 /**
2  *  fill a description in
3  */
4
5 tree grammar CharjASTModifier;
6
7 options {
8     backtrack = true; 
9     memoize = true;
10     tokenVocab = Charj;
11     ASTLabelType = CharjAST;
12     output = AST;
13 }
14
15 @header {
16 package charj.translator;
17 }
18
19 @members {
20     PackageScope currentPackage = null;
21     ClassSymbol currentClass = null;
22     MethodSymbol currentMethod = null;
23     LocalScope currentLocalScope = null;
24     Translator translator;
25
26     AstModifier astmod = new AstModifier();
27 }
28
29 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
30 @rulecatch {
31     catch (RecognitionException re) {
32         reportError(re);
33         throw re;
34     }
35 }
36
37
38 // Starting point for parsing a Charj file.
39 charjSource
40     // TODO: go back to allowing multiple type definitions per file, check that
41     // there is exactly one public type and return that one.
42     :   ^(CHARJ_SOURCE 
43         packageDeclaration?
44         importDeclaration*
45         readonlyDeclaration*
46         typeDeclaration*)
47     ;
48
49 packageDeclaration
50     :   ^(PACKAGE (ids+=IDENT)+)
51     ;
52     
53 importDeclaration
54     :   ^(IMPORT qualifiedIdentifier '.*'?)
55     ;
56
57 readonlyDeclaration
58     :   ^(READONLY localVariableDeclaration)
59     ;
60
61 typeOfType returns [boolean array_type]
62     : CLASS 
63     | chareType 
64     | chareArrayType { $array_type = true; }
65     ;
66
67 typeDeclaration
68 @init {
69     astmod = new AstModifier();
70 }
71     :   ^(TYPE typeOfType IDENT
72         (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
73         {
74         }
75         -> ^(TYPE typeOfType IDENT
76             (^('extends' type))? (^('implements' type+))? classScopeDeclaration* 
77         )
78     |   ^(INTERFACE IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
79     |   ^(ENUM IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
80     ;
81
82 chareArrayType
83     :   ^(CHARE_ARRAY ARRAY_DIMENSION)
84     ;
85
86 chareType
87     :   CHARE
88     |   GROUP
89     |   NODEGROUP
90     |   MAINCHARE
91     ;
92
93 enumConstant
94     :   ^(IDENT arguments?)
95     ;
96     
97 classScopeDeclaration
98     :   ^(d=FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
99             ty=type IDENT f=formalParameterList a=domainExpression? 
100             b=block?)
101         -> {$m.isEntry}? ^(ENTRY_FUNCTION_DECL modifierList? 
102             genericTypeParameterList? type IDENT formalParameterList domainExpression? block?)
103         -> ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
104             type IDENT formalParameterList domainExpression? block?)
105     |   ^(PRIMITIVE_VAR_DECLARATION m = modifierList? simpleType variableDeclaratorList)
106         -> {$modifierList.tree != null}? ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
107         -> ^(PRIMITIVE_VAR_DECLARATION 
108             ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST 'private') ^(LOCAL_MODIFIER_LIST) 
109                 ^(CHARJ_MODIFIER_LIST) ^(OTHER_MODIFIER_LIST))
110             simpleType variableDeclaratorList)
111     |   ^(OBJECT_VAR_DECLARATION m = modifierList? objectType variableDeclaratorList)
112         -> {$modifierList.tree != null}? ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
113         -> ^(OBJECT_VAR_DECLARATION  
114             ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST 'private') ^(LOCAL_MODIFIER_LIST) 
115                 ^(CHARJ_MODIFIER_LIST) ^(OTHER_MODIFIER_LIST))
116             objectType variableDeclaratorList)
117     |   ^(cd=CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
118             ^(BLOCK (blockStatement*)))
119         -> {$m.isEntry}? ^(ENTRY_CONSTRUCTOR_DECL modifierList? 
120             genericTypeParameterList? IDENT formalParameterList 
121             ^(BLOCK ^(EXPR ^(METHOD_CALL CHELPER ARGUMENT_LIST)) blockStatement*))
122         -> ^(CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT formalParameterList 
123             ^(BLOCK ^(EXPR ^(METHOD_CALL CHELPER ARGUMENT_LIST)) blockStatement*))
124     ;
125     
126 interfaceScopeDeclaration
127     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
128             type IDENT formalParameterList domainExpression?)
129         // Interface constant declarations have been switched to variable
130         // declarations by Charj.g; the parser has already checked that
131         // there's an obligatory initializer.
132     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
133     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
134     ;
135
136 variableDeclaratorList
137     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
138     ;
139
140 variableDeclarator
141     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
142     ;
143     
144 variableDeclaratorId
145     :   ^(IDENT domainExpression?)
146     ;
147
148 variableInitializer
149     :   arrayInitializer
150     |   expression
151     ;
152
153 arrayInitializer
154     :   ^(ARRAY_INITIALIZER variableInitializer*)
155     ;
156
157 templateArg
158     : genericTypeArgument
159     | literal
160     ;
161
162 templateArgList
163     :   templateArg templateArg*
164     ;
165
166 templateInstantiation
167     :    ^(TEMPLATE_INST templateArgList)
168     |    ^(TEMPLATE_INST templateInstantiation)
169     ;
170
171 genericTypeParameterList
172     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
173     ;
174
175 genericTypeParameter
176     :   ^(IDENT bound?)
177     ;
178         
179 bound
180     :   ^(EXTENDS_BOUND_LIST type+)
181     ;
182
183 modifierList returns [boolean isEntry]
184     :   ^(MODIFIER_LIST (localModifier | (am+=accessModifier) | charjModifier {if ($charjModifier.isEntry) {$isEntry = true;}} | otherModifier)*)
185         -> {$am == null}? ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST 'private') ^(LOCAL_MODIFIER_LIST localModifier*) ^(CHARJ_MODIFIER_LIST charjModifier*) ^(OTHER_MODIFIER_LIST otherModifier*))
186         -> ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST accessModifier*) ^(LOCAL_MODIFIER_LIST localModifier*) ^(CHARJ_MODIFIER_LIST charjModifier*) ^(OTHER_MODIFIER_LIST otherModifier*)) 
187     ;
188
189 localModifier
190     :   FINAL
191     |   STATIC
192     |   VOLATILE
193     ;
194
195 accessModifier
196     :   PUBLIC
197     |   PROTECTED
198     |   PRIVATE
199     ;
200
201 charjModifier returns [boolean isEntry] 
202     :   ENTRY { $isEntry = true; }
203     |   TRACED
204     ;
205
206 otherModifier
207     :   ABSTRACT
208     |   NATIVE
209     ;
210
211 modifier
212     :   PUBLIC
213     |   PRIVATE
214     |   PROTECTED
215     |   ENTRY
216     |   TRACED
217     |   ABSTRACT
218     |   NATIVE
219     |   localModifier
220     ;
221
222 localModifierList
223     :   ^(LOCAL_MODIFIER_LIST localModifier+)
224     ;
225
226 type
227     :   simpleType
228     |   objectType 
229     |   VOID
230     ;
231
232 simpleType
233     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
234     ;
235     
236 objectType
237     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
238     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
239     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
240     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
241         {
242             // TODO: This breaks all pointer types inside chares not used for sending
243             // them in entry methods, converting them to object types, which breaks
244             // Arrays inside chares.
245             //astmod.dealWithEntryMethodParam($POINTER_TYPE, $POINTER_TYPE.tree);
246         }
247     ;
248
249 qualifiedTypeIdent
250     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
251     ;
252
253 typeIdent
254     :   ^(IDENT templateInstantiation?)
255     ;
256
257 primitiveType
258     :   BOOLEAN
259     |   CHAR
260     |   BYTE
261     |   SHORT
262     |   INT
263     |   LONG
264     |   FLOAT
265     |   DOUBLE
266     ;
267
268 genericTypeArgument
269     :   type
270     |   '?'
271     ;
272
273 formalParameterList
274     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
275     ;
276     
277 formalParameterStandardDecl
278     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
279     ;
280     
281 formalParameterVarargDecl
282     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
283     ;
284     
285 // FIXME: is this rule right? Verify that this is ok, I expected something like:
286 // IDENT (^(DOT qualifiedIdentifier IDENT))*
287 qualifiedIdentifier
288     :   IDENT
289     |   ^(DOT qualifiedIdentifier IDENT)
290     ;
291     
292 block
293     :   ^(BLOCK (blockStatement)*)
294     ;
295     
296 blockStatement
297     :   localVariableDeclaration
298     |   statement
299     ;
300     
301 localVariableDeclaration
302     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
303     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
304     ;
305
306 statement
307     :   nonBlockStatement
308     |   sdagStatement
309     |   block
310     ;
311
312 sdagStatement
313     :   ^(OVERLAP block)
314     |   ^(WHEN (IDENT type IDENT)+ block)
315     ;
316
317 nonBlockStatement
318     :   ^(ASSERT expression expression?)
319     |   ^(IF parenthesizedExpression block block?)
320     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
321     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
322     |   ^(WHILE parenthesizedExpression block)
323     |   ^(DO block parenthesizedExpression)
324     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
325     |   ^(RETURN expression?)
326     |   ^(THROW expression)
327     |   ^(BREAK IDENT?) {
328             if ($IDENT != null) {
329                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
330             }
331         }
332     |   ^(CONTINUE IDENT?) {
333             if ($IDENT != null) {
334                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
335             }
336         }
337     |   ^(LABELED_STATEMENT IDENT statement)
338     |   expression
339     |   ^('delete' expression)
340     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
341     |   ';' // Empty statement.
342     |   ^(PRINT expression*)
343     |   ^(PRINTLN expression*)
344     |   ^(EXIT expression?)
345     |   EXITALL
346     ;
347         
348 switchCaseLabel
349     :   ^(CASE expression blockStatement*)
350     |   ^(DEFAULT blockStatement*)
351     ;
352     
353 forInit
354     :   localVariableDeclaration 
355     |   expression+
356     ;
357     
358 // EXPRESSIONS
359
360 parenthesizedExpression
361     :   ^(PAREN_EXPR expression)
362     ;
363     
364 expression
365     :   ^(EXPR expr)
366     ;
367
368 expr
369     :   ^(ASSIGNMENT expr expr)
370     |   ^(PLUS_EQUALS expr expr)
371     |   ^(MINUS_EQUALS expr expr)
372     |   ^(TIMES_EQUALS expr expr)
373     |   ^(DIVIDE_EQUALS expr expr)
374     |   ^(AND_EQUALS expr expr)
375     |   ^(OR_EQUALS expr expr)
376     |   ^(POWER_EQUALS expr expr)
377     |   ^(MOD_EQUALS expr expr)
378     |   ^('>>>=' expr expr)
379     |   ^('>>=' expr expr)
380     |   ^('<<=' expr expr)
381     |   ^('?' expr expr expr)
382     |   ^(OR expr expr)
383     |   ^(AND expr expr)
384     |   ^(BITWISE_OR expr expr)
385     |   ^(POWER expr expr)
386     |   ^(BITWISE_AND expr expr)
387     |   ^(EQUALS expr expr)
388     |   ^(NOT_EQUALS expr expr)
389     |   ^(INSTANCEOF expr type)
390     |   ^(LTE expr expr)
391     |   ^(GTE expr expr)
392     |   ^('>>>' expr expr)
393     |   ^('>>' expr expr)
394     |   ^(GT expr expr)
395     |   ^('<<' expr expr)
396     |   ^(LT expr expr)
397     |   ^(PLUS expr expr)
398     |   ^(MINUS expr expr)
399     |   ^(TIMES expr expr)
400     |   ^(DIVIDE expr expr)
401     |   ^(MOD expr expr)
402     |   ^(UNARY_PLUS expr)
403     |   ^(UNARY_MINUS expr)
404     |   ^(PRE_INC expr)
405     |   ^(PRE_DEC expr)
406     |   ^(POST_INC expr)
407     |   ^(POST_DEC expr)
408     |   ^(TILDE expr)
409     |   ^(NOT expr)
410     |   ^(CAST_EXPR type expr)
411     |   primaryExpression
412     ;
413     
414 primaryExpression
415     :   ^(DOT primaryExpression
416                 (   IDENT
417                 |   THIS
418                 |   SUPER
419                 )
420         )
421         ->   ^(ARROW primaryExpression
422                    IDENT?
423                    THIS?
424                    SUPER?
425              )
426     |   parenthesizedExpression
427     |   IDENT
428     |   ^(METHOD_CALL primaryExpression templateInstantiation? arguments)
429     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) templateInstantiation? arguments)
430         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) templateInstantiation? arguments)
431     |   explicitConstructorCall
432     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
433     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
434     |   literal
435     |   newExpression
436     |   THIS
437     |   arrayTypeDeclarator
438     |   SUPER
439     |   GETNUMPES
440     |   GETNUMNODES
441     |   GETMYPE
442     |   GETMYNODE
443     |   GETMYRANK
444     |   domainExpression
445     ;
446     
447 explicitConstructorCall
448     :   ^(THIS_CONSTRUCTOR_CALL templateInstantiation? arguments)
449     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? templateInstantiation? arguments)
450     ;
451
452 arrayTypeDeclarator
453     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
454     ;
455
456 newExpression
457     :   ^(NEW_EXPRESSION arguments? domainExpression)
458     |   ^(NEW type arguments)
459     ;
460
461 arguments
462     :   ^(ARGUMENT_LIST expression*)
463     ;
464
465 literal 
466     :   HEX_LITERAL
467     |   OCTAL_LITERAL
468     |   DECIMAL_LITERAL
469     |   FLOATING_POINT_LITERAL
470     |   CHARACTER_LITERAL
471     |   STRING_LITERAL          
472     |   TRUE
473     |   FALSE
474     |   NULL
475     ;
476
477 rangeItem
478     :   DECIMAL_LITERAL
479     |   IDENT
480     ;
481
482 rangeExpression
483     :   ^(RANGE_EXPRESSION rangeItem)
484     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
485     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
486     ;
487
488 rangeList
489     :   rangeExpression+
490     ;
491
492 domainExpression
493     :   ^(DOMAIN_EXPRESSION rangeList)
494     ;