Formale Sprachen und Automaten

Transkript

1 Formale Sprachen und Automaten Kapitel 6: Syntaxanalyse Vorlesung an der DHBW Karlsruhe Thomas Worsch Karlsruher Institut für Technologie, Fakultät für Informatik Wintersemester 2012

2 Kapitel 6 Syntaxanalyse Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Inhalt 2/112

3 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Einleitung 3/112

4 6.3 Phasen eines Übersetzers Analyseteil Vorverarbeitung (Makroersetzung) lexikalische Analyse syntaktische Analyse semantische Analyse Syntheseteil Erzeugung des Zwischencodes Optimierung des Zwischencodes Erzeugung des Maschinencodes Optimierung des Maschinencodes quer dazu Verwaltung der Symboltabelle Fehlerbehandlung Einleitung 4/112

5 T-Diagramme Übersetzer C von Quellsprache S nach Zielsprache T implementiert in Programmiersprache I : S C T I Beispielaufgabe: P C 1 Gegeben: zwei Übersetzer P M 2 und P C 2 M 1 M 1 Gesucht: ein Übersetzer P M 2 M 2 Einleitung 5/112

6 T-Diagramme (2) Gesucht: ein Übersetzer P M 2 M 2 : 1. Schritt: P C 1 P M 2 P P C 2 M 1 M 1 C 3 M 1 M 2 2. Schritt: P C 1 P Falls M 1 = M 2 = M: P C 1 M 2 P C 4 M 2 M 2 P P C 3 M 2 M 2 P C 2 M 1 M 1 M 1 P C 1 P P M P C 1 P C 2 M M P C 4 P C 3 M M M M M Einleitung 6/112

7 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Lexikalische Analyse 7/112

8 6.5 Ein Programm(teil), das die lexikalische Analyse durchführt, heißt auch Lexer oder Scanner. Im Deutschen manchmal: Symbolentschlüssler. Lexikalische Analyse 8/112

9 6.6 Aufgaben des Lexers Eingabetext an passenden Stellen in eine Folge von Lexemen aufteilen. Jedes Lexem passt zu einem Muster, oft durch reguläre Ausdrücke beschrieben. Daraus kann automatisch eine effizient arbeitende Implementierung des Lexers erzeugt werden. Lexikalische Analyse 9/112

10 6.6 Aufgaben des Lexers (2) Schnittstelle des Lexers: Prozeduren zur Initialisierung und Beendigung nexttoken: Aufruf führt dazu, dass der Lexer im Eingabestrom nach dem nächsten Lexem sucht, für das er ein Token zurückliefert. Token besteht aus Typ und unter Umständen noch weiteren Attributen. Beispiel: Token für Variablennamen Typ: id Attribute: Name der Variable oder Verweis auf den Eintrag des Namens in der Symboltabelle Die Token sind die Terminalsymbole der Grammatik, die den kontextfreien Anteil der Programmiersprachensyntax beschreibt. Lexikalische Analyse 10/112

11 6.7 Kommentare Einen Kommentar kann man als Lexem auffassen, für das kein Token erzeugt wird. Leerzeichen kann der Lexer auch überlesen, sofern sie für das Programm bedeutungslos sind. Es gibt allerdings Programmiersprachen (Fortran, Occam, Python,... ), bei denen die Position eines Lexems im Quellprogramm von Bedeutung sein kann. In einem solchen Fall ist der Lexer entsprechend aufwendiger zu implementieren. Lexikalische Analyse 11/112

12 6.8 Beispiel Eingabe: erna = hugo + 1; aufeinanderfolgende Aufrufe von nexttoken liefern: (id,erna) (assignop,) (id,hugo) (plusop,) (num,1) (semi,) Die syntaktische Analyse muss überprüfen, ob die Zeichenfolge id assignop id plusop num semi in der Grammatik ableitbar ist. Lexikalische Analyse 12/112

13 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Lexer-Generatoren 13/112

14 6.10 Lexer-Generatoren Lexer-Generator: Programm zur automatischen Erzeugung von Lexern Eingabe: Datei, in der insbesondere mit Hilfe regulärer Ausdrücke beschrieben ist, Lexeme welcher Struktur zu suchen sind, und welche Token daraus zu erzeugen sind. Ausgabe: Quelle eines Programmes, das als Lexer auf die gewünschte Art arbeitet. Beispiele: lex, flex und JLex, Werkzeuge in Übersetzergenerator-Suiten wie cocktail und Eli Lexer-Generatoren 14/112

