Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Fabian Berlin Syntaktische Analyse – Bottom-up Im Rahmen des Seminars Übersetzung von künstlichen Sprachen.

Ähnliche Präsentationen


Präsentation zum Thema: "Fabian Berlin Syntaktische Analyse – Bottom-up Im Rahmen des Seminars Übersetzung von künstlichen Sprachen."—  Präsentation transkript:

1 Fabian Berlin Syntaktische Analyse – Bottom-up Im Rahmen des Seminars Übersetzung von künstlichen Sprachen

2 1 Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse 2. Operator-Precedence-Syntaxanalyse 3. LR-Syntaxanalyse 3.1 LR-Syntaxanalysealgorithmus 3.2 LR(0) 3.3 SLR(1) 3.4 LR(1) 3.5 LALR(1) 4. Zusammenfassung

3 2 Einführung in die Bottom-Up-Syntaxanalyse Grammatik G 1 : Regel 1:S aABe Regel 2:A Abc | b Regel 3:B d abbcde S aABe aAde aAbcde Regel 2: A b Regel 2: A Abc Regel 3: B d Regel 1: S aABe Ziel: Anwendung von Reduktionsschritten, um von der Eingabe auf das Startsymbol S zu reduzieren

4 3 Einführung in die Bottom-Up-Syntaxanalyse S A B A abbcde Anwendung einer umgekehrten Rechtsableitung Problem: Bestimmung von Handles (rechte Seiten von Regeln, die reduziert werden können, um vorhergehenden Schritt der Rechtsableitung zu erhalten) Idee: Nutzung eines Stacks A b A Abc B d S aABe

5 4 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

6 5 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id Shift: Inputsymbol auf den Stack schieben (bis Handle erscheint)

7 6 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id Reduce: reduzieren des Handle

8 7 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

9 8 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

10 9 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

11 10 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

12 11 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

13 12 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

14 13 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

15 14 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

16 15 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$Reduce 9 12$ E + T * F$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

17 16 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$Reduce 9 12$ E + T * F$Reduce 5 13$ E + T$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

18 17 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$Reduce 9 12$ E + T * F$Reduce 5 13$ E + T$Reduce 2 14$ E$ 15 Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

19 18 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$Reduce 9 12$ E + T * F$Reduce 5 13$ E + T$Reduce 2 14$ E$Reduce 1 15$ S$ Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id

20 19 Syntaxanalyse mit einem Stack Nr. Stack:Input:Aktion: 1$id + num * id$Shift id 2$ id+ num * id$Reduce 9 3$ F+ num * id$Reduce 7 4$ T+ num * id$Reduce 4 5$ E+ num * id$Shift + 6$ E +num * id$Shift num 7$ E + num* id$Reduce 8 8$ E + F* id$Reduce 7 9$ E + T* id$Shift * 10$ E + T *id$Shift id 11$ E + T * id$Reduce 9 12$ E + T * F$Reduce 5 13$ E + T$Reduce 2 14$ E$Reduce 1 15$ S$Accept Grammatik G 2 : 1S E 2E E + T 3E E –T 4E T 5T T * F 6T T / F 7T F 8F num 9F id Accept: Eingabe entsprach der Grammatik erfolgreiches Ende

21 20 Operator-Precedence-Syntaxanalyse Definition von Relationen zwischen dem obersten Stackelement und dem ersten Eingabesymbol (begrenzt auf Terminalsymbole) Vorgehen: < oder =: Shift >: Reduce Handles werden erkannt: <: linke Markierung des Handle >: rechte Markierung des Handle Relation:Semantik: a < ba hat niedrigere Priorität als b a > ba hat höhere Priorität als b a = ba und b haben gleiche Priorität $ + * $ Erstes Handle

22 21 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$<<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

23 22 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

24 23 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E$E<+id*id$Shift: < *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

25 24 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+<<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

26 25 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

27 26 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

28 27 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* 7$ E<+<*<<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

29 28 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* 7$ E<+<*$Red: E id *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

30 29 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* 7$ E<+<*$Red: E id 9$E<+<*E>$Red: E E*E *()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

