Charj: better names for ast modification passes
[charm.git] / src / langs / charj / src / charj / translator / CharjPreAnalysis.g
1 /**
2  *  fill a description in
3  */
4
5 tree grammar CharjPreAnalysis;
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         (externDeclaration
46         |readonlyDeclaration
47         |typeDeclaration)*)
48     ;
49
50 packageDeclaration
51     :   ^(PACKAGE (ids+=IDENT)+)
52     ;
53     
54 importDeclaration
55     :   ^(IMPORT qualifiedIdentifier '.*'?)
56     ;
57
58 readonlyDeclaration
59     :   ^(READONLY localVariableDeclaration)
60     ;
61
62 externDeclaration
63     :   ^(EXTERN qualifiedIdentifier)
64     ;
65
66 typeOfType returns [boolean array_type]
67     : CLASS 
68     | chareType 
69     | chareArrayType { $array_type = true; }
70     ;
71
72 typeDeclaration
73 @init {
74     astmod = new AstModifier();
75 }
76     :   ^(TYPE typeOfType IDENT
77         (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
78         {
79         }
80         -> ^(TYPE typeOfType IDENT
81             (^('extends' type))? (^('implements' type+))? classScopeDeclaration* 
82         )
83     |   ^(INTERFACE IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
84     |   ^(ENUM IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
85     ;
86
87 chareArrayType
88     :   ^(CHARE_ARRAY ARRAY_DIMENSION)
89     ;
90
91 chareType
92     :   CHARE
93     |   GROUP
94     |   NODEGROUP
95     |   MAINCHARE
96     ;
97
98 enumConstant
99     :   ^(IDENT arguments?)
100     ;
101     
102 classScopeDeclaration
103     :   ^(d=FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
104             ty=type IDENT f=formalParameterList a=domainExpression? 
105             b=block?)
106                 -> {$m.tree==null}?     ^(FUNCTION_METHOD_DECL ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST PRIVATE["private"]) LOCAL_MODIFIER_LIST CHARJ_MODIFIER_LIST OTHER_MODIFIER_LIST)
107                                                                 genericTypeParameterList? type IDENT formalParameterList domainExpression? block?)
108         -> {$m.isEntry}? ^(ENTRY_FUNCTION_DECL modifierList? 
109                                 genericTypeParameterList? type IDENT formalParameterList domainExpression? block?)
110         -> ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
111                                 type IDENT formalParameterList domainExpression? block?)
112     |   ^(DIVCON_METHOD_DECL modifierList? type IDENT formalParameterList divconBlock)
113     |   ^(PRIMITIVE_VAR_DECLARATION m = modifierList? simpleType variableDeclaratorList)
114         -> {$modifierList.tree != null}? ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
115         -> ^(PRIMITIVE_VAR_DECLARATION 
116             ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST 'private') ^(LOCAL_MODIFIER_LIST) 
117                 ^(CHARJ_MODIFIER_LIST) ^(OTHER_MODIFIER_LIST))
118             simpleType variableDeclaratorList)
119     |   ^(OBJECT_VAR_DECLARATION m = modifierList? objectType variableDeclaratorList)
120         -> {$modifierList.tree != null}? ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
121         -> ^(OBJECT_VAR_DECLARATION  
122             ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST 'private') ^(LOCAL_MODIFIER_LIST) 
123                 ^(CHARJ_MODIFIER_LIST) ^(OTHER_MODIFIER_LIST))
124             objectType variableDeclaratorList)
125     |   ^(cd=CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
126             ^(BLOCK (blockStatement*)))
127
128                 -> { $m.tree == null }? ^(CONSTRUCTOR_DECL ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST PRIVATE["private"])
129                                                                                                                                 LOCAL_MODIFIER_LIST CHARJ_MODIFIER_LIST OTHER_MODIFIER_LIST)
130                                                                 genericTypeParameterList? IDENT formalParameterList 
131                                                  ^(BLOCK ^(EXPR ^(METHOD_CALL CHELPER ARGUMENT_LIST)) blockStatement*))
132
133         -> { $m.isEntry }? ^(ENTRY_CONSTRUCTOR_DECL modifierList? 
134                                                     genericTypeParameterList? IDENT formalParameterList 
135                                                          ^(BLOCK ^(EXPR ^(METHOD_CALL CHELPER ARGUMENT_LIST)) blockStatement*))
136
137         -> ^(CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT formalParameterList 
138             ^(BLOCK ^(EXPR ^(METHOD_CALL CHELPER ARGUMENT_LIST)) blockStatement*))
139     ;
140     
141 interfaceScopeDeclaration
142     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
143             type IDENT formalParameterList domainExpression?)
144         // Interface constant declarations have been switched to variable
145         // declarations by Charj.g; the parser has already checked that
146         // there's an obligatory initializer.
147     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
148     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
149     ;
150
151 variableDeclaratorList
152     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
153     ;
154
155 variableDeclarator
156     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
157     ;
158     
159 variableDeclaratorId
160     :   ^(IDENT domainExpression?)
161     ;
162
163 variableInitializer
164     :   arrayInitializer
165     |   expression
166     ;
167
168 arrayInitializer
169     :   ^(ARRAY_INITIALIZER variableInitializer*)
170     ;
171
172 templateArg
173     : genericTypeArgument
174     | literal
175     ;
176
177 templateArgList
178     :   templateArg templateArg*
179     ;
180
181 templateInstantiation
182     :    ^(TEMPLATE_INST templateArgList)
183     |    ^(TEMPLATE_INST templateInstantiation)
184     ;
185
186 genericTypeParameterList
187     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
188     ;
189
190 genericTypeParameter
191     :   ^(IDENT bound?)
192     ;
193         
194 bound
195     :   ^(EXTENDS_BOUND_LIST type+)
196     ;
197
198 modifierList returns [boolean isEntry]
199     :   ^(MODIFIER_LIST (localModifier | (am+=accessModifier) | charjModifier {if ($charjModifier.isEntry) {$isEntry = true;}} | otherModifier)*)
200         -> {$am == null && $isEntry}? ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST PUBLIC["public"]) ^(LOCAL_MODIFIER_LIST localModifier*) ^(CHARJ_MODIFIER_LIST charjModifier*) ^(OTHER_MODIFIER_LIST otherModifier*))
201         -> {$am == null}? ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST PRIVATE["private"]) ^(LOCAL_MODIFIER_LIST localModifier*) ^(CHARJ_MODIFIER_LIST charjModifier*) ^(OTHER_MODIFIER_LIST otherModifier*))
202         -> ^(MODIFIER_LIST ^(ACCESS_MODIFIER_LIST accessModifier*) ^(LOCAL_MODIFIER_LIST localModifier*) ^(CHARJ_MODIFIER_LIST charjModifier*) ^(OTHER_MODIFIER_LIST otherModifier*)) 
203     ;
204
205 localModifier
206     :   FINAL
207     |   STATIC
208     |   VOLATILE
209     ;
210
211 accessModifier
212     :   PUBLIC
213     |   PROTECTED
214     |   PRIVATE
215     ;
216
217 charjModifier returns [boolean isEntry] 
218     :   ENTRY { $isEntry = true; }
219     |   SDAGENTRY { $isEntry = true; }
220     |   TRACED
221     ;
222
223 otherModifier
224     :   ABSTRACT
225     |   NATIVE
226     ;
227
228 modifier
229     :   PUBLIC
230     |   PRIVATE
231     |   PROTECTED
232     |   ENTRY
233     |   TRACED
234     |   ABSTRACT
235     |   NATIVE
236     |   localModifier
237     ;
238
239 localModifierList
240     :   ^(LOCAL_MODIFIER_LIST localModifier+)
241     ;
242
243 type
244     :   simpleType
245     |   objectType 
246     |   VOID
247     ;
248
249 simpleType
250     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
251     ;
252     
253 objectType
254     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
255     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
256     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
257     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
258         |       ^(ARRAY_SECTION_TYPE qualifiedTypeIdent domainExpression?)
259     ;
260
261 qualifiedTypeIdent
262     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
263     ;
264
265 typeIdent
266     :   ^(IDENT templateInstantiation?)
267     ;
268
269 primitiveType
270     :   BOOLEAN
271     |   CHAR
272     |   BYTE
273     |   SHORT
274     |   INT
275     |   LONG
276     |   FLOAT
277     |   DOUBLE
278     ;
279
280 genericTypeArgument
281     :   type
282     |   '?'
283     ;
284
285 formalParameterList
286     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
287     ;
288     
289 formalParameterStandardDecl
290     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
291     ;
292     
293 formalParameterVarargDecl
294     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
295     ;
296     
297 // FIXME: is this rule right? Verify that this is ok, I expected something like:
298 // IDENT (^(DOT qualifiedIdentifier IDENT))*
299 qualifiedIdentifier
300     :   IDENT
301     |   ^(DOT qualifiedIdentifier IDENT)
302     ;
303     
304 block
305     :   ^(BLOCK (blockStatement)*)
306     ;
307     
308 blockStatement
309     :   localVariableDeclaration
310     |   statement
311     ;
312     
313 localVariableDeclaration
314     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
315     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
316     ;
317
318 statement
319     :   nonBlockStatement
320     |   sdagStatement
321     |   block
322     ;
323
324 divconBlock
325     :   ^(DIVCON_BLOCK divconExpr)
326     ;
327
328 divconAssignment
329     :   ^(LET_ASSIGNMENT IDENT expression)
330     ;
331
332 divconAssignmentList
333     :   divconAssignment+
334     ;
335
336 divconExpr
337     :   ^(IF parenthesizedExpression divconExpr divconExpr?)
338     |   ^(LET divconAssignmentList IN divconExpr)
339     |   expression
340     ;
341
342 sdagStatement
343     :   ^(OVERLAP block)
344     |   ^(WHEN (IDENT expression? formalParameterList)* block)
345     ;
346
347 nonBlockStatement
348     :   ^(ASSERT expression expression?)
349     |   ^(IF parenthesizedExpression block block?)
350     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
351     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
352     |   ^(WHILE parenthesizedExpression block)
353     |   ^(DO block parenthesizedExpression)
354     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
355     |   ^(RETURN expression?)
356     |   ^(THROW expression)
357     |   ^(BREAK IDENT?) {
358             if ($IDENT != null) {
359                 translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
360             }
361         }
362     |   ^(CONTINUE IDENT?) {
363             if ($IDENT != null) {
364                 translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
365             }
366         }
367     |   ^(LABELED_STATEMENT IDENT statement)
368     |   expression
369     |   ^('delete' expression)
370     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
371     |   ';' // Empty statement.
372     |   ^(PRINT expression*)
373     |   ^(PRINTLN expression*)
374     |   ^(EXIT expression?)
375     |   EXITALL
376     ;
377         
378 switchCaseLabel
379     :   ^(CASE expression blockStatement*)
380     |   ^(DEFAULT blockStatement*)
381     ;
382     
383 forInit
384     :   localVariableDeclaration 
385     |   expression+
386     ;
387     
388 // EXPRESSIONS
389
390 parenthesizedExpression
391     :   ^(PAREN_EXPR expression)
392     ;
393     
394 expression
395     :   ^(EXPR expr)
396     ;
397
398 expr
399     :   ^(ASSIGNMENT expr expr)
400     |   ^(PLUS_EQUALS expr expr)
401     |   ^(MINUS_EQUALS expr expr)
402     |   ^(TIMES_EQUALS expr expr)
403     |   ^(DIVIDE_EQUALS expr expr)
404     |   ^(AND_EQUALS expr expr)
405     |   ^(OR_EQUALS expr expr)
406     |   ^(POWER_EQUALS expr expr)
407     |   ^(MOD_EQUALS expr expr)
408     |   ^('>>>=' expr expr)
409     |   ^('>>=' expr expr)
410     |   ^('<<=' expr expr)
411     |   ^('?' expr expr expr)
412     |   ^(OR expr expr)
413     |   ^(AND expr expr)
414     |   ^(BITWISE_OR expr expr)
415     |   ^(POWER expr expr)
416     |   ^(BITWISE_AND expr expr)
417     |   ^(EQUALS expr expr)
418     |   ^(NOT_EQUALS expr expr)
419     |   ^(INSTANCEOF expr type)
420     |   ^(LTE expr expr)
421     |   ^(GTE expr expr)
422     |   ^('>>>' expr expr)
423     |   ^('>>' expr expr)
424     |   ^(GT expr expr)
425     |   ^('<<' expr expr)
426     |   ^(LT expr expr)
427     |   ^(PLUS expr expr)
428     |   ^(MINUS expr expr)
429     |   ^(TIMES expr expr)
430     |   ^(DIVIDE expr expr)
431     |   ^(MOD expr expr)
432     |   ^(UNARY_PLUS expr)
433     |   ^(UNARY_MINUS expr)
434     |   ^(PRE_INC expr)
435     |   ^(PRE_DEC expr)
436     |   ^(POST_INC expr)
437     |   ^(POST_DEC expr)
438     |   ^(TILDE expr)
439     |   ^(NOT expr)
440     |   ^(CAST_EXPR type expr)
441     |   primaryExpression
442     ;
443     
444 primaryExpression
445     :   ^(DOT primaryExpression
446                 (   IDENT
447                 |   THIS
448                 |   SUPER
449                 )
450         )
451     |   parenthesizedExpression
452     |   IDENT
453     |   ^(METHOD_CALL primaryExpression templateInstantiation? arguments)
454     |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) templateInstantiation? arguments)
455         ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) templateInstantiation? arguments)
456     |   explicitConstructorCall
457     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
458     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
459     |   literal
460     |   newExpression
461     |   THIS
462     |   arrayTypeDeclarator
463     |   SUPER
464     |   GETNUMPES
465     |   GETNUMNODES
466     |   GETMYPE
467     |   GETMYNODE
468     |   GETMYRANK
469         |       THISINDEX
470         |       THISPROXY
471     |   domainExpression
472     ;
473     
474 explicitConstructorCall
475     :   ^(THIS_CONSTRUCTOR_CALL templateInstantiation? arguments)
476     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? templateInstantiation? arguments)
477     ;
478
479 arrayTypeDeclarator
480     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
481     ;
482
483 newExpression
484     :   ^(NEW_EXPRESSION arguments? domainExpression)
485     |   ^(NEW type arguments)
486     ;
487
488 arguments
489     :   ^(ARGUMENT_LIST expression*)
490     ;
491
492 literal 
493     :   HEX_LITERAL
494     |   OCTAL_LITERAL
495     |   DECIMAL_LITERAL
496     |   FLOATING_POINT_LITERAL
497     |   CHARACTER_LITERAL
498     |   STRING_LITERAL          
499     |   TRUE
500     |   FALSE
501     |   NULL
502     ;
503
504 rangeItem
505     :   DECIMAL_LITERAL
506     |   IDENT
507     ;
508
509 rangeExpression
510     :   ^(RANGE_EXPRESSION rangeItem)
511     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
512     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
513     ;
514
515 rangeList
516     :   rangeExpression+
517     ;
518
519 domainExpression
520     :   ^(DOMAIN_EXPRESSION rangeList)
521     ;