Question

I have already looked at this question and even though the question titles seem to be the same; it doesn’t answer my question, at least not in any way that I can understand.

Parsing Math

Here is what I am parsing:

PI -> 3.14.
Number area(Number radius) -> PI * radius^2.

This is how I want my AST tree to look, minus all the useless root nodes.

how it should look http://vertigrated.com/images/How%20I%20want%20the%20tree%20to%20look.png

Here are what I hope are the relevant fragments of my grammar:

term : '(' expression ')'
     | number -> ^(NUMBER number)
     | (function_invocation)=> function_invocation 
     | ATOM
     | ID
     ;

power : term ('^' term)* -> ^(POWER term (term)* ) ;
unary : ('+'! | '-'^)* power ;
multiply : unary ('*' unary)* -> ^(MULTIPLY unary (unary)* ) ;
divide : multiply ('/' multiply)* -> ^(DIVIDE multiply (multiply)* );
modulo : divide ('%' divide)* -> ^(MODULO divide (divide)*) ;
subtract : modulo ('-' modulo)* -> ^(SUBTRACT modulo (modulo)* ) ;  
add : subtract ('+' subtract)* -> ^(ADDITION subtract (subtract)*) ;

relation : add (('=' | '!=' | '<' | '<=' | '>=' | '>') add)* ;

expression : relation (and_or relation)*
           | string  
           | container_access
           ;
and_or : '&' | '|' ;

Precedence

I still want to keep the precedence as illustrated in the following diagrams, but want to eliminate the useless nodes if at all possible.

Source: Number a(x) -> 0 - 1 + 2 * 3 / 4 % 5 ^ 6.

Here are the nodes I want to eliminate:

how I want the precedence tree to look http://vertigrated.com/images/example%202%20desired%20result.png

Basically I want to eliminate any of those nodes that don’t directly have a branch under them to binary options.

Answer 1

You must realize that the two rules:

add : sub ( ('+' sub)+ -> ^(ADD sub (sub)*) | -> sub ) ;

and

add : sub ('+'^ sub)* ;

do not produce the same AST. Given the input 1+2+3, the first rule will produce:

  ADD
   |
.--+--.
|  |  |
1  2  3

where the second rule produces:

     (+)
      |
   .--+--.  
   |     |
  (+)    3
   |
.--+--.
|     |
1     2

The latter makes more sense: infix expressions are expected to have 2 child nodes, not more.

Why not simply remove the literals in your parser rules and just do:

add : sub (ADD^ sub)*;

ADD : '+';

Creating the same AST using a rewrite rule would look like this:

add : (sub -> sub) ('+' s=sub -> ^(ADD $add $s))*;

Also see chapter 7: Tree Construction from The Definitive ANTLR Reference. Especially the paragraphs Rewrite Rules in Subrules (page 173) and Referencing Previous Rule ASTs in Rewrite Rules (page 174/175).