15 6.11 Reguläre Definitionen zur besseren Lesbarkeit regulärer Ausdrücke Teilausdrücke können mit Namen bezeichnet werden Beispiel: digit [0-9] letter [a-za-z] id letter (letter digit)* num digit+ (.digit+)? (O/*[-+]?digit+)? Wichtig: Auf der rechten Seite dürfen nur Namen regulärer Ausdrücke benutzen darf, die vorher definiert wurden. Direkte oder indirekte Rekursionen sind verboten. / Lexer-Generatoren 15/112

16 6.12 Eingabedatei für Lexergenerator reguläre Definitionen Regeln, die einigen regulären Ausdrücken Aktionen zuordnen. Programmstücke, die in den erzeugten Lexer mit eingebaut werden. Aktion gibt an, was der Lexer tun soll, wenn nexttoken aufgerufen wird und das zum nächsten Token gehörende Lexem zum jeweiligen regulären Ausdruck gehört. Zum Beispiel könnte für den regulären Ausdruck id als Aktion spezifiziert sein, dass der gefundene Name in der Symboltabelle zu suchen und gegebenenfalls einzutragen ist und der Rückgabewert das Token id und als Attribut der Verweis auf den Symboltabelleneintrag zu liefern ist. Lexer-Generatoren 16/112

17 6.13 Wichtig: Lexer versucht, zu einem regulären Ausdruck eine möglichst lange passende Folge von Eingabezeichen zu finden. Beispiel: aus Eingabe E67 wird vom Lexer ein Token num mit Attribut E67 gemacht und nicht z. B. zwei num-token mit Attributen und 5E67. Wenn das gleiche maximal lange Präfix der Eingabe auf die regulären Ausdrücke mehrerer Lexerregeln passt, wird bei vielen Lexergeneratoren ein Lexer erzeugt, der immer die erste passende Regel benutzt. Beispiel: reguläre Definition keyword for do if then mit Aktion für keyword vor der Aktion für id (wie oben) Dann wird der Lexer für die Zeichenfolge if in der Eingabe ein Token keyword zurückliefern und nicht ein Token id. Lexer-Generatoren 17/112

18 6.15 Beispiel: Lexerspezifikation für JLex Grobstruktur: Benutzer-Code %% reguläre Definitionen %% Regeln mit Aktionen Lexer-Generatoren 18/112

19 6.15 Beispiel: Lexerspezifikation für JLex (2) Beispiel: Benutzer-Code : import java.lang.system; class Simple { public static void main(string argv[])... { Yylex yy = new Yylex(System.in); Yytoken t; while ((t = yy.yylex())!= null) System.out.println(t); } } class Yytoken { Yytoken(int index, String text) {... } private static final String tokname[] = { "UNKNOWN", "FLOAT", "INT", "ID" }; public int m_index; public String m_text; public String tostring() {return... } } %% Lexer-Generatoren 19/112

20 6.15 Beispiel: Lexerspezifikation für JLex (3) reguläre Definitionen : ALPHA = [A-Za-z] DIGIT = [0-9] ID = {ALPHA}({ALPHA} {DIGIT} _)* INT = {DIGIT}+ FLOAT = {INT}\.{INT} %% WHITE_SPACE_CHAR = [\n\ \t\b\012] Lexer-Generatoren 20/112

21 6.15 Beispiel: Lexerspezifikation für JLex (4) Regeln mit Aktionen : {WHITE_SPACE_CHAR}+ { } {FLOAT} { return (new Yytoken(1,yytext())); } {INT} { } {ID} { }. { } return (new Yytoken(2,yytext())); return (new Yytoken(3,yytext())); return (new Yytoken(0,yytext())); Lexer-Generatoren 21/112

22 6.16 Arbeiten mit JLex Voraussetzungen: obige JLex-Spezifikation in Datei simple.lex JLex irgendwo im CLASSPATH verfügbar Dann: java JLex.Main simple.lex erzeugt Datei simple.lex.java: Java-Quelle eines Lexers Ausgaben von JLex: Processing first section -- user code. Processing second section -- JLex declarations. Processing third section -- lexical rules. Creating NFA... Creating DFA... Minimizing DFA... javac simple.lex.java erzeugt den lauffähigen Lexer java Simple startet den Lexer. Lexer-Generatoren 22/112

23 6.19 Viele (aber nicht alle) Lexergeneratoren erzeugen tabellengesteuerte Lexer. Sie bestehen im wesentlichen immer aus dem gleichen Code, der die endlichen Automaten simuliert, die in Form einer Tabelle gespeichert sind. Lexer-Generatoren 23/112

24 6.20 Kommentare in Programmiersprachen Angenommen, die lexikalische Analyse soll: alle Kommentare aus dem Programm entfernen durch endlichen Automaten erledigt werden Programmiersprachen, bei denen Kommentare durch ausgezeichnete Zeichenketten am Anfang und am Ende gekennzeichnet sind (z. B. /* und */ in C) geschachtelte Kommentare verboten Man müsste die Eingabe auf korrekte Klammerstruktur überprüfen, und das kann ein endlicher Automat nicht. andererseits: ein einfacher Zähler für die Schachtelungstiefe würde genügen Manche Lexergeneratoren unterstützen den Anwender bei solchen Problemen. Lexer-Generatoren 24/112

25 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Syntaktische Analyse 25/112

26 6.21 Wie kommt man von den nichtdeterministischen Kellerautomaten weg? Benutze nicht Kellerautomaten, sondern andere Algorithmen. Einschränkung auf eine echte Teilklasse aller kontextfreien Grammatiken, damit deterministischen Kellerautomaten oder wenigstens eine einfache Erweiterung davon reichen. Syntaktische Analyse 26/112

27 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Der Algorithmus von Cocke, Younger und Kasami 27/112

28 6.22 Definition Grammatik in Chomsky-Normalform: Jede Produktion X w mit X S hat als rechte Seite entweder ein Wort w N 2 (genau zwei Nichtterminalsymbole) oder ein Wort w T (genau ein Terminalsymbol). Wenn es die Produktion S ε gibt, dann kommt S bei keiner Produktion auf der rechten Seite vor. Der Algorithmus von Cocke, Younger und Kasami 28/112

29 6.23 Satz Zu jeder kontextfreien Grammatik G gibt es eine kontextfreie Grammatik G in Chomsky-Normalform, die zu G äquivalent ist (also L(G) = L(G )). Der Algorithmus von Cocke, Younger und Kasami 29/112

30 6.24 Lemma Für jede kontextfreie Grammatik G kann man die Menge EPS(G) = {X N X ε} aller Nichtterminalsymbole berechnen, aus denen das leere Wort ableitbar ist. Der Algorithmus von Cocke, Younger und Kasami 30/112

31 6.25 Beweisskizze Algorithmus: i 0 M 0 {X X ε P} do i i + 1 M i M i 1 {X w M i 1 : X w P} until M i = M i 1 return M i Der Algorithmus von Cocke, Younger und Kasami 31/112

32 6.26 Beispiel Grammatik G = ({X, Y, Z}, {a}, X, P) mit Produktionenmenge P = {X YZ, Y ZZ, Z a ε} Der obige Algorithmus berechnet nacheinander: M 0 = {Z} M 1 = {Z, Y } wegen Y ZZ P M 2 = {Z, Y, X } wegen X YZ P M 3 = {Z, Y, X } (keine Änderung mehr) Also ist EPS(G) = {X, Y, Z}. Der Algorithmus von Cocke, Younger und Kasami 32/112

