Charj : the main chare's default constructor is filled with the
[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     SymbolTable symtab = null;
21     PackageScope currentPackage = null;
22     ClassSymbol currentClass = null;
23     MethodSymbol currentMethod = null;
24     LocalScope currentLocalScope = null;
25     Translator translator;
26
27     AstModifier astmod = new AstModifier();
28 }
29
30 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
31 @rulecatch {
32     catch (RecognitionException re) {
33         reportError(re);
34         throw re;
35     }
36 }
37
38
39 // Starting point for parsing a Charj file.
40 charjSource[SymbolTable _symtab] returns [ClassSymbol cs]
41 @init {
42     symtab = _symtab;
43 }
44     // TODO: go back to allowing multiple type definitions per file, check that
45     // there is exactly one public type and return that one.
46     :   ^(CHARJ_SOURCE 
47         packageDeclaration?
48         importDeclaration*
49         readonlyDeclaration*
50         (typeDeclaration { $cs = $typeDeclaration.sym; })*)
51     ;
52
53 packageDeclaration
54     :   ^(PACKAGE (ids+=IDENT)+)  
55     ;
56     
57 importDeclaration
58     :   ^(IMPORT qualifiedIdentifier '.*'?)
59     ;
60
61 readonlyDeclaration
62     :   ^(READONLY localVariableDeclaration)
63     ;
64
65 typeDeclaration returns [ClassSymbol sym]
66 @init {
67     boolean array_type = false;
68     astmod = new AstModifier();
69 }
70     :   ^(TYPE (CLASS | (chareType | (chareArrayType { array_type = true; }))) IDENT
71         (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
72         {
73             $TYPE.tree.addChild(astmod.getPupRoutineNode());
74             $TYPE.tree.addChild(astmod.getInitRoutineNode());
75             astmod.ensureDefaultCtor($TYPE.tree);
76             if (array_type) astmod.ensureMigrationCtor($TYPE.tree);
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     :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
99             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
100             b=block?)
101         {
102             if($m.tree == null)
103                 astmod.fillPrivateModifier($FUNCTION_METHOD_DECL.tree);
104         }
105     |   ^(PRIMITIVE_VAR_DECLARATION m = modifierList? simpleType variableDeclaratorList)
106         {
107             if($m.tree == null)
108                 astmod.fillPrivateModifier($PRIMITIVE_VAR_DECLARATION.tree);
109         }
110     |   ^(OBJECT_VAR_DECLARATION m = modifierList? objectType variableDeclaratorList)
111         {
112             if($m.tree == null)
113                 astmod.fillPrivateModifier($OBJECT_VAR_DECLARATION.tree);
114         }
115     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
116             b=block)
117         {
118             astmod.checkForDefaultCtor($CONSTRUCTOR_DECL, $CONSTRUCTOR_DECL.tree);
119             astmod.checkForMigrationCtor($CONSTRUCTOR_DECL);
120             if($m.tree == null)
121                 astmod.fillPrivateModifier($CONSTRUCTOR_DECL.tree);
122         }
123     ;
124     
125 interfaceScopeDeclaration
126     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
127             type IDENT formalParameterList arrayDeclaratorList?)
128         // Interface constant declarations have been switched to variable
129         // declarations by Charj.g; the parser has already checked that
130         // there's an obligatory initializer.
131     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
132     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
133     ;
134
135 variableDeclaratorList
136     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
137     ;
138
139 variableDeclarator
140     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
141     ;
142     
143 variableDeclaratorId
144     :   ^(IDENT arrayDeclaratorList?)
145         {
146             astmod.varPup($IDENT);
147         }
148     ;
149
150 variableInitializer
151     :   arrayInitializer
152     |   expression
153     ;
154
155 arrayDeclaratorList
156     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
157     ;
158     
159 arrayInitializer
160     :   ^(ARRAY_INITIALIZER variableInitializer*)
161     ;
162
163 genericTypeParameterList
164     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
165     ;
166
167 genericTypeParameter
168     :   ^(IDENT bound?)
169     ;
170         
171 bound
172     :   ^(EXTENDS_BOUND_LIST type+)
173     ;
174
175 modifierList
176     :   ^(MODIFIER_LIST modifier+)
177         {
178             astmod.arrangeModifiers($MODIFIER_LIST.tree);
179         }
180     ;
181
182 modifier
183     :   PUBLIC
184     |   PRIVATE
185     |   PROTECTED
186     |   ENTRY
187     |   ABSTRACT
188     |   NATIVE
189     |   localModifier
190     ;
191
192 localModifierList
193     :   ^(LOCAL_MODIFIER_LIST localModifier+)
194     ;
195
196 localModifier
197     :   FINAL
198     |   STATIC
199     |   VOLATILE
200     ;
201
202 type
203     :   simpleType
204     |   objectType 
205     |   VOID
206     ;
207
208 simpleType
209     :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
210     ;
211     
212 objectType
213     :   ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
214     |   ^(PROXY_TYPE qualifiedTypeIdent arrayDeclaratorList?)
215     |   ^(REFERENCE_TYPE qualifiedTypeIdent arrayDeclaratorList?)
216     |   ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
217     ;
218
219 qualifiedTypeIdent
220     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
221     ;
222
223 typeIdent
224     :   ^(IDENT genericTypeArgumentList?)
225     ;
226
227 primitiveType
228     :   BOOLEAN     { $start.symbol = new Symbol(symtab, "bool_primitive", symtab.resolveBuiltinType("bool")); }
229     |   CHAR        { $start.symbol = new Symbol(symtab, "char_primitive", symtab.resolveBuiltinType("char")); }
230     |   BYTE        { $start.symbol = new Symbol(symtab, "byte_primitive", symtab.resolveBuiltinType("char")); }
231     |   SHORT       { $start.symbol = new Symbol(symtab, "short_primitive", symtab.resolveBuiltinType("short")); }
232     |   INT         { $start.symbol = new Symbol(symtab, "int_primitive", symtab.resolveBuiltinType("int")); }
233     |   LONG        { $start.symbol = new Symbol(symtab, "long_primitive", symtab.resolveBuiltinType("long")); }
234     |   FLOAT       { $start.symbol = new Symbol(symtab, "float_primitive", symtab.resolveBuiltinType("float")); }
235     |   DOUBLE      { $start.symbol = new Symbol(symtab, "double_primitive", symtab.resolveBuiltinType("double")); }
236     ;
237
238 genericTypeArgumentList
239     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
240     ;
241     
242 genericTypeArgument
243     :   type
244     |   '?'
245     ;
246
247 formalParameterList
248     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
249     ;
250     
251 formalParameterStandardDecl
252     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
253     ;
254     
255 formalParameterVarargDecl
256     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
257     ;
258     
259 // FIXME: is this rule right? Verify that this is ok, I expected something like:
260 // IDENT (^(DOT qualifiedIdentifier IDENT))*
261 qualifiedIdentifier
262     :   IDENT
263     |   ^(DOT qualifiedIdentifier IDENT)
264     ;
265     
266 block
267     :   ^(BLOCK (blockStatement)*)
268     ;
269     
270 blockStatement
271     :   localVariableDeclaration
272     |   statement
273     ;
274     
275 localVariableDeclaration
276     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
277     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
278     ;
279
280 statement
281     :   nonBlockStatement
282     |   block
283     ;
284
285 nonBlockStatement
286     :   ^(ASSERT expression expression?)
287     |   ^(IF parenthesizedExpression block block?)
288     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
289     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
290     |   ^(WHILE parenthesizedExpression block)
291     |   ^(DO block parenthesizedExpression)
292     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
293     |   ^(RETURN expression?)
294     |   ^(THROW expression)
295     |   ^(BREAK IDENT?) {
296             if ($IDENT != null) {
297                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
298             }
299         }
300     |   ^(CONTINUE IDENT?) {
301             if ($IDENT != null) {
302                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
303             }
304         }
305     |   ^(LABELED_STATEMENT IDENT statement)
306     |   expression
307     |   ^('delete' qualifiedIdentifier)
308     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
309     |   ';' // Empty statement.
310     |   ^(PRINT expression*)
311     |   ^(PRINTLN expression*)
312     |   ^(EXIT expression?)
313     |   EXITALL
314     ;
315         
316 switchCaseLabel
317     :   ^(CASE expression blockStatement*)
318     |   ^(DEFAULT blockStatement*)
319     ;
320     
321 forInit
322     :   localVariableDeclaration 
323     |   expression+
324     ;
325     
326 // EXPRESSIONS
327
328 parenthesizedExpression
329     :   ^(PAREN_EXPR expression)
330     ;
331     
332 expression
333     :   ^(EXPR expr)
334     ;
335
336 expr
337     :   ^(ASSIGNMENT expr expr)
338     |   ^(PLUS_EQUALS expr expr)
339     |   ^(MINUS_EQUALS expr expr)
340     |   ^(TIMES_EQUALS expr expr)
341     |   ^(DIVIDE_EQUALS expr expr)
342     |   ^(AND_EQUALS expr expr)
343     |   ^(OR_EQUALS expr expr)
344     |   ^(POWER_EQUALS expr expr)
345     |   ^(MOD_EQUALS expr expr)
346     |   ^('>>>=' expr expr)
347     |   ^('>>=' expr expr)
348     |   ^('<<=' expr expr)
349     |   ^('?' expr expr expr)
350     |   ^(OR expr expr)
351     |   ^(AND expr expr)
352     |   ^(BITWISE_OR expr expr)
353     |   ^(POWER expr expr)
354     |   ^(BITWISE_AND expr expr)
355     |   ^(EQUALS expr expr)
356     |   ^(NOT_EQUALS expr expr)
357     |   ^(INSTANCEOF expr type)
358     |   ^(LTE expr expr)
359     |   ^(GTE expr expr)
360     |   ^('>>>' expr expr)
361     |   ^('>>' expr expr)
362     |   ^(GT expr expr)
363     |   ^('<<' expr expr)
364     |   ^(LT expr expr)
365     |   ^(PLUS expr expr)
366     |   ^(MINUS expr expr)
367     |   ^(TIMES expr expr)
368     |   ^(DIVIDE expr expr)
369     |   ^(MOD expr expr)
370     |   ^(UNARY_PLUS expr)
371     |   ^(UNARY_MINUS expr)
372     |   ^(PRE_INC expr)
373     |   ^(PRE_DEC expr)
374     |   ^(POST_INC expr)
375     |   ^(POST_DEC expr)
376     |   ^(TILDE expr)
377     |   ^(NOT expr)
378     |   ^(CAST_EXPR type expr)
379     |   primaryExpression
380     ;
381     
382 primaryExpression
383     :   ^(DOT primaryExpression
384                 (   IDENT
385                 |   THIS
386                 |   SUPER
387                 )
388         )
389         ->   ^(ARROW primaryExpression
390                    IDENT?
391                    THIS?
392                    SUPER?
393              )
394     |   parenthesizedExpression
395     |   IDENT
396     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
397     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) genericTypeArgumentList? arguments)
398         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) genericTypeArgumentList? arguments)
399     |   explicitConstructorCall
400     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
401     |   literal
402     |   newExpression
403     |   THIS
404     |   arrayTypeDeclarator
405     |   SUPER
406     ;
407     
408 explicitConstructorCall
409     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
410     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
411     ;
412
413 arrayTypeDeclarator
414     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
415     ;
416
417 newExpression
418     :   ^(  STATIC_ARRAY_CREATOR
419             (   primitiveType newArrayConstruction
420             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
421             )
422         )
423     |   ^(NEW type arguments)
424     ;
425
426 newArrayConstruction
427     :   arrayDeclaratorList arrayInitializer
428     |   expression+ arrayDeclaratorList?
429     ;
430
431 arguments
432     :   ^(ARGUMENT_LIST expression*)
433     ;
434
435 literal 
436     :   HEX_LITERAL
437     |   OCTAL_LITERAL
438     |   DECIMAL_LITERAL
439     |   FLOATING_POINT_LITERAL
440     |   CHARACTER_LITERAL
441     |   STRING_LITERAL          
442     |   TRUE
443     |   FALSE
444     |   NULL
445     ;
446