Bottom-Up Analyse. im Einzelnen

Transkript

1 Bottom-Up Analyse im Einzelnen

2 ... mit Backtracking Wir können den Kellerautomaten zum Satz L(KFG)->L (N1KA) erweitern: Wir nummerieren die Produktionen.

3 ... mit Backtracking Der Automat nimmt dann immer die erste mögliche anwendbare Produktion und merkt sich diese. Kommt er nicht mehr weiter, nimmt er für die letzte Möglichkeit die erste Alternative, und so weiter. Dieser Automat liefert dann eine (umgedrehte) Rechtsableitung bzw. Rechtsreduktion für das Wort (S =r>* w)

4 ... mit Backtracking Der Automat nimmt dann immer die erste mögliche anwendbare Produktion und merkt sich diese. Kommt er nicht mehr weiter, nimmt er für die letzte Möglichkeit die erste Alternative, und so weiter. Dieser Automat liefert dann eine Rechtsableitung bzw. Rechtsreduktion für das Wort (S =r>* w) Aber Backtracking ist nicht effizient!

5 LR(k)-Analyse Um eindeutige Entscheidungen treffen zu können, wird dabei wie bei der LL-Analyse k Zeichen in der Eingabe vorausgeschaut. Das reicht natürlich nicht für beliebige Grammatiken, wir untersuchen deshalb, welche Bedingungen Grammatiken erfüllen müssen, damit eine LR(k)-Analyse möglich ist.

6 LR(k)-Analyse - reduce + shift Wenn eine rechte Regelseite auf dem Stack steht, wird sie mit dem Terminalsymbol auf rechten Regelseite ersetzt - man spricht dann von reduzieren oder reduce. Wenn aber noch ein oder mehrere Eingabesymbole dazugenommen werden müssen, um eine rechte Regelseite zu erreichen, spricht man von shift, da die Symbole einfach von der Eingabe auf den Stack übernommen werden.

7 LR(k)-Analyse - reduce + shift Zu der Entscheidung welche Regel anzuwenden ist kommt also die Entscheidung, ob man shiften muss statt eine rechte Regelseite zu reduzieren.

8 Def. LR(k)-Grammatik Sei G=(N,T,P,S) eine KFG und k eine natürliche Zahl. G ist eine LR(k)-Grammatik, wenn folgendes gilt: - G enthält keine nutzlosen Symbole und keine ε-produktionen, - S tritt in keiner rechten Regelseite auf, und - mit A,B N, x,u,a (N U T) * und y,v T* folgt aus 1. S =r>* xay =r> xay 2. S =r>* ubv =r> xav 3. start k (y) = start k (v) das x=u, A=B und y=v ist. (=r> bedeutet Rechtsableitung)

9 LR(0)-Grammatik Eine KFG G=(N,T,P,S) ist eine LR(0)-Grammatik, wenn - sie keine nutzlosen Symbole und keine ε-produktionen enthält, - S in keiner rechten Regelseite auftritt, und - mit A,B N, x,u,a (N U T) * und y,v T* aus 1. S =r>* xay =r> xay 2. S =r>* ubv =r> xav folgt, das x=u, A=B und y=v ist.

10 G startsepariert? Die Forderung, das S in keiner rechten Regelseite auftritt, nennt man auch startsepariert. Man kann das einfach erreichen, indem man zur Grammatik G' übergeht, die die Produktion S'->S zusätzlich hat, als Startsymbol S' verwendet, und sonst gleich zu G ist. Es ist dann L(G)=L(G') und G' ist startsepariert.

11 handle, viable prefix Sei G eine KFG und S =r>* aaw =r> abw eine Rechtsableitung (also w T*, a,b (N T)*, und A->b P). Dann heisst b ein Handle (machmal auch Griff) der Rechssatzform abw. Jedes Präfix der Symbolfolge ab heisst viable prefix bzw. geeignetes Präfix von G.

12 LR-Grammatiken Satz: LR(k)-Grammatiken sind eindeutig Beweis: Aus der Definition folgt sofort, das jedes Wort aus L(G) eine eindeutige Rechtsableitung haben muss, deswegen kann es auch nur einen Ableitungsbaum geben. Das ist die Definition von Eindeutigkeit.

13 LR-Grammatiken Def. Präfixeigenschaft Eine Sprache L über S hat die Präfixeigenschaft, wenn gilt: w L: ist x ein echtes Präfix von w, so gilt x L Satz: Für jede LR(0)-Grammatik G hat L(G) die Präfixeigenschaft. Bew. siehe etwas [AB], pp335

14 Tabellen der LR-Analyse Action-, und Goto-Tabelle, die Wertetabellen der zugehörigen Funktionen sind: action : Q x ( T U {$} ) -> P U {shift.z z Q} U {error, accept} goto: Q x N -> Q (Q = Menge der Zustände)

15 Tabellengesteuerter KA Beginnend mit dem Startzustand auf dem Stack und dem Eingabezeiger auf dem ersten Symbol der Eingabe werden nun abwechselnd die action- und die goto-funktion aufgerufen. Dabei finden folgende Aktionen statt: action(s,a) == ε => (error) Fehlerbehandlung wird eingeleitet action(s,a) == acc => Eingabe erfolgreich verarbeitet. action(s,a) = sz => lege a und Zustand Z auf den Stack, Eingabe rückt vor. action(s,a) = rn => Reduziere mit Regel N. Ist Regel N die Regel A->a, werden 2x a Elemente vom Stack entfernt. Der oberste Stackeintrag sei dann Zustand s'. Dann wird das Symbol A auf den Stack gelegt, und danach der Wert von goto(s',a), der den nächsten Zustand angibt.

