72b812f1aba8282c6d5f378eeb00ed3a5bd6a792
[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);
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     ;
313         
314 switchCaseLabel
315     :   ^(CASE expression blockStatement*)
316     |   ^(DEFAULT blockStatement*)
317     ;
318     
319 forInit
320     :   localVariableDeclaration 
321     |   expression+
322     ;
323     
324 // EXPRESSIONS
325
326 parenthesizedExpression
327     :   ^(PAREN_EXPR expression)
328     ;
329     
330 expression
331     :   ^(EXPR expr)
332     ;
333
334 expr
335     :   ^(ASSIGNMENT expr expr)
336     |   ^(PLUS_EQUALS expr expr)
337     |   ^(MINUS_EQUALS expr expr)
338     |   ^(TIMES_EQUALS expr expr)
339     |   ^(DIVIDE_EQUALS expr expr)
340     |   ^(AND_EQUALS expr expr)
341     |   ^(OR_EQUALS expr expr)
342     |   ^(POWER_EQUALS expr expr)
343     |   ^(MOD_EQUALS expr expr)
344     |   ^('>>>=' expr expr)
345     |   ^('>>=' expr expr)
346     |   ^('<<=' expr expr)
347     |   ^('?' expr expr expr)
348     |   ^(OR expr expr)
349     |   ^(AND expr expr)
350     |   ^(BITWISE_OR expr expr)
351     |   ^(POWER expr expr)
352     |   ^(BITWISE_AND expr expr)
353     |   ^(EQUALS expr expr)
354     |   ^(NOT_EQUALS expr expr)
355     |   ^(INSTANCEOF expr type)
356     |   ^(LTE expr expr)
357     |   ^(GTE expr expr)
358     |   ^('>>>' expr expr)
359     |   ^('>>' expr expr)
360     |   ^(GT expr expr)
361     |   ^('<<' expr expr)
362     |   ^(LT expr expr)
363     |   ^(PLUS expr expr)
364     |   ^(MINUS expr expr)
365     |   ^(TIMES expr expr)
366     |   ^(DIVIDE expr expr)
367     |   ^(MOD expr expr)
368     |   ^(UNARY_PLUS expr)
369     |   ^(UNARY_MINUS expr)
370     |   ^(PRE_INC expr)
371     |   ^(PRE_DEC expr)
372     |   ^(POST_INC expr)
373     |   ^(POST_DEC expr)
374     |   ^(TILDE expr)
375     |   ^(NOT expr)
376     |   ^(CAST_EXPR type expr)
377     |   primaryExpression
378     ;
379     
380 primaryExpression
381     :   ^(DOT primaryExpression
382                 (   IDENT
383                 |   THIS
384                 |   SUPER
385                 )
386         )
387         ->   ^(ARROW primaryExpression
388                    IDENT?
389                    THIS?
390                    SUPER?
391              )
392     |   parenthesizedExpression
393     |   IDENT
394     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
395     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) genericTypeArgumentList? arguments)
396         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) genericTypeArgumentList? arguments)
397     |   explicitConstructorCall
398     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
399     |   literal
400     |   newExpression
401     |   THIS
402     |   arrayTypeDeclarator
403     |   SUPER
404     ;
405     
406 explicitConstructorCall
407     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
408     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
409     ;
410
411 arrayTypeDeclarator
412     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
413     ;
414
415 newExpression
416     :   ^(  STATIC_ARRAY_CREATOR
417             (   primitiveType newArrayConstruction
418             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
419             )
420         )
421     |   ^(NEW type arguments)
422     ;
423
424 newArrayConstruction
425     :   arrayDeclaratorList arrayInitializer
426     |   expression+ arrayDeclaratorList?
427     ;
428
429 arguments
430     :   ^(ARGUMENT_LIST expression*)
431     ;
432
433 literal 
434     :   HEX_LITERAL
435     |   OCTAL_LITERAL
436     |   DECIMAL_LITERAL
437     |   FLOATING_POINT_LITERAL
438     |   CHARACTER_LITERAL
439     |   STRING_LITERAL          
440     |   TRUE
441     |   FALSE
442     |   NULL
443     ;
444