Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse

Name: Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse
Uploaded: 2018-01-15T03:22:41+00:00
Duration: PTH1M23S41
Channel: Ursel Gerich
Description: Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse

Syntaktische Analyse – Bottom-up
Im Rahmen des Seminars „Übersetzung von künstlichen Sprachen“

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

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

Einführung in die Bottom-Up-Syntaxanalyse
Anwendung einer umgekehrten Rechtsableitung Problem: Bestimmung von Handles (rechte Seiten von Regeln, die reduziert werden können, um vorhergehenden Schritt der Rechtsableitung zu erhalten) S→ aABe B B→ d A A → Abc A Rechtsableitung: Am weitesten rechts stehendes Nichtterminal zur Ersetzung gewählt Idee: Nutzung eines Stacks A → b a b b c d e

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

Nr. Stack: Input: Aktion: 1 $ id + num * id$ Shift id 2 $ id + num * id$ 3 4 5 6 7 8 9 10 11 12 13 14 15 Grammatik G2: 1 S  E 2 E  E + T 3 E  E –T 4 E  T 5 T  T * F 6 T  T / F 7 T  F 8 F  num 9 F  id Shift: Inputsymbol auf den Stack schieben (bis Handle erscheint)

Nr. Stack: Input: Aktion: 1 $ id + num * id$ Shift id 2 $ id + num * id$ Reduce 9 3 $ F 4 5 6 7 8 9 10 11 12 13 14 15 Grammatik G2: 1 S  E 2 E  E + T 3 E  E –T 4 E  T 5 T  T * F 6 T  T / F 7 T  F 8 F  num 9 F  id Reduce: reduzieren des Handle

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

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

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

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

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

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

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

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

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

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

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

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

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

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 <• b a hat niedrigere Priorität als b a •> b a hat höhere Priorität als b a = b a und b haben gleiche Priorität $ <• id •> + <• id •> * <• id•> $ Erstes Handle

Ablauf OP-Parser Input Nr Stack: R. Input: Aktion: 1 $ <• id+id*id$
Shift: <•id 2 3 4 5 6 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 4 5 6 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 5 6 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 6 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 $ E<•+<•* id$ 8 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 $ E<•+<•* id$ 8 $E<•+<•*<•id 9 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 $ E<•+<•* id$ 8 $E<•+<•*<•id 9 $E<•+<•*E Red: E  E*E 10 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 $ E<•+<•* id$ 8 $E<•+<•*<•id 9 $E<•+<•*E Red: E  E*E 10 $E<•+E Red: E  E+E 11 + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

Shift: <•id 2 $<•id •> +id*id$ Red: E  id 3 $E Shift: <•+ 4 $E<•+ id*id$ 5 $E<•+<•id *id$ 6 $ E<•+E Shift: <•* 7 $ E<•+<•* id$ 8 $E<•+<•*<•id 9 $E<•+<•*E Red: E  E*E 10 $E<•+E Red: E  E+E 11 Accept + * ( ) id $ •> <• = Stack Grammatik G3: Regel 1: E  E + E Regel 2: E  E * E Regel 3: E  ( E ) Regel 4: E  id

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

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).

Modell eines LR-Parsers
Syntaxanalyse-tabelle Zu -stand Action (Terminale) X1… Xn Goto (Nichtterminale) 1 … Goto[s‘, A] Input a1 … ai an $ Terminalsymbole Syntaxbaum Output LR-Syntaxanalyse-Programm Action[sm,ai] = shift s | reduce A  β | accept | error. Stack Sm Xm Sm-1 Xm-1 … S0

Ablauf LR-Parser Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 3 4
Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 3 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Ablauf LR-Parser Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2
Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 T + id $ Reduce 3 3 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 T 2 + id $ Reduce 3 3 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 $ 0 E 1 Shift 4 5 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 $ 0 E 1 Shift 4 5 $ 0 E 1 + 4 id $ 6 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 $ 0 E 1 Shift 4 5 $ 0 E 1 + 4 id $ 6 $ 0 E id 3 $ 7 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 $ 0 E 1 Shift 4 5 $ 0 E 1 + 4 id $ 6 $ 0 E id 3 $ 7 $ 0 E T 5 Reduce 1 8 Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

Nr Stack Input Action Goto 1 $ 0 id + id $ Shift 3 2 $ 0 id 3 + id $ Reduce 3 3 $ 0 T 2 Reduce 2 4 $ 0 E 1 Shift 4 5 $ 0 E 1 + 4 id $ 6 $ 0 E id 3 $ 7 $ 0 E T 5 Reduce 1 8 Accept Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

LR-Syntaxanalysetabelle-Konstruktion
Allgemeines Vorgehen: Erstellen von: „Dummy-Produktion“: S‘  S (S ist altes Startsymbol). Endlichem Automat. Syntaxanalysetabelle.

Erstellen eines Zustandsübergangsgraphen
Grundbegriffe: Items: Produktionen mit Markierungspunkt auf rechter Seite; zeigt an wie weit man im Parseprozess vorangeschritten ist. A  •XYZ A  X•YZ A  XY•Z 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.

