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