Combined all emitter grammars into one grammar with output templates controlled by
authorAaron Becker <abecker3@illinois.edu>
Mon, 9 Jun 2008 04:21:21 +0000 (04:21 +0000)
committerAaron Becker <abecker3@illinois.edu>
Mon, 9 Jun 2008 04:21:21 +0000 (04:21 +0000)
an OutputMode parameter. Combined all templates into one group. Made coding style
more consistent

src/langs/charj/build.xml
src/langs/charj/src/charj/Main.java
src/langs/charj/src/charj/translator/Charj.stg
src/langs/charj/src/charj/translator/CharjEmitter.g
src/langs/charj/src/charj/translator/Translator.java

index 193528d08455a2696019d84e205676f7ebaee1ab..611ba4c29b8bf9633e5f7d7fcadd2903096ea451 100644 (file)
@@ -81,9 +81,7 @@
     </target>\r
 \r
     <target name="CharjEmitter" depends="Charj">\r
-        <antlr3 grammar.name="CharjCCEmitter.g" \r
-            grammar.path="${buildsrc}/charj/translator"/>\r
-        <antlr3 grammar.name="CharjCIEmitter.g" \r
+        <antlr3 grammar.name="CharjEmitter.g" \r
             grammar.path="${buildsrc}/charj/translator"/>\r
     </target>\r
 \r
