ae3dfae78347af2387e321812232cc7582b930e3
[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 @members {
21     SymbolTable symtab_ = null;
22
23     PackageScope currentPackage_ = null;
24     ClassSymbol currentClass_ = null;
25     MethodSymbol currentMethod_ = null;
26     LocalScope currentLocalScope_ = null;
27
28     Translator translator_;
29
30     OutputMode mode_;
31     boolean messageCollectionEnabled_ = false;
32     private boolean hasErrors_ = false;
33     List<String> messages_;
34
35     private boolean emitCC() { return mode_ == OutputMode.cc; }
36     private boolean emitCI() { return mode_ == OutputMode.ci; }
37     private boolean emitH() { return mode_ == OutputMode.h; }
38
39     /**
40      *  Switches error message collection on or off.
41      *
42      *  The standard destination for parser error messages is 
43      *  <code>System.err</code>.
44      *  However, if <code>true</code> gets passed to this method this default
45      *  behaviour will be switched off and all error messages will be collected
46      *  instead of written to anywhere.
47      *
48      *  The default value is <code>false</code>.
49      *
50      *  @param newState  <code>true</code> if error messages should be collected.
51      */
52     public void enableErrorMessageCollection(boolean newState) {
53         messageCollectionEnabled_ = newState;
54         if (messages_ == null && messageCollectionEnabled_) {
55             messages_ = new ArrayList<String>();
56         }
57     }
58     
59     /**
60      *  Collects an error message or passes the error message to <code>
61      *  super.emitErrorMessage(...)</code>.
62      *
63      *  The actual behaviour depends on whether collecting error messages
64      *  has been enabled or not.
65      *
66      *  @param message  The error message.
67      */
68      @Override
69     public void emitErrorMessage(String message) {
70         if (messageCollectionEnabled_) {
71             messages_.add(message);
72         } else {
73             super.emitErrorMessage(message);
74         }
75     }
76     
77     /**
78      *  Returns collected error messages.
79      *
80      *  @return  A list holding collected error messages or <code>null</code> if
81      *           collecting error messages hasn't been enabled. Of course, this
82      *           list may be empty if no error message has been emited.
83      */
84     public List<String> getMessages() {
85         return messages_;
86     }
87     
88     /**
89      *  Tells if parsing a Charj source has caused any error messages.
90      *
91      *  @return  <code>true</code> if parsing a Charj source has caused at 
92      *           least one error message.
93      */
94     public boolean hasErrors() {
95         return hasErrors_;
96     }
97
98     /**
99      *  Test a list of CharjAST nodes to see if any of them has the given token
100      *  type.
101      */
102     public boolean listContainsToken(List<CharjAST> list, int tokenType) {
103         for (CharjAST node : list) {
104             if (node.token.getType() == tokenType) {
105                 return true;
106             }
107         }
108         return false;
109     }
110
111 }
112
113 // Starting point for parsing a Charj file.
114 charjSource[SymbolTable symtab, OutputMode m]
115 @init {
116     this.symtab_ = symtab;
117     this.mode_ = m;
118     String closingBraces = "";
119 }
120     :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
121         (i+=importDeclaration)* 
122         (t=typeDeclaration))
123         //(t+=typeDeclaration)*)
124         {
125             // construct string of }'s to close namespace 
126             if ($p.st != null) {
127                 String temp_p = $p.st.toString();
128                 for (int idx=0; idx<temp_p.length(); ++idx) {
129                     if (temp_p.charAt(idx) == '{') {
130                         closingBraces += "} ";
131                     }
132                 }
133             }
134         }
135         -> {emitCC()}? charjSource_cc(
136             pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces})
137         -> {emitCI()}? charjSource_ci(pd={$p.st}, ids={$i}, tds={$t.st})
138         -> {emitH()}? charjSource_h(
139             pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces})
140         ->
141     ;
142
143 packageDeclaration
144 @init { 
145     List<String> names = null; 
146 }
147     :   ^(PACKAGE qualifiedIdentifier)  {
148             names =  java.util.Arrays.asList(
149                     $qualifiedIdentifier.text.split("[.]"));
150         }
151         -> {(emitCC() || emitH())}? packageDeclaration_cc_h(
152             ids={names})
153         ->
154     ;
155     
156 importDeclaration
157     :   ^(IMPORT STATIC? qualifiedIdentifier DOTSTAR?)
158         -> {(emitCC() || emitH())}? importDeclaration_cc_h(
159             inc_id={$qualifiedIdentifier.text.replace(".","/")},
160             use_id={$qualifiedIdentifier.text.replace(".","::")})
161         ->
162     ;
163     
164 typeDeclaration
165     :   ^(CLASS m=modifierList IDENT g=genericTypeParameterList? 
166                 e=classExtendsClause? i=implementsClause? c=classTopLevelScope) 
167         -> {emitCC()}? classDeclaration_cc(
168                 mod={$m.st}, 
169                 ident={$IDENT.text}, 
170                 gen={$g.st}, 
171                 ext={$e.st}, 
172                 impl={$i.st},
173                 ctls={$c.st})
174         -> {emitCI()}? classDeclaration_ci(
175                 mod={$m.st}, 
176                 ident={$IDENT.text}, 
177                 gen={$g.st}, 
178                 ext={$e.st}, 
179                 impl={$i.st},
180                 ctls={$c.st})
181         -> {emitH()}? classDeclaration_h(
182                 mod={$m.st}, 
183                 ident={$IDENT.text}, 
184                 gen={$g.st}, 
185                 ext={$e.st}, 
186                 impl={$i.st},
187                 ctls={$c.st})
188         ->
189     |   ^(INTERFACE modifierList IDENT genericTypeParameterList? 
190                 interfaceExtendsClause? interfaceTopLevelScope)
191         -> template(t={$text}) "/*INTERFACE*/ <t>"
192     |   ^(ENUM modifierList IDENT implementsClause? enumTopLevelScope)
193         -> template(t={$text}) "/*ENUM*/ <t>"
194     ;
195
196
197 classExtendsClause
198     :   ^(EXTENDS_CLAUSE t=type) 
199         -> {emitCC() || emitH()}? classExtends_cc_h(type={$t.st})
200         -> {emitCI()}? classExtends_ci(type={$t.st})
201         ->
202     ;   
203
204 interfaceExtendsClause 
205     :   ^(EXTENDS_CLAUSE (typeList+=type)+) 
206         -> interfaceExtends(ts={$typeList})
207     ;   
208     
209 implementsClause
210     :   ^(IMPLEMENTS_CLAUSE type+)
211         -> template(t={$text}) "/*IMPLEMENTS_CLAUSE*/ <t>"
212     ;
213         
214 genericTypeParameterList
215     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
216         -> template(t={$text}) "/*GENERIC_TYPE_PARAM_LIST*/ <t>"
217     ;
218
219 genericTypeParameter
220     :   ^(IDENT bound?)
221         -> template(t={$text}) "/*genericTypeParameter*/ <t>"
222     ;
223         
224 bound
225     :   ^(EXTENDS_BOUND_LIST type+)
226         -> template(t={$text}) "/*EXTENDS_BOUND_LIST*/ <t>"
227     ;
228
229 enumTopLevelScope
230     :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
231         -> template(t={$text}) "/*enumTopLevelScope*/ <t>"
232     ;
233     
234 enumConstant
235     :   ^(IDENT arguments? classTopLevelScope?)
236         -> template(t={$text}) "/*enumConstant*/ <t>"
237     ;
238     
239     
240 classTopLevelScope
241     :   ^(CLASS_TOP_LEVEL_SCOPE (csd+=classScopeDeclarations)*) 
242         -> classTopLevelScope(classScopeDeclarations={$csd})
243     ;
244     
245 classScopeDeclarations
246 @init { boolean entry = false; }
247     :   ^(CLASS_INSTANCE_INITIALIZER block)
248         -> template(t={$text}) "/*cii*/ <t>"
249     |   ^(CLASS_STATIC_INITIALIZER block)
250         -> template(t={$text}) "/*csi*/ <t>"
251     |   ^(FUNCTION_METHOD_DECL m=modifierList g=genericTypeParameterList? 
252             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
253             tc=throwsClause? b=block?)
254         { 
255             // determine whether this is an entry method
256             entry = listContainsToken($m.start.getChildren(), ENTRY);
257         }
258         -> {emitCC()}? funcMethodDecl_cc(
259                 modl={$m.st}, 
260                 gtpl={$g.st}, 
261                 ty={$ty.text},
262                 id={$IDENT.text}, 
263                 fpl={$f.st}, 
264                 adl={$a.st},
265                 tc={$tc.st}, 
266                 block={$b.st})
267         -> {emitH()}? funcMethodDecl_h(
268                 modl={$m.st}, 
269                 gtpl={$g.st}, 
270                 ty={$ty.text},
271                 id={$IDENT.text}, 
272                 fpl={$f.st}, 
273                 adl={$a.st},
274                 tc={$tc.st}, 
275                 block={$b.st})
276         -> {(emitCI() && entry)}? funcMethodDecl_ci(
277                 modl={$m.st}, 
278                 gtpl={$g.st}, 
279                 ty={$ty.text},
280                 id={$IDENT.text}, 
281                 fpl={$f.st}, 
282                 adl={$a.st},
283                 tc={$tc.st}, 
284                 block={$b.st})
285         ->
286     |   ^(VOID_METHOD_DECL m=modifierList g=genericTypeParameterList? IDENT 
287             f=formalParameterList t=throwsClause? b=block?)
288         { 
289             // determine whether this is an entry method
290             entry = listContainsToken($m.start.getChildren(), ENTRY);
291         }
292         -> {emitCC()}? voidMethodDecl_cc(
293                 modl={$m.st}, 
294                 gtpl={$g.st}, 
295                 id={$IDENT.text}, 
296                 fpl={$f.st}, 
297                 tc={$t.st}, 
298                 block={$b.st})
299         -> {emitCI() && entry}? voidMethodDecl_ci(
300                 modl={$m.st}, 
301                 gtpl={$g.st}, 
302                 id={$IDENT.text}, 
303                 fpl={$f.st}, 
304                 tc={$t.st}, 
305                 block={$b.st})
306         -> {emitH()}? voidMethodDecl_h(
307                 modl={$m.st}, 
308                 gtpl={$g.st}, 
309                 id={$IDENT.text}, 
310                 fpl={$f.st}, 
311                 tc={$t.st}, 
312                 block={$b.st})
313         ->
314     |   ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType variableDeclaratorList)
315         -> {emitCC() || emitH()}? primitive_var_decl(
316             modList={$modifierList.st},
317             type={$simpleType.st},
318             declList={$variableDeclaratorList.st})
319         ->
320     |   ^(OBJECT_VAR_DECLARATION modifierList objectType variableDeclaratorList)
321         -> {emitCC() || emitH()}? object_var_decl(
322             modList={$modifierList.st},
323             type={$objectType.st},
324             declList={$variableDeclaratorList.st})
325         ->
326     |   ^(CONSTRUCTOR_DECL m=modifierList g=genericTypeParameterList? IDENT f=formalParameterList 
327             t=throwsClause? b=block)
328         { 
329             // determine whether this is an entry method
330             entry = listContainsToken($m.start.getChildren(), ENTRY);
331         }
332         -> {emitCC()}? ctorDecl_cc(
333                 modl={$m.st}, 
334                 gtpl={$g.st}, 
335                 id={$IDENT.text}, 
336                 fpl={$f.st}, 
337                 tc={$t.st}, 
338                 block={$b.st})
339         -> {emitCI() && entry}? ctorDecl_ci(
340                 modl={$m.st}, 
341                 gtpl={$g.st}, 
342                 id={$IDENT.text}, 
343                 fpl={$f.st}, 
344                 tc={$t.st}, 
345                 block={$b.st})
346         -> {emitH()}? ctorDecl_h(
347                 modl={$m.st}, 
348                 gtpl={$g.st}, 
349                 id={$IDENT.text}, 
350                 fpl={$f.st}, 
351                 tc={$t.st}, 
352                 block={$b.st})
353         ->
354     |   d=typeDeclaration
355         -> template(t={$d.st}) "/*typeDeclaration*/ <t>"
356     ;
357     
358 interfaceTopLevelScope
359     :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
360         -> template(t={$text}) "<t>"
361     ;
362     
363 interfaceScopeDeclarations
364     :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
365         -> template(t={$text}) "<t>"
366     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
367         -> template(t={$text}) "<t>"
368         // Interface constant declarations have been switched to variable
369         // declarations by Charj.g; the parser has already checked that
370         // there's an obligatory initializer.
371     |   ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType variableDeclaratorList)
372         -> template(t={$text}) "<t>"
373     |   ^(OBJECT_VAR_DECLARATION modifierList objectType variableDeclaratorList)
374         -> template(t={$text}) "<t>"
375     |   typeDeclaration
376         -> template(t={$text}) "<t>"
377     ;
378
379 variableDeclaratorList
380     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
381         -> template(t={$text}) "/*variableDeclaratorList*/ <t>"
382     ;
383
384 variableDeclarator
385     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
386         -> template(t={$text}) "/*variableDeclarator*/ <t>"
387     ;
388     
389 variableDeclaratorId
390     :   ^(IDENT arrayDeclaratorList?)
391         -> template(t={$text}) "/*variableDeclaratorId*/ <t>"
392     ;
393
394 variableInitializer
395     :   arrayInitializer
396         -> template(t={$text}) "<t>"
397     |   expression
398         -> template(t={$text}) "<t>"
399     ;
400
401 arrayDeclarator
402     :   LBRACK RBRACK
403         -> template(t={$text}) "<t>"
404     ;
405
406 arrayDeclaratorList
407     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
408         -> template(t={$text}) "<t>"
409     ;
410     
411 arrayInitializer
412     :   ^(ARRAY_INITIALIZER variableInitializer*)
413         -> template(t={$text}) "<t>"
414     ;
415
416 throwsClause
417     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
418         -> template(t={$text}) "<t>"
419     ;
420
421 modifierList
422     :   ^(MODIFIER_LIST (m+=modifier)*)
423         -> template(mod={$m}) "<mod; separator=\" \">"
424     ;
425
426 modifier
427     :   PUBLIC
428         -> template(t={$text}) "<t>"
429     |   PROTECTED
430         -> template(t={$text}) "<t>"
431     |   PRIVATE
432         -> template(t={$text}) "<t>"
433     |   ENTRY
434         -> template() "public"
435     |   STATIC
436         -> template(t={$text}) "<t>"
437     |   ABSTRACT
438         -> template(t={$text}) "<t>"
439     |   NATIVE
440         -> template(t={$text}) "<t>"
441     |   SYNCHRONIZED
442         -> template(t={$text}) "<t>"
443     |   TRANSIENT
444         -> template(t={$text}) "<t>"
445     |   VOLATILE
446         -> template(t={$text}) "<t>"
447     |   localModifier
448         -> template(t={$text}) "<t>"
449     ;
450
451 localModifierList
452     :   ^(LOCAL_MODIFIER_LIST localModifier*)
453         -> template(t={$text}) "<t>"
454     ;
455
456 localModifier
457     :   FINAL
458         -> template(t={$text}) "<t>"
459     ;
460
461     
462 type
463     :   simpleType
464         -> template(type={$simpleType.st}) "<type>"
465     |   objectType 
466         -> template(type={$objectType.st}) "<type>"
467     ;
468
469 simpleType
470     :   ^(TYPE primitiveType arrayDeclaratorList?)
471         -> type(typeID={$primitiveType.st}, arrDeclList={$arrayDeclaratorList.st})
472     ;
473
474 objectType
475     :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
476         -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
477     ;
478
479 qualifiedTypeIdent
480     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
481         -> template(t={$text}) "<t>"
482     ;
483
484 typeIdent
485     :   ^(IDENT genericTypeArgumentList?)
486         -> template(t={$text}) "<t>"
487     ;
488
489 primitiveType
490     :   BOOLEAN
491         -> template() "bool"
492     |   CHAR
493         -> template(t={$text}) "<t>"
494     |   BYTE
495         -> template(t={$text}) "<t>"
496     |   SHORT
497         -> template(t={$text}) "<t>"
498     |   INT
499         -> template(t={$text}) "<t>"
500     |   LONG
501         -> template(t={$text}) "<t>"
502     |   FLOAT
503         -> template(t={$text}) "<t>"
504     |   DOUBLE
505         -> template(t={$text}) "<t>"
506     ;
507
508 genericTypeArgumentList
509     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
510         -> template(t={$text}) "<t>"
511     ;
512     
513 genericTypeArgument
514     :   type
515         -> template(t={$text}) "<t>"
516     |   ^(QUESTION genericWildcardBoundType?)
517         -> template(t={$text}) "<t>"
518     ;
519
520 genericWildcardBoundType                                                                                                                      
521     :   ^(EXTENDS type)
522         -> template(t={$text}) "<t>"
523     |   ^(SUPER type)
524         -> template(t={$text}) "<t>"
525     ;
526
527 formalParameterList
528     :   ^(FORMAL_PARAM_LIST (fpsd+=formalParameterStandardDecl)* fpvd=formalParameterVarargDecl?)
529         -> formal_param_list(sdecl={$fpsd}, vdecl={$fpvd.st})
530     ;
531     
532 formalParameterStandardDecl
533     :   ^(FORMAL_PARAM_STD_DECL lms=localModifierList t=type vdid=variableDeclaratorId)
534         -> formal_param_decl(modList={$lms.st}, type={$t.st}, declID={$vdid.st})
535         //-> template(t={$text}) "/*fpsd*/ <t>"
536     ;
537     
538 formalParameterVarargDecl
539     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
540         -> template(t={$text}) "/*fpvd*/ <t>"
541     ;
542     
543 qualifiedIdentifier
544     :   IDENT
545         -> template(t={$text}) "<t>"
546     |   ^(DOT qualifiedIdentifier IDENT)
547         -> template(t={$text}) "<t>"
548     ;
549     
550 block
551 @init { boolean emptyBlock = true; }
552     :   ^(BLOCK_SCOPE (b+=blockStatement)*)
553         { emptyBlock = ($b == null || $b.size() == 0); }
554         -> {emitCC() && emptyBlock}? template(bsl={$b}) "{ }"
555         -> {emitCC()}? block_cc(bsl={$b})
556         ->
557     ;
558     
559 blockStatement
560     :   localVariableDeclaration
561         -> {$localVariableDeclaration.st}
562     |   typeDeclaration
563         -> {$typeDeclaration.st}
564     |   statement
565         -> {$statement.st}
566     ;
567
568
569 localVariableDeclaration
570     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList simpleType variableDeclaratorList)
571         -> primitive_var_decl(
572             modList={null},
573             type={$simpleType.st},
574             declList={$variableDeclaratorList.st})
575     |   ^(OBJECT_VAR_DECLARATION localModifierList objectType variableDeclaratorList)
576         -> object_var_decl(
577             modList={null},
578             type={$objectType.st},
579             declList={$variableDeclaratorList.st})
580     ;
581
582
583 statement
584     :   block
585         -> {$block.st}
586     |   ^(ASSERT expression expression?)
587         -> template(t={$text}) "<t>"
588     |   ^(IF parenthesizedExpression statement statement?)
589         -> template(t={$text}) "<t>"
590     |   ^(FOR forInit forCondition forUpdater statement)
591         -> template(t={$text}) "<t>"
592     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
593         -> template(t={$text}) "<t>"
594     |   ^(WHILE parenthesizedExpression statement)
595         -> template(t={$text}) "<t>"
596     |   ^(DO statement parenthesizedExpression)
597         -> template(t={$text}) "<t>"
598     |   ^(TRY block catches? block?)  // The second optional block is the optional finally block.
599         -> template(t={$text}) "<t>"
600     |   ^(SWITCH parenthesizedExpression switchBlockLabels)
601         -> template(t={$text}) "<t>"
602     |   ^(SYNCHRONIZED parenthesizedExpression block)
603         -> template(t={$text}) "<t>"
604     |   ^(RETURN expression?)
605         -> template(t={$text}) "<t>"
606     |   ^(THROW expression)
607         -> template(t={$text}) "<t>"
608     |   ^(BREAK IDENT?)
609         -> template(t={$text}) "<t>"
610     |   ^(CONTINUE IDENT?)
611         -> template(t={$text}) "<t>"
612     |   ^(LABELED_STATEMENT IDENT statement)
613         -> template(t={$text}) "<t>"
614     |   expression
615         -> template(t={$text}) "<t>"
616     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
617         ->  embed_cc(str={$STRING_LITERAL.text}, blk={$EMBED_BLOCK.text})
618     |   SEMI // Empty statement.
619         -> template(t={$text}) "<t>"
620     ;
621         
622 catches
623     :   ^(CATCH_CLAUSE_LIST catchClause+)
624         -> template(t={$text}) "<t>"
625     ;
626     
627 catchClause
628     :   ^(CATCH formalParameterStandardDecl block)
629         -> template(t={$text}) "<t>"
630     ;
631
632 switchBlockLabels
633     :   ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabel* switchDefaultLabel? switchCaseLabel*)
634         -> template(t={$text}) "<t>"
635     ;
636         
637 switchCaseLabel
638     :   ^(CASE expression blockStatement*)
639         -> template(t={$text}) "<t>"
640     ;
641     
642 switchDefaultLabel
643     :   ^(DEFAULT blockStatement*)
644         -> template(t={$text}) "<t>"
645     ;
646     
647 forInit
648     :   ^(FOR_INIT (localVariableDeclaration | expression*)?)
649         -> template(t={$text}) "<t>"
650     ;
651     
652 forCondition
653     :   ^(FOR_CONDITION expression?)
654         -> template(t={$text}) "<t>"
655     ;
656     
657 forUpdater
658     :   ^(FOR_UPDATE expression*)
659         -> template(t={$text}) "<t>"
660     ;
661     
662 // EXPRESSIONS
663
664 parenthesizedExpression
665     :   ^(PARENTESIZED_EXPR expression)
666         -> template(t={$text}) "<t>"
667     ;
668     
669 expression
670     :   ^(EXPR expr)
671         -> template(t={$text}) "<t>"
672     ;
673
674 expr
675     :   ^(ASSIGN expr expr)
676         -> template(t={$text}) "<t>"
677     |   ^(PLUS_ASSIGN expr expr)
678         -> template(t={$text}) "<t>"
679     |   ^(MINUS_ASSIGN expr expr)
680         -> template(t={$text}) "<t>"
681     |   ^(STAR_ASSIGN expr expr)
682         -> template(t={$text}) "<t>"
683     |   ^(DIV_ASSIGN expr expr)
684         -> template(t={$text}) "<t>"
685     |   ^(AND_ASSIGN expr expr)
686         -> template(t={$text}) "<t>"
687     |   ^(OR_ASSIGN expr expr)
688         -> template(t={$text}) "<t>"
689     |   ^(XOR_ASSIGN expr expr)
690         -> template(t={$text}) "<t>"
691     |   ^(MOD_ASSIGN expr expr)
692         -> template(t={$text}) "<t>"
693     |   ^(BIT_SHIFT_RIGHT_ASSIGN expr expr)
694         -> template(t={$text}) "<t>"
695     |   ^(SHIFT_RIGHT_ASSIGN expr expr)
696         -> template(t={$text}) "<t>"
697     |   ^(SHIFT_LEFT_ASSIGN expr expr)
698         -> template(t={$text}) "<t>"
699     |   ^(QUESTION expr expr expr)
700         -> template(t={$text}) "<t>"
701     |   ^(LOGICAL_OR expr expr)
702         -> template(t={$text}) "<t>"
703     |   ^(LOGICAL_AND expr expr)
704         -> template(t={$text}) "<t>"
705     |   ^(OR expr expr)
706         -> template(t={$text}) "<t>"
707     |   ^(XOR expr expr)
708         -> template(t={$text}) "<t>"
709     |   ^(AND expr expr)
710         -> template(t={$text}) "<t>"
711     |   ^(EQUAL expr expr)
712         -> template(t={$text}) "<t>"
713     |   ^(NOT_EQUAL expr expr)
714         -> template(t={$text}) "<t>"
715     |   ^(INSTANCEOF expr type)
716         -> template(t={$text}) "<t>"
717     |   ^(LESS_OR_EQUAL expr expr)
718         -> template(t={$text}) "<t>"
719     |   ^(GREATER_OR_EQUAL expr expr)
720         -> template(t={$text}) "<t>"
721     |   ^(BIT_SHIFT_RIGHT expr expr)
722         -> template(t={$text}) "<t>"
723     |   ^(SHIFT_RIGHT expr expr)
724         -> template(t={$text}) "<t>"
725     |   ^(GREATER_THAN expr expr)
726         -> template(t={$text}) "<t>"
727     |   ^(SHIFT_LEFT expr expr)
728         -> template(t={$text}) "<t>"
729     |   ^(LESS_THAN expr expr)
730         -> template(t={$text}) "<t>"
731     |   ^(PLUS expr expr)
732         -> template(t={$text}) "<t>"
733     |   ^(MINUS expr expr)
734         -> template(t={$text}) "<t>"
735     |   ^(STAR expr expr)
736         -> template(t={$text}) "<t>"
737     |   ^(DIV expr expr)
738         -> template(t={$text}) "<t>"
739     |   ^(MOD expr expr)
740         -> template(t={$text}) "<t>"
741     |   ^(UNARY_PLUS expr)
742         -> template(t={$text}) "<t>"
743     |   ^(UNARY_MINUS expr)
744         -> template(t={$text}) "<t>"
745     |   ^(PRE_INC expr)
746         -> template(t={$text}) "<t>"
747     |   ^(PRE_DEC expr)
748         -> template(t={$text}) "<t>"
749     |   ^(POST_INC expr)
750         -> template(t={$text}) "<t>"
751     |   ^(POST_DEC expr)
752         -> template(t={$text}) "<t>"
753     |   ^(NOT expr)
754         -> template(t={$text}) "<t>"
755     |   ^(LOGICAL_NOT expr)
756         -> template(t={$text}) "<t>"
757     |   ^(CAST_EXPR type expr)
758         -> template(t={$text}) "<t>"
759     |   primaryExpression
760         -> template(t={$text}) "<t>"
761     ;
762     
763 primaryExpression
764     :   ^(  DOT
765             (   primaryExpression
766                 (   IDENT
767                 |   THIS
768                 |   SUPER
769                 |   innerNewExpression
770                 |   CLASS
771                 )
772             |   primitiveType CLASS
773             |   VOID CLASS
774             )
775         )
776         -> template(t={$text}) "<t>"
777     |   parenthesizedExpression
778         -> template(t={$text}) "<t>"
779     |   IDENT
780         -> template(t={$text}) "<t>"
781     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
782         -> template(t={$text}) "<t>"
783     |   explicitConstructorCall
784         -> template(t={$text}) "<t>"
785     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
786         -> template(t={$text}) "<t>"
787     |   literal
788         -> template(t={$text}) "<t>"
789     |   newExpression
790         -> template(t={$text}) "<t>"
791     |   THIS
792         -> template(t={$text}) "<t>"
793     |   arrayTypeDeclarator
794         -> template(t={$text}) "<t>"
795     |   SUPER
796         -> template(t={$text}) "<t>"
797     ;
798     
799 explicitConstructorCall
800     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
801         -> template(t={$text}) "<t>"
802     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
803         -> template(t={$text}) "<t>"
804     ;
805
806 arrayTypeDeclarator
807     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
808         -> template(t={$text}) "<t>"
809     ;
810
811 newExpression
812     :   ^(  STATIC_ARRAY_CREATOR
813             (   primitiveType newArrayConstruction
814             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
815             )
816         )
817         -> template(t={$text}) "<t>"
818     |   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? qualifiedTypeIdent arguments classTopLevelScope?)
819         -> template(t={$text}) "<t>"
820     ;
821
822 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
823     :   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? IDENT arguments classTopLevelScope?)
824         -> template(t={$text}) "<t>"
825     ;
826     
827 newArrayConstruction
828     :   arrayDeclaratorList arrayInitializer
829         -> template(t={$text}) "<t>"
830     |   expression+ arrayDeclaratorList?
831         -> template(t={$text}) "<t>"
832     ;
833
834 arguments
835     :   ^(ARGUMENT_LIST expression*)
836         -> template(t={$text}) "<t>"
837     ;
838
839 literal 
840     :   HEX_LITERAL
841         -> template(t={$text}) "<t>"
842     |   OCTAL_LITERAL
843         -> template(t={$text}) "<t>"
844     |   DECIMAL_LITERAL
845         -> template(t={$text}) "<t>"
846     |   FLOATING_POINT_LITERAL
847         -> template(t={$text}) "<t>"
848     |   CHARACTER_LITERAL
849         -> template(t={$text}) "<t>"
850     |   STRING_LITERAL
851         -> template(t={$text}) "<t>"
852     |   TRUE
853         -> template(t={$text}) "<t>"
854     |   FALSE
855         -> template(t={$text}) "<t>"
856     |   NULL
857         -> template(t={$text}) "<t>"
858     ;