Interpreterbau - Ein Anfang

[henriknikolas]

Hallo, ich habe den Parser jetzt so modifiziert, dass man auch eigene Variablen verwenden kann.
NodeIdent habe ich noch eine Konstruktor verpasst der zusätzlich zu einem string noch eine map erwartet. NodeIdent::eval() durchsucht zuerst die Konstanten und dann die map.
Für den Parser habe ich die Funktion variable() eingeführt:

NodeIdent* Parser::variable()
{
    string var_name = myTok.getStrvalue();
    accept(TT_IDENT);
    if(myTok.equal(TT_ASSIGN))
    {
        accept(TT_ASSIGN);
        table[var_name] = start()->eval());
    }
    return new NodeIdent(table, var_name);
}

variable() wird ausgeführt, wenn keine funktion() ausgeführt wird. Deshalb brauche ich bezeichner() nur noch für funktion().
Und der Konstruktor von Parser erwartet eine Referenz auf eine map, sodass dort dann die variablen eingetragen werden.
Wie hättet ihr das gemacht, oder kann bei mir noch etwas verbessert werden?

Ach ja, ich habe meinen Parser noch um den Potenzoperator erweitert. Nur ist der bei mir jetzt linksassoziativ und nicht rechtsassoziativ. Wie kann ich das ändern?

[henriknikolas]

henriknikolas schrieb:

Ach ja, ich habe meinen Parser noch um den Potenzoperator erweitert. Nur ist der bei mir jetzt linksassoziativ und nicht rechtsassoziativ. Wie kann ich das ändern?

Ich habe das jetzt auch alleine gelöst, war eigentlich "voll trivial" wie unser alter Mathematiklehrer zu sagen pflegte, einfach die EBNF so ändern:

Potenz = Klammer {^ Potenz}

[SomeRandomGuy]

In dem Beitrag wurde ja schön gezeigt, wie man einen Mathe "Interpreter" baut. Ein echtes Program besteht ja aber meistens nicht nur aus einem Befehl, sondern aus mehreren. Legt ein echter Interpreter also ein Array von ASTs an und führt die der Reihe nach aus? Und was für einen Syntaxbaum bekommt eine While-Schleife, in deren Body mehrere Befehle stehen?

[fghfgh]

SomeRandomGuy schrieb:

In dem Beitrag wurde ja schön gezeigt, wie man einen Mathe "Interpreter" baut. Ein echtes Program besteht ja aber meistens nicht nur aus einem Befehl, sondern aus mehreren. Legt ein echter Interpreter also ein Array von ASTs an und führt die der Reihe nach aus? Und was für einen Syntaxbaum bekommt eine While-Schleife, in deren Body mehrere Befehle stehen?

Wenn man die Grammatik entsprechend festlegt, dann ergibt sich das von alleine. Dann gibt es z.B. einen AST namens Block und der hat wiederum Äste. Diese Äste sind dann entweder vom Typ Assignment, FuncCall oder wie auch immer. Wenn man dann noch eine Schleif drum rum packt und ein Ast Condition auswertet, dann kann man so eine Schleife, Abfrage, etc. implementieren.

Es ist nicht mehr ganz so trivial, aber es ist auch nicht wirklich schwierig.

[SomeRandomGuy]

Das ganze Programm ist also später ein großer AST? Dann geh ich mal Grammatik entwerfen

[gdfgdfg]

SomeRandomGuy schrieb:

Das ganze Programm ist also später ein großer AST? Dann geh ich mal Grammatik entwerfen

so wie im Beispiel oben beliebig viele Multiplikationsterme addiert werden können, so kannst du das noch weiter verallgemeinern.

Original:
Start = (Multiplikation) { ("+" | "-") (Multiplikation) } ;
...

wird noch erweitert sodass du beliebig viele Berechnungen hintereinander machen kannst (mit ";" getrennt)
GesamtesProgram = {(Start) (";")}
Start = (Multiplikation) { ("+" | "-") (Multiplikation) } ;

Zuerst ging nur: 3*(4+5)
Jetzt geht auch: 3*(4+5) ; 3*(99-1) ; 4+5 ; 4 ;

Der Baum besteht jetzt also zuerst mal aus der Wurzel, und dann aus den 4 Knoten "Start", und die wiederum setzen sich zusammen aus Knoten "Multiplikation" usw...

[henriknikolas]

Mir ist noch eine Kleinigkeit aufgefallen:
Man kann beispielsweise nicht 3- -e rechnen oder -sqrt(4), da nicht überprüft wird, ob vor einer Funktion oder vor einem Bezeichner ein Vorzeichen kommt
Man ändert klammer einfach:

Node *Parser::klammer()
{
    //...
    else if (myTok.equal(TT_IDENT))
    {
        // Ist das folgende Token eine öffnende Klammer?
        if (myScanner.getNextToken(true).equal(TT_LPAREN))
        {
            // Dann ist es eine Funktion
            return new NodeMul(funktion(), new NodeNumber(sign));
        }
        // Ansonsten eine Konstante
        return new NodeMul(bezeichner(), new NodeNumber(sign));
    }
    //...
}