33 6.27 Lemma Zu jeder kontextfreien Grammatik G = (N, T, S, P) kann man eine kontextfreie Grammatik G = (N, T, S, P ) berechnen, für die gilt: L(G ) = L(G) {ε} und keine Produktion von G hat ε als rechte Seite. Der Algorithmus von Cocke, Younger und Kasami 33/112

34 6.28 Beweisskizze In P nimmt man alle Produktionen X w auf, für die gilt: w ε und es gibt eine Produktion X w P, so dass w aus w entsteht, indem man einige Vorkommen von Symbolen aus EPS(G) entfernt. Der Algorithmus von Cocke, Younger und Kasami 34/112

35 6.29 Lemma Zu jeder kontextfreien Grammatik G = (N, T, S, P) kann man eine äquivalente kontextfreie Grammatik Ḡ = (N, T, S, P) berechnen, für die gilt: Wenn ε / L(G) ist, dann hat Ḡ keine Produktion ε als rechte Seite. Wenn ε L(G) ist, dann ist S ε die einzige Produktion von Ḡ mit ε als rechter Seite und S kommt bei keiner Produktion auf der rechten Seite vor. Der Algorithmus von Cocke, Younger und Kasami 35/112

36 6.30 Beweisskizze Konstruiere wie in Lemma 6.27 eine Grammatik G mit L(G ) = L(G) {ε}. Wenn ε / L(G) ist, kann man Ḡ = G setzen und ist fertig. Ist ε L(G), denn erweitert man G um ein neues Nichtterminalsymbol S, das Startsymbol von Ḡ wird und setzt P = P { S ε, S S }. Der Algorithmus von Cocke, Younger und Kasami 36/112

37 6.23 Satz Zu jeder kontextfreien Grammatik G gibt es eine kontextfreie Grammatik G in Chomsky-Normalform, die zu G äquivalent ist (also L(G) = L(G )). Der Algorithmus von Cocke, Younger und Kasami 37/112

38 6.31 Beweis (von Satz 6.23) Es sei G 0 = (N 0, T, S, P 0 ) eine beliebige kontextfreie Grammatik. Konstruiere äquivalente kontextfreie Grammatik G 4 in Chomsky-Normalform in vier Schritten: 1. Konstruiere aus G eine äquivalente Grammatik G 1, bei der Terminalsymbole a T nur in Produktionen der Form X a vorkommen. 2. Konstruiere aus G 1 eine äquivalente Grammatik G 2 wie in Lemma 6.29 beschrieben. 3. Konstruiere aus G 2 eine äquivalente Grammatik G 3, die keine Produktionen der Form X Y enthält. 4. Konstruiere aus G 3 eine äquivalente Grammatik G 4, die keine Produktionen der Form X Y 1 Y 2 Y k mit k 3 enthält. Der Algorithmus von Cocke, Younger und Kasami 38/112

39 6.31 Beweis (2) 1. Konstruiere aus G eine äquivalente Grammatik G 1, bei der Terminalsymbole a T nur in Produktionen der Form X a vorkommen: Der Algorithmus von Cocke, Younger und Kasami 39/112

40 6.31 Beweis (2) 1. Konstruiere aus G eine äquivalente Grammatik G 1, bei der Terminalsymbole a T nur in Produktionen der Form X a vorkommen: Führe für jedes Terminalsymbol a T ein neues Nichtterminalsymbol Z a ein: N 1 = N 0 {Z a a T }. Produktionenmenge P 1 enthält alle Produktionen der Form Z a a und alle Produktionen, die man erhält, indem man in jeder Produktion aus P 0 jedes Vorkommen eines Terminalsymboles a durch Z a ersetzt. Der Algorithmus von Cocke, Younger und Kasami 39/112

41 6.31 Beweis (3) 2. Konstruiere aus G 1 eine äquivalente Grammatik G 2 wie in Lemma 6.29 beschrieben: Der Algorithmus von Cocke, Younger und Kasami 40/112

42 6.31 Beweis (3) 2. Konstruiere aus G 1 eine äquivalente Grammatik G 2 wie in Lemma 6.29 beschrieben: Nun sind alle Produktionen von der Form X a oder von der Form X Y1 Y k mit k 1 (evtl. Ausnahme S ε) Der Algorithmus von Cocke, Younger und Kasami 40/112

43 6.31 Beweis (4) 3. Konstruiere aus G 2 eine äquivalente Grammatik G 3, die keine Produktionen der Form X Y enthält: Der Algorithmus von Cocke, Younger und Kasami 41/112

44 6.31 Beweis (4) 3. Konstruiere aus G 2 eine äquivalente Grammatik G 3, die keine Produktionen der Form X Y enthält: Für jedes X N2 berechnet man die Menge M(X ) = {X X X } der aus X ableitbaren Nichtterminalsymbole. i 0 M 0 (X ) {X } do i i + 1 M i (X ) M i 1 (X ) {X Y M i 1 (X ) : Y X P} until M i (X ) = M i 1 (X ) return M i (X ) Aus P2 streicht man zunächst alle Produktionen der Form X X. Für verbliebene Produktion X Y 1 Y k nimmt man alle X Y 1 Y k hinzu, sofern X M(X ) und für alle i, 1 i k, auch Y i M(Y i ) ist. Das ergibt P 3. Der Algorithmus von Cocke, Younger und Kasami 41/112

45 6.31 Beweis (5) 4. Konstruiere aus G 3 eine äquivalente Grammatik G 4, die keine Produktionen der Form X Y 1 Y 2 Y k mit k 3 enthält. Der Algorithmus von Cocke, Younger und Kasami 42/112