Erstellen eines Zustandsübergangsgraphen
Closure-Operation anwenden! S  •E S  E• S  E+ •T E  •E+T E  •T E E  E•+T + T  •id T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id

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

Erstellen der LR(0)-Syntaxanalysetabelle
E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T 1 2 3 4 5

E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T s3 1 2 3 4 5

E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T s3 1 2 s4 acc 3 4 5

E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 4 5

E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5

E  •E+T E  •T E  E•+T T  •id E + T  •id I0 I1 I4 id id T T E  T• T  id• E E+T• I2 I3 I5 Grammatik G4: Regel 1: E  E + T Regel 2: E  T Regel 3: T  id Action Goto Zust id + $ E T s3 1 2 s4 acc r2 3 r3 4 5 r1

LR(0)-Syntaxanalyse Grammatik G4: Regel 1: E  E + T Regel 2: E  T
T  id Grammatik G5: Regel 1: E  T + E Regel 2: E  T Regel 3: T  id

LR(0)-Syntaxanalyse S  •E E  •T+E E  •T T  •id E T id I0 S  E• I1
Action Goto Zust id + $ E T s4 1 2 acc r2 s3, r2 3 5 4 r3 r1 S  •E E  •T+E E  •T T  •id E T id I0 S  E• I1 E  T•+E I2 E  T• T  id• I4 E  T+ •E I3 E  T+E• I5 + Grammatik G5: Regel 1: E  T + E Regel 2: E  T Regel 3: T  id

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

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

SLR(1)-Syntaxanalysetabelle
Grammatik G5: Regel 1: E  T + E Regel 2: E  T Regel 3: T  id FOLLOW(S): {$} FOLLOW(E): FOLLOW(T): {+,$} Action Goto Zust id + $ E T s4 1 2 acc r2 s3, r2 3 5 4 r3 r1 Action Goto Zust id + $ E T s4 1 2 acc s3 r2 3 5 4 r3 r1 LR(0)-Syntaxanalysetabelle SLR(1)-Syntaxanalysetabelle

LR(1)-Syntaxanalyse Mit SLR(1) erstellte Syntaxanalysetabelle für Grammatik G6: Action Goto Zust = + id $ S E s3 1 2 acc s4 s6 3 r4 r2/r4 4 s8 5 r1 6 s7 7 r3 8 Grammatik G‘6: Regel 0: S‘ S Regel 1: S  E = E Regel 2: S  id Regel 3: E  E + id Regel 4: E  id FOLLOW(S‘): {$} FOLLOW(S): FOLLOW(E): {+,=,$}

LR(1)-Syntaxanalyse Grammatik G‘6: Regel 0: S‘ S Regel 1: S  E = E
S  id Regel 3: E  E + id Regel 4: E  id Action Goto Zust = + id $ S E s3 1 2 acc s4 s6 3 r4 r2/r4 4 s8 5 r1 6 s7 7 r3 8

LR(1)-Syntaxanalyse SLR(1)-Syntaxanalyse LR(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

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.

LR(1)-Syntaxanalyse LOOKAHEAD-Menge Kern S‘ •S {$} S‘ S• {$}
Grammatik G‘6: 0: S‘ S 1: S  E = E 2: S  id 3: E  E + id 4: E  id S  •E=E {$} S  •id {$} S E  •E+id {+,=} E  •id {+,=} I0 I1 E id S  id• {$} S  E•=E {$} + E  id• {+,=} E  E•+id {+,=} I4 = I3 I2 I6

LR(1)-Syntaxanalyse Mit LR(1) erstellte Syntaxanalysetabelle für Grammatik G6: Action Goto Zust = + id $ S E s3 1 2 acc s4 s6 3 r4 r2 4 s8 5 s9 r1 6 s7 7 r3 8 9 s10 10 Grammatik G‘6: Regel 0: S‘ S Regel 1: S  E = E Regel 2: S  id Regel 3: E  E + id Regel 4: E  id

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

LALR(1)-Syntaxanalyse
Gleiche Kerne

LALR(1)-Syntaxanalyse
Mit LALR(1) erstellte Syntaxanalysetabelle für Grammatik G6: Action Goto Zust = + id $ S E s3 1 2 acc s4 s69 3 r4 r2 4 s8 5 r1 69 s710 710 r3 8 Grammatik G‘6: Regel 0: S‘ S Regel 1: S  E = E Regel 2: S  id Regel 3: E  E + id Regel 4: E  id

Zusammenfassung Operator-Precedence-Syntaxanalyse LR-Parser
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

Fragen, Kommentare, Diskussion

Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse

Ähnliche Präsentationen

Präsentation zum Thema: "Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback

Anmelden

Anmeldung über soziales Netzwerk:

Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse

Ähnliche Präsentationen

Präsentation zum Thema: "Gliederung 1. Grundlagen der Bottom-Up-Syntaxanalyse"— Präsentation transkript:

Ähnliche Präsentationen

Über Projekt

Feedback