Charj : replaced occurrences of common keywords (eg 'int') with
[charm.git] / src / langs / charj / src / charj / translator / CharjASTModifier.g
1 /**
2  * The semantic phase walks the tree and builds the symbol table, handles
3  * all the imports, and does the semantic checks. The resulting tree and
4  * symbol table are used by the emitter to generate the output. 
5  */
6
7 tree grammar CharjASTModifier;
8
9 options {
10     backtrack = true; 
11     memoize = true;
12     tokenVocab = Charj;
13     ASTLabelType = CharjAST;
14 }
15
16 @header {
17 package charj.translator;
18 }
19
20 @members {
21     SymbolTable symtab = null;
22     PackageScope currentPackage = null;
23     ClassSymbol currentClass = null;
24     MethodSymbol currentMethod = null;
25     LocalScope currentLocalScope = null;
26     Translator translator;
27
28     PupRoutineCreator puper = new PupRoutineCreator();
29 }
30
31 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
32 @rulecatch {
33     catch (RecognitionException re) {
34         reportError(re);
35         throw re;
36     }
37 }
38
39
40 // Starting point for parsing a Charj file.
41 charjSource[SymbolTable _symtab] returns [ClassSymbol cs]
42 @init {
43     symtab = _symtab;
44 }
45     // TODO: go back to allowing multiple type definitions per file, check that
46     // there is exactly one public type and return that one.
47     :   ^(CHARJ_SOURCE 
48         (packageDeclaration)? 
49         (importDeclarations) 
50         (typeDeclaration[$importDeclarations.packageNames]))
51         { $cs = $typeDeclaration.sym; }
52     ;
53
54 packageDeclaration
55     :   ^(PACKAGE (ids+=IDENT)+)  
56     ;
57     
58 importDeclarations returns [List<CharjAST> packageNames]
59     :   (^('import' qualifiedIdentifier '.*'?))*
60     ;
61
62 typeDeclaration[List<CharjAST> imports] returns [ClassSymbol sym]
63     :   ^(TYPE (CLASS | chareType) IDENT (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
64     |   ^(INTERFACE IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
65     |   ^(ENUM IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
66     ;
67
68 chareType
69     :   CHARE
70     |   GROUP
71     |   NODEGROUP
72     |   ^(CHARE_ARRAY ARRAY_DIMENSION)
73     ;
74
75 enumConstant
76     :   ^(IDENT arguments?)
77     ;
78     
79 classScopeDeclaration
80     :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
81             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
82             b=block?)
83
84     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
85         {
86             puper.primitiveVarPup($PRIMITIVE_VAR_DECLARATION); // TODO: arrays
87         }
88     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
89         {
90             puper.objectVarPup($OBJECT_VAR_DECLARATION);
91         }
92     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
93             b=block)
94     ;
95     
96 interfaceScopeDeclaration
97     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
98             type IDENT formalParameterList arrayDeclaratorList?)
99         // Interface constant declarations have been switched to variable
100         // declarations by Charj.g; the parser has already checked that
101         // there's an obligatory initializer.
102     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
103     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
104     ;
105
106 variableDeclaratorList
107     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
108     ;
109
110 variableDeclarator
111     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
112     ;
113     
114 variableDeclaratorId
115     :   ^(IDENT arrayDeclaratorList?)
116     ;
117
118 variableInitializer
119     :   arrayInitializer
120     |   expression
121     ;
122
123 arrayDeclaratorList
124     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
125     ;
126     
127 arrayInitializer
128     :   ^(ARRAY_INITIALIZER variableInitializer*)
129     ;
130
131 genericTypeParameterList
132     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
133     ;
134
135 genericTypeParameter
136     :   ^(IDENT bound?)
137     ;
138         
139 bound
140     :   ^(EXTENDS_BOUND_LIST type+)
141     ;
142
143 modifierList
144     :   ^(MODIFIER_LIST modifier+)
145     ;
146
147 modifier
148     :   PUBLIC
149     |   PROTECTED
150     |   PRIVATE
151     |   ENTRY
152     |   ABSTRACT
153     |   NATIVE
154     |   localModifier
155     ;
156
157 localModifierList
158     :   ^(LOCAL_MODIFIER_LIST localModifier+)
159     ;
160
161 localModifier
162     :   FINAL
163     |   STATIC
164     |   VOLATILE
165     ;
166
167 type
168     :   simpleType
169     |   objectType 
170     |   VOID
171     ;
172
173 simpleType
174     :   ^(TYPE primitiveType arrayDeclaratorList?)
175     ;
176     
177 objectType
178     :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
179     ;
180
181 qualifiedTypeIdent
182     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
183     ;
184
185 typeIdent
186     :   ^(IDENT genericTypeArgumentList?)
187     ;
188
189 primitiveType
190     :   BOOLEAN     { $start.symbol = new Symbol(symtab, "bool_primitive", symtab.resolveBuiltinType("bool")); }
191     |   CHAR        { $start.symbol = new Symbol(symtab, "char_primitive", symtab.resolveBuiltinType("char")); }
192     |   BYTE        { $start.symbol = new Symbol(symtab, "byte_primitive", symtab.resolveBuiltinType("char")); }
193     |   SHORT       { $start.symbol = new Symbol(symtab, "short_primitive", symtab.resolveBuiltinType("short")); }
194     |   INT         { $start.symbol = new Symbol(symtab, "int_primitive", symtab.resolveBuiltinType("int")); }
195     |   LONG        { $start.symbol = new Symbol(symtab, "long_primitive", symtab.resolveBuiltinType("long")); }
196     |   FLOAT       { $start.symbol = new Symbol(symtab, "float_primitive", symtab.resolveBuiltinType("float")); }
197     |   DOUBLE      { $start.symbol = new Symbol(symtab, "double_primitive", symtab.resolveBuiltinType("double")); }
198     ;
199
200 genericTypeArgumentList
201     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
202     ;
203     
204 genericTypeArgument
205     :   type
206     |   '?'
207     ;
208
209 formalParameterList
210     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
211     ;
212     
213 formalParameterStandardDecl
214     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
215     ;
216     
217 formalParameterVarargDecl
218     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
219     ;
220     
221 // FIXME: is this rule right? Verify that this is ok, I expected something like:
222 // IDENT (^('.' qualifiedIdentifier IDENT))*
223 qualifiedIdentifier
224     :   IDENT
225     |   ^('.' qualifiedIdentifier IDENT)
226     ;
227     
228 block
229     :   ^(BLOCK (blockStatement)*)
230     ;
231     
232 blockStatement
233     :   localVariableDeclaration
234     |   statement
235     ;
236     
237 localVariableDeclaration
238     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
239     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
240     ;
241
242 statement
243     :   block
244     |   ^(ASSERT expression expression?)
245     |   ^(IF parenthesizedExpression statement statement?)
246     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* statement)
247     |   ^(FOR_EACH localModifierList? type IDENT expression statement) 
248     |   ^(WHILE parenthesizedExpression statement)
249     |   ^(DO statement parenthesizedExpression)
250     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
251     |   ^(RETURN expression?)
252     |   ^(THROW expression)
253     |   ^(BREAK IDENT?) {
254             if ($IDENT != null) {
255                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
256             }
257         }
258     |   ^(CONTINUE IDENT?) {
259             if ($IDENT != null) {
260                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
261             }
262         }
263     |   ^(LABELED_STATEMENT IDENT statement)
264     |   expression
265     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
266     |   ';' // Empty statement.
267     ;
268         
269 switchCaseLabel
270     :   ^(CASE expression blockStatement*)
271     |   ^(DEFAULT blockStatement*)
272     ;
273     
274 forInit
275     :   localVariableDeclaration 
276     |   expression+
277     ;
278     
279 // EXPRESSIONS
280
281 parenthesizedExpression
282     :   ^(PAREN_EXPR expression)
283     ;
284     
285 expression
286     :   ^(EXPR expr)
287     ;
288
289 expr
290     :   ^('=' expr expr)
291     |   ^('+=' expr expr)
292     |   ^('-=' expr expr)
293     |   ^('*=' expr expr)
294     |   ^('/=' expr expr)
295     |   ^('&=' expr expr)
296     |   ^('|=' expr expr)
297     |   ^('^=' expr expr)
298     |   ^('%=' expr expr)
299     |   ^('>>>=' expr expr)
300     |   ^('>>=' expr expr)
301     |   ^('<<=' expr expr)
302     |   ^('?' expr expr expr)
303     |   ^('||' expr expr)
304     |   ^('&&' expr expr)
305     |   ^('|' expr expr)
306     |   ^('^' expr expr)
307     |   ^('&' expr expr)
308     |   ^('==' expr expr)
309     |   ^('!=' expr expr)
310     |   ^('instanceof' expr type)
311     |   ^('<=' expr expr)
312     |   ^('>=' expr expr)
313     |   ^('>>>' expr expr)
314     |   ^('>>' expr expr)
315     |   ^('>' expr expr)
316     |   ^('<<' expr expr)
317     |   ^('<' expr expr)
318     |   ^('+' expr expr)
319     |   ^('-' expr expr)
320     |   ^('*' expr expr)
321     |   ^('/' expr expr)
322     |   ^('%' expr expr)
323     |   ^(UNARY_PLUS expr)
324     |   ^(UNARY_MINUS expr)
325     |   ^(PRE_INC expr)
326     |   ^(PRE_DEC expr)
327     |   ^(POST_INC expr)
328     |   ^(POST_DEC expr)
329     |   ^('~' expr)
330     |   ^('!' expr)
331     |   ^(CAST_EXPR type expr)
332     |   primaryExpression
333     ;
334     
335 primaryExpression
336     :   ^(  '.' primaryExpression
337                 (   IDENT
338                 |   THIS
339                 |   SUPER
340                 )
341         )
342     |   parenthesizedExpression
343     |   IDENT
344     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
345     |   explicitConstructorCall
346     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
347     |   literal
348     |   newExpression
349     |   THIS
350     |   arrayTypeDeclarator
351     |   SUPER
352     ;
353     
354 explicitConstructorCall
355     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
356     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
357     ;
358
359 arrayTypeDeclarator
360     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
361     ;
362
363 newExpression
364     :   ^(  STATIC_ARRAY_CREATOR
365             (   primitiveType newArrayConstruction
366             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
367             )
368         )
369     ;
370
371 newArrayConstruction
372     :   arrayDeclaratorList arrayInitializer
373     |   expression+ arrayDeclaratorList?
374     ;
375
376 arguments
377     :   ^(ARGUMENT_LIST expression*)
378     ;
379
380 literal 
381     :   HEX_LITERAL
382     |   OCTAL_LITERAL
383     |   DECIMAL_LITERAL
384     |   FLOATING_POINT_LITERAL
385     |   CHARACTER_LITERAL
386     |   STRING_LITERAL          
387     |   TRUE
388     |   FALSE
389     |   NULL
390     ;
391