16 Tabellengesteuerter KA Beginnend mit dem Startzustand auf dem Stack und dem Eingabezeiger auf dem ersten Symbol der Eingabe werden nun abwechselnd die action- und die goto-funktion aufgerufen. Dabei finden folgende Aktionen statt: action(s,a) == ε => (error) Fehlerbehandlung wird eingeleitet action(s,a) == acc => Eingabe erfolgreich verarbeitet. action(s,a) = sz => lege a und Zustand Z auf den Stack, die Eingabe rückt vor. action(s,a) = rn => Reduziere mit Regel N. Ist Regel N die Regel A->a, werden 2x a Elemente vom Stack entfernt. Der oberste Stackeintrag sei dann Zustand s'. Dann wird das Symbol A auf den Stack gelegt, und danach der Wert von goto(s',a), der den nächsten Zustand angibt.

17 Tabellengesteuerter KA Beginnend mit dem Startzustand auf dem Stack und dem Eingabezeiger auf dem ersten Symbol der Eingabe werden nun abwechselnd die action- und die goto-funktion aufgerufen. Dabei finden folgende Aktionen statt: action(s,a) == ε => (error) Fehlerbehandlung wird eingeleitet action(s,a) == acc => Eingabe erfolgreich verarbeitet. action(s,a) = sz => lege a und Zustand Z auf den Stack, Eingabe rückt vor. action(s,a) = rn => Reduziere mit Regel N. Ist Regel N die Regel A->b, werden 2x b Elemente vom Stack entfernt. Der oberste Stackeintrag sei dann Zustand s'. Dann wird das Symbol A auf den Stack gelegt, und danach der Wert von goto(s',a), der den nächsten Zustand angibt.

18 Bsp-Grammatik 0 $accept: expr $end 1 expr: expr '+' prod 2 prod 3 prod: prod '*' fakt 4 fakt 5 fakt: '(' expr ')' 6 id

19 Bsp-Grammatik - Tabelle

20 Bsp-Grammatik - Analyse (1) Stack Eingabe Bemerkungen 0 id * (id + id) $ s1 0 id 1 * ( id + id ) $ r6, g(0,fakt)=5 0 fakt 5 * ( id + id ) $ r4, g(0,prod)=4 0 prod 4 * ( id + id ) $ s9 0 prod 4 * 9 ( id + id ) $ s2 0 prod 4 * 9 ( 2 id + id ) $ s1 0 prod 4 * 9 ( 2 id 1 + id ) $ r6, g(2,fakt)=5 0 prod 4 * 9 ( 2 fakt 5 + id ) $ r4, g(2,prod)=4 0 prod 4 * 9 ( 2 prod 4 + id ) $ r2, g(2,expr)=6 0 prod 4 * 9 ( 2 expr 6 + id ) $ s8 0 prod 4 * 9 ( 2 expr id ) $ s1 0 prod 4 * 9 ( 2 expr id 1 ) $ r6, g(8,fakt)=5 0 prod 4 * 9 ( 2 expr fakt 5 ) $ r4, g(8,prod)=11 0 prod 4 * 9 ( 2 expr prod 11 ) $ r1, g(2,expr)=6

21 Bsp-Grammatik - Analyse (2) 0 prod 4 * 9 ( 2 expr 6 ) $ s10 0 expr 3 $ s7 0 prod 4 * 9 ( 2 expr 6 ) 10 $ r5, g(9,fakt)=12 0 expr 3 $ 7 acc 0 prod 4 * 9 fakt 12 $ r3, g(0,prod)=4 0 prod 4 $ r2, g(0,expr)=3

22 Erstellung der LRTAB Verarbeitungszustand - der Punkt ist relevant! Es bedeutet A->.abc A->a.bc A->ab.c A->abc. dass noch nichts der rechten Seite verarbeitet ist, dass der Teilbaum, der aus a entsteht, vollständig abgearbeitet auf dem Stack liegt, dass die aus a und b abgeleiteten Teilbäume vollständig abgearbeitet auf dem Stack liegen, und das die gesamte Regel abgearbeitet wurde.

23 Erstellung der LRTAB Def. LR(0)-Item Sei A->a eine Produktion einer KFG G. Für jede mögliche Zerlegung von a=bc mit b,c aus (N U T)* ist [A->b.c] ein LR(0)-Item von G. Man beachte, das b=ε oder c=ε sein kann!

24 Erstellung der LRTAB Def. closure(m), LR(0)-Kollektion: Sei M eine Menge von LR(0)-Items zu einer KFG G. Der Abschluss von M, also die Menge closure(m) ist dann induktiv definiert durch 1. Alle Elemente von M sind auch in closure(m) 2. Falls für ein Nichterminal B das Item [A->a.Bc] in closure (M) liegt, dann liegen für alle Produktionen B->x auch die Items [B->.x] in closure(m) Die Gesamtheit aller closures bilden die kanonische LR(0)- Kollektion zu einer Grammatik G.

25 Erstellung der LRTAB Def. goto-funktion Sei M eine Menge von LR(0)-Items, und X ein Element aus aus (N U T U {$}). Dann ist goto(m,x) := closure({[a->ax.b] [A->a.Xb] M})

26 Erstellung der LRTAB Algorithmus LR(0)-Kollektion Eingabe: KFG G=(N,T,P,S) Ausgabe: kanonische LR(0)-Kollektion C zur startseparierten Grammatik G' Vorgehen i. C = {closure({s'->.s})} ii. Für jedes Grammatiksymbol X und jede Menge M aus C, für die goto(x,m) nicht die leere Menge ist, füge goto(x,m) zu C hinzu. iii. Solange C sich ändert wiederhole Schritt (2)