31 30 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* 7$ E<+<*$Red: E id 9$E<+<*E>$Red: E E*E 10$E<+E>$Red: E E+E 11 +*()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

32 31 Ablauf OP-Parser NrStack:R.Input:Aktion: 1$+id*id$Red: E id 3$E<+id*id$Shift: <+ 4$E<+*id$Red: E id 6$ E<+E<*id$Shift: <* 7$ E<+<*$Red: E id 9$E<+<*E>$Red: E E*E 10$E<+E>$Red: E E+E 11$E$E$Accept +*()id$ +><<><> *>><><> (<<<=< )>>>> >>>> $<<<< Grammatik G 3 : Regel 1:E E + E Regel 2:E E * E Regel 3:E ( E ) Regel 4:E id Input Stack

33 32 Operator-Grammatik Grammatik muss folgende Bedingungen erfüllen, damit sie mit OP-Parser behandelt werden kann: 1.Keine zwei aufeinander folgenden Nichtterminale auf der rechten Seite einer Produktion. 2.Keine Produktion mit gleicher rechter Seite. 3.Keine ε-Produktionen. sehr schwaches Verfahren!

34 33 LR-Syntaxanalyse LR(k)-Syntaxanalyse: L: left-to-right-parse R: rightmost derivation: Rechtsableitung k: k-token lookahead: Anzahl im Voraus betrachteter Inputsymbole Quelle: Appel, Palsberg (2002).

35 34 Modell eines LR-Parsers Action[s m,a i ] = shift s | reduce A β | accept | error. a1a1 …aiai …anan $ SmSm XmXm S m-1 X m-1 … S0S0 LR-Syntaxanalyse- Programm Input Syntaxanalyse- tabelle Stack Terminalsymbole Output Syntaxbaum Zu -stand Action (Terminale) X 1 … X n Goto (Nichtterminale) X 1 … X n 0 1 … Goto[s, A]

36 35 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

37 36 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

38 37 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 T+ id $Reduce ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

39 38 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 T 2+ id $Reduce ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

40 39 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

41 40 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce 21 4$ 0 E 1+ id $Shift ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

42 41 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce 21 4$ 0 E 1+ id $Shift 4 5$ 0 E 1 + 4id $Shift ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

43 42 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce 21 4$ 0 E 1+ id $Shift 4 5$ 0 E 1 + 4id $Shift 3 6$ 0 E id 3$Reduce ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

44 43 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce 21 4$ 0 E 1+ id $Shift 4 5$ 0 E 1 + 4id $Shift 3 6$ 0 E id 3$Reduce 35 7$ 0 E T 5$Reduce 11 8 ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

45 44 Ablauf LR-Parser Nr StackInputActionGoto 1$ 0id + id $Shift 3 2$ 0 id 3+ id $Reduce 32 3$ 0 T 2+ id $Reduce 21 4$ 0 E 1+ id $Shift 4 5$ 0 E 1 + 4id $Shift 3 6$ 0 E id 3$Reduce 35 7$ 0 E T 5$Reduce 11 8$ 0 E 1$Accept ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1 Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id

46 45 LR-Syntaxanalysetabelle-Konstruktion Allgemeines Vorgehen: Erstellen von: 1.Dummy-Produktion: S S (S ist altes Startsymbol). 2.Endlichem Automat. 3.Syntaxanalysetabelle.

47 46 Erstellen eines Zustandsübergangsgraphen Grundbegriffe: Items: Produktionen mit Markierungspunkt auf rechter Seite; zeigt an wie weit man im Parseprozess vorangeschritten ist. A XYZ Closure-Operation: fügt weitere Items zu einer Menge von Items hinzu. Goto-Operation: Definiert Zustandsübergänge zwischen Mengen von Items/Zuständen des Automaten.

48 47 Erstellen eines Zustandsübergangsgraphen Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 Closure-Operation anwenden!

49 48 Erstellen einer LR(0)-Syntaxanalysetabelle Punkt am rechten Ende eines Items Falls Dummy-Item: Accept Sonst Reduce I J, mit X Terminalsymbol: Shift I J, mit X Nichtterminalsymbol: Goto

50 49 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET

51 50 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s

