Tengo que escribir un análisis (Tkns, T) que toma una expresión matemática en forma de una lista de tokens y encuentra T, y devolver una declaración que represente la sintaxis abstracta, respetando el orden de las operaciones y la asociatividad.

Por ejemplo,

?- parse( [ num(3), plus, num(2), star, num(1) ], T ).

T = add(integer(3), multiply(integer(2), integer(1))) ;
No

He intentado implementar + y * como sigue

parse([num(X)], integer(X)).
parse(Tkns, T) :-
  (  append(E1, [plus|E2], Tkns),
     parse(E1, T1),
     parse(E2, T2),
     T = add(T1,T2)
  ;  append(E1, [star|E2], Tkns),
     parse(E1, T1),
     parse(E2, T2),
     T = multiply(T1,T2)
  ).

Que encuentra la respuesta correcta, pero también devuelve respuestas que no siguen la asociatividad o el orden de las operaciones.

ex)

parse( [ num(3), plus, num(2), star, num(1) ], T ). 

tambien devuelve

mult(add(integer(3), integer(2)), integer(1))

y

parse([num(1), plus, num(2), plus, num(3)], T)

devuelve el equivalente de 1 + 2 + 3 y 1+ (2 + 3) cuando solo debe devolver el anterior.

¿Hay alguna manera de hacer que esto funcione?

Edición: más información: solo necesito implementar +, -, *, /, negar (-1, -2, etc.) y todos los números son enteros. Se dio una pista de que el código se estructurará de manera similar a la gramática.

<expression> ::= <expression> + <term>
              |  <expression> - <term>
              |  <term>

      <term> ::= <term> * <factor>
              |  <term> / <factor>
              |  <factor>

    <factor> ::= num
              |  ( <expression> )

Solo con negate implementado también.

Edit2: encontré un analizador de gramática escrito en Prolog (http://www.cs.sunysb.edu/~warren/xsbbook/node10.html). ¿Hay alguna forma de modificarlo para imprimir una derivación de la mano izquierda de una gramática ("imprimir" en el sentido de que el intérprete de Prolog emitirá "T = [la respuesta correcta]")