Charj: made SDAG grammar reflect actual SDAG implementation
[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     |   SDAGENTRY { $isEntry = true; }
204     |   TRACED
205     ;
206
207 otherModifier
208     :   ABSTRACT
209     |   NATIVE
210     ;
211
212 modifier
213     :   PUBLIC
214     |   PRIVATE
215     |   PROTECTED
216     |   ENTRY
217     |   TRACED
218     |   ABSTRACT
219     |   NATIVE
220     |   localModifier
221     ;
222
223 localModifierList
224     :   ^(LOCAL_MODIFIER_LIST localModifier+)
225     ;
226
227 type
228     :   simpleType
229     |   objectType 
230     |   VOID
231     ;
232
233 simpleType
234     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
235     ;
236     
237 objectType
238     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
239     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
240     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
241     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
242         {
243             // TODO: This breaks all pointer types inside chares not used for sending
244             // them in entry methods, converting them to object types, which breaks
245             // Arrays inside chares.
246             //astmod.dealWithEntryMethodParam($POINTER_TYPE, $POINTER_TYPE.tree);
247         }
248     ;
249
250 qualifiedTypeIdent
251     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
252     ;
253
254 typeIdent
255     :   ^(IDENT templateInstantiation?)
256     ;
257
258 primitiveType
259     :   BOOLEAN
260     |   CHAR
261     |   BYTE
262     |   SHORT
263     |   INT
264     |   LONG
265     |   FLOAT
266     |   DOUBLE
267     ;
268
269 genericTypeArgument
270     :   type
271     |   '?'
272     ;
273
274 formalParameterList
275     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
276     ;
277     
278 formalParameterStandardDecl
279     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
280     ;
281     
282 formalParameterVarargDecl
283     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
284     ;
285     
286 // FIXME: is this rule right? Verify that this is ok, I expected something like:
287 // IDENT (^(DOT qualifiedIdentifier IDENT))*
288 qualifiedIdentifier
289     :   IDENT
290     |   ^(DOT qualifiedIdentifier IDENT)
291     ;
292     
293 block
294     :   ^(BLOCK (blockStatement)*)
295     ;
296     
297 blockStatement
298     :   localVariableDeclaration
299     |   statement
300     ;
301     
302 localVariableDeclaration
303     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
304     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
305     ;
306
307 statement
308     :   nonBlockStatement
309     |   sdagStatement
310     |   block
311     ;
312
313 sdagStatement
314     :   ^(OVERLAP block)
315     |   ^(WHEN (IDENT expression? formalParameterList)* block)
316     ;
317
318 nonBlockStatement
319     :   ^(ASSERT expression expression?)
320     |   ^(IF parenthesizedExpression block block?)
321     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
322     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
323     |   ^(WHILE parenthesizedExpression block)
324     |   ^(DO block parenthesizedExpression)
325     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
326     |   ^(RETURN expression?)
327     |   ^(THROW expression)
328     |   ^(BREAK IDENT?) {
329             if ($IDENT != null) {
330                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
331             }
332         }
333     |   ^(CONTINUE IDENT?) {
334             if ($IDENT != null) {
335                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
336             }
337         }
338     |   ^(LABELED_STATEMENT IDENT statement)
339     |   expression
340     |   ^('delete' expression)
341     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
342     |   ';' // Empty statement.
343     |   ^(PRINT expression*)
344     |   ^(PRINTLN expression*)
345     |   ^(EXIT expression?)
346     |   EXITALL
347     ;
348         
349 switchCaseLabel
350     :   ^(CASE expression blockStatement*)
351     |   ^(DEFAULT blockStatement*)
352     ;
353     
354 forInit
355     :   localVariableDeclaration 
356     |   expression+
357     ;
358     
359 // EXPRESSIONS
360
361 parenthesizedExpression
362     :   ^(PAREN_EXPR expression)
363     ;
364     
365 expression
366     :   ^(EXPR expr)
367     ;
368
369 expr
370     :   ^(ASSIGNMENT expr expr)
371     |   ^(PLUS_EQUALS expr expr)
372     |   ^(MINUS_EQUALS expr expr)
373     |   ^(TIMES_EQUALS expr expr)
374     |   ^(DIVIDE_EQUALS expr expr)
375     |   ^(AND_EQUALS expr expr)
376     |   ^(OR_EQUALS expr expr)
377     |   ^(POWER_EQUALS expr expr)
378     |   ^(MOD_EQUALS expr expr)
379     |   ^('>>>=' expr expr)
380     |   ^('>>=' expr expr)
381     |   ^('<<=' expr expr)
382     |   ^('?' expr expr expr)
383     |   ^(OR expr expr)
384     |   ^(AND expr expr)
385     |   ^(BITWISE_OR expr expr)
386     |   ^(POWER expr expr)
387     |   ^(BITWISE_AND expr expr)
388     |   ^(EQUALS expr expr)
389     |   ^(NOT_EQUALS expr expr)
390     |   ^(INSTANCEOF expr type)
391     |   ^(LTE expr expr)
392     |   ^(GTE expr expr)
393     |   ^('>>>' expr expr)
394     |   ^('>>' expr expr)
395     |   ^(GT expr expr)
396     |   ^('<<' expr expr)
397     |   ^(LT expr expr)
398     |   ^(PLUS expr expr)
399     |   ^(MINUS expr expr)
400     |   ^(TIMES expr expr)
401     |   ^(DIVIDE expr expr)
402     |   ^(MOD expr expr)
403     |   ^(UNARY_PLUS expr)
404     |   ^(UNARY_MINUS expr)
405     |   ^(PRE_INC expr)
406     |   ^(PRE_DEC expr)
407     |   ^(POST_INC expr)
408     |   ^(POST_DEC expr)
409     |   ^(TILDE expr)
410     |   ^(NOT expr)
411     |   ^(CAST_EXPR type expr)
412     |   primaryExpression
413     ;
414     
415 primaryExpression
416     :   ^(DOT primaryExpression
417                 (   IDENT
418                 |   THIS
419                 |   SUPER
420                 )
421         )
422         ->   ^(ARROW primaryExpression
423                    IDENT?
424                    THIS?
425                    SUPER?
426              )
427     |   parenthesizedExpression
428     |   IDENT
429     |   ^(METHOD_CALL primaryExpression templateInstantiation? arguments)
430     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) templateInstantiation? arguments)
431         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) templateInstantiation? arguments)
432     |   explicitConstructorCall
433     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
434     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
435     |   literal
436     |   newExpression
437     |   THIS
438     |   arrayTypeDeclarator
439     |   SUPER
440     |   GETNUMPES
441     |   GETNUMNODES
442     |   GETMYPE
443     |   GETMYNODE
444     |   GETMYRANK
445     |   domainExpression
446     ;
447     
448 explicitConstructorCall
449     :   ^(THIS_CONSTRUCTOR_CALL templateInstantiation? arguments)
450     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? templateInstantiation? arguments)
451     ;
452
453 arrayTypeDeclarator
454     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
455     ;
456
457 newExpression
458     :   ^(NEW_EXPRESSION arguments? domainExpression)
459     |   ^(NEW type arguments)
460     ;
461
462 arguments
463     :   ^(ARGUMENT_LIST expression*)
464     ;
465
466 literal 
467     :   HEX_LITERAL
468     |   OCTAL_LITERAL
469     |   DECIMAL_LITERAL
470     |   FLOATING_POINT_LITERAL
471     |   CHARACTER_LITERAL
472     |   STRING_LITERAL          
473     |   TRUE
474     |   FALSE
475     |   NULL
476     ;
477
478 rangeItem
479     :   DECIMAL_LITERAL
480     |   IDENT
481     ;
482
483 rangeExpression
484     :   ^(RANGE_EXPRESSION rangeItem)
485     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
486     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
487     ;
488
489 rangeList
490     :   rangeExpression+
491     ;
492
493 domainExpression
494     :   ^(DOMAIN_EXPRESSION rangeList)
495     ;