Syntaxanalyse Bottom-Up und LR(0)

Präsentation zum Thema: "Syntaxanalyse Bottom-Up und LR(0)"—  Präsentation transkript:

1 Syntaxanalyse Bottom-Up und LR(0)
Daniel Matthey

2 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

3 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

4 Zwischencode-Generator
Compileraufbau Lexikalische Analyse Syntaxanalyse Semantische Analyse Zwischencode-Generator Code-Optimierer Code-Generator

5 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

6 Grammatik Besteht aus: Terminalen Nichtterminalen Produktionen
und einem Startsymbol

7 Grammatik Beispiel: E  E + E E  E * E E  ( E ) E  id

8 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

9 Ableitungen E → E + E → E + id → id + id E → E + E → id + E → id + id

10 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

11 Parse-Baum für id + id E E  E + E E  E * E E  ( E ) E  id

12 Parse-Baum für id + id E E + E E  E + E E  E * E E  ( E ) E  id

13 Parse-Baum für id + id E E + E id E  E + E E  E * E E  ( E ) E  id

14 Parse-Baum für id + id E E + E id id E  E + E E  E * E E  ( E )

15 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

16 Mehrdeutigkeit Beispiel: id * id + id E E E E E E id id + id id id +

17 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

18 Bottom-Up-Parsing id + id E  E + E E  E * E E  ( E ) E  id

19 Bottom-Up-Parsing E id + id E  E + E E  E * E E  ( E ) E  id

20 Bottom-Up-Parsing E E id + id E  E + E E  E * E E  ( E ) E  id

21 Bottom-Up-Parsing E E E id + id E  E + E E  E * E E  ( E ) E  id

22 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

23 Shift-Reduce-Parser Neue Grammatik: E  E + T | T T  T * F | F
F  ( E ) | id Rechtsableitung zu id * id: E → T → T * F → T * id → F * id → id * id

24 Shift-Reduce-Parser Parsen von id * id E  E + T | T T  T * F | F
F  ( E ) | id

25 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) E  E + T | T T  T * F | F F  ( E ) | id

26 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id E  E + T | T T  T * F | F F  ( E ) | id

27 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F E  E + T | T T  T * F | F F  ( E ) | id

28 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben E  E + T | T T  T * F | F F  ( E ) | id

29 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben $ T * id $ E  E + T | T T  T * F | F F  ( E ) | id

30 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben $ T * id $ $ T * id Reduzieren durch F → id E  E + T | T T  T * F | F F  ( E ) | id

31 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben $ T * id $ $ T * id Reduzieren durch F → id $ T * F Reduzieren durch T → T * F E  E + T | T T  T * F | F F  ( E ) | id

32 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben $ T * id $ $ T * id Reduzieren durch F → id $ T * F Reduzieren durch T → T * F Reduzieren durch E → T E  E + T | T T  T * F | F F  ( E ) | id

33 Shift-Reduce-Parser Parsen von id * id Stack Eingabe Aktion $
Verschieben(shift) $ id * id $ Reduzieren(reduce) durch F → id $ F Reduzieren durch T → F $ T Verschieben $ T * id $ $ T * id Reduzieren durch F → id $ T * F Reduzieren durch T → T * F Reduzieren durch E → T $ E Akzeptieren Angelehnt an DragonBook S.286 E  E + T | T T  T * F | F F  ( E ) | id

34 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

35 LR(0)-Syntaxanalyse LL(k) und LR(k)-Sprachen:
erste Buchstabe steht für die Eingabe zweiter Buchstabe steht für umgekehrte Ableitung k wird Lookahead genannt

36 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

37 Items Statt Grammatiksymbole auf dem Stack nun Zustände, die aus einer Menge von Items bestehen Folgende Items, für die Entscheidungsunterstützung, enthält die Produktion T  T * F: T  .T * F T  T .* F T  T * .F T  T * F. Wir sehen 3 verschiedene Fälle

38 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

39 CLOSURE(I) Bildet eine Hülle von einer Menge von Items durch:
Füge I zu CLOSURE(I) hinzu Gibt es ein Item A  a.Bb in CLOSURE(I) und eine Produktion B  x, so füge B  .x zu CLOSURE(I) hinzu

40 GOTO(I,X) Spezifiziert einen Folgezustand innerhalb eines LR(0)-Automaten anhand der gegebenen Informationen I: Item Menge und X: Grammatiksymbol

41 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

42 LR(0)-Automat Zunächst Erweiterung der Grammatik zu: E‘  E E  E + E
E  id

43 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

44 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 GOTO(0,id) gibt uns Zustand 5 an E  E + T | T T  T * F | F F  ( E ) | id

45 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

46 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id Gibt es keinen Folgezustand, weiß der Parser, dass er reduzieren soll. Bei einer Reduktion wird zunächst der Produktionsrumpf vom Stack entfernt und der Produktionskopf verschoben. Zustand 5  0  3 E  E + T | T T  T * F | F F  ( E ) | id