index 528123d1ccadccc09e0534adf0eba4dc90f978da..236d5e7be966ffe86c1bb9275689cc483cfbc843 100644 (file)
@@ -7,17 +7,17 @@ import com.martiansoftware.jsap.*;
 
 public class Main 
 {
-    public static String charmc;
-    public static boolean debug;
-    public static boolean verbose;
-    public static boolean stdout;
+    public static String m_charmc;
+    public static boolean m_debug;
+    public static boolean m_verbose;
+    public static boolean m_stdout;
 
     public static void main(String[] args) throws Exception
     {
         String[] files = processArgs(args);
-        Translator t = new Translator(charmc, debug, verbose);
+        Translator t = new Translator(m_charmc, m_debug, m_verbose);
         for (String filename : files) { 
-            if (!stdout) {
+            if (!m_stdout) {
                 t.translate(filename);
             } else {
                 String header = "\n\n" + filename + "\n";
@@ -74,10 +74,10 @@ public class Main
             System.exit(1);
         }
 
-        charmc = config.getString("charmc") + charmcFlags;
-        debug = config.getBoolean("debug", false);
-        verbose = config.getBoolean("verbose", false);
-        stdout = config.getBoolean("stdout", false);
+        m_charmc = config.getString("charmc") + charmcFlags;
+        m_debug = config.getBoolean("debug", false);
+        m_verbose = config.getBoolean("verbose", false);
+        m_stdout = config.getBoolean("stdout", false);
         String[] files = config.getStringArray("files");
         return files;
     }
index 9a420f5a1643bf244ca5bfda7d50e90e2e23b4c6..4b9c92377a31d6fdffd3875f843bd2265b7a3d93 100644 (file)
 group Charj;
 
-classExtends(type) ::= ": public CBase_<type>"
+charjSource_ci(pd, ids, tds) ::= 
+//<pd>
+//<ids>
+<<
+<tds>
+>>
+
+
+charjSource_cc(pd, ids, tds) ::= 
+<<
+<pd>
+<ids>
+<tds>
+>>
+
+
+classExtends_ci(type) ::= "<type>"
+
+
+classExtends_cc(type) ::= ": public CBase_<type>"
+
+
+interfaceExtends_ci(ts) ::=
+<<
+: public <ts; separator=", public ">
+>>
+
+
+interfaceExtends_cc(ts) ::=
+<<
+: public <ts; separator=", public ">
+>>
+
+
+classDeclaration_ci(mod, ident, gen, ext, impl, ctls) ::=
+<<
+module <ident> {
+    <ident> <gen>: public <ext> {
+        <ctls>
+    }
+}
+
+>>
+
+
+classDeclaration_cc(mod, ident, gen, ext, impl, ctls) ::=
+<<
+
+
+#include "<ident>.decl.h"
+<mod> class <ident> <gen>: public CBase_<ident> <impl> {
+    <ctls>
+};
+#include "<ident>.def.h"
 
 
-interfaceExtends(ts) ::=
+>>
+
+
+classTopLevelScope_ci(classScopeDeclarations) ::= 
+<<
+// _classTopLevelScope_
+<classScopeDeclarations; separator="\n">
+// _!classTopLevelScope_
+>>
+
+
+classTopLevelScope_cc(classScopeDeclarations) ::= 
+<<
+// _classTopLevelScope_
+<classScopeDeclarations; separator="\n">
+// _!classTopLevelScope_
+>>
+
+
+funcMethodDecl_cc(modl, 
+            gtpl,
+            ty,
+            id,
+            fpl,
+            adl,
+            tc,
+            block) ::=
+<<
+<modl>: <ty> <gtpl> <id><fpl> <adl> <tc> <block>
+>>
+
+
+voidMethodDecl_ci(modl, gtpl, id, fpl, tc, block) ::=
+<<
+entry void<gtpl> <id><fpl> <tc>;
+>>
+
+
+voidMethodDecl_cc(modl, gtpl, id, fpl, tc, block) ::=
+<<
+<modl>: void<gtpl> <id><fpl> <tc> <block>
+>>
+
+
+ctorDecl_ci(modl, gtpl, id, fpl, tc, block) ::=
 <<
-: public CBase_<ts; separator=", public CBase_">
+entry<gtpl> <id><fpl> <tc>;
 >>
 
+
+ctorDecl_cc(modl, gtpl, id, fpl, tc, block) ::=
+<<
+<modl>:<gtpl> <id><fpl> <tc> <block>
+>>
+
+
index b354217b89aad4f98724d338ae5216ebf7987636..16a208481bc135661bb591b5a32076210e6ff913 100644 (file)
@@ -10,24 +10,28 @@ options {
     tokenVocab = Charj;
     ASTLabelType = CommonTree;
     output = template;
-    rewrite = true;
 }
 
 
-@treeparser::header {
+@header {
 package charj.translator;
 }
 
-@treeparser::members {
-    
-    boolean mMessageCollectionEnabled = false;
-    private boolean mHasErrors = false;
-    List<String> mMessages;
+@members {
+    OutputMode m_mode;
+    boolean m_messageCollectionEnabled = false;
+    private boolean m_hasErrors = false;
+    List<String> m_messages;
+
+    private boolean emitCC() { return m_mode == OutputMode.cc; }
+    private boolean emitCI() { return m_mode == OutputMode.ci; }
+    private boolean emitH() { return m_mode == OutputMode.h; }
 
     /**
      *  Switches error message collection on or off.
      *
-     *  The standard destination for parser error messages is <code>System.err</code>.
+     *  The standard destination for parser error messages is 
+     *  <code>System.err</code>.
      *  However, if <code>true</code> gets passed to this method this default
      *  behaviour will be switched off and all error messages will be collected
      *  instead of written to anywhere.
@@ -36,10 +40,10 @@ package charj.translator;
      *
      *  @param pNewState  <code>true</code> if error messages should be collected.
      */
-    public void enableErrorMessageCollection(boolean pNewState) {
-        mMessageCollectionEnabled = pNewState;
-        if (mMessages == null && mMessageCollectionEnabled) {
-            mMessages = new ArrayList<String>();
+    public void enableErrorMessageCollection(boolean newState) {
+        m_messageCollectionEnabled = newState;
+        if (m_messages == null && m_messageCollectionEnabled) {
+            m_messages = new ArrayList<String>();
         }
     }
     
@@ -53,11 +57,11 @@ package charj.translator;
      *  @param pMessage  The error message.
      */
      @Override
-    public void emitErrorMessage(String pMessage) {
-        if (mMessageCollectionEnabled) {
-            mMessages.add(pMessage);
+    public void emitErrorMessage(String message) {
+        if (m_messageCollectionEnabled) {
+            m_messages.add(message);
         } else {
-            super.emitErrorMessage(pMessage);
+            super.emitErrorMessage(message);
         }
     }
     
@@ -69,7 +73,7 @@ package charj.translator;
      *           list may be empty if no error message has been emited.
      */
     public List<String> getMessages() {
-        return mMessages;
+        return m_messages;
     }
     
     /**
@@ -79,327 +83,532 @@ package charj.translator;
      *           least one error message.
      */
     public boolean hasErrors() {
-        return mHasErrors;
+        return m_hasErrors;
     }
 }
 
 // Starting point for parsing a Charj file.
-charjSource
-    :   ^(CHARJ_SOURCE packageDeclaration? importDeclaration* (ts+=typeDeclaration)*)
-        -> template(allText={$text}, types={$ts}) <<
-        <allText>
-        >>
+charjSource[OutputMode m]
+@init {
+    this.m_mode = m;
+}
+    :   ^(CHARJ_SOURCE (p=packageDeclaration)? (i+=importDeclaration)* (t+=typeDeclaration)*)
+        -> {emitCC()}? charjSource_cc(pd={$p.st}, ids={$i}, tds={$t})
+        -> charjSource_ci(pd={$p.st}, ids={$i}, tds={$t})
     ;
 
 packageDeclaration
     :   ^(PACKAGE qualifiedIdentifier)  
+        -> template(t={$text}) "//<t>"
     ;
     
 importDeclaration
     :   ^(IMPORT STATIC? qualifiedIdentifier DOTSTAR?)
+        -> template(t={$text}) "//<t>"
     ;
     
 typeDeclaration
-    :   ^(CLASS modifierList IDENT genericTypeParameterList? classExtendsClause? implementsClause? classTopLevelScope) -> template(t={$text}) "<t>"
+    :   ^(CLASS m=modifierList IDENT g=genericTypeParameterList? e=classExtendsClause? i=implementsClause? c=classTopLevelScope) 
+        -> {emitCC()}? classDeclaration_cc(
+            mod={$m.st}, 
+            ident={$IDENT.text}, 
+            gen={$g.st}, 
+            ext={$e.st}, 
+            impl={$i.st},
+            ctls={$c.st})
+        -> classDeclaration_ci(
+            mod={$m.st}, 
+            ident={$IDENT.text}, 
+            gen={$g.st}, 
+            ext={$e.st}, 
+            impl={$i.st},
+            ctls={$c.st})
     |   ^(INTERFACE modifierList IDENT genericTypeParameterList? interfaceExtendsClause? interfaceTopLevelScope)
+        -> template(t={$text}) "<t>"
     |   ^(ENUM modifierList IDENT implementsClause? enumTopLevelScope)
+        -> template(t={$text}) "<t>"
     ;
 
 
 classExtendsClause
-    :   ^(EXTENDS_CLAUSE t=type) -> classExtends(type={$t.st})
+    :   ^(EXTENDS_CLAUSE t=type) 
+        -> {emitCC()}? classExtends_cc(type={$t.st})
+        -> classExtends_ci(type={$t.st})
     ;   
 
 interfaceExtendsClause 
-    :   ^(EXTENDS_CLAUSE (typeList+=type)+) -> interfaceExtends(ts={$typeList})
+    :   ^(EXTENDS_CLAUSE (typeList+=type)+) 
+        -> {emitCC()}? interfaceExtends_cc(ts={$typeList})
+        -> interfaceExtends_ci(ts={$typeList})
     ;   
     
 implementsClause
     :   ^(IMPLEMENTS_CLAUSE type+)
+        -> template(t={$text}) "<t>"
     ;
         
 genericTypeParameterList
     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
+        -> template(t={$text}) "<t>"
     ;
 
 genericTypeParameter
     :   ^(IDENT bound?)
+        -> template(t={$text}) "<t>"
     ;
         
 bound
     :   ^(EXTENDS_BOUND_LIST type+)
+        -> template(t={$text}) "<t>"
     ;
 
 enumTopLevelScope
     :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
+        -> template(t={$text}) "<t>"
     ;
     
 enumConstant
     :   ^(IDENT arguments? classTopLevelScope?)
+        -> template(t={$text}) "<t>"
     ;
     
     
 classTopLevelScope
-    :   ^(CLASS_TOP_LEVEL_SCOPE classScopeDeclarations*)
+    :   ^(CLASS_TOP_LEVEL_SCOPE (csd+=classScopeDeclarations)*) 
+        -> {emitCC()}? classTopLevelScope_cc(classScopeDeclarations={$csd})
+        -> classTopLevelScope_ci(classScopeDeclarations={$csd})
     ;
     
 classScopeDeclarations
     :   ^(CLASS_INSTANCE_INITIALIZER block)
+        -> template(t={$text}) "/*cii*/ <t>"
     |   ^(CLASS_STATIC_INITIALIZER block)
-    |   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
-    |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
+        -> template(t={$text}) "/*csi*/ <t>"
+    |   ^(FUNCTION_METHOD_DECL m=modifierList g=genericTypeParameterList? 
+            ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
+            tt=throwsClause? b=block?)
+        -> funcMethodDecl_cc(
+            modl={$m.st}, 
+            gtpl={$g.st}, 
+            ty={$t.text},
+            id={$IDENT.text}, 
+            fpl={$f.st}, 
+            adl={$a.st},
+            tc={$tt.st}, 
+            block={$b.st})
+    |   ^(VOID_METHOD_DECL m=modifierList g=genericTypeParameterList? IDENT 
+            f=formalParameterList t=throwsClause? b=block?)
+        -> {emitCC()}? voidMethodDecl_cc(
+            modl={$m.st}, 
+            gtpl={$g.st}, 
+            id={$IDENT.text}, 
+            fpl={$f.st}, 
+            tc={$t.st}, 
+            block={$b.st})
+        -> voidMethodDecl_ci(
+            modl={$m.st}, 
+            gtpl={$g.st}, 
+            id={$IDENT.text}, 
+            fpl={$f.st}, 
+            tc={$t.st}, 
+            block={$b.st})
+
+// template(t={$text}) "/*voidmethod*/ <t>"
     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
-    |   ^(CONSTRUCTOR_DECL modifierList genericTypeParameterList? formalParameterList throwsClause? block)
-    |   typeDeclaration
+        -> template(t={$text}) "vardecl <t>"
+    |   ^(CONSTRUCTOR_DECL m=modifierList g=genericTypeParameterList? IDENT f=formalParameterList 
+            t=throwsClause? b=block)
+        -> {emitCC()}? ctorDecl_cc(
+            modl={$m.st}, 
+            gtpl={$g.st}, 
+            id={$IDENT.text}, 
+            fpl={$f.st}, 
+            tc={$t.st}, 
+            block={$b.st})
+        -> ctorDecl_ci(
+            modl={$m.st}, 
+            gtpl={$g.st}, 
+            id={$IDENT.text}, 
+            fpl={$f.st}, 
+            tc={$t.st}, 
+            block={$b.st})
+        //-> template(t={$text}) "ctor <t>"
+    |   d=typeDeclaration
+        -> template(t={$d.st}) "type <t>"
     ;
     
 interfaceTopLevelScope
     :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
+        -> template(t={$text}) "<t>"
     ;
     
 interfaceScopeDeclarations
     :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
+        -> template(t={$text}) "<t>"
     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
+        -> template(t={$text}) "<t>"
         // Interface constant declarations have been switched to variable
         // declarations by Charj.g; the parser has already checked that
         // there's an obligatory initializer.
     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
+        -> template(t={$text}) "<t>"
     |   typeDeclaration
+        -> template(t={$text}) "<t>"
     ;
 
 variableDeclaratorList
     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
+        -> template(t={$text}) "<t>"
     ;
 
 variableDeclarator
     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
+        -> template(t={$text}) "<t>"
     ;
     
 variableDeclaratorId
     :   ^(IDENT arrayDeclaratorList?)
+        -> template(t={$text}) "<t>"
     ;
 
 variableInitializer
     :   arrayInitializer
+        -> template(t={$text}) "<t>"
     |   expression
+        -> template(t={$text}) "<t>"
     ;
 
 arrayDeclarator
     :   LBRACK RBRACK
+        -> template(t={$text}) "<t>"
     ;
 
 arrayDeclaratorList
     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
+        -> template(t={$text}) "<t>"
     ;
     
 arrayInitializer
     :   ^(ARRAY_INITIALIZER variableInitializer*)
+        -> template(t={$text}) "<t>"
     ;
 
 throwsClause
     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
+        -> template(t={$text}) "<t>"
     ;
 
 modifierList
-    :   ^(MODIFIER_LIST modifier*)
+    :   ^(MODIFIER_LIST (m+=modifier)*)
+        -> template(mod={$m}) "<mod; separator=\" \">"
     ;
 
 modifier
     :   PUBLIC
+        -> template(t={$text}) "<t>"
     |   PROTECTED
+        -> template(t={$text}) "<t>"
     |   PRIVATE
+        -> template(t={$text}) "<t>"
+    |   ENTRY
+        -> template() "public"
     |   STATIC
+        -> template(t={$text}) "<t>"
     |   ABSTRACT
+        -> template(t={$text}) "<t>"
     |   NATIVE
+        -> template(t={$text}) "<t>"
     |   SYNCHRONIZED
+        -> template(t={$text}) "<t>"
     |   TRANSIENT
+        -> template(t={$text}) "<t>"
     |   VOLATILE
+        -> template(t={$text}) "<t>"
     |   localModifier
+        -> template(t={$text}) "<t>"
     ;
 
 localModifierList
     :   ^(LOCAL_MODIFIER_LIST localModifier*)
+        -> template(t={$text}) "<t>"
     ;
 
 localModifier
     :   FINAL
+        -> template(t={$text}) "<t>"
     ;
 
 type
-    :   ^(TYPE (primitiveType | qualifiedTypeIdent) arrayDeclaratorList?) -> template(t={$text}) "<t>"
+    :   ^(TYPE (primitiveType | qualifiedTypeIdent) arrayDeclaratorList?) 
+        -> template(t={$text}) "<t>"
     ;
 
 qualifiedTypeIdent
     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
+        -> template(t={$text}) "<t>"
     ;
 
 typeIdent
     :   ^(IDENT genericTypeArgumentList?)
+        -> template(t={$text}) "<t>"
     ;
 
 primitiveType
     :   BOOLEAN
+        -> template(t={$text}) "<t>"
     |   CHAR
+        -> template(t={$text}) "<t>"
     |   BYTE
+        -> template(t={$text}) "<t>"
     |   SHORT
+        -> template(t={$text}) "<t>"
     |   INT
+        -> template(t={$text}) "<t>"
     |   LONG
+        -> template(t={$text}) "<t>"
     |   FLOAT
+        -> template(t={$text}) "<t>"
     |   DOUBLE
+        -> template(t={$text}) "<t>"
     ;
 
 genericTypeArgumentList
     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
+        -> template(t={$text}) "<t>"
     ;
     
 genericTypeArgument
     :   type
+        -> template(t={$text}) "<t>"
     |   ^(QUESTION genericWildcardBoundType?)
+        -> template(t={$text}) "<t>"
     ;
 
 genericWildcardBoundType                                                                                                                      
     :   ^(EXTENDS type)
+        -> template(t={$text}) "<t>"
     |   ^(SUPER type)
+        -> template(t={$text}) "<t>"
     ;
 
 formalParameterList
     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
+        -> template(t={$text}) "<t>"
     ;
     
 formalParameterStandardDecl
     :   ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
+        -> template(t={$text}) "<t>"
     ;
     
 formalParameterVarargDecl
     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
+        -> template(t={$text}) "<t>"
     ;
     
 qualifiedIdentifier
     :   IDENT
+        -> template(t={$text}) "<t>"
     |   ^(DOT qualifiedIdentifier IDENT)
+        -> template(t={$text}) "<t>"
     ;
     
 block
     :   ^(BLOCK_SCOPE blockStatement*)
+        -> template(t={$text}) "<t>"
     ;
     
 blockStatement
     :   localVariableDeclaration
+        -> template(t={$text}) "<t>"
     |   typeDeclaration
+        -> template(t={$text}) "<t>"
     |   statement
+        -> template(t={$text}) "<t>"
     ;
     
 localVariableDeclaration
     :   ^(VAR_DECLARATION localModifierList type variableDeclaratorList)
+        -> template(t={$text}) "<t>"
     ;
     
         
 statement
     :   block
+        -> template(t={$text}) "<t>"
     |   ^(ASSERT expression expression?)
+        -> template(t={$text}) "<t>"
     |   ^(IF parenthesizedExpression statement statement?)
+        -> template(t={$text}) "<t>"
     |   ^(FOR forInit forCondition forUpdater statement)
+        -> template(t={$text}) "<t>"
     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
+        -> template(t={$text}) "<t>"
     |   ^(WHILE parenthesizedExpression statement)
+        -> template(t={$text}) "<t>"
     |   ^(DO statement parenthesizedExpression)
+        -> template(t={$text}) "<t>"
     |   ^(TRY block catches? block?)  // The second optional block is the optional finally block.
+        -> template(t={$text}) "<t>"
     |   ^(SWITCH parenthesizedExpression switchBlockLabels)
+        -> template(t={$text}) "<t>"
     |   ^(SYNCHRONIZED parenthesizedExpression block)
+        -> template(t={$text}) "<t>"
     |   ^(RETURN expression?)
+        -> template(t={$text}) "<t>"
     |   ^(THROW expression)
+        -> template(t={$text}) "<t>"
     |   ^(BREAK IDENT?)
+        -> template(t={$text}) "<t>"
     |   ^(CONTINUE IDENT?)
+        -> template(t={$text}) "<t>"
     |   ^(LABELED_STATEMENT IDENT statement)
+        -> template(t={$text}) "<t>"
     |   expression
+        -> template(t={$text}) "<t>"
     |   SEMI // Empty statement.
+        -> template(t={$text}) "<t>"
     ;
         
 catches
     :   ^(CATCH_CLAUSE_LIST catchClause+)
+        -> template(t={$text}) "<t>"
     ;
     
 catchClause
     :   ^(CATCH formalParameterStandardDecl block)
+        -> template(t={$text}) "<t>"
     ;
 
 switchBlockLabels
     :   ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabel* switchDefaultLabel? switchCaseLabel*)
+        -> template(t={$text}) "<t>"
     ;
         
 switchCaseLabel
     :   ^(CASE expression blockStatement*)
+        -> template(t={$text}) "<t>"
     ;
     
 switchDefaultLabel
     :   ^(DEFAULT blockStatement*)
+        -> template(t={$text}) "<t>"
     ;
     
 forInit
     :   ^(FOR_INIT (localVariableDeclaration | expression*)?)
+        -> template(t={$text}) "<t>"
     ;
     
 forCondition
     :   ^(FOR_CONDITION expression?)
+        -> template(t={$text}) "<t>"
     ;
     
 forUpdater
     :   ^(FOR_UPDATE expression*)
+        -> template(t={$text}) "<t>"
     ;
     
 // EXPRESSIONS
 
 parenthesizedExpression
     :   ^(PARENTESIZED_EXPR expression)
+        -> template(t={$text}) "<t>"
     ;
     
 expression
     :   ^(EXPR expr)
+        -> template(t={$text}) "<t>"
     ;
 
 expr
     :   ^(ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(PLUS_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(MINUS_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(STAR_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(DIV_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(AND_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(OR_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(XOR_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(MOD_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(BIT_SHIFT_RIGHT_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(SHIFT_RIGHT_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(SHIFT_LEFT_ASSIGN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(QUESTION expr expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(LOGICAL_OR expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(LOGICAL_AND expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(OR expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(XOR expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(AND expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(EQUAL expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(NOT_EQUAL expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(INSTANCEOF expr type)
+        -> template(t={$text}) "<t>"
     |   ^(LESS_OR_EQUAL expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(GREATER_OR_EQUAL expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(BIT_SHIFT_RIGHT expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(SHIFT_RIGHT expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(GREATER_THAN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(SHIFT_LEFT expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(LESS_THAN expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(PLUS expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(MINUS expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(STAR expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(DIV expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(MOD expr expr)
+        -> template(t={$text}) "<t>"
     |   ^(UNARY_PLUS expr)
+        -> template(t={$text}) "<t>"
     |   ^(UNARY_MINUS expr)
+        -> template(t={$text}) "<t>"
     |   ^(PRE_INC expr)
+        -> template(t={$text}) "<t>"
     |   ^(PRE_DEC expr)
+        -> template(t={$text}) "<t>"
     |   ^(POST_INC expr)
+        -> template(t={$text}) "<t>"
     |   ^(POST_DEC expr)
+        -> template(t={$text}) "<t>"
     |   ^(NOT expr)
+        -> template(t={$text}) "<t>"
     |   ^(LOGICAL_NOT expr)
+        -> template(t={$text}) "<t>"
     |   ^(CAST_EXPR type expr)
+        -> template(t={$text}) "<t>"
     |   primaryExpression
+        -> template(t={$text}) "<t>"
     ;
     
 primaryExpression
@@ -415,25 +624,39 @@ primaryExpression
             |   VOID CLASS
             )
         )
+        -> template(t={$text}) "<t>"
     |   parenthesizedExpression
+        -> template(t={$text}) "<t>"
     |   IDENT
+        -> template(t={$text}) "<t>"
     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
+        -> template(t={$text}) "<t>"
     |   explicitConstructorCall
+        -> template(t={$text}) "<t>"
     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
+        -> template(t={$text}) "<t>"
     |   literal
+        -> template(t={$text}) "<t>"
     |   newExpression
+        -> template(t={$text}) "<t>"
     |   THIS
+        -> template(t={$text}) "<t>"
     |   arrayTypeDeclarator
+        -> template(t={$text}) "<t>"
     |   SUPER
+        -> template(t={$text}) "<t>"
     ;
     
 explicitConstructorCall
     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
+        -> template(t={$text}) "<t>"
     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
+        -> template(t={$text}) "<t>"
     ;
 
 arrayTypeDeclarator
     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
+        -> template(t={$text}) "<t>"
     ;
 
 newExpression
@@ -442,30 +665,45 @@ newExpression
             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
             )
         )
+        -> 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}) "<t>"
     ;
     
 newArrayConstruction
     :   arrayDeclaratorList arrayInitializer
+        -> template(t={$text}) "<t>"
     |   expression+ arrayDeclaratorList?
+        -> template(t={$text}) "<t>"
     ;
 
 arguments
     :   ^(ARGUMENT_LIST expression*)
+        -> template(t={$text}) "<t>"
     ;
 
 literal 
     :   HEX_LITERAL
+        -> template(t={$text}) "<t>"
     |   OCTAL_LITERAL
+        -> template(t={$text}) "<t>"
     |   DECIMAL_LITERAL
+        -> template(t={$text}) "<t>"
     |   FLOATING_POINT_LITERAL
+        -> template(t={$text}) "<t>"
     |   CHARACTER_LITERAL
+        -> template(t={$text}) "<t>"
     |   STRING_LITERAL
+        -> template(t={$text}) "<t>"
     |   TRUE
+        -> template(t={$text}) "<t>"
     |   FALSE
+        -> template(t={$text}) "<t>"
     |   NULL
+        -> template(t={$text}) "<t>"
     ;
index 55e8b2c7a9523427449b20711690c6af4ef8fac2..1248f7c97d5724959e46b2bebdbc80329b97a12d 100644 (file)
@@ -9,26 +9,9 @@ import org.antlr.runtime.tree.*;
 import org.antlr.stringtemplate.*;
 import charj.translator.StreamEmitter;
 
-/**
- * Indicates whether we are working on .ci or .cc output.
- */
-enum OutputMode {
-    cc(".cc"), 
-    ci(".ci");
-
-    private final String extension;
-
-    OutputMode(String ext) {
-        this.extension = ext;
-    }
-
-    public String extension() {
-        return extension;
-    }
-}
 
 /**
- * Driver class for lexing, parsing, and output.
+ * Driver class for lm_exing, parsing, and output.
  * Takes in file names, parses them and generates code
  * for .ci and .cc files in a .charj directory. Invokes
  * charmc on these outputs and moves any resulting .o file 
@@ -37,27 +20,24 @@ enum OutputMode {
 public class Translator {
 
     // template file locations
-    public static final String ccTemplateFile = 
-        "charj/translator/CharjCC.stg";
-    public static final String ciTemplateFile = 
-        "charj/translator/CharjCI.stg";
+    public static final String templateFile = "charj/translator/Charj.stg";
 
     // variables controlled by command-line arguments
-    public String charmc;
-    public boolean debug;
-    public boolean verbose;
-    public boolean errorCondition;
+    public String m_charmc;
+    public boolean m_debug;
+    public boolean m_verbose;
+    public boolean m_errorCondition;
 
     public Translator(
             String _charmc,
             boolean _debug,
             boolean _verbose)
     {
-        charmc = _charmc;
-        debug = _debug;
-        verbose = _verbose;
+        m_charmc = _charmc;
+        m_debug = _debug;
+        m_verbose = _verbose;
 
-        errorCondition = false;
+        m_errorCondition = false;
     }
 
     public String translate(String filename) throws Exception 
@@ -71,7 +51,7 @@ public class Translator {
         input.seek(0);
         String ccOutput = translationPass(lexer, OutputMode.cc);
         writeTempFile(filename, ccOutput, OutputMode.cc);
-        compileTempFiles(filename, charmc);
+        compileTempFiles(filename, m_charmc);
 
         String ciHeader = "-----CI----------------------------\n";
         String ccHeader = "-----CC----------------------------\n";
@@ -95,11 +75,7 @@ public class Translator {
         nodes.setTokenStream(tokens);
 
         String output = null;
-        if (m == OutputMode.cc) {
-            output = generateCC(nodes);
-        } else if (OutputMode.ci == m) {
-            output = generateCI(nodes);
-        }
+        output = emit(nodes, m);
         return output;
     }
 
@@ -120,7 +96,7 @@ public class Translator {
         String tempFile = filename.substring(0, lastSlash + 1) + ".charj/";
         new File(tempFile).mkdir();
         tempFile += filename.substring(lastSlash + 1, lastDot) + m.extension();
-        if (verbose) System.out.println("\n [charjc] create: " + tempFile);
+        if (m_verbose) System.out.println("\n [charjc] create: " + tempFile);
         FileWriter fw = new FileWriter(tempFile);
         fw.write(output);
         fw.close();
@@ -161,7 +137,7 @@ public class Translator {
     private int exec(String cmd, File outputDir) throws
         IOException, InterruptedException
     {
-        if (verbose) System.out.println("\n [charjc] exec: " + cmd + "\n");
+        if (m_verbose) System.out.println("\n [charjc] exec: " + cmd + "\n");
         Process p = Runtime.getRuntime().exec(cmd, null, outputDir);
         StreamEmitter stdout = new StreamEmitter(
                 p.getInputStream(), System.out);
@@ -176,23 +152,15 @@ public class Translator {
         return retVal;
     }
 
-    private String generateCC(CommonTreeNodeStream nodes) throws
-        RecognitionException, IOException, InterruptedException
-    {
-        CharjCCEmitter emitter = new CharjCCEmitter(nodes);
-        StringTemplateGroup templates = getTemplates(ccTemplateFile);
-        emitter.setTemplateLib(templates);
-        StringTemplate st = (StringTemplate)emitter.charjSource().getTemplate();
-        return st.toString();
-    }
-
-    private String generateCI(CommonTreeNodeStream nodes) throws
+    private String emit(
+            CommonTreeNodeStream nodes, 
+            OutputMode m) throws
         RecognitionException, IOException, InterruptedException
     {
-        CharjCIEmitter emitter = new CharjCIEmitter(nodes);
-        StringTemplateGroup templates = getTemplates(ciTemplateFile);
+        CharjEmitter emitter = new CharjEmitter(nodes);
+        StringTemplateGroup templates = getTemplates(templateFile);
         emitter.setTemplateLib(templates);
-        StringTemplate st = (StringTemplate)emitter.charjSource().getTemplate();
+        StringTemplate st = (StringTemplate)emitter.charjSource(m).getTemplate();
         return st.toString();
     }
 
@@ -202,7 +170,8 @@ public class Translator {
         try {
             ClassLoader loader = Thread.currentThread().getContextClassLoader();
             InputStream istream = loader.getResourceAsStream(templateFile);
-            BufferedReader reader = new BufferedReader(new InputStreamReader(istream));
+            BufferedReader reader = 
+                new BufferedReader(new InputStreamReader(istream));
             templates = new StringTemplateGroup(reader);
             reader.close();
         } catch(IOException ex) {
@@ -216,7 +185,7 @@ public class Translator {
             String msg, 
             CommonTree node) 
     {
-        errorCondition = true;
+        m_errorCondition = true;
         String linecol = ":";
         if ( node!=null ) {
             CommonToken t = (CommonToken)node.getToken();