46 6.31 Beweis (5) 4. Konstruiere aus G 3 eine äquivalente Grammatik G 4, die keine Produktionen der Form X Y 1 Y 2 Y k mit k 3 enthält. P 4 erhält man aus P 3, indem man jede Produktion der Form X Y1 Y k mit k 3 entfernt und ersetzt durch die k 1 Produktionen X Y1 V 1, V 1 Y 2 V 2,..., V k 1 Y k 1 Y k. Dabei seien die V i jeweils neue Nichtterminalsymbole (die natürlich alle zu N 4 hinzugenommen werden). Der Algorithmus von Cocke, Younger und Kasami 42/112

47 6.32 Beispiel Grammatik mit Startsymbol E und den Produktionen: E E + F F F ( E ) a 1. Schritt: Behandlung der Terminalsymbole ergibt: E E Z + F F Z + + Z a a F Z ( E Z ) Z a Z ( ( Z ) ) Für das Terminalsymbol a ist das Vorgehen natürlich überflüssig. 2. Schritt: keine ε-produktionen vorhanden, also ändert sich nichts. Der Algorithmus von Cocke, Younger und Kasami 43/112

48 6.32 Beispiel (2) 3. Schritt: Berechne zunächst die Mengen M i (X ): X M 0 (X ) M 1 (X ) M 2 (X ) M 3 (X ) E {E} {E, F } {E, F, Z a } {E, F, Z a } F {F } {F, Z a } {F, Z a } {F, Z a } Die Produktionen E F und F Za werden entfernt und dafür neue aufgenommen. Aus E E Z + F entstehen: E E Z + F F Z + F Z a Z + F E Z + Z a F Z + Z a Z a Z + Z a Aus F Z( E Z ) ergeben sich F Z ( E Z ) Z ( F Z ) Z ( Z a Z ) E Z ( E Z ) Z ( F Z ) Z ( Z a Z ) Der Algorithmus von Cocke, Younger und Kasami 44/112