Ich habe vor längerer Zeit den Operator ^ für Potenzen eingeführt, dabei bin ich nach der folgenden EBNF vorgegangen:
...
potenz = klammer {^potenz}
klammer = ["+" | "-"] ((funktion) | (variable {= start}) | (Zahl) | "(" (Start) ")")

Jetzt gibt es aber das Problem wie Ausdrücke wie -3² interpretiert werden. Mathematisch richtig wäre das dann -9, nach der Grammatik hier aber +9, da potenz() klammer() aufruft, das -3 zurückgibt was mit 2 potenziert wird und dann 9 ergibt. Deshalb habe ich klammer so verändert, dass wenn ein Vorzeichen gefunden wurde, überprüft wird, ob das nächste Zeichen ein ^ ist.

klammer sieht jetzt bei mir so aus:

Node* Parser::klammer()
{
  //Vorzeichen
  int sign = 1;
  if(myTok.equal(TT_PLUS) || myTok.equal(TT_MINUS))
  {
    if(myTok.equal(TT_MINUS))
      sign = -1;
    getNextToken();
    if(myScanner.getNextToken(true).equal(TT_POT))
      return new NodeMul(new NodeNumber(sign), potenz());
  }
  //...
}

Ach ja, potenz() noch:

Node* Parser::potenz()
{
  Node* ergb = klammer();
  if(myTok.equal(Type::TT_POT))
  {
    getNextToken();
    ergb = new NodePot(ergb, potenz());           
  }
  return ergb;
}

Jetzt die Fragen an die Spezialisten:
1. Ist die Vorgehensweise richtig, oder gibt es einen besseren Ansatz
2. Hat eine Potenz nicht die gleiche Priorität wie eine Funktion oder eine Variable, sprich würde es sich nicht lohnen Potenzen in klammer() auszuwerten?

Das war jetzt ziemlich viel Text :D...

[xxxxxxxxxxxxxxxxxxxxx]

Ich habe vor längerer Zeit den Operator ^ für Potenzen eingeführt, dabei bin ich nach der folgenden EBNF vorgegangen:
...
potenz = klammer {^potenz}
klammer = ["+" | "-"] ((funktion) | (variable {= start}) | (Zahl) | "(" (Start) ")")

um dein Beispiel -3^2 korrekt auszuwerten reicht folgende Änderung:
(Zahl){ "^" (Zahl) }

klammer = ["+" | "-"] ((funktion) | (variable {= start}) | (Zahl){ "^" (Zahl) } | "(" (Start) ")")

wenns auch ganze ausdrücke und nicht nur konstante zahlen sein dürfen, dann musst halt auch eine ähnliche regel dafür aufstellen.

oder du machst es dir noch einfacher und führst eine funktion pow(basis,potenz) ein.

[henriknikolas]

Ich hab mir die folgende EBNF dafür aufgestellt:
...
Multiplikation = Vorzeichen { "*" Vorzeichen}
Vorzeichen = ["+"|"-"] Potenz
Potenz = Primary { "^" Vorzeichen}
Primary = Funktion | Klammer | Variable | Zahl
...

Dadurch haben Funktionen, Klammern, Variablen und Zahlen die höchste Priorität, danach kommen Potenzen, die als Argument einen positiven oder einen negativen Exponenten erwarten und dann kommen Vorzeichen.

[buchtipp]

henriknikolas schrieb:

Ich hab mir die folgende EBNF dafür aufgestellt:
...
Multiplikation = Vorzeichen { "*" Vorzeichen}
Vorzeichen = ["+"|"-"] Potenz
Potenz = Primary { "^" Vorzeichen}
Primary = Funktion | Klammer | Variable | Zahl
...

Dadurch haben Funktionen, Klammern, Variablen und Zahlen die höchste Priorität, danach kommen Potenzen, die als Argument einen positiven oder einen negativen Exponenten erwarten und dann kommen Vorzeichen.

wenn du deinen Interpreter noch weiter ausbauen möchtest, kann ich dir folgendes Buch empfehlen: "Grundlagen und Techniken des Compilerbaus" von N. Wirth.
Dort wird ein Compiler für die Sprache Oberon 0 (so ähnlich wie Pascal) entwickelt, und die Sprache kann eigentlich alles, was man sich so wünscht.

[henriknikolas]

Dankeschön, ich werde mir das Buch mal ansehen.

[henriknikolas]

Ich habe noch eine Frage zum Buch, der Compiler der dort entwickelt wird ist ja sicherlich in Pascal geschrieben. Kann man das dann auch als Pascal-Anfänger verstehen, ich programmiere halt nur in der Schule mit Pascal.

[buchtipp]

henriknikolas schrieb:

Ich habe noch eine Frage zum Buch, der Compiler der dort entwickelt wird ist ja sicherlich in Pascal geschrieben. Kann man das dann auch als Pascal-Anfänger verstehen, ich programmiere halt nur in der Schule mit Pascal.

