Intermediate Representations using Javacc - javacc

Question

I am trying to write the Intermediate Representations for expressions like:
a= 1+2-3*5/6
a= 1+2-3
a= 5/6+3
I am pretty new to JavaCC but I have basic knowledge about generating an AST using JJTree. I haven't made a separate class for IR, or implemented it with JJTree. I have written the grammar and tried to implement IR right in it.
The code is:
// E -> T (addop T)*
// T -> F (mulop F)*
// F -> intlit | "(" E ")"
SKIP :
{
" "
| "\t"
| "\n"
| "\r"
}
TOKEN :
{
< ADDOP :
"+"
| "-" >
| < MULOP :
"*"
| "/" >
| < INTLIT : ([ "0"-"9" ])+ >
}
String S() :
{
String s;
}
{
s = E()
{
return "a=" + s;
}
}
String E() :
{
String left, right;
Token op;
}
{
left = T()
(
op = < ADDOP > right = T()
{
left = ("t" + count++) + ": " + left + op.image + right + "\t";
}
)*
{
return left;
}
}
String T() :
{
String left, right;
Token op;
}
{
left = F()
(
op = < MULOP > right = F()
{
left = ("t" + count++) + ": " + left + op.image + right;
}
)*
{
return left;
}
}
String F() :
{
String s;
Token t;
}
{
t = < INTLIT >
{
return t.image;
}
}
My code works fine for Expressions like 1+2*3; or 1-2/4; where a particular operator is not repeated in an expression.
It would give a messy output for expressions where one out of + - or * / is repeating or + - or / *, both are included in expression. e.g. 1+2-4 (+ - both included), 1-2-3 (minus repeating) so on. (See attached picture for output)
My questions are:
How can I eliminate the above mentioned problems?
If my way of doing IR in Grammar file/class is not appropriate then what is a better way to perform IR in JavaCC?**

Answer 1

What I would do is to use a string buffer, output stream, or mutable list to accumulate the quadruples and return the value or intermediate representing the value of each nonterminal as a result.
E.g., for example
String E(StringBuffer buf) :
{
String left, right;
Token op;
}
{
left = T(buf)
(
op = < ADDOP > right = T(buf)
{
left = buildQuad( buf, left, op.image, right ) ;
}
)*
{
return left;
}
}
where buildQuad is defined as
String buildQuad( StringBuffer buf, String left, String op, String right )
{
String register = "t" + count++
buf.append( register + ": " + left + op + right + "\t" );
return register ;
}