Precedence and Associativity - Grammar Mistake using JavaCC - grammar

Question

I'm having a problem with my grammar and I don't really know how to solve it. I'm facing the issue with precedence and associativity in operations. I included the whole grammar but I avoided to put all the Tokens otherwise it'd be too long.
PARSER_BEGIN(UcParse)
Node Start() :
{
Node tree = new Node(Id.PROGRAM);
Node td;
}
{
( td = TopLevelDeclaration() { tree.add(td); }
)*
<EOF> { return tree; }
}
Node TopLevelDeclaration() :
{
Node n;
}
{
LOOKAHEAD(3)
n = Declaration() <SEMI> { return n; }
| n = Function() { return n; }
| n = IncludeFile() {return n; }
}
Node Function() :
{
Node tld = new Node(Id.FUNC);
Node bt;
Node dr;
Node body;
Node formals;
Node s;
}
{
bt = ReturnType() { tld.add(bt); }
Declarator(tld)
(
FunctionParameters(tld)
(
body = CompoundStatement() { tld.add(body); }
|
<SEMI>
)
| { }
)
{ return tld; }
}
//List FunctionParameters () :
void FunctionParameters (Node func) :
{
Node f;
}
{
<LPAREN>
(
<VOID> { func.add(new Node(Id.VOID)); }
|
f = Declaration() { func.add(f); }
( <COMMA>
f = Declaration() { func.add(f); }
)*
)
<RPAREN>
}
Node Declaration () :
{
Node d = new Node(Id.VARDEC);
Node bt;
Node dr;
}
{
bt = DeclarationType() { d.add(bt); }
Declarator(d) { return d; }
}
Node SimpleDeclaration () :
{
Node d = new Node(Id.VARDEC);
Node bt;
Node id;
}
{
bt = DeclarationType() { d.add(bt); }
id = Identifier() { d.add(id); }
<SEMI>
{ return d; }
}
Node ReturnType () :
{}
{
<CHAR> { return new Node(Id.CHAR); }
| <INT> { return new Node(Id.INT); }
| <VOID> { return new Node(Id.VOID); }
}
Node DeclarationType () :
{}
{
<CHAR> { return new Node(Id.CHAR); }
|
<INT> { return new Node(Id.INT); }
}
void Declarator (Node p) :
{
Node id;
Node r;
}
{
id = Identifier() { p.add(id); }
( <LBRACK>
( r = IntegerLiteral() { p.add(r); } ) *
<RBRACK>
|
{ }
)
}
Node CompoundStatement () :
{
Node cs = new Node(Id.COMPOUND_STMNT);
Node d;
Node s;
}
{
<LBRACE>
( d = Declaration() { cs.add(d); }
<SEMI>
)*
( s = Statement() { cs.add(s); }
)*
<RBRACE>
{ return cs; }
}
Node Statement() :
{
Node stmt = new Node(Id.STMNT);
Node s;
Token t;
Node c;
Node s1;
Node s2;
}
{
(s = SimpleCompoundStatement() { stmt.add(s); }
|
Expression(stmt)
<SEMI> // expr;
|
<SEMI> { stmt.add(new Node(Id.EMPTY_STMNT)); } //;
|
t = { s = new Node(Id.IF); stmt.add(s); }
<LPAREN>
Expression(s)
<RPAREN>
s1 = Statement() { s.add(s1); }
( LOOKAHEAD(1)
<ELSE>
s2 = Statement() { s.add(s2); } ) *
|
t = <WHILE> { s = new Node(Id.WHILE); stmt.add(s); }
<LPAREN>
Expression(s)
<RPAREN>
s2 = Statement() { s.add(s2); }
|
(Expression(stmt)) *
<SEMI>) //return expr*;
{ return stmt; }
}
Node SimpleCompoundStatement() :
{
Node scs = new Node(Id.SIMPLE_COMPOUND_STMNT);
Token left;
Token right;
Node s;
}
{
left = <LBRACE>
( s = Statement() { scs.add(s); }
)*
right = <RBRACE>
{ return scs; }
}
void Expression (Node e) :
{
Node exp;
Node id;
Node p;
Node op;
}
{
(
op = IntegerLiteral()
OperatorExpression(e, op)
|
exp = CharLiteral()
OperatorExpression(e, exp)
|
<LPAREN> { p = new Node(Id.PAREN); }
Expression(p)
<RPAREN>
OperatorExpression(e, p)
| id = Identifier()
( <LBRACK>
Expression(e)
<RBRACK>
| <LPAREN>
(
Expression(e)
( <COMMA>
Expression(e)
)*
| { } )
<RPAREN>
| { }
)
OperatorExpression(e, id)
|
exp = Unary()
Expression(e)
OperatorExpression(e, exp)
)
}
void OperatorExpression(Node par, Node op) :
{
Node n;
Node p;
}
{
( LOOKAHEAD(2)
n = BinaryMulDiv() { par.add(n); }
{ n.add(op); }
Expression(n)
| OperatorExpressionPlusMin(par, op) )
}
void OperatorExpressionPlusMin(Node par, Node op) :
{
Node n;
}
{
( LOOKAHEAD(2)
n = BinaryPlusMin() { par.add(n); }
{ n.add(op); }
Expression(n)
| OperatorExpressionComp(par, op))
}
void OperatorExpressionComp(Node par, Node op) :
{
Node n;
}
{
( LOOKAHEAD(2)
n = BinaryComp() { par.add(n); }
{ n.add(op); }
Expression(par)
| {} {par.add(op);} )
}
Node BinaryComp () :
{
Token t;
}
{
(t = <LT> // >
|
t = <GT> // // // >=
|
t = <EQ> // =
|
t = <EQEQ> // ==
|
t = <NOTEQ> // !=
|
t = <ANDAND> // &&
|
t = <OROR>) // ||
{return new Node(Id.BINARY, t.image); }
}
Node BinaryMulDiv () :
{
Token t;
}
{
(t = <MUL> // *
|
t = <DIV>) // /
{return new Node(Id.BINARY, t.image); }
}
Node BinaryPlusMin () :
{
Token t;
}
{
(t = <PLUS> // +
|
t = <MINUS>) // -
{return new Node(Id.BINARY, t.image); }
}
Node Unary() :
{
Token t;
}
{
t = <MINUS> { return new Node(Id.UNARY, t.image); }
|
t = <NOT> { return new Node(Id.UNARY, t.image); } // !
}
Node Identifier() :
{
Token t;
}
{
t = <IDENT> { return new Node(Id.IDENT, t.image); }
}
Node IntegerLiteral() :
{
Token t;
}
{
t = <INTEGER_LITERAL>
{ return new Node(Id.INTEGER_LITERAL, t.image); }
}
Node CharLiteral() :
{
Token t;
}
{
t = <CHAR_LITERAL>
{ return new Node(Id.CHAR_LITERAL, t.image); }
}
Node FileName() :
{
Token dot;
}
{
(<IDENT> <DOT> <IDENT>)
{ return new Node(Id.FILE_NAME); }
}
Node IncludeFile() :
{
Node include = new Node(Id.INCLUDE);
Node name;
Token incl;
Token lt;
Token gt;
}
{
incl = <INCLUDE>
lt = <LT>
name = FileName() { include.add(name); }
gt = <GT>
{ return include; }
}
This is the program I'm using for my tests.
int main(void) {
int i;
1!=!3;
4&&(6);
7* 8+10; // wrong tree
10+8*7; // right tree
(11-12)+(12/16);
17=27>28;
}
I guess that the part that doesn't work in my grammar is the OperatorExpression() because when I print the syntax tree for the code above, I obtain two different branches for those line I put a comment in.
Here the syntax tree
PROGRAM
FUNC
INT
IDENT ( main )
VOID
COMPOUND_STMNT
VARDEC
INT
IDENT ( i )
STMNT
BINARY ( != )
INTEGER_LITERAL ( 1 )
INTEGER_LITERAL ( 3 )
UNARY ( ! )
STMNT
BINARY ( && )
INTEGER_LITERAL ( 4 )
PAREN
INTEGER_LITERAL ( 6 )
STMNT
BINARY ( * )
INTEGER_LITERAL ( 7 )
BINARY ( + )
INTEGER_LITERAL ( 8 )
INTEGER_LITERAL ( 10 )
STMNT
BINARY ( + )
INTEGER_LITERAL ( 10 )
BINARY ( * )
INTEGER_LITERAL ( 8 )
INTEGER_LITERAL ( 7 )
STMNT
BINARY ( + )
PAREN
BINARY ( - )
INTEGER_LITERAL ( 11 )
INTEGER_LITERAL ( 12 )
PAREN
BINARY ( / )
INTEGER_LITERAL ( 12 )
INTEGER_LITERAL ( 16 )
STMNT
BINARY ( = )
INTEGER_LITERAL ( 25 )
BINARY ( > )
INTEGER_LITERAL ( 27 )
INTEGER_LITERAL ( 28 )
Any help is really appreciate! Thanks

Answer 1

There is a write up called Parsing Expressions by Recursive Descent, which outlines 3 approaches to getting precedence and associativity right in recursive descent parsers. All three techniques can be applied to JavaCC parsers. The second one (the "classic" algorithm) is probably simplest to use.