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