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