52 51 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s312 1s4acc

53 52 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s312 1s4acc 2r

54 53 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4 5

55 54 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5

56 55 Erstellen der LR(0)-Syntaxanalysetabelle Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id S E E E+T E T T id S E E E+T E T T id S E+ T T id E E+T E+ T id T I0I0 I2I2 I1I1 I3I3 I4I4 I5I5 ActionGoto Zust id+$ET 0s312 1s4acc 2r2 3r3 4s35 5r1

57 56 LR(0)-Syntaxanalyse Grammatik G 4 : Regel 1:E E + T Regel 2:E T Regel 3:T id Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id

58 57 LR(0)-Syntaxanalyse Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id ActionGoto Zust id+$ET 0s412 1acc 2r2s3, r2r2 3s452 4r3 5r1 S E E T+E E T T id E T id I0I0 S E I1I1 E T+E I2I2 E T T id I4I4 E T+ E E T T id I3I3 E T+E I5I5 E T +

59 58 LR(0)-Syntaxanalyse Zwei mögliche Konflikte bei LR-Analyse: Shift-reduce-Konflikt Reduce-reduce-Konflikt

60 59 SLR(1)-Syntaxanalyse SLR(1)-Syntaxanalyse ist Erweiterung von LR(0): Anzahl von Reduce-Einträgen in Action-Tabelle kann verringert werden Reduce-Aktionen werden nicht mehr für jedes Terminalsymbol eines Zustands eingetragen Eintrag nur bei Terminalsymbolen, die sich in FOLLOW-Menge des Nichtterminals der Regel befinden Informale FOLLOW-Definition: X ist ein Nichtterminal FOLLOW(X) ist die Menge aller Terminale, die in einem Wort direkt rechts neben X stehen können

61 60 SLR(1)-Syntaxanalysetabelle FOLLOW(S):{$} FOLLOW(E):{$} FOLLOW(T):{+,$} ActionGoto Zust id+$ET 0s412 1acc 2r2s3, r2r2 3s452 4r3 5r1 Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id ActionGoto Zust id+$ET 0s412 1acc 2s3r2 3s452 4r3 5r1 LR(0)-Syntaxanalysetabelle SLR(1)-Syntaxanalysetabelle

62 61 SLR(1)-Syntaxanalysetabelle FOLLOW(S):{$} FOLLOW(E):{$} FOLLOW(T):{+,$} ActionGoto Zust id+$ET 0s412 1acc 2r2s3, r2r2 3s452 4r3 5r1 Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id ActionGoto Zust id+$ET 0s412 1acc 2s3r2 3s452 4r3 5r1 LR(0)-Syntaxanalysetabelle SLR(1)-Syntaxanalysetabelle

63 62 SLR(1)-Syntaxanalysetabelle FOLLOW(S):{$} FOLLOW(E):{$} FOLLOW(T):{+,$} ActionGoto Zust id+$ET 0s412 1acc 2r2s3, r2r2 3s452 4r3 5r1 Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id ActionGoto Zust id+$ET 0s412 1acc 2s3r2 3s452 4r3 5r1 LR(0)-Syntaxanalysetabelle SLR(1)-Syntaxanalysetabelle

64 63 SLR(1)-Syntaxanalysetabelle FOLLOW(S):{$} FOLLOW(E):{$} FOLLOW(T):{+,$} ActionGoto Zust id+$ET 0s412 1acc 2r2s3, r2r2 3s452 4r3 5r1 Grammatik G 5 : Regel 1:E T + E Regel 2:E T Regel 3:T id ActionGoto Zust id+$ET 0s412 1acc 2s3r2 3s452 4r3 5r1 LR(0)-Syntaxanalysetabelle SLR(1)-Syntaxanalysetabelle

65 64 LR(1)-Syntaxanalyse Mit SLR(1) erstellte Syntaxanalysetabelle für Grammatik G 6 : FOLLOW(S):{$} FOLLOW(S):{$} FOLLOW(E):{+,=,$} ActionGoto Zust =+id$SE 0s312 1acc 2s4s6 3r4 r2/r4 4s85 5s6r1 6s7 7r3 8r4 Grammatik G 6 : Regel 0:S Regel 1:S E = E Regel 2:S id Regel 3:E E + id Regel 4:E id

