Fixed small conflicts in Translator.
[charm.git] / src / langs / charj / src / charj / translator / CharjEmitter.g
1 /**
2  * ANTLR (v3) Tree Parser for the Charj Language
3  */
4
5 tree grammar CharjEmitter;
6
7 options {
8     backtrack = true; 
9     memoize = true;
10     tokenVocab = Charj;
11     ASTLabelType = CharjAST;
12     output = template;
13 }
14
15
16 @header {
17 package charj.translator;
18 }
19
20
21 @members {
22     SymbolTable symtab = null;
23
24     PackageScope currentPackage = null;
25     ClassSymbol currentClass = null;
26     MethodSymbol currentMethod = null;
27     LocalScope currentLocalScope = null;
28
29     Translator translator_;
30     OutputMode mode_;
31
32     private boolean emitCC() { return mode_ == OutputMode.cc; }
33     private boolean emitCI() { return mode_ == OutputMode.ci; }
34     private boolean emitH() { return mode_ == OutputMode.h; }
35     private boolean debug() { return translator_.debug(); }
36     private String basename() { return translator_.basename(); }
37
38     /**
39      *  Override ANTLR's token mismatch behavior so we throw exceptions early.
40      */
41     protected void mismatch(IntStream input, int ttype, BitSet follow)
42         throws RecognitionException {
43         throw new MismatchedTokenException(ttype, input);
44     }
45
46     /**
47      *  Override ANTLR's set mismatch behavior so we throw exceptions early.
48      */
49     public Object recoverFromMismatchedSet(IntStream input, RecognitionException e, BitSet follow)
50         throws RecognitionException {
51         throw e;
52     }
53
54     /**
55      *  Test a list of CharjAST nodes to see if any of them has the given token
56      *  type.
57      */
58     public boolean listContainsToken(List<CharjAST> list, int tokenType) {
59         if (list == null) return false;
60         for (CharjAST node : list) {
61             if (node.token.getType() == tokenType) {
62                 return true;
63             }
64         }
65         return false;
66     }
67 }
68
69
70 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
71 @rulecatch {
72     catch (RecognitionException re) {
73         reportError(re);
74         throw re;
75     }
76 }
77
78
79 // Starting point for parsing a Charj file.
80 charjSource[SymbolTable symtab, OutputMode m]
81 @init {
82     this.symtab = symtab;
83     this.translator_ = symtab.translator;
84     this.mode_ = m;
85 }
86     :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
87         (i+=importDeclaration)*
88         (r+=readonlyDeclaration)*
89         (t+=typeDeclaration)*)
90         -> {emitCC()}? charjSource_cc(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
91         -> {emitCI()}? charjSource_ci(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
92         -> {emitH()}? charjSource_h(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
93         ->
94     ;
95
96 topLevelDeclaration
97     :   importDeclaration -> {$importDeclaration.st;}
98     |   typeDeclaration -> {$typeDeclaration.st;}
99     ;
100
101 packageDeclaration returns [List names]
102     :   ^('package' (ids+=IDENT)+)
103         {
104             $names = $ids;
105         }
106         ->
107     ;
108
109 readonlyDeclaration
110     :   ^(READONLY lvd=localVariableDeclaration)
111         -> {emitCI()}? template(bn={basename()}, v={$lvd.st}) "readonly <v>"
112         -> {emitH()}? template(v={$lvd.st}) "extern <v>"
113         -> {emitCC()}? {$lvd.st;}
114         ->
115     ;
116     
117 importDeclaration
118 @init {
119     String importID = null;
120 }
121     :   ^('import' qualifiedIdentifier ds='.*'?)
122         {
123             importID = $qualifiedIdentifier.text;
124             if ($ds != null) {
125             }
126         }
127         {$ds == null}? // TODO: add support for importing x.*
128         -> {(emitCC() || emitH())}? importDeclaration_cc_h(
129             inc_id={importID.replace(".","/")},
130             use_id={importID.replace(".","::")})
131         ->
132     ;
133     
134 typeDeclaration
135     :   ^(TYPE CLASS IDENT (^('extends' su=type))? (^('implements' type+))?
136         {
137             currentClass = (ClassSymbol)$IDENT.symbol;
138         }
139         (csds+=classScopeDeclaration)*)
140         -> {emitCC()}? classDeclaration_cc(
141                 sym={currentClass},
142                 ident={$IDENT.text}, 
143                 ext={$su.st}, 
144                 csds={$csds})
145         -> {emitH()}?  classDeclaration_h(
146                 sym={currentClass},
147                 ident={$IDENT.text}, 
148                 ext={$su.st}, 
149                 csds={$csds})
150         ->
151     |   ^('template' (i0+=IDENT*) ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*))
152         -> {emitH()}? templateDeclaration_h(
153             tident={$i0},
154             ident={$i1.text},
155             ext={$su.st},
156             csds={$csds})
157         -> 
158     |   ^(INTERFACE IDENT (^('extends' type+))? interfaceScopeDeclaration*)
159         -> template(t={$text}) "/*INTERFACE-not implemented*/ <t>"
160     |   ^(ENUM IDENT (^('implements' type+))? classScopeDeclaration*)
161         -> template(t={$text}) "/*ENUM-not implemented*/ <t>"
162     |   ^(TYPE chareType IDENT (^('extends' type))? (^('implements' type+))?
163         {
164             currentClass = (ClassSymbol)$IDENT.symbol;
165         }
166         (csds+=classScopeDeclaration)*)
167         -> {emitCC()}? chareDeclaration_cc(
168                 sym={currentClass},
169                 ident={$IDENT.text}, 
170                 ext={$su.st}, 
171                 csds={$csds})
172         -> {emitCI()}? chareDeclaration_ci(
173                 sym={currentClass},
174                 chareType={$chareType.st},
175                 arrayDim={null},
176                 ident={$IDENT.text}, 
177                 ext={$su.st}, 
178                 csds={$csds})
179         -> {emitH()}? chareDeclaration_h(
180                 sym={currentClass},
181                 ident={$IDENT.text}, 
182                 ext={$su.st}, 
183                 csds={$csds})
184         ->
185     ;
186
187 chareType
188 @init {
189 $st = %{$start.getText()};
190 }
191     :   CHARE
192     |   GROUP
193     |   NODEGROUP
194     |   MAINCHARE
195     |   ^(CHARE_ARRAY ARRAY_DIMENSION)
196         -> template(t={$ARRAY_DIMENSION.text}) "array [<t>]"
197     ;
198
199 enumConstant
200     :   ^(IDENT arguments?)
201         -> template(t={$text}) "/*enumConstant-not implemented*/ <t>"
202     ;
203
204 classScopeDeclaration
205 @init
206 {
207     boolean entry = false;
208     boolean migrationCtor = false;
209 }
210     :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
211             ty=type IDENT f=formalParameterList
212             b=block?)
213         -> {emitCC()}? funcMethodDecl_cc(
214                 sym={currentClass},
215                 modl={$m.st}, 
216                 gtpl={$g.st}, 
217                 ty={$ty.st},
218                 id={$IDENT.text}, 
219                 fpl={$f.st}, 
220                 block={$b.st})
221         -> {emitH()}? funcMethodDecl_h(
222                 modl={$m.st}, 
223                 gtpl={$g.st}, 
224                 ty={$ty.st},
225                 id={$IDENT.text}, 
226                 fpl={$f.st}, 
227                 block={$b.st})
228         -> {emitCI()}? // do nothing, since it's not an entry method
229         ->
230     |   ^(ENTRY_FUNCTION_DECL m=modifierList? g=genericTypeParameterList? 
231             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
232             b=block?)
233         -> {emitCC()}? funcMethodDecl_cc(
234                 sym={currentClass},
235                 modl={$m.st}, 
236                 gtpl={$g.st}, 
237                 ty={$ty.st},
238                 id={$IDENT.text}, 
239                 fpl={$f.st}, 
240                 adl={$a.st},
241                 block={$b.st})
242         -> {emitH()}? funcMethodDecl_h(
243                 modl={$m.st}, 
244                 gtpl={$g.st}, 
245                 ty={$ty.st},
246                 id={$IDENT.text}, 
247                 fpl={$f.st}, 
248                 adl={$a.st},
249                 block={$b.st})
250         -> {emitCI()}? funcMethodDecl_ci(
251                 modl={$m.st}, 
252                 gtpl={$g.st}, 
253                 ty={$ty.st},
254                 id={$IDENT.text}, 
255                 fpl={$f.st}, 
256                 block={$b.st})
257         ->
258     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[null, false])
259         -> {emitH()}? class_var_decl(
260             modl={$modifierList.st},
261             type={$simpleType.st},
262             declList={$variableDeclaratorList.st})
263         ->
264     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
265         -> {emitH()}? class_var_decl(
266             modl={$modifierList.st},
267             type={$objectType.st},
268             declList={$variableDeclaratorList.st})
269         ->
270     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList b=block)
271         -> {emitCC()}? ctorDecl_cc(
272                 modl={$m.st},
273                 gtpl={$g.st}, 
274                 id={$IDENT.text}, 
275                 fpl={$f.st}, 
276                 block={$b.st})
277         -> {emitCI()}? // do nothing, it's not an entry constructor
278         -> {emitH()}? ctorDecl_h(
279                 modl={$m.st},
280                 gtpl={$g.st}, 
281                 id={$IDENT.text}, 
282                 fpl={$f.st}, 
283                 block={$b.st})
284         ->
285     |   ^(ENTRY_CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList b=block)
286         {
287             migrationCtor = currentClass.migrationCtor == $ENTRY_CONSTRUCTOR_DECL;
288         }
289         -> {emitCC()}? ctorDecl_cc(
290                 modl={$m.st},
291                 gtpl={$g.st}, 
292                 id={$IDENT.text}, 
293                 fpl={$f.st}, 
294                 block={$b.st})
295         -> {emitCI() && !migrationCtor}? ctorDecl_ci(
296                 modl={$m.st},
297                 gtpl={$g.st}, 
298                 id={$IDENT.text}, 
299                 fpl={$f.st}, 
300                 block={$b.st})
301         -> {emitH()}? ctorDecl_h(
302                 modl={$m.st},
303                 gtpl={$g.st}, 
304                 id={$IDENT.text}, 
305                 fpl={$f.st}, 
306                 block={$b.st})
307         ->
308     ;
309     
310 interfaceScopeDeclaration
311     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT formalParameterList)
312         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
313     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[$simpleType.st, false])
314         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
315     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
316         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
317     ;
318
319 variableDeclaratorList[StringTemplate obtype, boolean output]
320     :   ^(VAR_DECLARATOR_LIST (var_decls+=variableDeclarator[obtype, output])+ )
321         -> var_decl_list(var_decls={$var_decls})
322     ;
323
324 variableDeclarator[StringTemplate obtype, boolean output]
325     :   ^(VAR_DECLARATOR id=variableDeclaratorId[output] initializer=variableInitializer[obtype, output]?)
326         -> {$output && emitCC()}? var_decl_cc(id={$id.st}, initializer={$initializer.st})
327         -> {$output && emitH()}?  var_decl_h(id={$id.st}, initializer={$initializer.st})
328         -> {$output && emitCI()}? var_decl_ci(id={$id.st}, initializer={$initializer.st})
329         -> {!$output && emitCC()}? var_decl_cc(id={$id.st})
330         -> {!$output && emitH()}?  var_decl_h(id={$id.st})
331         -> {!$output && emitCI()}? var_decl_ci(id={$id.st})
332         ->
333     ; 
334     
335 variableDeclaratorId[boolean output]
336     :   ^(IDENT de=domainExpression[null]?)
337         -> {$output}? var_decl_id(id={$IDENT.text}, domainExp={$de.st})
338         -> {!$output}? var_decl_id(id={$IDENT.text})
339         ->
340     ;
341
342 variableInitializer[StringTemplate obtype, boolean output]
343     :   arrayInitializer
344         -> {$arrayInitializer.st}
345     |   newExpression[obtype, output]
346         -> {$newExpression.st}
347     |   expression
348         -> {$expression.st}
349     ;
350
351 rangeItem
352     :   dl=DECIMAL_LITERAL
353         -> template(t={$dl.text}) "<t>"
354     |   IDENT
355         -> template(t={$IDENT.text}) "<t>"
356     ;
357
358 rangeExpression
359     :   ^(RANGE_EXPRESSION (ri+=rangeItem)*)
360         -> template(t={$ri}) "Range(<t; separator=\",\">)"
361     ;
362
363 rangeList returns [int len]
364     :   (r+=rangeExpression)*
365         { $len = $r.size(); }
366         -> template(t={$r}) "<t; separator=\", \">"
367         
368     ;
369
370 domainExpression[List<StringTemplate> otherParams]
371     :   ^(DOMAIN_EXPRESSION rl=rangeList)
372         -> range_constructor(range={$rl.st}, others={$otherParams}, len={$rl.len})
373
374     ;
375
376 /*arrayDeclaratorList
377     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
378         -> template(t={$text}) "<t>"
379     ;*/
380     
381 arrayInitializer
382     :   ^(ARRAY_INITIALIZER variableInitializer[null, false]*)
383         -> template(t={$text}) "/* arrayInitializer-not implemented */ <t>"
384     ;
385
386 genericTypeParameterList
387     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
388         -> template(t={$text}) "/*GENERIC_TYPE_PARAM_LIST-not implemented*/ <t>"
389     ;
390
391 genericTypeParameter
392     :   ^(IDENT bound?)
393         -> template(t={$text}) "/*genericTypeParameter-not implemented*/ <t>"
394     ;
395         
396 bound
397     :   ^(EXTENDS_BOUND_LIST type+)
398         -> template(t={$text}) "/*EXTENDS_BOUND_LIST-not implemented*/ <t>"
399     ;
400
401 throwsClause
402     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
403         -> template(t={$text}) "/* throwsClause-not implemented */ <t>"
404     ;
405
406 modifierList
407     :   ^(MODIFIER_LIST accessModifierList? localModifierList? charjModifierList? otherModifierList?)
408         ->  {emitCC()}? mod_list_cc(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
409         ->  {emitH()}? mod_list_h(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
410         ->  {emitCI()}? mod_list_ci(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
411         ->
412     ;
413
414 modifier
415     :   accessModifier
416     |   localModifier
417     |   charjModifier
418     |   otherModifier
419     ;
420
421 accessModifierList
422 returns [List names]
423     :   ^(ACCESS_MODIFIER_LIST (m+=accessModifier)+)
424         {
425             $names = $m;
426         }
427     ;
428 localModifierList
429 returns [List names]
430     :   ^(LOCAL_MODIFIER_LIST (m+=localModifier)+)
431         {
432             $names = $m;
433         }
434         ->  local_mod_list(mods = {$names})
435     ;
436
437 charjModifierList
438 returns [List names]
439     :   ^(CHARJ_MODIFIER_LIST (m+=charjModifier)+)
440         {
441             $names = $m;
442         }
443     ;
444
445 otherModifierList
446 returns [List names]
447     :   ^(OTHER_MODIFIER_LIST (m+=otherModifier)+)
448         {
449             $names = $m;
450         }
451     ;
452     
453 localModifier
454 @init
455 {
456     $st = %{$start.getText()};
457 }
458     :   FINAL
459     |   STATIC
460     |   VOLATILE
461     ;
462
463 accessModifier
464 @init
465 {
466     $st = %{$start.getText()};
467 }
468     :   PUBLIC
469     |   PROTECTED
470     |   PRIVATE
471     ;
472
473 charjModifier
474 @init
475 {
476     $st = %{$start.getText()};
477 }
478     :   ENTRY
479     ;
480
481 otherModifier
482 @init
483 {
484     $st = %{$start.getText()};
485 }
486     :   ABSTRACT
487     |   NATIVE
488     ;
489     
490 type
491     :   simpleType
492         -> {$simpleType.st}
493     |   objectType 
494         -> {$objectType.st}
495     |   VOID
496         {
497             $st = %{$start.getText()};
498         }
499     ;
500
501 simpleType
502     :   ^(SIMPLE_TYPE primitiveType domainExpression[null]?)
503         -> simple_type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
504     ;
505
506 objectType
507     : proxyType -> {$proxyType.st;}
508     | nonProxyType -> {$nonProxyType.st}
509     ;
510
511 nonProxyType
512     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression[null]?)
513         -> obj_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
514     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression[null]?)
515         -> pointer_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
516     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression[null]?)
517         -> reference_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
518     ;
519
520 proxyType
521     :   ^(PROXY_TYPE qualifiedTypeIdent domainExpression[null]?)
522         -> proxy_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
523     ;
524
525 qualifiedTypeIdent returns [ClassSymbol type]
526     :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+)
527         {$type = (ClassSymbol)$QUALIFIED_TYPE_IDENT.symbol;}
528         -> template(types={$t}) "<types; separator=\"::\">"
529     ;
530
531 typeIdent
532     :   ^(IDENT templateInstantiation?)
533         -> typeIdent(typeID={$IDENT.text}, generics={$templateInstantiation.st})
534     ;
535
536 primitiveType
537 @init {
538 $st = %{$start.getText()};
539 }
540     :   BOOLEAN
541         -> template() "bool"
542     |   CHAR
543     |   BYTE
544         -> template() "char"
545     |   SHORT
546     |   INT
547     |   LONG
548     |   FLOAT
549     |   DOUBLE
550     ;
551
552 templateArg
553     :   genericTypeArgument
554         -> {$genericTypeArgument.st}
555     |   literal
556         -> {$literal.st}
557     ;
558
559 templateArgList
560     :   params+=templateArg+
561         -> template(params={$params}) "<params; separator=\", \">"
562     ;
563
564 templateInstantiation
565     :   ^(TEMPLATE_INST templateArgList)
566         -> template(args={$templateArgList.st}) "\<<args>\>"
567     |   ^(TEMPLATE_INST ts=templateInstantiation)
568         -> template(inst={$ts.st}) "\<<inst>\>"
569     ;
570
571 genericTypeArgumentList
572     :   ^(GENERIC_TYPE_ARG_LIST (gta+=genericTypeArgument)+)
573         -> template(gtal={$gta}) "\<<gtal; separator=\", \">\>"
574     ;
575
576 genericTypeArgument
577     :   type
578         -> {$type.st}
579     |   '?'
580         -> template(t={$text}) "/* genericTypeArgument: wildcard bound types not implemented */ <t>"
581     ;
582
583 formalParameterList
584     :   ^(FORMAL_PARAM_LIST (fpsd+=formalParameterStandardDecl)* fpvd=formalParameterVarargDecl?)
585         -> formal_param_list(sdecl={$fpsd}, vdecl={$fpvd.st})
586     ;
587     
588 formalParameterStandardDecl
589     :   ^(FORMAL_PARAM_STD_DECL lms=localModifierList? t=type vdid=variableDeclaratorId[true])
590         -> formal_param_decl(modList={$lms.st}, type={$t.st}, declID={$vdid.st})
591     ;
592     
593 formalParameterVarargDecl
594     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId[true])
595         -> template(t={$text}) "/*formal parameter varargs not implemented*/ <t>"
596     ;
597     
598 qualifiedIdentifier
599     :   IDENT
600         -> template(t={$text}) "<t>"
601     |   ^(DOT qualifiedIdentifier IDENT)
602         -> template(t={$text}) "<t>"
603     ;
604     
605 block
606 @init { boolean emptyBlock = true; }
607     :   ^(BLOCK (b+=blockStatement)*)
608         { emptyBlock = ($b == null || $b.size() == 0); }
609         -> {emitCC() && emptyBlock}? template(bsl={$b}) "{ }"
610         -> {emitCC()}? block_cc(bsl={$b})
611         ->
612     ;
613     
614 blockStatement
615     :   localVariableDeclaration
616         -> {$localVariableDeclaration.st}
617     |   statement
618         -> {$statement.st}
619     ;
620
621
622 localVariableDeclaration
623     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType vdl=variableDeclaratorList[null, true])
624         -> local_var_decl(
625             modList={$localModifierList.st},
626             type={$simpleType.st},
627             declList={$vdl.st})
628     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType vdl=variableDeclaratorList[$objectType.st, true])
629         -> local_var_decl(
630             modList={$localModifierList.st},
631             type={$objectType.st},
632             declList={$vdl.st})
633     ;
634
635
636 statement
637     :   nonBlockStatement
638         -> {$nonBlockStatement.st}
639     |   block
640         -> {$block.st}
641     ;
642
643 nonBlockStatement
644     :   ^(ASSERT cond=expression msg=expression?)
645         -> assert(cond={$cond.st}, msg={$msg.st})
646     |   ^(IF parenthesizedExpression then=block else_=block?)
647         -> if(cond={$parenthesizedExpression.st}, then={$then.st}, else_={$else_.st})
648     |   ^(FOR forInit? FOR_EXPR cond=expression? FOR_UPDATE (update+=expression)* b=block)
649         -> for(initializer={$forInit.st}, cond={$cond.st}, update={$update}, body={$block.st})
650     |   ^(FOR_EACH localModifierList? type IDENT expression block) 
651         -> template(t={$text}) "/* foreach not implemented */ <t>"
652     |   ^(WHILE pe=parenthesizedExpression b=block)
653         -> while(cond={$pe.st}, body={$b.st})
654     |   ^(DO b=block pe=parenthesizedExpression)
655         -> dowhile(cond={$pe.st}, block={$b.st})
656     |   ^(SWITCH pe=parenthesizedExpression (scls+=switchCaseLabel)*)
657         -> switch(expr={$pe.st}, labels={$scls})
658     |   ^(RETURN e=expression?)
659         -> return(val={$e.st})
660     |   ^(THROW expression)
661         -> template(t={$text}) "/* throw not implemented */ <t>"
662     |   ^(BREAK IDENT?)
663         -> template() "break;" // TODO: support labeling
664     |   ^(CONTINUE IDENT?)
665         -> template() "continue;" // TODO: support labeling
666     |   ^(LABELED_STATEMENT i=IDENT s=statement)
667         -> label(text={$i.text}, stmt={$s.st})
668     |   expression
669         -> template(expr={$expression.st}) "<expr>;"
670     |   ^('delete' qualifiedIdentifier)
671         -> template(t={$qualifiedIdentifier.st}) "delete <t>;"
672     |   ^('embed' STRING_LITERAL EMBED_BLOCK)
673         ->  embed_cc(str={$STRING_LITERAL.text}, blk={$EMBED_BLOCK.text})
674     |   ';' // Empty statement.
675         -> {%{$start.getText()}}
676     |   ^(PRINT (exprs += expression)*)
677         ->  print(exprs = {$exprs})
678     |   ^(PRINTLN (exprs += expression)*)
679         ->  println(exprs = {$exprs})
680     |   ^(EXIT expression?)
681         ->  exit(expr = {$expression.st})
682     |   EXITALL
683         ->  exitall()
684     ;
685         
686 switchCaseLabel
687     :   ^(CASE expression (b+=blockStatement)*)
688         -> case(expr={$expression.st}, block={$b})
689     |   ^(DEFAULT (b+=blockStatement)*)
690         -> template(block={$b}) "default: <block>"
691     ;
692     
693 forInit
694     :   localVariableDeclaration
695         -> template(lvd={$localVariableDeclaration.st}) "<lvd>"
696     |   (ex+=expression)+
697         -> template(ex={$ex}) "<ex; separator=\", \">"
698     ;
699
700 // EXPRESSIONS
701
702 parenthesizedExpression
703     :   ^(PAREN_EXPR exp=expression)
704         -> template(expr={$exp.st}) "(<expr>)"
705     ;
706     
707 expression
708     :   ^(EXPR expr)
709         -> {$expr.st}
710     |   domainExpression[null]
711         -> {$domainExpression.st}
712     ;
713
714 expr
715     :   ^(ASSIGNMENT e1=expr e2=expr)
716         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> = <e2>"
717     |   ^('+=' e1=expr e2=expr)
718         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> += <e2>"
719     |   ^('-=' e1=expr e2=expr)
720         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> -= <e2>"
721     |   ^('*=' e1=expr e2=expr)
722         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> *= <e2>"
723     |   ^('/=' e1=expr e2=expr)
724         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> /= <e2>"
725     |   ^('&=' e1=expr e2=expr)
726         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> &= <e2>"
727     |   ^('|=' e1=expr e2=expr)
728         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> |= <e2>"
729     |   ^('^=' e1=expr e2=expr)
730         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^= <e2>"
731     |   ^('%=' e1=expr e2=expr)
732         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> %= <e2>"
733     |   ^('>>>=' e1=expr e2=expr)
734         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>\>= <e2>"
735     |   ^('>>=' e1=expr e2=expr)
736         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>= <e2>"
737     |   ^('<<=' e1=expr e2=expr)
738         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<\<= <e2>"
739     |   ^('?' e1=expr e2=expr e3=expr)
740         -> template(e1={$e1.st}, e2={$e2.st}, e3={$e3.st}) "<e1> ? <e2> : <e3>"
741     |   ^('||' e1=expr e2=expr)
742         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> || <e2>"
743     |   ^('&&' e1=expr e2=expr)
744         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> && <e2>"
745     |   ^(BITWISE_OR e1=expr e2=expr)
746         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> | <e2>"
747     |   ^('^' e1=expr e2=expr)
748         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^ <e2>"
749     |   ^('&' e1=expr e2=expr)
750         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> & <e2>"
751     |   ^(EQUALS e1=expr e2=expr)
752         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> == <e2>"
753     |   ^('!=' e1=expr e2=expr)
754         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> != <e2>"
755     |   ^('instanceof' expr type)
756         -> template(t={$text}) "/* instanceof not implemented */ <t>"
757     |   ^('<=' e1=expr e2=expr)
758         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<= <e2>"
759     |   ^('>=' e1=expr e2=expr)
760         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>= <e2>"
761     |   ^('>>>' e1=expr e2=expr)
762         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>\> <e2>"
763     |   ^('>>' e1=expr e2=expr)
764         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\> <e2>"
765     |   ^('>' e1=expr e2=expr)
766         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \> <e2>"
767     |   ^('<<' e1=expr e2=expr)
768         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<\< <e2>"
769     |   ^('<' e1=expr e2=expr)
770         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \< <e2>"
771     |   ^('+' e1=expr e2=expr)
772         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> + <e2>"
773     |   ^('-' e1=expr e2=expr)
774         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> - <e2>"
775     |   ^('*' e1=expr e2=expr)
776         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> * <e2>"
777     |   ^('/' e1=expr e2=expr)
778         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> / <e2>"
779     |   ^('%' e1=expr e2=expr)
780         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> % <e2>"
781     |   ^(UNARY_PLUS e1=expr)
782         -> template(e1={$e1.st}) "+<e1>"
783     |   ^(UNARY_MINUS e1=expr)
784         -> template(e1={$e1.st}) "-<e1>"
785     |   ^(PRE_INC e1=expr)
786         -> template(e1={$e1.st}) "++<e1>"
787     |   ^(PRE_DEC e1=expr)
788         -> template(e1={$e1.st}) "--<e1>"
789     |   ^(POST_INC e1=expr)
790         -> template(e1={$e1.st}) "<e1>++"
791     |   ^(POST_DEC e1=expr)
792         -> template(e1={$e1.st}) "<e1>--"
793     |   ^(TILDE e1=expr)
794         -> template(e1={$e1.st}) "~<e1>"
795     |   ^(NOT e1=expr)
796         -> template(e1={$e1.st}) "!<e1>"
797     |   ^(CAST_EXPR ty=type e1=expr)
798         -> template(ty={$ty.st}, e1={$e1.st}) "(<ty>)<e1>"
799     |   primaryExpression
800         -> {$primaryExpression.st}
801     |   ^(POINTER_DEREFERENCE e1 = expr)
802         ->  template(e = {$e1.st}) "*(<e>)"
803     ;
804
805 primaryExpression
806     :   ^(DOT prim=primaryExpression
807             ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>.<id>"
808             | THIS    -> template(prim={$prim.st}) "<prim>.this"
809             | SUPER   -> template(prim={$prim.st}) "<prim>.super"
810             )
811         )
812     |   ^(ARROW prim=primaryExpression
813             ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>-><id>"
814             | THIS    -> template(prim={$prim.st}) "<prim>->this"
815             | SUPER   -> template(prim={$prim.st}) "<prim>->super"
816             )
817         )
818     |   parenthesizedExpression
819         -> {$parenthesizedExpression.st}
820     |   IDENT
821         -> {%{$start.getText()}}
822     |   ^(METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
823         -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
824     |   ^(ENTRY_METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
825         -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
826     |   explicitConstructorCall
827         -> {$explicitConstructorCall.st}
828     |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression ex=expression)
829         -> template(pe={$pe.st}, ex={$ex.st}) "<pe>[<ex>]"
830     |   literal
831         -> {$literal.st}
832     |   newExpression[null, false]
833         -> {$newExpression.st}
834     |   THIS
835         -> {%{$start.getText()}}
836     |   arrayTypeDeclarator
837         -> {$arrayTypeDeclarator.st}
838     |   SUPER
839         -> {%{$start.getText()}}
840     |   GETNUMPES
841         ->  template() "CkNumPes()"
842     |   GETNUMNODES
843         ->  template() "CkNumNodes()"
844     |   GETMYPE
845         ->  template() "CkMyPe()"
846     |   GETMYNODE
847         ->  template() "CkMyNode()"
848     |   GETMYRANK
849         ->  template() "CkMyRank()"
850
851     ;
852     
853 explicitConstructorCall
854     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
855         -> template(t={$text}) "<t>"
856     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
857         -> template(t={$text}) "<t>"
858     ;
859
860 arrayTypeDeclarator
861     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
862         -> template(t={$text}) "<t>"
863     ;
864
865 newExpression[StringTemplate obtype, boolean output] returns [StringTemplate initArray]
866     :   ^(NEW_EXPRESSION arguments? domainExpression[$arguments.args])
867         -> {$output}? template(domain={$domainExpression.st},type={$obtype}) "new <type>(<domain>)"
868         -> {!$output}? template() ""
869         ->
870     |   ^(NEW proxyType arguments)
871         -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
872     |   ^(NEW nonProxyType arguments)
873         -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
874     ;
875
876 /*newExpression
877     :   ^(  STATIC_ARRAY_CREATOR
878             (   primitiveType newArrayConstruction
879             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
880             )
881         )
882         -> template(t={$text}) "<t>"
883     |   ^(NEW proxyType arguments)
884         -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
885     |   ^(NEW nonProxyType arguments)
886         -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
887     ;
888 */
889 /*newArrayConstruction
890     :   arrayDeclaratorList arrayInitializer
891         -> array_construction_with_init(
892                 array_decls={$arrayDeclaratorList.st},
893                 initializer={$arrayInitializer.st})
894     |   (ex+=expression)+ adl=arrayDeclaratorList?
895         -> array_construction(exprs={$ex}, array_decls={$adl.st})
896     ;
897 */
898 arguments returns [List<StringTemplate> args]
899 @init {
900     $args = new ArrayList<StringTemplate>();
901 }
902     :   ^(ARGUMENT_LIST (e=expression { $args.add($e.st); } )*)        
903         ->  arguments(exprs={$args})
904     ;
905
906 literal
907 @init {
908 $st = %{$start.getText()};
909 }
910     :   HEX_LITERAL
911     |   OCTAL_LITERAL
912     |   DECIMAL_LITERAL
913     |   FLOATING_POINT_LITERAL
914     |   CHARACTER_LITERAL
915     |   STRING_LITERAL
916     |   TRUE
917     |   FALSE
918     |   NULL
919     ;
920