fixed output templates to match grammar updates
[charm.git] / src / langs / charj / src / charj / translator / CharjEmitter.g
index 47898635129249cda365060ecf029e35ee09cd79..0f725cc396060eb32af606c6ba69ccca13a433cd 100644 (file)
@@ -86,7 +86,6 @@ charjSource[SymbolTable symtab, OutputMode m]
     :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
         (i+=importDeclaration)* 
         (t=typeDeclaration))
-        //(t+=typeDeclaration)*)
         {
             // construct string of }'s to close namespace 
             if ($p.st != null) {
@@ -110,7 +109,7 @@ packageDeclaration
 @init { 
     List<String> names = null; 
 }
-    :   ^(PACKAGE qualifiedIdentifier)  {
+    :   ^('package' qualifiedIdentifier)  {
             names =  java.util.Arrays.asList(
                     $qualifiedIdentifier.text.split("[.]"));
         }
@@ -123,13 +122,13 @@ importDeclaration
 @init {
     String importID = null;
 }
-    :   ^(IMPORT STATIC? qualifiedIdentifier DOTSTAR?)
+    :   ^('import' qualifiedIdentifier ds='.*'?)
         {
             importID = $qualifiedIdentifier.text;
-            if ($DOTSTAR != null) {
+            if ($ds != null) {
             }
         }
-        {$DOTSTAR == null}? // TODO: add support for importing x.*
+        {$ds == null}? // TODO: add support for importing x.*
         -> {(emitCC() || emitH())}? importDeclaration_cc_h(
             inc_id={importID.replace(".","/")},
             use_id={importID.replace(".","::")})
@@ -137,95 +136,36 @@ importDeclaration
     ;
     
 typeDeclaration
-    :   ^(CLASS m=modifierList IDENT g=genericTypeParameterList? 
-                e=classExtendsClause? i=implementsClause? c=classTopLevelScope) 
+    :   ^('class' IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*)
         -> {emitCC()}? classDeclaration_cc(
-                mod={$m.st}, 
                 ident={$IDENT.text}, 
-                gen={$g.st}, 
-                ext={$e.st}, 
-                impl={$i.st},
-                ctls={$c.st})
+                ext={$su.st}, 
+                csds={$csds})
         -> {emitCI()}? classDeclaration_ci(
-                mod={$m.st}, 
                 ident={$IDENT.text}, 
-                gen={$g.st}, 
-                ext={$e.st}, 
-                impl={$i.st},
-                ctls={$c.st})
+                ext={$su.st}, 
+                csds={$csds})
         -> {emitH()}? classDeclaration_h(
-                mod={$m.st}, 
                 ident={$IDENT.text}, 
-                gen={$g.st}, 
-                ext={$e.st}, 
-                impl={$i.st},
-                ctls={$c.st})
+                ext={$su.st}, 
+                csds={$csds})
         ->
-    |   ^(INTERFACE modifierList IDENT genericTypeParameterList? 
-                interfaceExtendsClause? interfaceTopLevelScope)
+    |   ^('interface' IDENT (^('extends' type+))? interfaceScopeDeclaration*)
         -> template(t={$text}) "/*INTERFACE-not implemented*/ <t>"
-    |   ^(ENUM modifierList IDENT implementsClause? enumTopLevelScope)
+    |   ^('enum' IDENT (^('implements' type+))? classScopeDeclaration*)
         -> template(t={$text}) "/*ENUM-not implemented*/ <t>"
     ;
 
-
-classExtendsClause
-    :   ^(EXTENDS_CLAUSE t=type) 
-        -> {emitCC() || emitH()}? classExtends_cc_h(type={$t.st})
-        -> {emitCI()}? classExtends_ci(type={$t.st})
-        ->
-    ;   
-
-interfaceExtendsClause 
-    :   ^(EXTENDS_CLAUSE (typeList+=type)+) 
-        -> interfaceExtends(ts={$typeList})
-    ;   
-    
-implementsClause
-    :   ^(IMPLEMENTS_CLAUSE type+)
-        -> template(t={$text}) "/*IMPLEMENTS_CLAUSE-not implemented*/ <t>"
-    ;
-        
-genericTypeParameterList
-    :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
-        -> template(t={$text}) "/*GENERIC_TYPE_PARAM_LIST-not implemented*/ <t>"
-    ;
-
-genericTypeParameter
-    :   ^(IDENT bound?)
-        -> template(t={$text}) "/*genericTypeParameter-not implemented*/ <t>"
-    ;
-        
-bound
-    :   ^(EXTENDS_BOUND_LIST type+)
-        -> template(t={$text}) "/*EXTENDS_BOUND_LIST-not implemented*/ <t>"
-    ;
-
-enumTopLevelScope
-    :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
-        -> template(t={$text}) "/*enumTopLevelScope-not implemented*/ <t>"
-    ;
-    
 enumConstant
-    :   ^(IDENT arguments? classTopLevelScope?)
+    :   ^(IDENT arguments?)
         -> template(t={$text}) "/*enumConstant-not implemented*/ <t>"
     ;
-    
-    
-classTopLevelScope
-    :   ^(CLASS_TOP_LEVEL_SCOPE (csd+=classScopeDeclarations)*) 
-        -> classTopLevelScope(classScopeDeclarations={$csd})
-    ;
-    
-classScopeDeclarations
+
+classScopeDeclaration
 @init { boolean entry = false; }
-    :   ^(CLASS_INSTANCE_INITIALIZER block)
-        -> {$block.st}
-    |   ^(CLASS_STATIC_INITIALIZER block)
-        -> {$block.st}
-    |   ^(FUNCTION_METHOD_DECL m=modifierList g=genericTypeParameterList? 
+    :   ^(FUNCTION_METHOD_DECL m=modifierList g=genericTypeParameterList? 
             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
-            tc=throwsClause? b=block?)
+            b=block?)
         { 
             // determine whether this is an entry method
             entry = listContainsToken($m.start.getChildren(), ENTRY);
@@ -237,7 +177,6 @@ classScopeDeclarations
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
-                tc={$tc.st}, 
                 block={$b.st})
         -> {emitH()}? funcMethodDecl_h(
                 modl={$m.st}, 
@@ -246,7 +185,6 @@ classScopeDeclarations
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
-                tc={$tc.st}, 
                 block={$b.st})
         -> {(emitCI() && entry)}? funcMethodDecl_ci(
                 modl={$m.st}, 
@@ -255,11 +193,10 @@ classScopeDeclarations
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
-                tc={$tc.st}, 
                 block={$b.st})
         ->
     |   ^(VOID_METHOD_DECL m=modifierList g=genericTypeParameterList? IDENT 
-            f=formalParameterList t=throwsClause? b=block?)
+            f=formalParameterList b=block?)
         { 
             // determine whether this is an entry method
             entry = listContainsToken($m.start.getChildren(), ENTRY);
@@ -269,21 +206,18 @@ classScopeDeclarations
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         -> {emitCI() && entry}? voidMethodDecl_ci(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         -> {emitH()}? voidMethodDecl_h(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         ->
     |   ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType variableDeclaratorList)
@@ -298,8 +232,7 @@ classScopeDeclarations
             type={$objectType.st},
             declList={$variableDeclaratorList.st})
         ->
-    |   ^(CONSTRUCTOR_DECL m=modifierList g=genericTypeParameterList? IDENT f=formalParameterList 
-            t=throwsClause? b=block)
+    |   ^(CONSTRUCTOR_DECL m=modifierList g=genericTypeParameterList? IDENT f=formalParameterList b=block)
         { 
             // determine whether this is an entry method
             entry = listContainsToken($m.start.getChildren(), ENTRY);
@@ -309,46 +242,31 @@ classScopeDeclarations
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         -> {emitCI() && entry}? ctorDecl_ci(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         -> {emitH()}? ctorDecl_h(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                tc={$t.st}, 
                 block={$b.st})
         ->
-    |   typeDeclaration
-        -> {$typeDeclaration.st}
-    ;
-    
-interfaceTopLevelScope
-    :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
-        -> template(t={$text}) "/*interfaceTopLevelScope-not implemented */ <t>"
     ;
     
-interfaceScopeDeclarations
-    :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
+interfaceScopeDeclaration
+    :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList?)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-    |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
+    |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-        // Interface constant declarations have been switched to variable
-        // declarations by Charj.g; the parser has already checked that
-        // there's an obligatory initializer.
     |   ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType variableDeclaratorList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
     |   ^(OBJECT_VAR_DECLARATION modifierList objectType variableDeclaratorList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-    |   typeDeclaration
-        -> {$typeDeclaration.st}
     ;
 
 variableDeclaratorList
@@ -373,11 +291,6 @@ variableInitializer
         -> {$expression.st}
     ;
 
-arrayDeclarator
-    :   LBRACK RBRACK
-        -> template(t={$text}) "<t>"
-    ;
-
 arrayDeclaratorList
     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
         -> template(t={$text}) "<t>"
@@ -388,6 +301,21 @@ arrayInitializer
         -> template(t={$text}) "/* arrayInitializer-not implemented */ <t>"
     ;
 
+genericTypeParameterList
+    :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
+        -> template(t={$text}) "/*GENERIC_TYPE_PARAM_LIST-not implemented*/ <t>"
+    ;
+
+genericTypeParameter
+    :   ^(IDENT bound?)
+        -> template(t={$text}) "/*genericTypeParameter-not implemented*/ <t>"
+    ;
+        
+bound
+    :   ^(EXTENDS_BOUND_LIST type+)
+        -> template(t={$text}) "/*EXTENDS_BOUND_LIST-not implemented*/ <t>"
+    ;
+
 throwsClause
     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
         -> template(t={$text}) "/* throwsClause-not implemented */ <t>"
@@ -402,14 +330,12 @@ modifier
 @init {
 $st = %{$start.getText()};
 }
-    :   PUBLIC
-    |   PROTECTED
-    |   PRIVATE
-    |   ENTRY
-    |   ABSTRACT
-    |   NATIVE
-    |   SYNCHRONIZED
-    |   TRANSIENT
+    :   'public'
+    |   'protected'
+    |   'private'
+    |   'entry'
+    |   'abstract'
+    |   'native'
     |   localModifier
         -> {$localModifier.st}
     ;
@@ -423,9 +349,9 @@ localModifier
 @init {
 $st = %{$start.getText()};
 }
-    :   FINAL
-    |   STATIC
-    |   VOLATILE
+    :   'final'
+    |   'static'
+    |   'volatile'
     ;
 
     
@@ -460,14 +386,14 @@ primitiveType
 @init {
 $st = %{$start.getText()};
 }
-    :   BOOLEAN
-    |   CHAR
-    |   BYTE
-    |   SHORT
-    |   INT
-    |   LONG
-    |   FLOAT
-    |   DOUBLE
+    :   'boolean'
+    |   'char'
+    |   'byte'
+    |   'short'
+    |   'int'
+    |   'long'
+    |   'float'
+    |   'double'
     ;
 
 genericTypeArgumentList
@@ -478,17 +404,10 @@ genericTypeArgumentList
 genericTypeArgument
     :   type
         -> {$type.st}
-    |   ^(QUESTION genericWildcardBoundType?)
+    |   '?'
         -> template(t={$text}) "/* genericTypeArgument: wildcard bound types not implemented */ <t>"
     ;
 
-genericWildcardBoundType                                                                                                                      
-    :   ^(EXTENDS type)
-        -> template(t={$text}) "/* genericWildcardBoundType not implemented */ <t>"
-    |   ^(SUPER type)
-        -> template(t={$text}) "/* genericWildcardBoundType not implemented */ <t>"
-    ;
-
 formalParameterList
     :   ^(FORMAL_PARAM_LIST (fpsd+=formalParameterStandardDecl)* fpvd=formalParameterVarargDecl?)
         -> formal_param_list(sdecl={$fpsd}, vdecl={$fpvd.st})
@@ -507,7 +426,7 @@ formalParameterVarargDecl
 qualifiedIdentifier
     :   IDENT
         -> template(t={$text}) "<t>"
-    |   ^(DOT qualifiedIdentifier IDENT)
+    |   ^('.' qualifiedIdentifier IDENT)
         -> template(t={$text}) "<t>"
     ;
     
@@ -523,8 +442,6 @@ block
 blockStatement
     :   localVariableDeclaration
         -> {$localVariableDeclaration.st}
-    |   typeDeclaration
-        -> {$typeDeclaration.st}
     |   statement
         -> {$statement.st}
     ;
@@ -547,78 +464,52 @@ localVariableDeclaration
 statement
     :   block
         -> {$block.st}
-    |   ^(ASSERT cond=expression msg=expression?)
+    |   ^('assert' cond=expression msg=expression?)
         -> assert(cond={$cond.st}, msg={$msg.st})
-    |   ^(IF parenthesizedExpression then=statement else_=statement?)
+    |   ^('if' parenthesizedExpression then=statement else_=statement?)
         -> if(cond={$parenthesizedExpression.st}, then={$then.st}, else_={$else_.st})
-    |   ^(FOR forInit forCondition forUpdater s=statement)
-        -> for(initializer={$forInit.st}, cond={$forCondition.st}, update={$forUpdater.st}, body={$s.st})
+    |   ^('for' forInit cond=expression? (update+=expression)* s=statement)
+        -> for(initializer={$forInit.st}, cond={$cond.st}, update={$update}, body={$s.st})
     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
         -> template(t={$text}) "/* foreach not implemented */ <t>"
-    |   ^(WHILE pe=parenthesizedExpression s=statement)
+    |   ^('while' pe=parenthesizedExpression s=statement)
         -> while(cond={$pe.st}, body={$s.st})
-    |   ^(DO s=statement pe=parenthesizedExpression)
+    |   ^('do' s=statement pe=parenthesizedExpression)
         -> dowhile(cond={$pe.st}, block={$s.st})
-    |   ^(TRY block catches? block?)  // The second optional block is the finally block.
-        -> template(t={$text}) "/* try/catch not implemented */ <t>"
-    |   ^(SWITCH pe=parenthesizedExpression sbls=switchBlockLabels)
-        -> switch(expr={$pe.st}, labels={$sbls.st})
-    |   ^(SYNCHRONIZED parenthesizedExpression block)
-        -> template(t={$text}) "/* synchronized not implemented */ <t>"
-    |   ^(RETURN e=expression?)
+    |   ^('switch' pe=parenthesizedExpression (scls+=switchCaseLabel)*)
+        -> switch(expr={$pe.st}, labels={$scls})
+    |   ^('return' e=expression?)
         -> return(val={$e.st})
-    |   ^(THROW expression)
+    |   ^('throw' expression)
         -> template(t={$text}) "/* throw not implemented */ <t>"
-    |   ^(BREAK IDENT?)
+    |   ^('break' IDENT?)
         -> template() "break;" // TODO: support labeling
-    |   ^(CONTINUE IDENT?)
+    |   ^('continue' IDENT?)
         -> template() "continue;" // TODO: support labeling
     |   ^(LABELED_STATEMENT i=IDENT s=statement)
         -> label(text={$i.text}, stmt={$s.st})
     |   expression
         -> template(expr={$expression.st}) "<expr>;"
-    |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
+    |   ^('embed' STRING_LITERAL EMBED_BLOCK)
         ->  embed_cc(str={$STRING_LITERAL.text}, blk={$EMBED_BLOCK.text})
-    |   SEMI // Empty statement.
+    |   ';' // Empty statement.
         -> {%{$start.getText()}}
     ;
         
-catches
-    :   ^(CATCH_CLAUSE_LIST catchClause+)
-        -> template(t={$text}) "/* catch not implemented */ <t>"
-    ;
-    
-catchClause
-    :   ^(CATCH formalParameterStandardDecl block)
-        -> template(t={$text}) "/* catchClause not implemented */ <t>"
-    ;
-
 switchCaseLabel
-    :   ^(CASE expression (b+=blockStatement)*)
+    :   ^('case' expression (b+=blockStatement)*)
         -> case(expr={$expression.st}, block={$b})
-    |   ^(DEFAULT (b+=blockStatement)*)
+    |   ^('default' (b+=blockStatement)*)
         -> template(block={$b}) "default: <block>"
     ;
     
-//forInit
-//    :   ^(FOR_INIT lvd=localVariableDeclaration?)
-//        -> template(lvd={$lvd.st}) "<lvd>"
-//    |   ^(FOR_INIT (ex+=expression)*)
-//        -> template(ex={$ex}) "<ex; separator=\", \">;"
-//    |   FOR_INIT
-//        -> template() ";"
-//    ;
-//    
-//forCondition
-//    :   ^(FOR_CONDITION (ex=expression)?)
-//        -> for_cond(expr={$ex.st})
-//    ;
-//    
-//forUpdater
-//    :   ^(FOR_UPDATE (exs+=expression)*)
-//        -> for_update(exprs={$exs})
-//    ;
-    
+forInit
+    :   localVariableDeclaration
+        -> template(lvd={$localVariableDeclaration.st}) "<lvd>"
+    |   (ex+=expression)+
+        -> template(ex={$ex}) "<ex; separator=\", \">"
+    ;
+
 // EXPRESSIONS
 
 parenthesizedExpression
@@ -632,71 +523,71 @@ expression
     ;
 
 expr
-    :   ^(ASSIGN e1=expr e2=expr)
+    :   ^('=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> = <e2>"
-    |   ^(PLUS_ASSIGN e1=expr e2=expr)
+    |   ^('+=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> += <e2>"
-    |   ^(MINUS_ASSIGN e1=expr e2=expr)
+    |   ^('-=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> -= <e2>"
-    |   ^(STAR_ASSIGN e1=expr e2=expr)
+    |   ^('*=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> *= <e2>"
-    |   ^(DIV_ASSIGN e1=expr e2=expr)
+    |   ^('/=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> /= <e2>"
-    |   ^(AND_ASSIGN e1=expr e2=expr)
+    |   ^('&=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> &= <e2>"
-    |   ^(OR_ASSIGN e1=expr e2=expr)
+    |   ^('|=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> |= <e2>"
-    |   ^(XOR_ASSIGN e1=expr e2=expr)
+    |   ^('^=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^= <e2>"
-    |   ^(MOD_ASSIGN e1=expr e2=expr)
+    |   ^('%=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> %= <e2>"
-    |   ^(BIT_SHIFT_RIGHT_ASSIGN e1=expr e2=expr)
+    |   ^('>>>=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>\>= <e2>"
-    |   ^(SHIFT_RIGHT_ASSIGN e1=expr e2=expr)
+    |   ^('>>=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>= <e2>"
-    |   ^(SHIFT_LEFT_ASSIGN e1=expr e2=expr)
+    |   ^('<<=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<\<= <e2>"
-    |   ^(QUESTION e1=expr e2=expr e3=expr)
+    |   ^('?' e1=expr e2=expr e3=expr)
         -> template(e1={$e1.st}, e2={$e2.st}, e3={$e3.st}) "<e1> ? <e2> : <e3>"
-    |   ^(LOGICAL_OR e1=expr e2=expr)
+    |   ^('||' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> || <e2>"
-    |   ^(LOGICAL_AND e1=expr e2=expr)
+    |   ^('&&' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> && <e2>"
-    |   ^(OR e1=expr e2=expr)
+    |   ^('|' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> | <e2>"
-    |   ^(XOR e1=expr e2=expr)
+    |   ^('^' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^ <e2>"
-    |   ^(AND e1=expr e2=expr)
+    |   ^('&' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> & <e2>"
-    |   ^(EQUAL e1=expr e2=expr)
+    |   ^('==' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> == <e2>"
-    |   ^(NOT_EQUAL e1=expr e2=expr)
+    |   ^('!=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> != <e2>"
-    |   ^(INSTANCEOF expr type)
+    |   ^('instanceof' expr type)
         -> template(t={$text}) "/* instanceof not implemented */ <t>"
-    |   ^(LESS_OR_EQUAL e1=expr e2=expr)
+    |   ^('<=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<= <e2>"
-    |   ^(GREATER_OR_EQUAL e1=expr e2=expr)
+    |   ^('>=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>= <e2>"
-    |   ^(BIT_SHIFT_RIGHT e1=expr e2=expr)
+    |   ^('>>>' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\>\> <e2>"
-    |   ^(SHIFT_RIGHT e1=expr e2=expr)
+    |   ^('>>' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \>\> <e2>"
-    |   ^(GREATER_THAN e1=expr e2=expr)
+    |   ^('>' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \> <e2>"
-    |   ^(SHIFT_LEFT e1=expr e2=expr)
+    |   ^('<<' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \<\< <e2>"
-    |   ^(LESS_THAN e1=expr e2=expr)
+    |   ^('<' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> \< <e2>"
-    |   ^(PLUS e1=expr e2=expr)
+    |   ^('+' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> + <e2>"
-    |   ^(MINUS e1=expr e2=expr)
+    |   ^('-' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> - <e2>"
-    |   ^(STAR e1=expr e2=expr)
+    |   ^('*' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> * <e2>"
-    |   ^(DIV e1=expr e2=expr)
+    |   ^('/' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> / <e2>"
-    |   ^(MOD e1=expr e2=expr)
+    |   ^('%' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> % <e2>"
     |   ^(UNARY_PLUS e1=expr)
         -> template(e1={$e1.st}) "+<e1>"
@@ -710,9 +601,9 @@ expr
         -> template(e1={$e1.st}) "<e1>++"
     |   ^(POST_DEC e1=expr)
         -> template(e1={$e1.st}) "<e1>--"
-    |   ^(NOT e1=expr)
+    |   ^('~' e1=expr)
         -> template(e1={$e1.st}) "~<e1>"
-    |   ^(LOGICAL_NOT e1=expr)
+    |   ^('!' e1=expr)
         -> template(e1={$e1.st}) "!<e1>"
     |   ^(CAST_EXPR ty=type e1=expr)
         -> template(ty={$ty.st}, e1={$e1.st}) "(<ty>)<e1>"
@@ -721,16 +612,11 @@ expr
     ;
     
 primaryExpression
-    :   ^(  DOT
-            (   primaryExpression
-                (   IDENT
-                |   THIS
-                |   SUPER
-                |   innerNewExpression
-                |   CLASS
-                )
-            |   primitiveType CLASS
-            |   VOID CLASS
+    :   ^(  '.' primaryExpression
+            (   IDENT
+            |   'this'
+            |   'super'
+            |   'class'
             )
         )
         -> template(t={$text}) "/* AKB: not sure what's up with this primaryExpression yet */ <t>"
@@ -748,11 +634,11 @@ primaryExpression
         -> {$literal.st}
     |   newExpression
         -> {$newExpression.st}
-    |   THIS
+    |   'this'
         -> {%{$start.getText()}}
     |   arrayTypeDeclarator
         -> {$arrayTypeDeclarator.st}
-    |   SUPER
+    |   'super'
         -> {%{$start.getText()}}
     ;
     
@@ -775,15 +661,8 @@ newExpression
             )
         )
         -> template(t={$text}) "<t>"
-    |   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? qualifiedTypeIdent arguments classTopLevelScope?)
-        -> template(t={$text}) "<t>"
     ;
 
-innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
-    :   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? IDENT arguments classTopLevelScope?)
-        -> template(t={$text}) " /* AKB: innerNewExpression not supported */ <t>"
-    ;
-    
 newArrayConstruction
     :   arrayDeclaratorList arrayInitializer
         -> array_construction_with_init(
@@ -808,8 +687,8 @@ $st = %{$start.getText()};
     |   FLOATING_POINT_LITERAL
     |   CHARACTER_LITERAL
     |   STRING_LITERAL
-    |   TRUE
-    |   FALSE
-    |   NULL
+    |   'true'
+    |   'false'
+    |   'null'
     ;