Merged arrays into Charj mainline.
[charm.git] / src / langs / charj / src / charj / translator / CharjEmitter.g
index 0406c7033abf669d14f648d9993cfb5722145b58..e680c7d00a36ae5c2f8cd93e2393e64c128344d4 100644 (file)
@@ -19,12 +19,12 @@ package charj.translator;
 
 
 @members {
-    SymbolTable symtab_ = null;
+    SymbolTable symtab = null;
 
-    PackageScope currentPackage_ = null;
-    ClassSymbol currentClass_ = null;
-    MethodSymbol currentMethod_ = null;
-    LocalScope currentLocalScope_ = null;
+    PackageScope currentPackage = null;
+    ClassSymbol currentClass = null;
+    MethodSymbol currentMethod = null;
+    LocalScope currentLocalScope = null;
 
     Translator translator_;
     OutputMode mode_;
@@ -33,6 +33,7 @@ package charj.translator;
     private boolean emitCI() { return mode_ == OutputMode.ci; }
     private boolean emitH() { return mode_ == OutputMode.h; }
     private boolean debug() { return translator_.debug(); }
+    private String basename() { return translator_.basename(); }
 
     /**
      *  Override ANTLR's token mismatch behavior so we throw exceptions early.
@@ -78,43 +79,38 @@ package charj.translator;
 // Starting point for parsing a Charj file.
 charjSource[SymbolTable symtab, OutputMode m]
 @init {
-    this.symtab_ = symtab;
+    this.symtab = symtab;
     this.translator_ = symtab.translator;
     this.mode_ = m;
-    String closingBraces = "";
 }
     :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
-        (i+=importDeclaration)* 
-        (t=typeDeclaration))
+        (i+=importDeclaration)*
+        (r+=readonlyDeclaration)*
+        (t+=typeDeclaration)*)
+        -> {emitCC()}? charjSource_cc(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
+        -> {emitCI()}? charjSource_ci(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
+        -> {emitH()}? charjSource_h(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
+        ->
+    ;
+
+topLevelDeclaration
+    :   importDeclaration -> {$importDeclaration.st;}
+    |   typeDeclaration -> {$typeDeclaration.st;}
+    ;
+
+packageDeclaration returns [List names]
+    :   ^('package' (ids+=IDENT)+)
         {
-            // construct string of }'s to close namespace 
-            if ($p.st != null) {
-                String temp_p = $p.st.toString();
-                for (int idx=0; idx<temp_p.length(); ++idx) {
-                    if (temp_p.charAt(idx) == '{') {
-                        closingBraces += "} ";
-                    }
-                }
-            }
+            $names = $ids;
         }
-        -> {emitCC()}? charjSource_cc(
-            pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces}, debug={debug()})
-        -> {emitCI()}? charjSource_ci(pd={$p.st}, ids={$i}, tds={$t.st}, debug={debug()})
-        -> {emitH()}? charjSource_h(
-            pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces}, debug={debug()})
         ->
     ;
 
-packageDeclaration
-@init { 
-    List<String> names = null; 
-}
-    :   ^('package' qualifiedIdentifier)  {
-            names =  java.util.Arrays.asList(
-                    $qualifiedIdentifier.text.split("[.]"));
-        }
-        -> {(emitCC() || emitH())}? packageDeclaration_cc_h(
-            ids={names})
+readonlyDeclaration
+    :   ^(READONLY lvd=localVariableDeclaration)
+        -> {emitCI()}? template(bn={basename()}, v={$lvd.st}) "readonly <v>"
+        -> {emitH()}? template(v={$lvd.st}) "extern <v>"
+        -> {emitCC()}? {$lvd.st;}
         ->
     ;
     
@@ -136,47 +132,52 @@ importDeclaration
     ;
     
 typeDeclaration
-    :   ^('template' (i0+=IDENT*) ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*))
-        -> {emitH()}? templateDeclaration_h(
-            tident={$i0},
-            ident={$i1.text},
-            ext={$su.st},
-            csds={$csds})
-        ->
-    |   ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*)
+    :   ^(TYPE CLASS IDENT (^('extends' su=type))? (^('implements' type+))?
+        {
+            currentClass = (ClassSymbol)$IDENT.symbol;
+        }
+        (csds+=classScopeDeclaration)*)
         -> {emitCC()}? classDeclaration_cc(
-                ident={$i1.text}, 
+                sym={currentClass},
+                ident={$IDENT.text}, 
                 ext={$su.st}, 
                 csds={$csds})
-        -> {emitH()}? classWrapper_h(
-                ident={$i1.text}, 
+        -> {emitH()}?  classDeclaration_h(
+                sym={currentClass},
+                ident={$IDENT.text}, 
                 ext={$su.st}, 
                 csds={$csds})
         ->
-    |   ^('interface' IDENT (^('extends' type+))? interfaceScopeDeclaration*)
+    |   ^('template' (i0+=IDENT*) ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*))
+        -> {emitH()}? templateDeclaration_h(
+            tident={$i0},
+            ident={$i1.text},
+            ext={$su.st},
+            csds={$csds})
+        -> 
+    |   ^(INTERFACE IDENT (^('extends' type+))? interfaceScopeDeclaration*)
         -> template(t={$text}) "/*INTERFACE-not implemented*/ <t>"
-    |   ^('enum' IDENT (^('implements' type+))? classScopeDeclaration*)
+    |   ^(ENUM IDENT (^('implements' type+))? classScopeDeclaration*)
         -> template(t={$text}) "/*ENUM-not implemented*/ <t>"
-    |   ^(chareType IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
-        -> {emitCC()}? classDeclaration_cc(
+    |   ^(TYPE chareType IDENT (^('extends' type))? (^('implements' type+))?
+        {
+            currentClass = (ClassSymbol)$IDENT.symbol;
+        }
+        (csds+=classScopeDeclaration)*)
+        -> {emitCC()}? chareDeclaration_cc(
+                sym={currentClass},
                 ident={$IDENT.text}, 
                 ext={$su.st}, 
                 csds={$csds})
-        -> {emitCI()}? charedeclaration_ci(
+        -> {emitCI()}? chareDeclaration_ci(
+                sym={currentClass},
                 chareType={$chareType.st},
                 arrayDim={null},
                 ident={$IDENT.text}, 
                 ext={$su.st}, 
                 csds={$csds})
-        -> {emitH()}? classDeclaration_h(
-                ident={$IDENT.text}, 
-                ext={$su.st}, 
-                csds={$csds})
-        ->
-    |   ^('chare_array' ARRAY_DIMENSION IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
-        -> {emitCI()}? charedeclaration_ci(
-                chareType={"array"},
-                arrayDim={$ARRAY_DIMENSION.text.toUpperCase()},
+        -> {emitH()}? chareDeclaration_h(
+                sym={currentClass},
                 ident={$IDENT.text}, 
                 ext={$su.st}, 
                 csds={$csds})
@@ -187,9 +188,12 @@ chareType
 @init {
 $st = %{$start.getText()};
 }
-    :   'chare'
-    |   'group'
-    |   'nodegroup'
+    :   CHARE
+    |   GROUP
+    |   NODEGROUP
+    |   MAINCHARE
+    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
+        -> template(t={$ARRAY_DIMENSION.text}) "array [<t>]"
     ;
 
 enumConstant
@@ -198,61 +202,38 @@ enumConstant
     ;
 
 classScopeDeclaration
-@init { boolean entry = false; }
+@init
+{
+    boolean entry = false;
+    boolean migrationCtor = false;
+}
     :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
             ty=type IDENT f=formalParameterList
             b=block?)
-        { 
-            if ($m.st != null) {
-                // determine whether this is an entry method
-                entry = listContainsToken($m.start.getChildren(), ENTRY);
-            }
+        {
+            // determine whether it's an entry method
+            if($m.start != null)
+                entry = listContainsToken($m.start.getChildren(), CHARJ_MODIFIER_LIST);
         }
         -> {emitCC()}? funcMethodDecl_cc(
+                sym={currentClass},
                 modl={$m.st}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 block={$b.st})
         -> {emitH()}? funcMethodDecl_h(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 block={$b.st})
         -> {(emitCI() && entry)}? funcMethodDecl_ci(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
-                id={$IDENT.text}, 
-                fpl={$f.st}, 
-                block={$b.st})
-        ->
-    |   ^(VOID_METHOD_DECL m=modifierList? g=genericTypeParameterList? IDENT 
-            f=formalParameterList b=block?)
-        { 
-            // determine whether this is an entry method
-            if ($m.st != null) {
-                entry = listContainsToken($m.start.getChildren(), ENTRY);
-            }
-        }
-        -> {emitCC()}? voidMethodDecl_cc(
-                modl={$m.st}, 
-                gtpl={$g.st}, 
-                id={$IDENT.text}, 
-                fpl={$f.st}, 
-                block={$b.st})
-        -> {emitCI() && entry}? voidMethodDecl_ci(
-                modl={$m.st}, 
-                gtpl={$g.st}, 
-                id={$IDENT.text}, 
-                fpl={$f.st}, 
-                block={$b.st})
-        -> {emitH()}? voidMethodDecl_h(
-                modl={$m.st}, 
-                gtpl={$g.st}, 
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 block={$b.st})
@@ -264,37 +245,33 @@ classScopeDeclaration
             declList={$variableDeclaratorList.st})
         ->
     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
-        /*{
-            if ($currentClass != null) {
-                $currentClass.members.put(
-            }
-        }*/
         -> {emitCC() || emitH()}? class_var_decl(
             modl={$modifierList.st},
             type={$objectType.st},
             declList={$variableDeclaratorList.st})
         ->
     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList b=block)
-        { 
-            // determine whether this is an entry method
-            if ($m.st != null) {
-                entry = listContainsToken($m.start.getChildren(), ENTRY);
+        {
+            // determine whether it's an entry method
+            if ($m.start != null) {
+                entry = listContainsToken($m.start.getChildren(), CHARJ_MODIFIER_LIST);
             }
+            migrationCtor = currentClass.migrationCtor == $CONSTRUCTOR_DECL;
         }
         -> {emitCC()}? ctorDecl_cc(
-                modl={$m.st}, 
+                modl={$m.st},
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 block={$b.st})
-        -> {emitCI() && entry}? ctorDecl_ci(
-                modl={$m.st}, 
+        -> {emitCI() && entry && !migrationCtor}? ctorDecl_ci(
+                modl={$m.st},
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 block={$b.st})
         -> {emitH()}? ctorDecl_h(
-                modl={$m.st}, 
+                modl={$m.st},
                 gtpl={$g.st}, 
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
@@ -305,8 +282,6 @@ classScopeDeclaration
 interfaceScopeDeclaration
     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT formalParameterList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-    |   ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)
-        -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[$simpleType.st, false])
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
@@ -320,10 +295,14 @@ variableDeclaratorList[StringTemplate obtype, boolean output]
 
 variableDeclarator[StringTemplate obtype, boolean output]
     :   ^(VAR_DECLARATOR id=variableDeclaratorId[output] initializer=variableInitializer[obtype, output]?)
-        -> {$output}? var_decl(id={$id.st}, initializer={$initializer.st})
-        -> {!$output}? var_decl(id={$id.st})
+        -> {$output && emitCC()}? var_decl_cc(id={$id.st}, initializer={$initializer.st})
+        -> {$output && emitH()}?  var_decl_h(id={$id.st}, initializer={$initializer.st})
+        -> {$output && emitCI()}? var_decl_ci(id={$id.st}, initializer={$initializer.st})
+        -> {!$output && emitCC()}? var_decl_cc(id={$id.st})
+        -> {!$output && emitH()}?  var_decl_h(id={$id.st})
+        -> {!$output && emitCI()}? var_decl_ci(id={$id.st})
         ->
-    ;
+    ; 
     
 variableDeclaratorId[boolean output]
     :   ^(IDENT de=domainExpression[null]?)
@@ -337,6 +316,8 @@ variableInitializer[StringTemplate obtype, boolean output]
         -> {$arrayInitializer.st}
     |   newExpression[obtype, output]
         -> {$newExpression.st}
+    |   expression
+        -> {$expression.st}
     ;
 
 rangeItem
@@ -395,59 +376,128 @@ throwsClause
     ;
 
 modifierList
-    :   ^(MODIFIER_LIST (m+=modifier)+)
-        -> mod_list(mods={$m})
+    :   ^(MODIFIER_LIST accessModifierList? localModifierList? charjModifierList? otherModifierList?)
+        ->  {emitCC()}? mod_list_cc(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
+        ->  {emitH()}? mod_list_h(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
+        ->  {emitCI()}? mod_list_ci(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
+        ->
     ;
 
 modifier
-@init {
-$st = %{$start.getText()};
-}
-    :   'public'
-    |   'protected'
-    |   'private'
-    |   'entry'
-    |   'abstract'
-    |   'native'
+    :   accessModifier
     |   localModifier
-        -> {$localModifier.st}
+    |   charjModifier
+    |   otherModifier
     ;
 
+accessModifierList
+returns [List names]
+    :   ^(ACCESS_MODIFIER_LIST (m+=accessModifier)+)
+        {
+            $names = $m;
+        }
+    ;
 localModifierList
+returns [List names]
     :   ^(LOCAL_MODIFIER_LIST (m+=localModifier)+)
-        -> local_mod_list(mods={$m})
+        {
+            $names = $m;
+        }
+        ->  local_mod_list(mods = {$names})
     ;
 
+charjModifierList
+returns [List names]
+    :   ^(CHARJ_MODIFIER_LIST (m+=charjModifier)+)
+        {
+            $names = $m;
+        }
+    ;
+
+otherModifierList
+returns [List names]
+    :   ^(OTHER_MODIFIER_LIST (m+=otherModifier)+)
+        {
+            $names = $m;
+        }
+    ;
+    
 localModifier
-@init {
-$st = %{$start.getText()};
+@init
+{
+    $st = %{$start.getText()};
+}
+    :   FINAL
+    |   STATIC
+    |   VOLATILE
+    ;
+
+accessModifier
+@init
+{
+    $st = %{$start.getText()};
+}
+    :   PUBLIC
+    |   PROTECTED
+    |   PRIVATE
+    ;
+
+charjModifier
+@init
+{
+    $st = %{$start.getText()};
 }
-    :   'final'
-    |   'static'
-    |   'volatile'
+    :   ENTRY
     ;
 
+otherModifier
+@init
+{
+    $st = %{$start.getText()};
+}
+    :   ABSTRACT
+    |   NATIVE
+    ;
     
 type
     :   simpleType
         -> {$simpleType.st}
     |   objectType 
         -> {$objectType.st}
+    |   VOID
+        {
+            $st = %{$start.getText()};
+        }
     ;
 
 simpleType
-    :   ^(TYPE primitiveType domainExpression[null]?)
-        -> type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
+    :   ^(SIMPLE_TYPE primitiveType domainExpression[null]?)
+        -> simple_type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
     ;
 
 objectType
-    :   ^(TYPE qualifiedTypeIdent domainExpression[null]?)
-        -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
+    : proxyType -> {$proxyType.st;}
+    | nonProxyType -> {$nonProxyType.st}
+    ;
+
+nonProxyType
+    :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression[null]?)
+        -> obj_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
+    |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression[null]?)
+        -> pointer_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
+    |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression[null]?)
+        -> reference_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
     ;
 
-qualifiedTypeIdent
-    :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+) 
-        -> template(types={$t}) "<types; separator=\".\">"
+proxyType
+    :   ^(PROXY_TYPE qualifiedTypeIdent domainExpression[null]?)
+        -> proxy_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
+    ;
+
+qualifiedTypeIdent returns [ClassSymbol type]
+    :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+)
+        {$type = (ClassSymbol)$QUALIFIED_TYPE_IDENT.symbol;}
+        -> template(types={$t}) "<types; separator=\"::\">"
     ;
 
 typeIdent
@@ -459,16 +509,16 @@ primitiveType
 @init {
 $st = %{$start.getText()};
 }
-    :   'boolean'
+    :   BOOLEAN
         -> template() "bool"
-    |   'char'
-    |   'byte'
+    |   CHAR
+    |   BYTE
         -> template() "char"
-    |   'short'
-    |   'int'
-    |   'long'
-    |   'float'
-    |   'double'
+    |   SHORT
+    |   INT
+    |   LONG
+    |   FLOAT
+    |   DOUBLE
     ;
 
 templateArg
@@ -520,7 +570,7 @@ formalParameterVarargDecl
 qualifiedIdentifier
     :   IDENT
         -> template(t={$text}) "<t>"
-    |   ^('.' qualifiedIdentifier IDENT)
+    |   ^(DOT qualifiedIdentifier IDENT)
         -> template(t={$text}) "<t>"
     ;
     
@@ -544,56 +594,71 @@ blockStatement
 localVariableDeclaration
     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType vdl=variableDeclaratorList[null, true])
         -> local_var_decl(
-            modList={null},
+            modList={$localModifierList.st},
             type={$simpleType.st},
             declList={$vdl.st})
     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType vdl=variableDeclaratorList[$objectType.st, true])
         -> local_var_decl(
-            modList={null},
+            modList={$localModifierList.st},
             type={$objectType.st},
             declList={$vdl.st})
     ;
 
 
 statement
-    :   block
+    :   nonBlockStatement
+        -> {$nonBlockStatement.st}
+    |   block
         -> {$block.st}
-    |   ^('assert' cond=expression msg=expression?)
+    ;
+
+nonBlockStatement
+    :   ^(ASSERT cond=expression msg=expression?)
         -> assert(cond={$cond.st}, msg={$msg.st})
-    |   ^('if' parenthesizedExpression then=statement else_=statement?)
+    |   ^(IF parenthesizedExpression then=block else_=block?)
         -> if(cond={$parenthesizedExpression.st}, then={$then.st}, else_={$else_.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
+    |   ^(FOR forInit? FOR_EXPR cond=expression? FOR_UPDATE (update+=expression)* b=block)
+        -> for(initializer={$forInit.st}, cond={$cond.st}, update={$update}, body={$block.st})
+    |   ^(FOR_EACH localModifierList? type IDENT expression block
         -> template(t={$text}) "/* foreach not implemented */ <t>"
-    |   ^('while' pe=parenthesizedExpression s=statement)
-        -> while(cond={$pe.st}, body={$s.st})
-    |   ^('do' s=statement pe=parenthesizedExpression)
-        -> dowhile(cond={$pe.st}, block={$s.st})
-    |   ^('switch' pe=parenthesizedExpression (scls+=switchCaseLabel)*)
+    |   ^(WHILE pe=parenthesizedExpression b=block)
+        -> while(cond={$pe.st}, body={$b.st})
+    |   ^(DO b=block pe=parenthesizedExpression)
+        -> dowhile(cond={$pe.st}, block={$b.st})
+    |   ^(SWITCH pe=parenthesizedExpression (scls+=switchCaseLabel)*)
         -> switch(expr={$pe.st}, labels={$scls})
-    |   ^('return' e=expression?)
+    |   ^(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>;"
+    |   ^('delete' qualifiedIdentifier)
+        -> template(t={$qualifiedIdentifier.st}) "delete <t>;"
     |   ^('embed' STRING_LITERAL EMBED_BLOCK)
         ->  embed_cc(str={$STRING_LITERAL.text}, blk={$EMBED_BLOCK.text})
     |   ';' // Empty statement.
         -> {%{$start.getText()}}
+    |   ^(PRINT (exprs += expression)*)
+        ->  print(exprs = {$exprs})
+    |   ^(PRINTLN (exprs += expression)*)
+        ->  println(exprs = {$exprs})
+    |   ^(EXIT expression?)
+        ->  exit(expr = {$expression.st})
+    |   EXITALL
+        ->  exitall()
     ;
         
 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>"
     ;
     
@@ -619,7 +684,7 @@ expression
     ;
 
 expr
-    :   ^('=' e1=expr e2=expr)
+    :   ^(ASSIGNMENT e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> = <e2>"
     |   ^('+=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> += <e2>"
@@ -649,13 +714,13 @@ expr
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> || <e2>"
     |   ^('&&' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> && <e2>"
-    |   ^('|' e1=expr e2=expr)
+    |   ^(BITWISE_OR e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> | <e2>"
     |   ^('^' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^ <e2>"
     |   ^('&' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> & <e2>"
-    |   ^('==' e1=expr e2=expr)
+    |   ^(EQUALS e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> == <e2>"
     |   ^('!=' e1=expr e2=expr)
         -> template(e1={$e1.st}, e2={$e2.st}) "<e1> != <e2>"
@@ -697,29 +762,37 @@ expr
         -> template(e1={$e1.st}) "<e1>++"
     |   ^(POST_DEC e1=expr)
         -> template(e1={$e1.st}) "<e1>--"
-    |   ^('~' e1=expr)
+    |   ^(TILDE e1=expr)
         -> template(e1={$e1.st}) "~<e1>"
-    |   ^('!' e1=expr)
+    |   ^(NOT e1=expr)
         -> template(e1={$e1.st}) "!<e1>"
     |   ^(CAST_EXPR ty=type e1=expr)
         -> template(ty={$ty.st}, e1={$e1.st}) "(<ty>)<e1>"
     |   primaryExpression
         -> {$primaryExpression.st}
     ;
-    
+
 primaryExpression
-    :   ^('.' prim=primaryExpression IDENT)
-        -> template(id={$IDENT}, prim={$prim.st}) "<prim>.<id>"
-    |   ^('.' prim=primaryExpression 'this')
-        -> template(prim={$prim.st}) "<prim>.this"
-    |   ^('.' prim=primaryExpression 'super')
-        -> template(prim={$prim.st}) "<prim>.super"
+    :   ^(DOT prim=primaryExpression
+            ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>.<id>"
+            | THIS    -> template(prim={$prim.st}) "<prim>.this"
+            | SUPER   -> template(prim={$prim.st}) "<prim>.super"
+            )
+        )
+    |   ^(ARROW prim=primaryExpression
+            ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>-><id>"
+            | THIS    -> template(prim={$prim.st}) "<prim>->this"
+            | SUPER   -> template(prim={$prim.st}) "<prim>->super"
+            )
+        )
     |   parenthesizedExpression
         -> {$parenthesizedExpression.st}
     |   IDENT
         -> {%{$start.getText()}}
     |   ^(METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
         -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
+    |   ^(ENTRY_METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
+        -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
     |   explicitConstructorCall
         -> {$explicitConstructorCall.st}
     |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression ex=expression)
@@ -728,12 +801,23 @@ primaryExpression
         -> {$literal.st}
     |   newExpression[null, false]
         -> {$newExpression.st}
-    |   'this'
+    |   THIS
         -> {%{$start.getText()}}
     |   arrayTypeDeclarator
         -> {$arrayTypeDeclarator.st}
-    |   'super'
+    |   SUPER
         -> {%{$start.getText()}}
+    |   GETNUMPES
+        ->  template() "CkNumPes()"
+    |   GETNUMNODES
+        ->  template() "CkNumNodes()"
+    |   GETMYPE
+        ->  template() "CkMyPe()"
+    |   GETMYNODE
+        ->  template() "CkMyNode()"
+    |   GETMYRANK
+        ->  template() "CkMyRank()"
+
     ;
     
 explicitConstructorCall
@@ -753,6 +837,10 @@ newExpression[StringTemplate obtype, boolean output] returns [StringTemplate ini
         -> {$output}? template(domain={$domainExpression.st},type={$obtype}) "new <type>(<domain>)"
         -> {!$output}? template() ""
         ->
+    |   ^(NEW proxyType arguments)
+        -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
+    |   ^(NEW nonProxyType arguments)
+        -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
     ;
 
 /*newExpression
@@ -762,6 +850,10 @@ newExpression[StringTemplate obtype, boolean output] returns [StringTemplate ini
             )
         )
         -> template(t={$text}) "<t>"
+    |   ^(NEW proxyType arguments)
+        -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
+    |   ^(NEW nonProxyType arguments)
+        -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
     ;
 */
 /*newArrayConstruction
@@ -791,8 +883,8 @@ $st = %{$start.getText()};
     |   FLOATING_POINT_LITERAL
     |   CHARACTER_LITERAL
     |   STRING_LITERAL
-    |   'true'
-    |   'false'
-    |   'null'
+    |   TRUE
+    |   FALSE
+    |   NULL
     ;