Der Compiler wird in Oberon programmiert - und die Sprache die compiliert wird ist eine Untermenge von Oberon.
Schau dir einfach ein Online Tutorial zu der Sprache an. Wenn du Pascal kannst, ist der Unterschied nicht allzu groß.

Ich sehe die Sprache Oberon in dem Fall eher als "Pseudosprache" um zu zeigen, wie man einen Compiler implementieren kann. Es wird wohl kaum jemand auf die Idee kommen, tatsächlich Oberon zu verwenden
Das Gelernte ist nicht schwierig auf andere Programmiersprachen zu übertragen - ich hab parallel zum Lesen des Buchs eine Skriptsprache in C++ implementiert.

[henriknikolas]

Das hat mich überzeugt, dankeschön. Dann werde ich mir das Buch mal bestellen.

[joko&klaas]

was ist der vorteil gegenueber wenn ich die grammatik in ebnf definiere anstatt in yacc?

[Cherup]

Hi,

vielen Dank für dieses tolle Tutorial, das hat mir sehr weitergeholfen und einen guten Einblick in den Parser-Bau geliefert
Ich habe jetzt das Problem, dass ich mit diesem Parser dynamische Formeln lösen möchte.
Dazu hänge ich den AST in einen Struct, in dem die Formeln gespeichert werden. Das Problem dabei ist, dass Variablen eingesetzt werden müssen, die sich erst zur Laufzeit des Programms ändern (ist ja klar bei Variablen ).
Diese Variablen sind ebenfalls in dem Struct gespeichert.
Ich habe dazu die "klammer()"-Funktion um eckige Klammern erweitert, die eine Variable für den Scanner anzeigen sollen und auch einen entsprechenden Node angelegt.
Nun meine Frage: Ich möchte das am liebsten über einen Pointer lösen, damit ich nicht immer die Formel neu "Übersetzen" muss. Aber wie bekomme ich den Pointer der Variablen in das entsprechende Token/den Node? Ist das möglich, ohne den Pointer durch alle Klassen durchschleifen zu müssen?

[context00000]

erweitere die Basisklasse zu:

struct Context
{
     // Zuordnung Variablenname - Variablenwert
     std::map<str::string,int> vars;

     // und was du halt sonst noch so zur Lautzeit brauchst ...
};

// Basisklasse 
class Node 
{ 
    public: 
        virtual ~Node() { } 

        // Ergebnis berechnen 
        virtual int eval(Context& context) const = 0; 
};

// Zugriff auf Variable "myVar" in einer der eval Funktionen
context.vars["myVar"]=123;
// oder 
return context.vars["myVar"];
// usw.

[Namenloser324]

Wollte mal ein großes Danke und "Super!" aussprechen, ist gerade genau das was ich suche^^ (also der ursprüngliche Beitrag, auh wenn die Abhandlung mit lauter "case's" mir irgendwie umständlich vorkommt)

[namenloser324]

huhu,

ich überlege gerade, wie man das ganze am besten für die einführung von ints und floats sowie operatoren die nur für (unsigned) ints definiert sind funktioniert.

Es kommt mir recht umständlich vor, separate Ableitungsregeln für diese zu erzeugen.
Nehmen wir mal an ich würde den Moduloperator "%" mit gleicher Priorität wie "+" und "-" einführen wollen. Üblicherweise ist % nur für unsignes definiert (d.h. <uint> % <uint> ist legal, <float> % <x> nicht z.B.)

Erster Gedanke:

[b]Start[/b] = (Multiplikation) { ("+" | "-") (Multiplikation) } ;

[b]Multiplikation[/b] = (Klammer) { ("*" | "/") (Klammer) } ;

[b]Klammer[/b] = [b]["+" | "-"][/b] ((Zahl) | "(" (Start) ")") ;

[b]Zahl[/b] = (Ziffer) { (Ziffer) } ;

[b]Ziffer[/b] = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;

zu

[b]Start[/b] = (Multiplikation) { ("+" | "-") (Multiplikation) } | (?) {"%"} (?) ;

[b]Multiplikation[/b] = (Klammer) { ("*" | "/") (Klammer) } ;

[b]Klammer[/b] = [b]["+" | "-"][/b] ((Zahl) | "(" (Start) ")") ;

[b]Zahl[/b] (== UINT) = (Ziffer) { (Ziffer) } ;

[b]Float[/b] = (Ziffer) {"."} (Ziffer);
[b]Ziffer[/b] = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;

wobei nun unklar ist, was ich für "?" einsetzen soll. (falls das überhaupt so sinnvoll ist).
Es scheint mir so, als müsste ich für Int und Float separate Ableitungsregeln definieren, denn offenkundig ist nach Standardregeln etwa <int><float> == <float><int> = <float>

[Bashar]

Denk mal kurz darüber nach, was passiert, wenn du Variablen einführst. Wie würdest du a % 2 parsen?