89adb2dc778dd91e3f0312ab412bbb4f89019f71
[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     |   ^(DIVCON_METHOD_DECL modifierList? type IDENT formalParameterList divconBlock)
103     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
104             //^(VAR_DECLARATOR_LIST field[$simpleType.type]+))
105     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
106             //^(VAR_DECLARATOR_LIST field[$objectType.type]+))
107     |   ^(CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT formalParameterList 
108             block)
109     |   ^(ENTRY_CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT entryFormalParameterList 
110             block)
111     ;
112
113 field [ClassSymbol type]
114     :   ^(VAR_DECLARATOR ^(IDENT domainExpression?) variableInitializer?)
115     ;
116     
117 interfaceScopeDeclaration
118     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
119             type IDENT formalParameterList domainExpression?)
120         // Interface constant declarations have been switched to variable
121         // declarations by Charj.g; the parser has already checked that
122         // there's an obligatory initializer.
123     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
124     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
125     ;
126
127 variableDeclaratorList
128     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
129     ;
130
131 variableDeclarator
132     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
133     ;
134     
135 variableDeclaratorId
136     :   ^(IDENT domainExpression?)
137     ;
138
139 variableInitializer
140     :   arrayInitializer
141     |   expression
142     ;
143     
144 arrayInitializer
145     :   ^(ARRAY_INITIALIZER variableInitializer*)
146     ;
147
148 templateArg
149     : genericTypeArgument
150     | literal
151     ;
152
153 templateArgList
154     :   templateArg templateArg*
155     ;
156
157 templateInstantiation
158     :    ^(TEMPLATE_INST templateArgList)
159     |    ^(TEMPLATE_INST templateInstantiation)
160     ;
161
162 genericTypeParameterList
163     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
164     ;
165
166 genericTypeParameter
167     :   ^(IDENT bound?)
168     ;
169         
170 bound
171     :   ^(EXTENDS_BOUND_LIST type+)
172     ;
173
174 modifierList
175     :   ^(MODIFIER_LIST accessModifierList localModifierList charjModifierList otherModifierList)
176     ;
177
178 modifier
179     :   accessModifier
180     |   localModifier
181     |   charjModifier
182     |   otherModifier
183     ;
184
185 localModifierList
186     :   ^(LOCAL_MODIFIER_LIST localModifier*)
187     ;
188
189 accessModifierList
190     :   ^(ACCESS_MODIFIER_LIST accessModifier*)
191     ;
192
193 charjModifierList
194     :   ^(CHARJ_MODIFIER_LIST charjModifier*)
195     ;
196
197 otherModifierList
198     :   ^(OTHER_MODIFIER_LIST otherModifier*)
199     ;
200     
201 localModifier
202     :   FINAL
203     |   STATIC
204     |   VOLATILE
205     ;
206
207 accessModifier
208     :   PUBLIC
209     |   PROTECTED
210     |   PRIVATE
211     ;
212
213 charjModifier
214     :   ENTRY
215     |   SDAGENTRY
216     |   TRACED
217     ;
218
219 otherModifier
220     :   ABSTRACT
221     |   NATIVE
222     ;
223
224 entryArgType
225     :   simpleType
226     |   entryArgObjectType
227     |   VOID
228     ;
229
230 type
231     :   simpleType
232     |   objectType
233     |   VOID
234     ;
235
236 simpleType returns [ClassSymbol type]
237     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
238     ;
239     
240 objectType returns [ClassSymbol type]
241     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
242     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
243     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
244     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
245     ;
246
247 entryArgObjectType returns [ClassSymbol type]
248     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
249     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
250     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
251     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
252     ;
253
254 qualifiedTypeIdent returns [ClassSymbol type]
255     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
256     ;
257
258 typeIdent returns [String name]
259     :   ^(IDENT templateInstantiation?)
260     ;
261
262 primitiveType
263     :   BOOLEAN
264     |   CHAR
265     |   BYTE
266     |   SHORT
267     |   INT
268     |   LONG
269     |   FLOAT
270     |   DOUBLE
271     ;
272
273 genericTypeArgumentList
274     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
275     ;
276     
277 genericTypeArgument
278     :   type
279     |   '?'
280     ;
281
282 formalParameterList
283     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
284     ;
285
286 formalParameterStandardDecl
287     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
288     ;
289
290 entryFormalParameterList
291     :   ^(FORMAL_PARAM_LIST entryFormalParameterStandardDecl* formalParameterVarargDecl?) 
292     ;
293
294 entryFormalParameterStandardDecl
295     :   ^(FORMAL_PARAM_STD_DECL localModifierList? entryArgType variableDeclaratorId)
296     ;
297     
298 formalParameterVarargDecl
299     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
300     ;
301     
302 // FIXME: is this rule right? Verify that this is ok, I expected something like:
303 // IDENT (^(DOT qualifiedIdentifier IDENT))*
304 qualifiedIdentifier
305     :   IDENT
306     |   ^(DOT qualifiedIdentifier IDENT)
307     ;
308     
309 block
310     :   ^(BLOCK (blockStatement)*)
311     ;
312     
313 blockStatement
314     :   localVariableDeclaration
315     |   statement
316     ;
317     
318 localVariableDeclaration
319     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
320     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
321     ;
322
323 statement
324     : nonBlockStatement
325     | sdagStatement
326     | block
327     ;
328
329 divconBlock
330     :   ^(DIVCON_BLOCK divconExpr)
331     ;
332
333 divconAssignment
334     :   ^(LET_ASSIGNMENT IDENT expression)
335     ;
336
337 divconAssignmentList
338     :   divconAssignment+
339     ;
340
341 divconExpr
342     :   ^(IF parenthesizedExpression divconExpr divconExpr?)
343     |   ^(LET divconAssignmentList IN divconExpr)
344     |   expression
345     ;
346
347 sdagStatement
348     :   ^(OVERLAP block)
349     |   ^(WHEN (IDENT expression? formalParameterList)* block)
350     ;
351
352 nonBlockStatement
353     :   ^(ASSERT expression expression?)
354     |   ^(IF parenthesizedExpression block block?)
355     |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
356     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
357     |   ^(WHILE parenthesizedExpression block)
358     |   ^(DO block parenthesizedExpression)
359     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
360     |   ^(RETURN expression?)
361     |   ^(THROW expression)
362     |   ^(BREAK IDENT?) 
363     |   ^(CONTINUE IDENT?) 
364     |   ^(LABELED_STATEMENT IDENT statement)
365     |   expression
366     |   ^('delete' expression)
367     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
368     |   ';' // Empty statement.
369     |   ^(PRINT expression*)
370     |   ^(PRINTLN expression*)
371     |   ^(EXIT expression?)
372     |   EXITALL
373     ;
374         
375 switchCaseLabel
376     :   ^(CASE expression blockStatement*)
377     |   ^(DEFAULT blockStatement*)
378     ;
379     
380 forInit
381     :   localVariableDeclaration 
382     |   expression+
383     ;
384     
385 // EXPRESSIONS
386
387 parenthesizedExpression
388     :   ^(PAREN_EXPR expression)
389     ;
390     
391 expression
392     :   ^(EXPR expr)
393     ;
394
395 expr
396     :   ^(ASSIGNMENT expr expr)
397     |   ^(PLUS_EQUALS expr expr)
398     |   ^(MINUS_EQUALS expr expr)
399     |   ^(TIMES_EQUALS expr expr)
400     |   ^(DIVIDE_EQUALS expr expr)
401     |   ^(AND_EQUALS expr expr)
402     |   ^(OR_EQUALS expr expr)
403     |   ^(POWER_EQUALS expr expr)
404     |   ^(MOD_EQUALS expr expr)
405     |   ^('>>>=' expr expr)
406     |   ^('>>=' expr expr)
407     |   ^('<<=' expr expr)
408     |   ^('?' expr expr expr)
409     |   ^(OR expr expr)
410     |   ^(AND expr expr)
411     |   ^(BITWISE_OR expr expr)
412     |   ^(POWER expr expr)
413     |   ^(BITWISE_AND expr expr)
414     |   ^(EQUALS expr expr)
415     |   ^(NOT_EQUALS expr expr)
416     |   ^(INSTANCEOF expr type)
417     |   ^(LTE expr expr)
418     |   ^(GTE expr expr)
419     |   ^('>>>' expr expr)
420     |   ^('>>' expr expr)
421     |   ^(GT expr expr)
422     |   ^('<<' expr expr)
423     |   ^(LT expr expr)
424     |   ^(PLUS expr expr)
425     |   ^(MINUS expr expr)
426     |   ^(TIMES expr expr)
427     |   ^(DIVIDE expr expr)
428     |   ^(MOD expr expr)
429     |   ^(UNARY_PLUS expr)
430     |   ^(UNARY_MINUS expr)
431     |   ^(PRE_INC expr)
432     |   ^(PRE_DEC expr)
433     |   ^(POST_INC expr)
434     |   ^(POST_DEC expr)
435     |   ^(TILDE expr)
436     |   ^(NOT expr)
437     |   ^(CAST_EXPR type expr)
438     |   primaryExpression
439     ;
440     
441 primaryExpression
442     :   ^(DOT primaryExpression
443                 (   IDENT
444                 |   THIS
445                 |   SUPER
446                 )
447         )
448     |   ^(ARROW primaryExpression
449                 (   IDENT
450                 |   THIS
451                 |   SUPER
452                 )
453         )
454     |   parenthesizedExpression
455     |   IDENT
456     |   CHELPER
457     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
458     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
459     |   explicitConstructorCall
460     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
461     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
462     |   literal
463     |   newExpression
464     |   THIS
465     |   arrayTypeDeclarator
466     |   SUPER
467     |   GETNUMPES
468     |   GETNUMNODES
469     |   GETMYPE
470     |   GETMYNODE
471     |   GETMYRANK
472         |       THISINDEX
473         |       THISPROXY
474     |   domainExpression
475     ;
476     
477 explicitConstructorCall
478     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
479     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
480     ;
481
482 arrayTypeDeclarator
483     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
484     ;
485
486 newExpression
487     :   ^(NEW_EXPRESSION arguments? domainExpression)
488     |   ^(NEW type arguments)
489     ;
490
491 arguments
492     :   ^(ARGUMENT_LIST expression*)
493     ;
494
495 entryArguments
496     :   ^(ARGUMENT_LIST entryArgExpr*)
497     ;
498
499 entryArgExpr
500     :   ^(EXPR entryExpr)
501     ;
502
503 entryExpr
504     :   ^(ASSIGNMENT expr expr)
505     |   ^(PLUS_EQUALS expr expr)
506     |   ^(MINUS_EQUALS expr expr)
507     |   ^(TIMES_EQUALS expr expr)
508     |   ^(DIVIDE_EQUALS expr expr)
509     |   ^(AND_EQUALS expr expr)
510     |   ^(OR_EQUALS expr expr)
511     |   ^(POWER_EQUALS expr expr)
512     |   ^(MOD_EQUALS expr expr)
513     |   ^('>>>=' expr expr)
514     |   ^('>>=' expr expr)
515     |   ^('<<=' expr expr)
516     |   ^('?' expr expr expr)
517     |   ^(OR expr expr)
518     |   ^(AND expr expr)
519     |   ^(BITWISE_OR expr expr)
520     |   ^(POWER expr expr)
521     |   ^(BITWISE_AND expr expr)
522     |   ^(EQUALS expr expr)
523     |   ^(NOT_EQUALS expr expr)
524     |   ^(INSTANCEOF expr type)
525     |   ^(LTE expr expr)
526     |   ^(GTE expr expr)
527     |   ^('>>>' expr expr)
528     |   ^('>>' expr expr)
529     |   ^(GT expr expr)
530     |   ^('<<' expr expr)
531     |   ^(LT expr expr)
532     |   ^(PLUS expr expr)
533     |   ^(MINUS expr expr)
534     |   ^(TIMES expr expr)
535     |   ^(DIVIDE expr expr)
536     |   ^(MOD expr expr)
537     |   ^(UNARY_PLUS expr)
538     |   ^(UNARY_MINUS expr)
539     |   ^(PRE_INC expr)
540     |   ^(PRE_DEC expr)
541     |   ^(POST_INC expr)
542     |   ^(POST_DEC expr)
543     |   ^(TILDE expr)
544     |   ^(NOT expr)
545     |   ^(CAST_EXPR type expr)
546     |   entryPrimaryExpression
547     ;
548     
549 entryPrimaryExpression
550     :   ^(DOT primaryExpression
551                 (   IDENT
552                 |   THIS
553                 |   SUPER
554                 )
555         )
556     |   ^(ARROW primaryExpression
557                 (   IDENT
558                 |   THIS
559                 |   SUPER
560                 )
561         )
562     |   parenthesizedExpression
563     |   IDENT
564         {
565             //System.out.println("Derefing ID with type " + $IDENT.symbolType.getClass().getName() +
566             //    ":\n" + $IDENT.symbolType + "\nand def info " + $IDENT.def.getClass().getName() + ":\n" + $IDENT.def);
567             if ($IDENT.symbolType instanceof ClassSymbol) {
568                 if (!((ClassSymbol)$IDENT.symbolType).isPrimitive) {
569                     astmod.makePointerDereference($IDENT);
570                 }
571             }
572         }
573     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
574     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
575     |   explicitConstructorCall
576     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
577     |   literal
578     |   newExpression
579         ->  ^(POINTER_DEREFERENCE newExpression)
580     |   THIS
581         ->  ^(POINTER_DEREFERENCE THIS)
582     |   arrayTypeDeclarator
583     |   SUPER
584     |   GETNUMPES
585     |   GETNUMNODES
586     |   GETMYPE
587     |   GETMYNODE
588     |   GETMYRANK
589     |   domainExpression
590     ;
591
592 literal 
593     :   HEX_LITERAL
594     |   OCTAL_LITERAL
595     |   DECIMAL_LITERAL
596     |   FLOATING_POINT_LITERAL
597     |   CHARACTER_LITERAL
598     |   STRING_LITERAL          
599     |   TRUE
600     |   FALSE
601     |   NULL 
602     ;
603
604 rangeItem
605     :   DECIMAL_LITERAL
606     |   IDENT
607     ;
608
609 rangeExpression
610     :   ^(RANGE_EXPRESSION rangeItem)
611     |   ^(RANGE_EXPRESSION rangeItem rangeItem)
612     |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
613     ;
614
615 rangeList
616     :   rangeExpression+
617     ;
618
619 domainExpression
620     :   ^(DOMAIN_EXPRESSION rangeList)
621     ;