Parser und Übersetzer

Übersetzer für Additions-/Subtraktions-Ausdrücke

Bei der syntax­gesteuerten Übersetzung wird von einem Parser ausgegangen. Zu jeder Parser-Funktion, die einer Variablen der Grammatik entspricht, werden geeignete Übersetzungs­aktionen hinzugefügt. Das Ergebnis ist eine Compiler-Funktion; diese liefert das Ergebnis der Übersetzung als Rückgabewert.

Im Folgenden wird dieses Vorgehen an einem konkreten Beispiel erläutert.

Recursive-Descent-Übersetzung von Ausdrücken

Wir nehmen den Parser für Additions-/Subtraktions-Ausdrücke als Grundlage, um nunmehr die eingegebenen Ausdrücke nicht nur zu parsen, sondern syntax­gesteuert in ihren Wert zu übersetzen. Zum Beispiel liefert der Ausdruck "9-3-4" als Ergebnis den Wert 2.

Hierzu wird die Klasse SimpleExpressionParser in eine Klasse SimpleExpressionCompiler umgeschrieben. Jede Funktion, die einer Variablen der Grammatik entspricht, liefert nun einen Wert zurück. Dieser Wert wird durch Übersetzungs­aktionen in der Implementierung der Funktion gebildet.

Die Klasse SimpleExpressionCompiler wird von der abstrakten Basisklasse Compiler abgeleitet. Die Additions-/Subtraktions-Ausdrücke liefern Werte vom Typ Integer zurück, daher wird Integer als Typ-Parameter für die Basisklasse Compiler angegeben.

 

public class SimpleExpressionCompiler extends Compiler<Integer>
{
    // Startsymbol ist expr
    @Override
    protected Integer startSymbol()
    {
        return expr();
    }

    // expr -> number (+ number | - number)*
    private Integer expr()
    {
        Integer v=number();
        while (comes("+") || comes("-"))
            if (comes("+"))
            {
                match("+");
                v+=number();
            }
            else
            {
                match("-");
                v-=number();
            }
        return v;
    }

    // number -> 0 | 1 | ... | 9
    private Integer number()
    {
        if (comes("0"))
        {
            match("0");
            return 0;
        }
        else if (comes("1"))
        {
            match("1");
            return 1;
        }
        else if (comes("2"))
        {
            match("2");
            return 2;
        }
        else if (comes("3"))
        {
            match("3");
            return 3;
        }
        else if (comes("4"))
        {
            match("4");
            return 4;
        }
        else if (comes("5"))
        {
            match("5");
            return 5;
        }
        else if (comes("6"))
        {
            match("6");
            return 6;
        }
        else if (comes("7"))
        {
            match("7");
            return 7;
        }
        else if (comes("8"))
        {
            match("8");
            return 8;
        }
        else if (comes("9"))
        {
            match("9");
            return 9;
        }
        else
            throw new RuntimeException("Ziffer erwartet");
    }

    // Test
    public static void main(String[] args)
    {
        Compiler<Integer> p=new SimpleExpressionCompiler();
        String x="9-5-8+4";
        Integer r=p.compile(x);
        System.out.println(x);
        System.out.println(p.errorPointer());
        System.out.println(p.errormessage);
        System.out.println("Ergebnis: "+r);
    }

}    // end class SimpleExpressionCompiler

Zusammenfassung

Ein syntax­gesteuerter Recursive-Descent-Übersetzer ergibt sich aus einem ent­sprechenden Parser. In jeder Funktion, die einer Variablen der Grammatik entspricht, werden geeignete Übersetzungs­aktionen hinzugefügt. Diese Übersetzungs­aktionen errechnen den Wert, den die Funktion zurückgibt.

Eine allgemeine, formale Vorgehens­weise für die Konstruktion von Compiler-Funktionen, die Variablen der Grammatik entsprechen, ist unter Recursive-Descent-Übersetzung – systematisch angegeben.

 

Weiter mit: [Recursive-Descent-Übersetzung – systematisch]   oder   [up]

 

H.W. Lang   mail@hwlang.de   Impressum   Datenschutz
Created: 02.12.2011   Updated: 17.02.2023
Diese Webseiten sind während meiner Lehrtätigkeit an der Hochschule Flensburg entstanden