9672e6b7ad94a86090eed886c828ff25babfdebe
[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 { currentClass = (ClassSymbol) $IDENT.def.type; }
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 nonArraySectionObjectType
241         :       simpleType
242         |   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
243     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
244     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
245     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
246         |       VOID
247         ;       
248
249 simpleType returns [ClassSymbol type]
250     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
251     ;
252     
253 objectType returns [ClassSymbol type]
254     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
255     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
256     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
257     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
258         |       ^(ARRAY_SECTION_TYPE qualifiedTypeIdent domainExpression?)
259     ;
260
261 entryArgObjectType returns [ClassSymbol type]
262     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
263     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
264     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
265     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
266     ;
267
268 qualifiedTypeIdent returns [ClassSymbol type]
269     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
270     ;
271
272 typeIdent returns [String name]
273     :   ^(IDENT templateInstantiation?)
274     ;
275
276 primitiveType
277     :   BOOLEAN
278     |   CHAR
279     |   BYTE
280     |   SHORT
281     |   INT
282     |   LONG
283     |   FLOAT
284     |   DOUBLE
285     ;
286
287 genericTypeArgumentList
288     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
289     ;
290     
291 genericTypeArgument
292     :   type
293     |   '?'
294     ;
295
296 formalParameterList
297     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
298     ;
299
300 formalParameterStandardDecl
301     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
302     ;
303
304 entryFormalParameterList
305     :   ^(FORMAL_PARAM_LIST entryFormalParameterStandardDecl* formalParameterVarargDecl?) 
306     ;
307
308 entryFormalParameterStandardDecl
309     :   ^(FORMAL_PARAM_STD_DECL localModifierList? entryArgType variableDeclaratorId)
310     ;
311     
312 formalParameterVarargDecl
313     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
314     ;
315     
316 // FIXME: is this rule right? Verify that this is ok, I expected something like:
317 // IDENT (^(DOT qualifiedIdentifier IDENT))*
318 qualifiedIdentifier
319     :   IDENT
320     |   ^(DOT qualifiedIdentifier IDENT)
321     ;
322     
323 block returns [boolean sdag]
324 @init { $sdag = false; }
325     :   ^(BLOCK (blockStatement { $sdag |= $blockStatement.sdag; })*)
326     ;
327
328 blockStatement returns [boolean sdag]
329 @init { $sdag = false; }
330     :   localVariableDeclaration
331     |   statement { $sdag = $statement.sdag; }
332     ;
333     
334 localVariableDeclaration
335     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
336     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
337     ;
338
339 statement returns [boolean sdag]
340 @init { $sdag = false; }
341     : nonBlockStatement { $sdag = $nonBlockStatement.sdag; }
342     | sdagStatement { $sdag = true; }
343     | block { $sdag = $block.sdag; }
344     ;
345
346 divconBlock
347     :   ^(DIVCON_BLOCK divconExpr)
348     ;
349
350 divconAssignment
351     :   ^(LET_ASSIGNMENT IDENT expression)
352     ;
353
354 divconAssignmentList
355     :   divconAssignment+
356     ;
357
358 divconExpr
359     :   ^(IF parenthesizedExpression divconExpr divconExpr?)
360     |   ^(LET divconAssignmentList IN divconExpr)
361     |   expression
362     ;
363
364 sdagStatement
365     :   ^(OVERLAP block)
366     |   ^(WHEN (IDENT expression? formalParameterList)* block)
367     ;
368
369 nonBlockStatement returns [boolean sdag]
370 @init { $sdag = false; }
371     :   ^(ASSERT expression expression?)
372     |   ^(IF parenthesizedExpression (i=block { $sdag |= $i.sdag; }) (e=block { $sdag |= $e.sdag; })?)
373         -> {$sdag}? ^(SDAG_IF parenthesizedExpression $i $e)
374         -> ^(IF parenthesizedExpression $i $e)
375     |   ^(FOR forInit? FOR_EXPR (e1=expression)? FOR_UPDATE (e2+=expression)* block {
376             $sdag = $block.sdag;
377         })
378         -> {$sdag}? ^(SDAG_FOR forInit? FOR_EXPR $e1 FOR_UPDATE $e2 block)
379         -> ^(FOR forInit? FOR_EXPR $e1 FOR_UPDATE $e2 block)
380     |   ^(FOR_EACH localModifierList? type IDENT expression block { $sdag = $block.sdag; })
381     |   ^(WHILE parenthesizedExpression block { $sdag = $block.sdag; })
382         -> {$sdag}? ^(SDAG_WHILE parenthesizedExpression block)
383         -> ^(WHILE parenthesizedExpression block)
384     |   ^(DO block parenthesizedExpression { $sdag = $block.sdag; })
385         -> {$sdag}? ^(SDAG_DO block parenthesizedExpression)
386         -> ^(DO block parenthesizedExpression)
387     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
388     |   ^(RETURN expression?)
389     |   ^(THROW expression)
390     |   ^(BREAK IDENT?) 
391     |   ^(CONTINUE IDENT?) 
392     |   ^(LABELED_STATEMENT IDENT statement)
393     |   expression
394     |   ^('delete' expression)
395     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
396     |   ';' // Empty statement.
397     |   ^(PRINT expression*)
398     |   ^(PRINTLN expression*)
399     |   ^(EXIT expression?)
400     |   EXITALL
401     ;
402         
403 switchCaseLabel
404     :   ^(CASE expression blockStatement*)
405     |   ^(DEFAULT blockStatement*)
406     ;
407     
408 forInit
409     :   localVariableDeclaration 
410     |   expression+
411     ;
412     
413 // EXPRESSIONS
414
415 parenthesizedExpression
416     :   ^(PAREN_EXPR expression)
417     ;
418     
419 expression
420     :   ^(EXPR expr)
421     ;
422
423 expr
424     :   ^(ASSIGNMENT expr expr)
425     |   ^(PLUS_EQUALS expr expr)
426     |   ^(MINUS_EQUALS expr expr)
427     |   ^(TIMES_EQUALS expr expr)
428     |   ^(DIVIDE_EQUALS expr expr)
429     |   ^(AND_EQUALS expr expr)
430     |   ^(OR_EQUALS expr expr)
431     |   ^(POWER_EQUALS expr expr)
432     |   ^(MOD_EQUALS expr expr)
433     |   ^('>>>=' expr expr)
434     |   ^('>>=' expr expr)
435     |   ^('<<=' expr expr)
436     |   ^('?' expr expr expr)
437     |   ^(OR expr expr)
438     |   ^(AND expr expr)
439     |   ^(BITWISE_OR expr expr)
440     |   ^(POWER expr expr)
441     |   ^(BITWISE_AND expr expr)
442     |   ^(EQUALS expr expr)
443     |   ^(NOT_EQUALS expr expr)
444     |   ^(INSTANCEOF expr type)
445     |   ^(LTE expr expr)
446     |   ^(GTE expr expr)
447     |   ^('>>>' expr expr)
448     |   ^('>>' expr expr)
449     |   ^(GT expr expr)
450     |   ^('<<' expr expr)
451     |   ^(LT expr expr)
452     |   ^(PLUS expr expr)
453     |   ^(MINUS expr expr)
454     |   ^(TIMES expr expr)
455     |   ^(DIVIDE expr expr)
456     |   ^(MOD expr expr)
457     |   ^(UNARY_PLUS expr)
458     |   ^(UNARY_MINUS expr)
459     |   ^(PRE_INC expr)
460     |   ^(PRE_DEC expr)
461     |   ^(POST_INC expr)
462     |   ^(POST_DEC expr)
463     |   ^(TILDE expr)
464     |   ^(NOT expr)
465     |   ^(CAST_EXPR type expr)
466     |   primaryExpression
467     ;
468     
469 primaryExpression
470     :   ^(DOT primaryExpression
471                 (   IDENT
472                 |   THIS
473                 |   SUPER
474                 )
475         )
476     |   ^(ARROW primaryExpression
477                 (   IDENT
478                 |   THIS
479                 |   SUPER
480                 )
481         )
482     |   parenthesizedExpression
483     |   IDENT
484     |   CHELPER
485     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
486     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
487     |   explicitConstructorCall
488     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
489     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
490     |   literal
491     |   newExpression
492     |   THIS
493     |   arrayTypeDeclarator
494     |   SUPER
495     |   GETNUMPES
496     |   GETNUMNODES
497     |   GETMYPE
498     |   GETMYNODE
499     |   GETMYRANK
500         |       THISINDEX
501         |       THISPROXY
502     |   domainExpression
503     ;
504     
505 explicitConstructorCall
506     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
507     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
508     ;
509
510 arrayTypeDeclarator
511     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
512     ;
513
514 newExpression
515     :   ^(NEW_EXPRESSION arguments? domainExpression)
516         |       ^(NEW ^(ARRAY_SECTION_TYPE qualifiedTypeIdent domainExpression) ^(ARGUMENT_LIST expression))
517                 {
518                         currentClass.sectionInitializers.add(new ArraySectionInitializer($domainExpression.ranges, $qualifiedTypeIdent.text));
519                 }
520                 ->      ^(METHOD_CALL IDENT["arraySectionInit" + ArraySectionInitializer.getCount()] ^(ARGUMENT_LIST expression))
521     |   ^(NEW nonArraySectionObjectType arguments)
522     ;
523
524 arguments returns [Object expr]
525     :   ^(ARGUMENT_LIST expression*) 
526     ;
527
528 entryArguments
529     :   ^(ARGUMENT_LIST entryArgExpr*)
530     ;
531
532 entryArgExpr
533     :   ^(EXPR entryExpr)
534     ;
535
536 entryExpr
537     :   ^(ASSIGNMENT expr expr)
538     |   ^(PLUS_EQUALS expr expr)
539     |   ^(MINUS_EQUALS expr expr)
540     |   ^(TIMES_EQUALS expr expr)
541     |   ^(DIVIDE_EQUALS expr expr)
542     |   ^(AND_EQUALS expr expr)
543     |   ^(OR_EQUALS expr expr)
544     |   ^(POWER_EQUALS expr expr)
545     |   ^(MOD_EQUALS expr expr)
546     |   ^('>>>=' expr expr)
547     |   ^('>>=' expr expr)
548     |   ^('<<=' expr expr)
549     |   ^('?' expr expr expr)
550     |   ^(OR expr expr)
551     |   ^(AND expr expr)
552     |   ^(BITWISE_OR expr expr)
553     |   ^(POWER expr expr)
554     |   ^(BITWISE_AND expr expr)
555     |   ^(EQUALS expr expr)
556     |   ^(NOT_EQUALS expr expr)
557     |   ^(INSTANCEOF expr type)
558     |   ^(LTE expr expr)
559     |   ^(GTE expr expr)
560     |   ^('>>>' expr expr)
561     |   ^('>>' expr expr)
562     |   ^(GT expr expr)
563     |   ^('<<' expr expr)
564     |   ^(LT expr expr)
565     |   ^(PLUS expr expr)
566     |   ^(MINUS expr expr)
567     |   ^(TIMES expr expr)
568     |   ^(DIVIDE expr expr)
569     |   ^(MOD expr expr)
570     |   ^(UNARY_PLUS expr)
571     |   ^(UNARY_MINUS expr)
572     |   ^(PRE_INC expr)
573     |   ^(PRE_DEC expr)
574     |   ^(POST_INC expr)
575     |   ^(POST_DEC expr)
576     |   ^(TILDE expr)
577     |   ^(NOT expr)
578     |   ^(CAST_EXPR type expr)
579     |   entryPrimaryExpression
580     ;
581     
582 entryPrimaryExpression
583     :   ^(DOT primaryExpression
584                 (   IDENT
585                 |   THIS
586                 |   SUPER
587                 )
588         )
589     |   ^(ARROW primaryExpression
590                 (   IDENT
591                 |   THIS
592                 |   SUPER
593                 )
594         )
595     |   parenthesizedExpression
596     |   IDENT
597         {
598             //System.out.println("Derefing ID with type " + $IDENT.symbolType.getClass().getName() +
599             //    ":\n" + $IDENT.symbolType + "\nand def info " + $IDENT.def.getClass().getName() + ":\n" + $IDENT.def);
600             if ($IDENT.symbolType instanceof ClassSymbol) {
601                 if (!((ClassSymbol)$IDENT.symbolType).isPrimitive) {
602                     astmod.makePointerDereference($IDENT);
603                 }
604             }
605         }
606     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
607     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
608     |   explicitConstructorCall
609     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
610     |   literal
611     |   newExpression
612         ->  ^(POINTER_DEREFERENCE newExpression)
613     |   THIS
614         ->  ^(POINTER_DEREFERENCE THIS)
615     |   arrayTypeDeclarator
616     |   SUPER
617     |   GETNUMPES
618     |   GETNUMNODES
619     |   GETMYPE
620     |   GETMYNODE
621     |   GETMYRANK
622     |   domainExpression
623     ;
624
625 literal 
626     :   HEX_LITERAL
627     |   OCTAL_LITERAL
628     |   DECIMAL_LITERAL
629     |   FLOATING_POINT_LITERAL
630     |   CHARACTER_LITERAL
631     |   STRING_LITERAL          
632     |   TRUE
633     |   FALSE
634     |   NULL 
635     ;
636
637 rangeItem returns [Object item]
638     :   DECIMAL_LITERAL { $item = $DECIMAL_LITERAL; }
639     |   IDENT                   { $item = $IDENT; }
640     ;
641
642 rangeExpression returns [ArrayList<Object> range]
643 @init
644 {
645         $range = new ArrayList<Object>();
646 }
647     :   ^(RANGE_EXPRESSION rangeItem)                                                           { $range.add($rangeItem.item); }        
648     |   ^(RANGE_EXPRESSION i1=rangeItem i2=rangeItem)                           { $range.add($i1.item); $range.add($i2.item); }
649     |   ^(RANGE_EXPRESSION i1=rangeItem i2=rangeItem i3=rangeItem)      { $range.add($i1.item); $range.add($i2.item); $range.add($i3.item); }
650     ;
651
652 rangeList returns [ArrayList<ArrayList<Object>> ranges]
653 @init
654 {
655         $ranges = new ArrayList<ArrayList<Object>>();
656 }
657     :   (rangeExpression { $ranges.add($rangeExpression.range); })+
658     ;
659
660 domainExpression returns [ArrayList<ArrayList<Object>> ranges]
661     :   ^(DOMAIN_EXPRESSION rangeList)  { $ranges = $rangeList.ranges; }
662     ;