66 65 LR(1)-Syntaxanalyse Grammatik G 6 : Regel 0:S Regel 1:S E = E Regel 2:S id Regel 3:E E + id Regel 4:E id ActionGoto Zust=+id$SE 0s312 1acc 2s4s6 3r4 r2/r4 4s85 5s6r1 6s7 7r3 8r4

67 66 LR(1)-Syntaxanalyse SLR(1)-Syntaxanalyse Nutzung von FOLLOW-Mengen Globale Betrachtung, Zustand wird nicht berücksichtigt LR(1)-Syntaxanalyse Nutzung von LOOKAHEAD-Mengen Für jeden Zustand wird Information mitverwaltet, welche Terminale auf ein Nichtterminal nach Reduktion einer bestimmten Reduktionsregel im Zustandsautomaten folgen können

68 67 LR(1)-Syntaxanalyse Änderungen im Vergleich zu SLR(1): Verwendung von LR(1)- anstelle von LR(0)-Items. Definition von closure- und goto-Operation für Behandlung der LOOKAHEAD-Mengen abgeändert. Anfangszustand ist [S S, $]. Action-Tabelle nutzt LOOKAHEAD-Mengen und nicht FOLLOW- Mengen.

69 68 LR(1)-Syntaxanalyse S S {$} S E=E {$} S id {$} E E+id {+,=} I0I0 E id {+,=} S S {$} S I1I1 S id {$} id E id {+,=} I3I3 S E=E {$} E E E+id {+,=} I2I2 I4I4 I6I6 + = Grammatik G 6 : 0:S 1:S E = E 2:S id 3:E E + id 4:E id Kern LOOKAHEAD- Menge

70 69 LR(1)-Syntaxanalyse Mit LR(1) erstellte Syntaxanalysetabelle für Grammatik G 6 : ActionGoto Zust =+id$SE 0s312 1acc 2s4s6 3r4 r2 4s85 5s9r1 6s7 7r3 8r4 9s10 10r3 Grammatik G 6 : Regel 0:S Regel 1:S E = E Regel 2:S id Regel 3:E E + id Regel 4:E id

71 70 LR(1)-Syntaxanalyse LR(1) mächtiges Verfahren Anzahl Zustände: Typische Programmiersprachen bei LR(0)/SLR(1) mehrere 100 Typische Programmiersprache bei LR(1) werden mehrere 1000 Motivation für LALR(1): Weniger Zustände als LR(1) Trotzdem mächtig genug für typische Programmiersprachen Vorgehen bei LALR(1): Zustände eines LR(1)-Zustandsübergangsgraphen mit gleichen Kernen zusammenfassen

72 71 LALR(1)-Syntaxanalyse Gleiche Kerne

73 72 LALR(1)-Syntaxanalyse Mit LALR(1) erstellte Syntaxanalysetabelle für Grammatik G 6 : ActionGoto Zust =+id$SE 0s312 1acc 2s4s69 3r4 r2 4s85 5s69r1 69s r3 8r4 Grammatik G 6 : Regel 0:S Regel 1:S E = E Regel 2:S id Regel 3:E E + id Regel 4:E id

74 73 Zusammenfassung Operator-Precedence-Syntaxanalyse Einfach umzusetzendes Verfahren Geringe Mächtigkeit LR-Parser Mächtigste effiziente Parser LR(0), SLR(1), LALR(1), LR(1) Gleicher Ablaufalgorithmus, Unterschied Syntaxanalysetabelle Immer Konstruktion eines Zustandsautomaten, aus dem Syntaxanalysetabelle abgeleitet werden kann Meist wird LALR(1) eingesetzt Derzeitige Algorithmen der Syntaxanalyse ausreichend für gängige Programmiersprachen

75 74 Fragen, Kommentare, Diskussion


Herunterladen ppt "Fabian Berlin Syntaktische Analyse – Bottom-up Im Rahmen des Seminars Übersetzung von künstlichen Sprachen."

Ähnliche Präsentationen


Google-Anzeigen