Zwischendarstellungen mit JavaCC

Question

Ich versuche, die Zwischendarstellungen für Ausdrücke zu schreiben wie:

a= 1+2-3*5/6 
a= 1+2-3 
a= 5/6+3 

Ich bin ziemlich neu in JavaCC aber ich habe Grundkenntnisse über eine AST mit JJTree zu erzeugen. Ich habe keine separate Klasse für IR erstellt oder es mit JJTree implementiert. Ich habe die Grammatik geschrieben und versucht, IR direkt darin zu implementieren.

Der Code ist:

// 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; 
    } 
} 

Mein Code funktioniert gut für Ausdrücke wie 1+2*3; oder 1-2/4;, wo ein bestimmte Betreiber nicht in einem Ausdruck wiederholt.

Es wäre ein schmutzigen Ausgang für Ausdrücke geben, wo man aus + - oder * / oder + - oder / * wiederholen, sowohl im Ausdruck enthalten sind. z.B. 1+2-4 (+ - beide enthalten), 1-2-3 (minus wiederholen) so weiter.

Meine Fragen sind (siehe picture for output im Anhang):

Wie kann ich beseitigen die oben erwähnten Probleme?

Wenn mein Weg IR in Grammar Datei/Klasse nicht angemessen zu tun ist, dann was ist ein besserer Weg IR in JavaCC? **

Answer 1

Was ausführen ich tun würde, ist ein String-Puffer zu verwenden, Ausgang Strom oder veränderbare Liste, um die Quadrupel zu akkumulieren und den Wert oder das Zwischenprodukt zurückzugeben, die als Ergebnis den Wert jedes Nichtterminals darstellen.

Z. B. zum Beispiel

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; 
    } 
} 

wo buildQuad ist definiert als

String buildQuad(StringBuffer buf, String left, String op, String right) 
{ 
    String register = "t" + count++ 
    buf.append(register + ": " + left + op + right + "\t"); 
    return register ; 
}