Question

I’ve already a grammar definition in ANTLR for the very simple expressions like (a + b) * c:

grammar SimpleCalc;

options {
    language=CSharp2;
    output=AST;
}

tokens {
    PLUS  = '+' ;
    MINUS = '-' ;
    MULT = '*' ;
    DIV = '/' ;
}

/*------------------------------------------------------------------
 * LEXER RULES
 *------------------------------------------------------------------*/

ID  : ('a'..'z' | 'A' .. 'Z' | '0' .. '9')+ ;

WHITESPACE : ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+    { Skip(); } ;

/*------------------------------------------------------------------
 * PARSER RULES
 *------------------------------------------------------------------*/

expr : multExpr ((PLUS | MINUS)^ multExpr)*;

multExpr : atom ((MULT | DIV)^ atom )*;

atom : ID
     | '(' expr ')' -> expr;

Now I have some pre-defined type for creating tree structure:

public class Expr { }

public class SimpleExpr : Expr
{
    public SimpleExpr(string name) { ... }
}

public enum BinaryExprType
{
    Plus,
    Minus,
    Multiply,
    Divide
}

public class BinaryExpr : Expr
{
    public BinaryExpr(Expr left, BinaryExprType op, Expr right) { ... }
}

I know we can write some code to convert a CommonTree to Expr tree, but I’d like to rewrite directly to the custom types like:

atom returns [Expr e]
    : ID { $e = new SimpleExpr($ID.text); }
    | '(' expr ')' { $e = $expr.e; };

expr returns [Expr e]
    : /* ??? */;

multExpr returns [Expr e]
    : /* ??? */;

But how should I do for expr and multExpr to create BinaryExpr with proper BinaryExprType?

Answer 1

Try something like this (untested!):

expr returns [Expr e]
 : m1=multExpr         {$e = $m1.e;} 
   ( PLUS m2=multExpr  {$e = new BinaryExpr($expr.e, BinaryExprType.Plus, $m2.e);}
   | MINUS m2=multExpr {$e = new BinaryExpr($expr.e, BinaryExprType.Minus, $m2.e);}
   )*
 ;

multExpr returns [Expr e]
 : a1=atom        {$e = $a1.e;}
   ( MULT a2=atom {$e = new BinaryExpr($multExpr.e, BinaryExprType.Multiply, $a2.e);}
   | DIV a2=atom  {$e = new BinaryExpr($multExpr.e, BinaryExprType.Divide, $a2.e);}
   )*
 ;

atom returns [Expr e]
 : ID           {$e = new SimpleExpr($ID.text);}
 | '(' expr ')' {$e = $expr.e;}
 ;

The trick is to recursively use the rule itself in the binary expressions: the $expr.e and $multExpr.e in new BinaryExpr(...).