Charj: simplify and improve SDAG handling
[charm.git] / src / langs / charj / src / charj / translator / CharjASTModifier2.g
1 /**
2  *  TODO add a description
3  */
4
5 tree grammar CharjASTModifier2;
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 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
20 @rulecatch {
21     catch (RecognitionException re) {
22         reportError(re);
23         throw re;
24     }
25 }
26
27 @members {
28     SymbolTable symtab = null;
29     PackageScope currentPackage = null;
30     ClassSymbol currentClass = null;
31     MethodSymbol currentMethod = null;
32     LocalScope currentLocalScope = null;
33     Translator translator;
34
35     AstModifier astmod = new AstModifier();
36
37     protected boolean containsModifier(CharjAST modlist, int type)
38     {
39         if(modlist == null)
40             return false;
41         CharjAST charjModList = modlist.getChildOfType(CharjParser.CHARJ_MODIFIER_LIST);
42         if(charjModList == null)
43             return false;
44         if(charjModList.getChildOfType(CharjParser.ENTRY) == null)
45             return false;
46         return true;
47     }
48 }
49
50 // Starting point for parsing a Charj file.
51 charjSource[SymbolTable _symtab] returns [ClassSymbol cs]
52     :   ^(CHARJ_SOURCE 
53         (packageDeclaration)? 
54         (importDeclaration
55         | typeDeclaration { $cs = $typeDeclaration.sym; }
56         | readonlyDeclaration)*)
57     ;
58
59 // note: no new scope here--this replaces the default scope
60 packageDeclaration
61     :   ^(PACKAGE IDENT+)
62     ;
63     
64 importDeclaration
65     :   ^(IMPORT qualifiedIdentifier '.*'?)
66     ;
67
68 readonlyDeclaration
69     :   ^(READONLY localVariableDeclaration)
70     ;
71
72 typeDeclaration returns [ClassSymbol sym]
73     :   ^(TYPE classType IDENT
74             (^('extends' parent=type))? (^('implements' type+))?
75                 classScopeDeclaration*)
76     |   ^('interface' IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
77     |   ^('enum' IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
78     ;
79
80 classType
81     :   CLASS
82     |   chareType
83     ;
84
85 chareType
86     :   CHARE
87     |   GROUP
88     |   NODEGROUP
89     |   MAINCHARE
90     |   ^(CHARE_ARRAY ARRAY_DIMENSION)
91     ;
92
93 enumConstant
94     :   ^(IDENT arguments?)
95     ;
96     
97 classScopeDeclaration
98     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList?
99             type IDENT formalParameterList domainExpression? b=block)
100     |   ^(ENTRY_FUNCTION_DECL modifierList? genericTypeParameterList?
101             type IDENT entryFormalParameterList domainExpression? b=block?)
102         -> {$b.sdag}? ^(SDAG_FUNCTION_DECL modifierList? genericTypeParameterList?
103                 type IDENT entryFormalParameterList domainExpression? block?)
104         -> ^(ENTRY_FUNCTION_DECL modifierList? genericTypeParameterList?
105             type IDENT entryFormalParameterList domainExpression? block?)
106     |   ^(DIVCON_METHOD_DECL modifierList? type IDENT formalParameterList divconBlock)
107     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
108             //^(VAR_DECLARATOR_LIST field[$simpleType.type]+))
109     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
110             //^(VAR_DECLARATOR_LIST field[$objectType.type]+))
111     |   ^(CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT formalParameterList 
112             block)
113     |   ^(ENTRY_CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT entryFormalParameterList 
114             block)
115     ;
116
117 field [ClassSymbol type]
118     :   ^(VAR_DECLARATOR ^(IDENT domainExpression?) variableInitializer?)
119     ;
120     
121 interfaceScopeDeclaration
122     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
123             type IDENT formalParameterList domainExpression?)
124         // Interface constant declarations have been switched to variable
125         // declarations by Charj.g; the parser has already checked that
126         // there's an obligatory initializer.
127     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
128     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
129     ;
130
131 variableDeclaratorList
132     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
133     ;
134
135 variableDeclarator
136     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
137     ;
138     
139 variableDeclaratorId
140     :   ^(IDENT domainExpression?)
141     ;
142
143 variableInitializer
144     :   arrayInitializer
145     |   expression
146     ;
147     
148 arrayInitializer
149     :   ^(ARRAY_INITIALIZER variableInitializer*)
150     ;
151
152 templateArg
153     : genericTypeArgument
154     | literal
155     ;
156
157 templateArgList
158     :   templateArg templateArg*
159     ;
160
161 templateInstantiation
162     :    ^(TEMPLATE_INST templateArgList)
163     |    ^(TEMPLATE_INST templateInstantiation)
164     ;
165
166 genericTypeParameterList
167     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
168     ;
169
170 genericTypeParameter
171     :   ^(IDENT bound?)
172     ;
173         
174 bound
175     :   ^(EXTENDS_BOUND_LIST type+)
176     ;
177
178 modifierList
179     :   ^(MODIFIER_LIST accessModifierList localModifierList charjModifierList otherModifierList)
180     ;
181
182 modifier
183     :   accessModifier
184     |   localModifier
185     |   charjModifier
186     |   otherModifier
187     ;
188
189 localModifierList
190     :   ^(LOCAL_MODIFIER_LIST localModifier*)
191     ;
192
193 accessModifierList
194     :   ^(ACCESS_MODIFIER_LIST accessModifier*)
195     ;
196
197 charjModifierList
198     :   ^(CHARJ_MODIFIER_LIST charjModifier*)
199     ;
200
201 otherModifierList
202     :   ^(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
218     :   ENTRY
219     |   SDAGENTRY
220     |   TRACED
221     ;
222
223 otherModifier
224     :   ABSTRACT
225     |   NATIVE
226     ;
227
228 entryArgType
229     :   simpleType
230     |   entryArgObjectType
231     |   VOID
232     ;
233
234 type
235     :   simpleType
236     |   objectType
237     |   VOID
238     ;
239
240 simpleType returns [ClassSymbol type]
241     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
242     ;
243     
244 objectType returns [ClassSymbol type]
245     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
246     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
247     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
248     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
249     ;
250
251 entryArgObjectType returns [ClassSymbol type]
252     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
253     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
254     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
255     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
256     ;
257
258 qualifiedTypeIdent returns [ClassSymbol type]
259     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
260     ;
261
262 typeIdent returns [String name]
263     :   ^(IDENT templateInstantiation?)
264     ;
265
266 primitiveType
267     :   BOOLEAN
268     |   CHAR
269     |   BYTE
270     |   SHORT
271     |   INT
272     |   LONG
273     |   FLOAT
274     |   DOUBLE
275     ;
276
277 genericTypeArgumentList
278     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
279     ;
280     
281 genericTypeArgument
282     :   type
283     |   '?'
284     ;
285
286 formalParameterList
287     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
288     ;
289
290 formalParameterStandardDecl
291     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
292     ;
293
294 entryFormalParameterList
295     :   ^(FORMAL_PARAM_LIST entryFormalParameterStandardDecl* formalParameterVarargDecl?) 
296     ;
297
298 entryFormalParameterStandardDecl
299     :   ^(FORMAL_PARAM_STD_DECL localModifierList? entryArgType variableDeclaratorId)
300     ;
301     
302 formalParameterVarargDecl
303     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
304     ;
305     
306 // FIXME: is this rule right? Verify that this is ok, I expected something like:
307 // IDENT (^(DOT qualifiedIdentifier IDENT))*
308 qualifiedIdentifier
309     :   IDENT
310     |   ^(DOT qualifiedIdentifier IDENT)
311     ;
312     
313 block returns [boolean sdag]
314 @init { $sdag = false; }
315     :   ^(BLOCK (blockStatement { $sdag |= $blockStatement.sdag; })*)
316     ;
317
318 blockStatement returns [boolean sdag]
319 @init { $sdag = false; }
320     :   localVariableDeclaration
321     |   statement { $sdag = $statement.sdag; }
322     ;
323     
324 localVariableDeclaration
325     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
326     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
327     ;
328
329 statement returns [boolean sdag]
330 @init { $sdag = false; }
331     : nonBlockStatement { $sdag = $nonBlockStatement.sdag; }
332     | sdagStatement { $sdag = true; }
333     | block { $sdag = $block.sdag; }
334     ;
335
336 divconBlock
337     :   ^(DIVCON_BLOCK divconExpr)
338     ;
339
340 divconAssignment
341     :   ^(LET_ASSIGNMENT IDENT expression)
342     ;
343
344 divconAssignmentList
345     :   divconAssignment+
346     ;
347
348 divconExpr
349     :   ^(IF parenthesizedExpression divconExpr divconExpr?)
350     |   ^(LET divconAssignmentList IN divconExpr)
351     |   expression
352     ;
353
354 sdagStatement
355     :   ^(OVERLAP block)
356     |   ^(WHEN (IDENT expression? formalParameterList)* block)
357     ;
358
359 nonBlockStatement returns [boolean sdag]
360 @init { $sdag = false; }
361     :   ^(ASSERT expression expression?)
362     |   ^(IF parenthesizedExpression (i=block { $sdag |= $i.sdag; }) (e=block { $sdag |= $e.sdag; })?)
363         -> {$sdag}? ^(SDAG_IF parenthesizedExpression $i $e)
364         -> ^(IF parenthesizedExpression $i $e)
365     |   ^(FOR forInit? FOR_EXPR (e1=expression)? FOR_UPDATE (e2+=expression)* block {
366             $sdag = $block.sdag;
367         })
368         -> {$sdag}? ^(SDAG_FOR forInit? FOR_EXPR $e1 FOR_UPDATE $e2 block)
369         -> ^(FOR forInit? FOR_EXPR $e1 FOR_UPDATE $e2 block)
370     |   ^(FOR_EACH localModifierList? type IDENT expression block { $sdag = $block.sdag; })
371     |   ^(WHILE parenthesizedExpression block { $sdag = $block.sdag; })
372         -> {$sdag}? ^(SDAG_WHILE parenthesizedExpression block)
373         -> ^(WHILE parenthesizedExpression block)
374     |   ^(DO block parenthesizedExpression { $sdag = $block.sdag; })
375         -> {$sdag}? ^(SDAG_DO block parenthesizedExpression)
376         -> ^(DO block parenthesizedExpression)
377     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
378     |   ^(RETURN expression?)
379     |   ^(THROW expression)
380     |   ^(BREAK IDENT?) 
381     |   ^(CONTINUE IDENT?) 
382     |   ^(LABELED_STATEMENT IDENT statement)
383     |   expression
384     |   ^('delete' expression)
385     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
386     |   ';' // Empty statement.
387     |   ^(PRINT expression*)
388     |   ^(PRINTLN expression*)
389     |   ^(EXIT expression?)
390     |   EXITALL
391     ;
392         
393 switchCaseLabel
394     :   ^(CASE expression blockStatement*)
395     |   ^(DEFAULT blockStatement*)
396     ;
397     
398 forInit
399     :   localVariableDeclaration 
400     |   expression+
401     ;
402     
403 // EXPRESSIONS
404
405 parenthesizedExpression
406     :   ^(PAREN_EXPR expression)
407     ;
408     
409 expression
410     :   ^(EXPR expr)
411     ;
412
413 expr
414     :   ^(ASSIGNMENT expr expr)
415     |   ^(PLUS_EQUALS expr expr)
416     |   ^(MINUS_EQUALS expr expr)
417     |   ^(TIMES_EQUALS expr expr)
418     |   ^(DIVIDE_EQUALS expr expr)
419     |   ^(AND_EQUALS expr expr)
420     |   ^(OR_EQUALS expr expr)
421     |   ^(POWER_EQUALS expr expr)
422     |   ^(MOD_EQUALS expr expr)
423     |   ^('>>>=' expr expr)
424     |   ^('>>=' expr expr)
425     |   ^('<<=' expr expr)
426     |   ^('?' expr expr expr)
427     |   ^(OR expr expr)
428     |   ^(AND expr expr)
429     |   ^(BITWISE_OR expr expr)
430     |   ^(POWER expr expr)
431     |   ^(BITWISE_AND expr expr)
432     |   ^(EQUALS expr expr)
433     |   ^(NOT_EQUALS expr expr)
434     |   ^(INSTANCEOF expr type)
435     |   ^(LTE expr expr)
436     |   ^(GTE expr expr)
437     |   ^('>>>' expr expr)
438     |   ^('>>' expr expr)
439     |   ^(GT expr expr)
440     |   ^('<<' expr expr)
441     |   ^(LT expr expr)
442     |   ^(PLUS expr expr)
443     |   ^(MINUS expr expr)
444     |   ^(TIMES expr expr)
445     |   ^(DIVIDE expr expr)
446     |   ^(MOD expr expr)
447     |   ^(UNARY_PLUS expr)
448     |   ^(UNARY_MINUS expr)
449     |   ^(PRE_INC expr)
450     |   ^(PRE_DEC expr)
451     |   ^(POST_INC expr)
452     |   ^(POST_DEC expr)
453     |   ^(TILDE expr)
454     |   ^(NOT expr)
455     |   ^(CAST_EXPR type expr)
456     |   primaryExpression
457     ;
458     
459 primaryExpression
460     :   ^(DOT primaryExpression
461                 (   IDENT
462                 |   THIS
463                 |   SUPER
464                 )
465         )
466     |   ^(ARROW primaryExpression
467                 (   IDENT
468                 |   THIS
469                 |   SUPER
470                 )
471         )
472     |   parenthesizedExpression
473     |   IDENT
474     |   CHELPER
475     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
476     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
477     |   explicitConstructorCall
478     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
479     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
480     |   literal
481     |   newExpression
482     |   THIS
483     |   arrayTypeDeclarator
484     |   SUPER
485     |   GETNUMPES
486     |   GETNUMNODES
487     |   GETMYPE
488     |   GETMYNODE
489     |   GETMYRANK
490         |       THISINDEX
491         |       THISPROXY
492     |   domainExpression
493     ;
494     
495 explicitConstructorCall
496     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
497     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
498     ;
499
500 arrayTypeDeclarator
501     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
502     ;
503
504 newExpression
505     :   ^(NEW_EXPRESSION arguments? domainExpression)
506     |   ^(NEW type arguments)
507     ;
508
509 arguments
510     :   ^(ARGUMENT_LIST expression*)
511     ;
512
513 entryArguments
514     :   ^(ARGUMENT_LIST entryArgExpr*)
515     ;
516
517 entryArgExpr
518     :   ^(EXPR entryExpr)
519     ;
520
521 entryExpr
522     :   ^(ASSIGNMENT expr expr)
523     |   ^(PLUS_EQUALS expr expr)
524     |   ^(MINUS_EQUALS expr expr)
525     |   ^(TIMES_EQUALS expr expr)
526     |   ^(DIVIDE_EQUALS expr expr)
527     |   ^(AND_EQUALS expr expr)
528     |   ^(OR_EQUALS expr expr)
529     |   ^(POWER_EQUALS expr expr)
530     |   ^(MOD_EQUALS expr expr)
531     |   ^('>>>=' expr expr)
532     |   ^('>>=' expr expr)
533     |   ^('<<=' expr expr)
534     |   ^('?' expr expr expr)
535     |   ^(OR expr expr)
536     |   ^(AND expr expr)
537     |   ^(BITWISE_OR expr expr)
538     |   ^(POWER expr expr)
539     |   ^(BITWISE_AND expr expr)
540     |   ^(EQUALS expr expr)
541     |   ^(NOT_EQUALS expr expr)
542     |   ^(INSTANCEOF expr type)
543     |   ^(LTE expr expr)
544     |   ^(GTE expr expr)
545     |   ^('>>>' expr expr)
546     |   ^('>>' expr expr)
547     |   ^(GT expr expr)
548     |   ^('<<' expr expr)
549     |   ^(LT expr expr)
550     |   ^(PLUS expr expr)
551     |   ^(MINUS expr expr)
552     |   ^(TIMES expr expr)
553     |   ^(DIVIDE expr expr)
554     |   ^(MOD expr expr)
555     |   ^(UNARY_PLUS expr)
556     |   ^(UNARY_MINUS expr)
557     |   ^(PRE_INC expr)
558     |   ^(PRE_DEC expr)
559     |   ^(POST_INC expr)
560     |   ^(POST_DEC expr)
561     |   ^(TILDE expr)
562     |   ^(NOT expr)
563     |   ^(CAST_EXPR type expr)
564     |   entryPrimaryExpression
565     ;
566     
567 entryPrimaryExpression
568     :   ^(DOT primaryExpression
569                 (   IDENT
570                 |   THIS
571                 |   SUPER
572                 )
573         )
574     |   ^(ARROW primaryExpression
575                 (   IDENT
576                 |   THIS
577                 |   SUPER
578                 )
579         )
580     |   parenthesizedExpression
581     |   IDENT
582         {
583             //System.out.println("Derefing ID with type " + $IDENT.symbolType.getClass().getName() +
584             //    ":\n" + $IDENT.symbolType + "\nand def info " + $IDENT.def.getClass().getName() + ":\n" + $IDENT.def);
585             if ($IDENT.symbolType instanceof ClassSymbol) {
586                 if (!((ClassSymbol)$IDENT.symbolType).isPrimitive) {
587                     astmod.makePointerDereference($IDENT);
588                 }
589             }
590         }
591     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
592     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
593     |   explicitConstructorCall
594     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
595     |   literal
596     |   newExpression
597         ->  ^(POINTER_DEREFERENCE newExpression)
598     |   THIS
599         ->  ^(POINTER_DEREFERENCE THIS)
600     |   arrayTypeDeclarator
601     |   SUPER
602     |   GETNUMPES
603     |   GETNUMNODES
604     |   GETMYPE
605     |   GETMYNODE
606     |   GETMYRANK
607     |   domainExpression
608     ;
609
610 literal 
611     :   HEX_LITERAL
612     |   OCTAL_LITERAL
613     |   DECIMAL_LITERAL
614     |   FLOATING_POINT_LITERAL
615     |   CHARACTER_LITERAL
616     |   STRING_LITERAL          
617     |   TRUE
618     |   FALSE
619     |   NULL 
620     ;
621
622 rangeItem
623     :   DECIMAL_LITERAL
624     |   IDENT
625     ;
626
627 rangeExpression
628     :   ^(RANGE_EXPRESSION rangeItem)
629     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
630     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
631     ;
632
633 rangeList
634     :   rangeExpression+
635     ;
636
637 domainExpression
638     :   ^(DOMAIN_EXPRESSION rangeList)
639     ;