49 6.32 Beispiel (3) 4. Schritt: Jede Produktion mit drei Nichtterminalzeichen auf der rechten Seite wird ersetzt durch zwei Produktionen mit nur zwei Nichtterminalzeichen auf der rechten Seite. Zum Beispiel: E E Z + F ersetzt durch E E V 1 und V 1 Z + F. Analog in allen anderen Fällen vor, wobei jedes Mal neue zusätzliche Nichtterminalsymbole V 2, V 3,... eingeführt werden. Jedenfalls verlangt das der Algorithmus so. Scharfes Hinsehen ergibt hier, dass man sparsamer sein kann: E E V 1 F V 1 Z a V 1 V 1 Z + F E E V 2 F V 2 Z a V 2 V 2 Z + Z a E Z ( V 3 Z ( V 4 Z ( V 5 V 3 E Z ) F Z ( V 3 Z ( V 4 Z ( V 5 V 4 F Z ) V 5 Z a Z ) Der Algorithmus von Cocke, Younger und Kasami 45/112

50 6.33 Der Algorithmus von Cocke, Younger und Kasami (kurz CYK) kann für jede Grammatik G = (N, T, S, P) in Chomsky-Normalform und jedes Wort w T auf deterministische Weise feststellen, ob w L(G) ist oder nicht. Eingabe w = x 1 x n T n ist mit n + 1 Trennstellen versehen, die neben den einzelnen Symbolen liegen. 0 a 1 b 2 b 3 a b 4 5 Es sei w(i, j] das Teilwort zwischen den Trennstellen i also w(i, j] = x i+1 x j (für 0 i < j n). Beispiele: w(0, n] = w w(i, i] = ε und, j Der Algorithmus von Cocke, Younger und Kasami 46/112

51 6.34 Algorithmus (Cocke, Younger, Kasami) CYK berechnet eine Pyramiden-Datenstruktur. D[0, 5] D[0, 4] D[1, 5] D[0, 3] D[1, 4] D[2, 5] D[0, 2] D[1, 3] D[2, 4] D[3, 5] D[0, 1] D[1, 2] D[2, 3] D[3, 4] D[4, 5] 0 x 1 1 x 2 2 x 3 3 x 4 4 x 5 5 Die einzelnen Komponenten D[i, j] sind (möglicherweise leere) Teilmengen von Nichtterminalsymbolen. Ziel: D[i, j] = {X X w(i, j] } Der Algorithmus von Cocke, Younger und Kasami 47/112

52 6.34 Algorithmus CYK (2) for i 0 to n 1 do D[i, i + 1] = {X X x i+1 P} od for k 2 to n do for i 0 to n k do D[i, i + k] for m i + 1 to i + k 1 do if X YZ P Y D[i, m] Z D[m, i + k] then D[i, i + k] D[i, i + k] {X } fi od od od Der Algorithmus von Cocke, Younger und Kasami 48/112

53 6.34 Algorithmus CYK (3) Drei ineinander geschachelte Schleifen, für die ersten n/4 Durchläufe der äußersten und die letzten n/4 Durchläufe der mittleren Schleife wird die innerste jeweils mindestens n/4 mal durchlaufen. Der Test für die if-anweisung benötigt konstante Zeit. Also ist die Laufzeit des Algorithmus in Θ(n 3 ). Es ist auch nicht schwer, einzusehen, dass am Ende in der Tat D[i, j] = {X X x i+1 x j } ist. Also ist x 1 x n genau dann aus L(G), wenn S D[0, n] ist. Der Algorithmus von Cocke, Younger und Kasami 49/112

54 6.35 Beispiel für Grammatik aus Beispiel 6.32: {E, F } {V 3 } {E} {V 2 } {V 5 } {Z ( } {Z a } {Z + } {Z a } {Z ) } 0 ( 1 a a 4 ) 5 leere Kästchen: D[i, j] =. Der Algorithmus von Cocke, Younger und Kasami 50/112

55 Zur Vorbereitung auf den Algorithmus von Earley: einfache Umformung von CYK Der Algorithmus von Earley ist nicht relevant für die Klausur. Deswegen springen wir jetzt zum Abschnitt über LR Parsing Der Algorithmus von Cocke, Younger und Kasami 51/112

56 6.36 Algorithmus Andere Darstellung der Pyramide: D[0, 5] D[0, 4] D[1, 5] D[0, 3] D[1, 4] D[2, 5] D[0, 2] D[1, 3] D[2, 4] D[3, 5] D[0, 1] D[1, 2] D[2, 3] D[3, 4] D[4, 5] 0 x 1 1 x 2 2 x 3 3 x 4 4 x 5 5 neue Berechnungsreihenfolge: spaltenweise von links nach rechts und innerhalb jeder Spalte von unten nach oben. Der Algorithmus von Cocke, Younger und Kasami 52/112

57 6.36 Algorithmus (2) for j 1 to n do D[j 1, j] {X X x j P} for i j 1 downto 0 do D[i, j] for m i + 1 to j do if X YZ P Y D[i, m] Z D[m, j] then D[i, j] D[i, j] {X } fi od od od Der Algorithmus von Cocke, Younger und Kasami 53/112

58 6.37 Weitere Transformation von CYK S 0 S 1 S 2 S 3 S 4 S 5 D[4, 5] D[3, 4] D[3, 5] D[2, 3] D[2, 4] D[2, 5] D[1, 2] D[1, 3] D[1, 4] D[1, 5] D[0, 1] D[0, 2] D[0, 3] D[0, 4] D[0, 5] 0 x 1 1 x 2 2 x 3 3 x 4 4 x 5 5 Der Algorithmus von Cocke, Younger und Kasami 54/112

59 6.38 Beispiel Für obige Grammatik ergibt sich mit zusätzlicher Angabe der Produktionen und relevanten Trennstellen: S 0 S 1 S 2 S 3 S 4 S 5 E Z ( V V 3 EZ ) 1 5 E Z a V V 2 Z + Z a 2 4 V 5 Z a Z ) 3 5 Z ( ( 0 1 Z a a 1 2 Z Z a a 3 4 Z ) ) ( 1 a a 4 ) 5 Der Algorithmus von Cocke, Younger und Kasami 55/112

60 6.38 Beispiel (2) Angabe der rechten Trennstelle redundant stattdessen dicker Punkt: S 0 S 1 S 2 S 3 S 4 S 5 E Z ( V 3 0 V 3 EZ ) 1 E Z a V 2 1 V 2 Z + Z a 2 V 5 Z a Z ) 3 Z ( ( 0 Z a a 1 Z Z a a 3 Z ) ) 4 0 ( 1 a a 4 ) 5 Der Algorithmus von Cocke, Younger und Kasami 56/112

61 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Der Algorithmus von Earley 57/112

62 Achtung Dieser Abschnitt ist nicht relevant für die Klausur. Der Algorithmus von Earley 58/112

63 6.39 In der vorangegangenen Abbildung gibt es für eine Eingabe der Länge n Mengen S 0, S 1,..., S n, die sogenannte Items enthalten: Produktionen mit einem Markierungspunkt, bei denen an der gleiche Stelle oder links davon noch eine Trennstelle angegeben ist. Der Algorithmus von Earley 59/112

64 6.40 Bei CYK gilt für die Items: Hat die Trennstelle Nummer i und ist das Item in S j, so ist sicher, dass man aus dem, was auf der rechten Seite der Produktion zwischen Trennstelle und steht, das Teilwort w(i, j] der Eingabe ableiten kann. Eine Produktion X YZ wird in S j aufgenommen, wenn i es ein m gibt, so dass ein Item Y v in S m ist und ein Item Z v in S j. m Beim Algorithmus von Earley ändern sich die Form der Items und die Regeln zur Berechung der S j. i Der Algorithmus von Earley 60/112

65 6.41 Definition Ein Item hat die Form X v 1 v 2. i Dabei ist X v 1 v 2 eine ursprünglichen Produktion. Präfix v 1 und Suffix v 2 sind ansonsten nicht eingeschränkt. Z. B. erlaubt: Items der Form X w i Ein Item X v 1 v 2 wird immer nur zu Mengen S j mit i j gehören. i Der Algorithmus von Earley 61/112

66 6.42 Bedeutung der Items Für ein Item X v 1 v 2, das in S j ist, gilt: i markiert die Stelle j, bis zu der man schon gekommen ist, und aus dem, was zwischen Trennstelle und steht, kann man das Teilwort w(i, j] ableiten. Für das Suffix hinter dem, wird noch offen sein, ob aus ihm ein weiteres Stück der Eingabe ableitbar ist. i Der Algorithmus von Earley 62/112

67 6.43 Algorithmus von Earley Wie kommt ein Item X v 1 v 2 in eine Menge S j? i 1. Lexer-Regel 2. Completer-Regel 3. Predictor-Regel Der Algorithmus von Earley 63/112

68 6.43 Algorithmus von Earley (2) Wann kann man an einem Terminalsymbol vorbeischieben? Prüfe, ob das nächste Eingabesymbol gerade a ist. Falls ja, dann füge X v 1 a v 2 zu S j+1 hinzu. 1. Lexer-Regel: nein, dann lässt man das. i Wenn X v 1 av 2 in S j und a = w(j, j + 1], dann kommt X i i v 1 a v 2 zu S j+1 hinzu. Der Algorithmus von Earley 64/112

69 6.43 Algorithmus von Earley (3) Wann an Y in X v 1 Yv 2 aus S m vorbeischieben? i Sinnvoll, wenn man aus Y ein Teilwort der Eingabe ableiten kann, das an Trennstelle m beginnt. Das soll man aber gerade daran ablesen können, dass ein Item Y v in einem S j ist für ein j > m. m 2. Completer-Regel: Wenn X v 1 Yv 2 in S m ist und Y v in S j, dann i m kommt X v 1 Y v 2 zu S j hinzu. i Der Algorithmus von Earley 65/112

70 6.43 Algorithmus von Earley (4) Woher kommen Items der Form Y v 2 mit dem am Anfang? i Plausibel: Item Y v 2 dann zu einem S j hinzuzunehmen, wenn man das Y brauchen kann. 3. Predictor-Regel: i Wenn X v 1 Yv 2 in S j ist, dann kommt Y v zu S j i j hinzu für jede ProduktionY v. Der Algorithmus von Earley 66/112

71 6.43 Algorithmus von Earley (5) Der Algorithmus von Earley (genauer gesagt die Variante, die ohne sogenannten Look-Ahead in der Eingabe arbeitet) für eine Grammatik G = (N, T, S, P) ergibt sich nun einfach wie folgt: Man beginnt mit der Menge S 0, die genau alle Items der Form S w für jede Produktion der Form S w P (S ist 0 das Startsymbol der Grammatik). Auf eine Menge S j werden solange die Lexer-, Completer- und Predictor-Regeln angewendet, bis sich nichts mehr ändert. Dann fährt man mit S j+1 fort. Der Algorithmus von Earley 67/112

72 6.43 Algorithmus von Earley (6) Ende des Algorithmus: Ist einmal ein S j =, dann ist die Eingabe nicht ableitbar. Andernfalls muss man am Ende überprüfen, ob S n ein Item der Form S w enthält. 0 Wenn das der Fall ist (und nur dann), ist die Eingabe in der Grammatik ableitbar. Der Nachweis, dass dieser Algorithmus wirklich das Richtige tut, wurde von Jay Earley geführt. Der Algorithmus von Earley 68/112

73 6.44 Beispiel Betrachte sehr einfache Grammatik G = (N, T, S, P) mit N = {S, X, A, B, C}, T = {a, b, c}, Startsymbol S P = {S AX, X BC, A a, B b, C c}. Eingabe abc: S 0 S 1 S 2 S 3 S AX 0 S A X 0 S AX 0 X BC 1 X B C 1 X BC 1 A a 0 B b 1 C c 2 A a 0 B b 1 C c 2 0 a 1 b 2 c 3 Der Algorithmus von Earley 69/112

74 6.44 Beispiel (2) Lexer-Regel: durchgezogene Linien Predictor-Regel: gestrichelte Linien Completer-Regel: gepunktete Linien. S 0 S 1 S 2 S 3 S AX 0 S A X 0 S AX 0 X BC 1 X B C 1 X BC 1 A a 0 B b 1 C c 2 A a 0 B b 1 C c 2 0 a 1 b 2 c 3 Der Algorithmus von Earley 70/112

75 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse LR Parsing 71/112

76 Achtung Dieser Abschnitt und die folgenden sind wieder relevant für die Klausur. LR Parsing 72/112

77 6.45 Beispielgrammatik E E+T T T T *F F F (E) a LR Parsing 73/112

78 6.46 Vereinbarung Stets Eingabebegrenzungen vorhanden: E E E E+T T T T *F F F (E) a LR Parsing 74/112

79 6.47 Definition Eine Grammatik hat die Eigenschaft LR(k) für ein k N 0, wenn für zwei beliebige Rechtsableitungen S r ξ 1 A 1 ωη 1 r ξ1 γ 1 ωη 1 r αωη 1 T S r ξ 2 A 2 τ 2 r ξ1 γ 1 ωη 2 r αωη 2 T mit ω = k oder η 1 = η 2 = ε immer gilt: ξ 2 A 2 τ 2 = ξ 1 A 1 ωη 2. M.a.W.: Wenn τ 2 T ist, wenn also A 2 das zuletzt durch eine Reduktion entstandene Zeichen ist, dann ist A 1 = A 2, ξ 1 = ξ 2 und τ 2 = ωη 2. D. h. durch den Kellerinhalt (ξ 1 γ 1 ) und die nächsten k Eingabezeichen (ω) ist der nächste Reduktionsschritt bei der Bottom-Up-Syntaxanalyse eindeutig bestimmt. LR Parsing 75/112

80 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken Erweiterung der Kellerautomaten um Zustandskeller Zustand z(κ): Äquivalenzklasse von Kellerinhalten Aktionen: shift- und reduce-schritte außerdem accept und error shift reduce A γ act(z(κ), ω) = accept error Funktion goto zur einfachen Berechnung neuer Zustände: goto(z(κ), X ) = z(κx ) zunächst Annahme: Funktionen act und goto liegen schon vor LR Parsing 76/112

81 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (2) Automatenmodell: Zustandskeller z z = z(κ) Symbolkeller κ Eingabe α ω η LR Parsing 77/112

82 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (3) Shift-Aktion: vorher Zustandskeller z z = z(κ) Symbolkeller κ Eingabe α ω η LR Parsing 78/112

83 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (3) Shift-Aktion: nachher Zustandskeller z z z = goto(z, a) Symbolkeller κ a Eingabe α a ω η LR Parsing 79/112

84 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (4) Reduce-Aktion: vorher Zustandskeller z z Symbolkeller ξ γ Eingabe α ω η LR Parsing 80/112

85 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (4) Reduce-Aktion: nachher Zustandskeller z z z = goto(z, A) Symbolkeller ξ A Eingabe α ω η LR Parsing 81/112

86 6.49 Prinzip der Syntaxanalyse für LR(k)-Grammatiken (5) Beginn der Analyse: in den Symbolkeller wird unten ein gelegt und in den Zustandskeller entsprechend z( ) Ende der Analyse: im Symbolkeller ist nur noch S das kann zu S reduziert werden Der Kellerautomat kann schon akzeptieren, wenn im Symbolkeller S steht und als letztes Eingabesymbol ansteht. LR Parsing 82/112

87 6.50 Beispiel E E E E+T T 1 2 T T *F F 3 4 F (E) a 5 6 LR Parsing 83/112

88 6.50 Beispiel (2) Die folgenden Tabellen kann man algorithmisch finden wie, verraten wir gleich Es ist hier ω = 1. act(z, ω) goto(z, X ) z κ a + * ( ) a + * ( ) E T F 0 S S E S A (E S S 3 3 E+ S S E+T R 1 S R 1 R (T R 2 S R 2 R T * S S T *F R 3 R 3 R 3 R 3 8 (F R 4 R 4 R 4 R 4 9 ( S S (E) R 5 R 5 R 5 R 5 11 a R 6 R 6 R 6 R 6 LR Parsing 84/112

89 6.50 Beispiel (3) κ ω η 0 ( a + a ) * a 0 9 ( a + a ) * a ( a + a ) * a ( F + a ) * a ( T + a ) * a ( E + a ) * a ( E + a ) * a LR Parsing 85/112

90 6.50 Beispiel (4) ( E + a ) * a ( E + a ) * a ( E + F ) * a ( E + T ) * a ( E ) * a ( E ) * a 0 8 F * a LR Parsing 86/112

91 6.50 Beispiel (5) 0 8 F * a 0 5 T * a T * a T * a T * F 0 5 T 0 1 E LR Parsing 87/112

92 6.51 Definition Zu jeder Produktion A X 1 X 2 X k (mit X i N T ) gehören die k + 1 markierten Produktionen (Items) A X1 X 2 X k A X1 X 2 X k. A X 1 X 2 X k A X 1 X 2 X k Zu A ε gehört A LR Parsing 88/112

93 6.52 Konstruktion der Zustände: Jeder Zustand ist eine Menge markierter Produktionen. Beginne mit Zustandskern M 0 = {S S }. Vervollständigungsregel: M i wird erweitert zu z i = kompl(m i ) M i gemäß folgender Predictor-Regel : Wenn A µ Bν kompl(mi ) und B γ P, dann auch B γ kompl(m i ) Fortschreibungsregel: erzeuge Kerne für neue M-Mengen gemäß: wenn A µ X ν z(κ), dann A µx ν z(κx ) anschließend Vervollständigung LR Parsing 89/112

94 6.52 (2) Wenn man das so macht, dann gilt: z(κ) enthält genau diejenigen A µ ν, für die gilt: A µν P, ξ V : κ = ξµ und η T : S r ξaη LR Parsing 90/112

95 6.53 großes Beispiel an der Tafel LR Parsing 91/112

96 6.54 Also: z(κx ) = kompl({a µx ν A µ X ν z(κ)}). Damit hat man auch schon goto(z(κ), X ) = z(κx ). LR Parsing 92/112

97 6.55 Beispiel E T F a ( ) + * z 0 z 1 z 2 z 3 z 4 z 5 z 6 z 6 z 6 z 6 z 1 z 6 z 6 z 6 z 6 z 6 z 6 z 7 z 6 z 8 z 2 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 9 z 6 z 3 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 4 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 5 z 10 z 2 z 3 z 4 z 5 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 7 z 6 z 11 z 3 z 4 z 5 z 6 z 6 z 6 z 6 z 8 z 9 z 6 z 6 z 12 z 4 z 5 z 6 z 6 z 6 z 6 z 10 z 6 z 6 z 6 z 6 z 6 z 13 z 7 z 6 z 6 z 11 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 9 z 6 z 12 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 13 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 z 6 LR Parsing 93/112

98 6.56 Wie findet man die Funktion act? Idee: Look-ahead-Mengen la(z, A µ ν) T und la(z, shift) T, so dass für jedes z alle diese Mengen disjunkt sind. Dann definieren die folgenden Festlegungen act konsistent und sinnvoll: reduce A γ falls a la(z, A µ ) shift falls a la(z, shift) f (z, a) = accept falls z = z( S ) (oder falls S z und a = ) error sonst LR Parsing 94/112

99 6.57 Mitteilung Für verschieden nette Grammatiken kann man auf mehr oder weniger einfache Weise geeignete Look-ahead-Mengen konstruieren. Zum Beispiel ist eine Grammatik LALR(1), wenn die wie folgt definierten la-mengen paarweise disjunkt sind: la(z, S S ) = a la(z, A µ Bν) b anf (νa) = b la(z, B γ) a la(z, A µ X ν) = a la(goto(z, X ), A µx ν) LR Parsing 95/112

100 Einleitung Lexikalische Analyse Lexer-Generatoren Syntaktische Analyse Der Algorithmus von Cocke, Younger und Kasami Der Algorithmus von Earley LR Parsing Nach der Syntaxanalyse Nach der Syntaxanalyse 96/112

101 6.59 Grammatiken mit semantischen Aktionen Produktionen der Form A {code 0 } X 1 {code 1 } X 2 X m {code m } Codefragment am Ende wird nach der Reduktion auf dem Keller gemäß der kontextfreien Produktion ausgeführt. Für andere Codestücke stelle man sich vor: A M 0 X 1 M 1 X 2 X m {code m } M 0 ε {code 0 } M 1 ε {code 1 }. M m 1 ε {code m 1 } Nach der Syntaxanalyse 97/112

102 6.60 Beispiel E E+T { printf("reduktion mit E -> E+T \n"); } E T { printf("reduktion mit E -> T \n"); } T T *F { printf("reduktion mit T -> T*F \n"); } T F { printf("reduktion mit T -> F \n"); } F (E) { printf("reduktion mit F -> (E) \n"); } F a { printf("reduktion mit F -> a \n"); } Nach der Syntaxanalyse 98/112

103 6.61 Anwendung semantischer Aktionen: Berechnung von Werten für Attribute von Kellersymbolen Nach der Syntaxanalyse 99/112

104 6.62 Beispiel (Auswertung arithmetischer Ausdrücke) Attribut val für Terminal- und Nichtterminalsymbole Indizes zur Unterscheidung mehrerer Vorkommen des gleichen Symbols in einer Produktion E 0 E 1 +T 1 { E 0.val = E 1.val + T 1.val } E 0 T 1 { E 0.val = T 1.val } T 0 T 1 *F 1 { T 0.val = T 1.val F 1.val } T 0 F 1 { T 0.val = F 1.val } F 0 (E 1 ) { F 0.val = E 1.val } F 0 num { F 0.val = num.val } Nach der Syntaxanalyse 100/112

105 6.62 Beispiel (2) Sinnvoll: Auswertung von unten nach oben E.val =? E.val =? + T.val =? T.val =? F.val =? * F.val =? F.val =? num.val = 3 num.val = 4 num.val = 2 Nach der Syntaxanalyse 101/112

106 6.62 Beispiel (2) Sinnvoll: Auswertung von unten nach oben E.val =? E.val =? + T.val =? T.val =? F.val = 3 * F.val = 4 F.val = 2 num.val = 3 num.val = 4 num.val = 2 Nach der Syntaxanalyse 101/112

107 6.62 Beispiel (2) Sinnvoll: Auswertung von unten nach oben E.val =? E.val =? + T.val = 12 T.val = 2 F.val = 3 * F.val = 4 F.val = 2 num.val = 3 num.val = 4 num.val = 2 Nach der Syntaxanalyse 101/112

108 6.62 Beispiel (2) Sinnvoll: Auswertung von unten nach oben E.val =? E.val = 2 + T.val = 12 T.val = 2 F.val = 3 * F.val = 4 F.val = 2 num.val = 3 num.val = 4 num.val = 2 Nach der Syntaxanalyse 101/112

109 6.62 Beispiel (2) Sinnvoll: Auswertung von unten nach oben E.val = 14 E.val = 2 + T.val = 12 T.val = 2 F.val = 3 * F.val = 4 F.val = 2 num.val = 3 num.val = 4 num.val = 2 Nach der Syntaxanalyse 101/112

110 6.63 Attributierte Grammatik Kontextfreie Grammatik G(N, T, S, P) mit endlicher Menge A von Attributen a A (mit je einem Wertebereich V a ). Zu jedem Symbol X N T disjunkte Attributmengen DX A sogenannter synthetisierter Attribute (engl. synthesized oder derived) IX A sogenannter vererbter (engl. inherited) Attribute Nach der Syntaxanalyse 102/112

111 6.63 Attributierte Grammatik (2) Zu jedem p : X 0 X 1 X m für jedes a D X0 eine Funktion, die in Abhängigkeit von allen Attributen aller auf der rechten Seite vorkommenden Symbole einen Wert für das Attribut a festlegt. Zu p : X 0 X 1 X m für jedes i = 1,..., n und a I Xi eine Funktion, die in Abhängigkeit von allen Attributen aller vorkommenden Symbole einen Wert für das Attribut a festlegt. Nach der Syntaxanalyse 103/112

112 6.64 S-attributierte Grammatik nur synthetisierte Attribute Solche Grammtiken sind sehr nützlich und für Bottom-up-Syntaxanalyse gut geeignet. Kellerautomat: Bei Reduktion gemäß Produktion A w berechnet er aus den Attributwerten der Symbole in w die Attributwerte für A. Nach der Syntaxanalyse 104/112

113 6.65 Beispiel Kellersymbole noch nicht gelesene Eingabe Attributwerte ( ) * 4 ( ) * 4 ( ) * 4 2 ( F + 3 ) * 4 2 ( T + 3 ) * 4 2 ( E + 3 ) * 4 2 Nach der Syntaxanalyse 105/112

114 6.65 Beispiel (2) ( E + 3 ) * 4 2 ( E + 3 ) * ( E + F ) * ( E + T ) * ( E ) * 4 5 ( E ) * 4 5 F * 4 5 Nach der Syntaxanalyse 106/112

115 6.65 Beispiel (3) T * 4 5 T * 4 5 T * T * F 5 4 T 20 E 20 Nach der Syntaxanalyse 107/112

116 6.66 L-attributierte Grammatik nur synthetisierte Attribute und solche vererbte Attribute, für die gilt: In jeder Produktion A X 1 X m hängen die vererbten Attribute jedes X j nur von den vererbten Attributen von A und von den links von Xj stehenden Symbolen X 1,..., X j 1 ab. auch noch für Bottom-up-Syntaxanalyse gut geeignet Nach der Syntaxanalyse 108/112

117 6.67 Beispiel Ableitungsbäume enthalten manchmal überflüssige Knoten. Z. B. kompaktere Darstellung arithmetischer Ausdrücke: So genannter abstrakter Syntaxbaum (AST); analog etwa bei Produktionen für Kontrollstrukturen Nach der Syntaxanalyse 109/112

118 6.67 Beispiel (2) Die Kontruktion eines Syntaxbaumes aus Ableitungsbaum kann man mit Hilfe eines synthetisiserten Attributes ast (die englische Abkürzung für abstract syntax tree ) durchführen. Attributwert für ein Nichtterminalsymbol A ist dabei ein Zeiger auf die Wurzel des Syntax(teil)baumes, der A entspricht. Nach der Syntaxanalyse 110/112

119 6.68 Beispiel Einfache (!) Codeerzeugung (nur die, aber immerhin) kann man auch mit attributierten Grammatiken machen. synthetisierte Attribute code für den erzeugten Code temp für den Namen einer Hilfsvariable, z. B. der Form H4711 Beispiel-Produktion E 0 E 1 +T 1 neuer Name für Hilfsvariable: E 0.temp = H gefolgt von 1 + Maximum der Nummern von E 1.temp und T 1.temp alten Code übernehmen und zusätzlichen Code anhängen: E 0.code = E 1.code; T 1.code; E 0.temp E 1.temp + T 1.temp primitive Methode, sie demonstriert aber das Prinzip Nach der Syntaxanalyse 111/112

120 Parser-Generatoren lesen eine Eingabedatei, in der im wesentlichen eine kontextfreie Grammatik G beschrieben ist, und erzeugen als Ausgabedatei ein Programm, dass die Syntaxanalyse fur G macht, (implizit) den Ableitungsbaum erzeugt und evtl. Berechnung von Attributwerten durchführt Beispiele: in der Shell Nach der Syntaxanalyse 112/112