47 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

48 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F E  E + T | T T  T * F | F F  ( E ) | id

49 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

50 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 E  E + T | T T  T * F | F F  ( E ) | id

51 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

52 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 (5) 027 $ T * id $ E  E + T | T T  T * F | F F  ( E ) | id

53 Der LR(0)-Automat E  E + T | T T  T * F | F F  ( E ) | id
DragonBook S.294 E  E + T | T T  T * F | F F  ( E ) | id

54 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 (5) 027 $ T * id $ (6) 0275 $ T * id E  E + T | T T  T * F | F F  ( E ) | id

55 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 (5) 027 $ T * id $ (6) 0275 $ T * id (7) 02710 $ T * F Reduzieren durch T → T * F E  E + T | T T  T * F | F F  ( E ) | id

56 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 (5) 027 $ T * id $ (6) 0275 $ T * id (7) 02710 $ T * F Reduzieren durch T → T * F (8) Reduzieren durch E → T E  E + T | T T  T * F | F F  ( E ) | id

57 Shift-Reduce-Parser mit Hilfe des LR(0)-Automaten
Parsen von id * id Zeile Stack Symbole Eingabe Aktion (1) $ id * id $ Verschieben zu 5 (2) 05 $ id * id $ Reduzieren durch F → id (3) 03 $ F Reduzieren durch T → F (4) 02 $ T Verschieben zu 7 (5) 027 $ T * id $ (6) 0275 $ T * id (7) 02710 $ T * F Reduzieren durch T → T * F (8) Reduzieren durch E → T (9) 01 $ E Akzeptieren DragonBook S.298 E  E + T | T T  T * F | F F  ( E ) | id

58 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

59 Parsertabellen Jeder Parser besteht aus: Eingabe Ausgabe Stack
Treiberprogramm Parsertabelle mit zwei Teilen (ACTION und GOTO)

60 ACTION(i,a) Gibt dem Parser konkrete Entscheidungen an:
Eingabe von Zustand i und Terminal a Ergebnisse können sein: shift j reduce accept error

61 Agenda Basics Bottom-Up-Parsing Compileraufbau Grammatiken Ableitungen
Beispiel Parse-Baum Mehrdeutigkeit Bottom-Up-Parsing Shift-Reduce-Parser inkl. Beispiel LR(0)-Syntaxanalyse Items Die Funktionen CLOSURE(I) und GOTO(I,X) Der LR(0)-Automat inkl. Beispiel Parsertabellen Beispiel

62 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 DragonBook S.303 E  E + T | T T  T * F | F F  ( E ) | id

63 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 E  E + T | T T  T * F | F F  ( E ) | id

64 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 E  E + T | T T  T * F | F F  ( E ) | id

65 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id E  E + T | T T  T * F | F F  ( E ) | id

66 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 E  E + T | T T  T * F | F F  ( E ) | id

67 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F E  E + T | T T  T * F | F F  ( E ) | id

68 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 E  E + T | T T  T * F | F F  ( E ) | id

69 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F (4) 02 T Verschieben zu 7 E  E + T | T T  T * F | F F  ( E ) | id

70 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 E  E + T | T T  T * F | F F  ( E ) | id

71 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F (4) 02 T Verschieben zu 7 (5) 027 T * id + id $ Weitere Tabellen E  E + T | T T  T * F | F F  ( E ) | id

72 Parsertabellen Zustand ACTION GOTO - id + * ( ) $ E T F s5 s4 1 2 3 s6
s5 s4 1 2 3 s6 acc r2 s7 r4 8 4 5 r6 9 6 10 7 s11 r1 r3 11 r5 E  E + T | T T  T * F | F F  ( E ) | id

73 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F (4) 02 T Verschieben zu 7 (5) 027 T * id + id $ (6) 0275 T * id + id $ E  E + T | T T  T * F | F F  ( E ) | id

74 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F (4) 02 T Verschieben zu 7 (5) 027 T * id + id $ (6) 0275 T * id + id $ (7) 02710 T * F Reduzieren durch T → T * F E  E + T | T T  T * F | F F  ( E ) | id

75 LR-Parser mit Hilfe der Parsertabelle
Parsen von id * id Stack Symbole Eingabe Aktion (1) id * id + id $ Verschieben zu 5 (2) 05 id * id + id $ Reduzieren durch F → id (3) 03 F Reduzieren durch T → F (4) 02 T Verschieben zu 7 (5) 027 T * id + id $ (6) 0275 T * id + id $ (7) 02710 T * F Reduzieren durch T → T * F (8) Reduzieren durch E → T (9) 01 E Verschieben (10) 016 E + id $ (11) 0165 E + id $ (12) 0163 E + F (13) 0169 E + T Reduzieren durch E → E + T (14) Akzeptieren E  E + T | T T  T * F | F F  ( E ) | id

76 Parse-Baum Reduktionsschritte: F  id T  F T  T * F E  T E  E + T

77 Fragen?