9c640adc2db1876c6cdce515debc9e77124c863d
[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     |   block
309     ;
310
311 nonBlockStatement
312     :   ^(ASSERT expression expression?)
313     |   ^(IF parenthesizedExpression block block?)
314     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
315     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
316     |   ^(WHILE parenthesizedExpression block)
317     |   ^(DO block parenthesizedExpression)
318     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
319     |   ^(RETURN expression?)
320     |   ^(THROW expression)
321     |   ^(BREAK IDENT?) {
322             if ($IDENT != null) {
323                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
324             }
325         }
326     |   ^(CONTINUE IDENT?) {
327             if ($IDENT != null) {
328                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
329             }
330         }
331     |   ^(LABELED_STATEMENT IDENT statement)
332     |   expression
333     |   ^('delete' expression)
334     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
335     |   ';' // Empty statement.
336     |   ^(PRINT expression*)
337     |   ^(PRINTLN expression*)
338     |   ^(EXIT expression?)
339     |   EXITALL
340     ;
341         
342 switchCaseLabel
343     :   ^(CASE expression blockStatement*)
344     |   ^(DEFAULT blockStatement*)
345     ;
346     
347 forInit
348     :   localVariableDeclaration 
349     |   expression+
350     ;
351     
352 // EXPRESSIONS
353
354 parenthesizedExpression
355     :   ^(PAREN_EXPR expression)
356     ;
357     
358 expression
359     :   ^(EXPR expr)
360     ;
361
362 expr
363     :   ^(ASSIGNMENT expr expr)
364     |   ^(PLUS_EQUALS expr expr)
365     |   ^(MINUS_EQUALS expr expr)
366     |   ^(TIMES_EQUALS expr expr)
367     |   ^(DIVIDE_EQUALS expr expr)
368     |   ^(AND_EQUALS expr expr)
369     |   ^(OR_EQUALS expr expr)
370     |   ^(POWER_EQUALS expr expr)
371     |   ^(MOD_EQUALS expr expr)
372     |   ^('>>>=' expr expr)
373     |   ^('>>=' expr expr)
374     |   ^('<<=' expr expr)
375     |   ^('?' expr expr expr)
376     |   ^(OR expr expr)
377     |   ^(AND expr expr)
378     |   ^(BITWISE_OR expr expr)
379     |   ^(POWER expr expr)
380     |   ^(BITWISE_AND expr expr)
381     |   ^(EQUALS expr expr)
382     |   ^(NOT_EQUALS expr expr)
383     |   ^(INSTANCEOF expr type)
384     |   ^(LTE expr expr)
385     |   ^(GTE expr expr)
386     |   ^('>>>' expr expr)
387     |   ^('>>' expr expr)
388     |   ^(GT expr expr)
389     |   ^('<<' expr expr)
390     |   ^(LT expr expr)
391     |   ^(PLUS expr expr)
392     |   ^(MINUS expr expr)
393     |   ^(TIMES expr expr)
394     |   ^(DIVIDE expr expr)
395     |   ^(MOD expr expr)
396     |   ^(UNARY_PLUS expr)
397     |   ^(UNARY_MINUS expr)
398     |   ^(PRE_INC expr)
399     |   ^(PRE_DEC expr)
400     |   ^(POST_INC expr)
401     |   ^(POST_DEC expr)
402     |   ^(TILDE expr)
403     |   ^(NOT expr)
404     |   ^(CAST_EXPR type expr)
405     |   primaryExpression
406     ;
407     
408 primaryExpression
409     :   ^(DOT primaryExpression
410                 (   IDENT
411                 |   THIS
412                 |   SUPER
413                 )
414         )
415         ->   ^(ARROW primaryExpression
416                    IDENT?
417                    THIS?
418                    SUPER?
419              )
420     |   parenthesizedExpression
421     |   IDENT
422     |   ^(METHOD_CALL primaryExpression templateInstantiation? arguments)
423     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) templateInstantiation? arguments)
424         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) templateInstantiation? arguments)
425     |   explicitConstructorCall
426     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
427     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
428     |   literal
429     |   newExpression
430     |   THIS
431     |   arrayTypeDeclarator
432     |   SUPER
433     |   GETNUMPES
434     |   GETNUMNODES
435     |   GETMYPE
436     |   GETMYNODE
437     |   GETMYRANK
438     |   domainExpression
439     ;
440     
441 explicitConstructorCall
442     :   ^(THIS_CONSTRUCTOR_CALL templateInstantiation? arguments)
443     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? templateInstantiation? arguments)
444     ;
445
446 arrayTypeDeclarator
447     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
448     ;
449
450 newExpression
451     :   ^(NEW_EXPRESSION arguments? domainExpression)
452     |   ^(NEW type arguments)
453     ;
454
455 arguments
456     :   ^(ARGUMENT_LIST expression*)
457     ;
458
459 literal 
460     :   HEX_LITERAL
461     |   OCTAL_LITERAL
462     |   DECIMAL_LITERAL
463     |   FLOATING_POINT_LITERAL
464     |   CHARACTER_LITERAL
465     |   STRING_LITERAL          
466     |   TRUE
467     |   FALSE
468     |   NULL
469     ;
470
471 rangeItem
472     :   DECIMAL_LITERAL
473     |   IDENT
474     ;
475
476 rangeExpression
477     :   ^(RANGE_EXPRESSION rangeItem)
478     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
479     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
480     ;
481
482 rangeList
483     :   rangeExpression+
484     ;
485
486 domainExpression
487     :   ^(DOMAIN_EXPRESSION rangeList)
488     ;