BOTTOM UP PARSING ora sta per r S

BOTTOM UP PARSING (ora => sta per =>r) S: : = ab. ABe A: : = Abc | b B: : = d abbbcde L(S) ? Reversed rigthmost abbbcde<=ab. Ade<=ab. ABe<=S shift-reduce parsing (LR)

Ricostruire all’indietro una derivazione destra significa saper dire: Abbbcde abbbcde A: : =b<= a. Abbcde A: : =b<= ab. Acde B: : =d<= abbc. Be Quale delle 4 riduzioni e’ corretta? , Quell’unica che fa parte di una derivazione ovvero forma sentenziale destra

Maniglia Sia 1 2 una RFS allora A: : = e’ maniglia se e solo se S=>* 1 A 2 (=> 1 2 =>…. ) Le maniglie ci fanno viaggiare lungo RFS solamente

Shift-Reduce: Un semplice riconoscitore a due operazioni: lookahead top 1) Shift se non hai superato la maniglia metti il lookahed in pila 2)Reduce: altrimenti (lookahed e’ a destra della m. ) estrai dalla pila i simboli di della maniglia A: : = e rimpiazzali con A

1) riconoscitore: automa a pila con driver D a operazioni shift-reduce tabella M con maniglie 2) LR piu’ potente di LL: per individuare la riduzione vediamo l’intera parte sinistra della sentenziale S: : = u S | u A A: : = u A z | u B z B: : = v B | v

MECCANIZIAMO LA SCELTA Come individuare le maniglie scorrendo la sequenza da sinistra a destra? Usiamo viable prefix (prefisso percorribile)

viable prefix Sia 1 2 una qualunque RFS (i. e. S=>* 1 2 ) maniglia di 1 2 sia A: : = (i. e. S=>* 1 A 2 => 1 2) ed ogni prefisso di 1 e’ un viable prefix

Insieme dei viable prefix di G VPG = {prefix( 1 ) | A: : = G, 1 A 2=> 1 2 RFS per qualche 2} L’insieme dei viable prefix forma un automa a stati finito deterministico se G e’ LR Che ci fornisce la tabella M

TRE differenti automi: SLR i piu’ semplici (tabella/FSA piccolo) LR i piu’ potenti (tabella/FSA grande) LALR un compromesso: semplicita’/potenza

L’idea: Gli Items LR(0) Sia A: : = una produzione della grammatica G allora: A: : = . e’ un item LR(0) S =>* A => e’ un tratto del viable prefix A: : = . e’ un valid item per Componiamo valid item per riconoscere viable prefix

La tecnica: Collezione canonica di LR(0) items raccogliamo in insiemi i valid item di viable prefix di una stessa maniglia. Su questi insiemi I deve valere la seguente proprieta’ (I=Closure(I)) Closure(I)=min I Closure{B: : =. | A: : =. B I} B e’ un noterminale se A: : =. B e’ valid item per un prefix allora anche B : : =. e’ valid per quello stesso prefix quindi devono stare insieme S =>*r. A => r B =>* r ’

Su questi insiemi I, J deve valere la seguente relazione J=Goto(I, x), per qualche insieme I e simbolo x Goto(I, x)= Closure{A: : = x. | A: : =. x I} x e’ un teminale o nonterminale I x x J

Collezione Canonica di LR(0) items: Coll(0) Formata da un insieme di stati I ciascuno chiuso rispetto a Closure l’intero insieme chiuso rispetto a Goto Occorre uno stato iniziale Io: Aumentiamo la grammatica G=<S, V, P, s> diventa G’=<S {s’}, V, P {s’: : =S}, s’> Io=Closure({s’: : =. s})

ESEMPIO S’: : =S S: : = a. ABe A: : = Abc | b B: : = d I 0: Closure({S’: : =. S})={S’: : =. S S: : =. a. ABe} Calcoliamo gli altri stati J

S’: : =S S: : = a. ABe A: : = Abc | b B: : = d I 0: Closure({S’: : =. S}) ={S’: : =. S S: : =. a. ABe} I 1: Goto(I 0, S) ={S’: : =S. } I 2: Goto(I 0, a) ={S: : = a. ABe A: : =. Abc A: : =. b} I 3: Goto(I 2, A) ={S: : = a. A. Be A: : =A. bc B: : =. d} I 4: Goto(I 2, b) ={A: : =b. } I 5: Goto(I 3, B) ={S: : = a. AB. e} I 6: Goto(I 3, b) ={A: : =Ab. c} I 7: Goto(I 3, d) ={B: : = d. } I 8: Goto(I 5, e) ={S: : = a. ABe. } I 9: Goto(I 6, c) ={A: : =Abc. }

Ognuno di questi insiemi In contiene possibili maniglie per prefix che da I 0 conducono a In attraverso transizioni goto. Scoprite la maniglia di abbcde Quando non possiamo piu’ continuare a percorrere l’automa siamo a destra di una maniglia

TABELLA M per SLR per ogni stato indica: action: shift/reduce goto: nuovo stato dopo reduce come si costruisce (due sottotabelle): calcolo della collezione canonica calcolo dei follows

Calcolo della action ACTION(i, a)=<shift, j> se goto(Ii, a)=Ij and a ACTION(i, a)= <reduce, p> se A: : =. Ii and p A: : = and a follow(A) ACTION(i, $)= <accept, -> se S’: : =S. Ii

GOTO(i, A)=j se goto(Ii, A)=Ij and A S(nonterminali)

ESEMPIO S’: : =S S: : = a. ABe [0] A: : = Abc [1]| b [2] B: : = d [3] follow(S)={$} follow(A)={b, d} follow(B)={e}

scanner Sym a a a Tabelle di analisi Controllo I/O ACTION(Top, Sym) = S/K {push(Sym); push(K)} = R/p {pop(2*n), push(A), push(goto(top-1, top))} dove: p=A: : = and | |= = ACC {stop} = undef {error} Stack driver S Ik. . t a xc I 0 top

Applicabilita’ SLR(1) proprieta’ 1: (No shift-reduce) ( Ik Coll(0)), ( A: : =. a , B: : = . Ik) a follow(B) proprieta’ 2: (No reduce-reduce) ( Ik Coll(0)), ( A: : =. , B: : = . Ik) follow(A) follow(B) = {} Th. Data una grammatica G: - G SLR(1) se e solo se entranbe prop. 1 e prop. 2 - G ha parser a riduzione 1 -simbolo SLR se e solo se entranbe prop. 1 e prop. 2

SLR: Conclusioni 1. In che senso il rionoscitore bottom-up, basato sui viable perfix e sull’attraversamento della maniglia, non e’predittivo ? 2. Se una grammatica G e’ SLR(1), la tabella: ACTION puo’ contenere piu’ azioni per una stessa entry ? GOTO puo’ contenere piu’ stati per una stessa entry ? 3. Cosa significa per una grammatica G SLR(1), avere la tabella: ACTION tale che per ogni I, per ogni simbolo a≠b, ACTION(I, a)=ACTION(I, b) tali che ACTION(I, a)≠ ?

SLR: Conclusioni (continua) 4. Per ogni grammatica G e’ decidibile G SLR(1) ? 5. Per ogni linguaggio T e’ decidibile esistenza G tale che: L(G) = T ed in piu’ G LL(1) ? 6. Perche’, in SLR(1), se A: : =. Ik Coll(0), allora A : : = e’ maniglia per ogni a follow(A) ?

SLR: CONFLITTI VERI E FALSI Nell’analisi bottom-up: LR - LALR S =>r* A =>r S =>r* A e’ una sentenziale destra A =>r e’ una deriv. destra First( ) follow(A) A: : = e’ maniglia di First(b) follow(A) e’ solo una condizione necessaria

S =>r* viable prefix First( ) follow(A) A: : = e’ produzione Possiamo concludere che A: : = e’ maniglia di ? Questa e’condizione necessaria per First(b) follow(A)

RICONOSCIAMO I CONFLITTI VERI Ricordiamo il contesto a destra di ogni viable prefix che ci porta ad una maniglia I 0={S: : =. Au, A: : =. a. . . } ----> I 3: ={. . A: : =a. } A: : =. a e’ un item che segue da S: : =. Au solo se (la riduzione ad) A ha come lookahead il simbolo u

A: : = . A Ik ed A: : = e’ una produzione allora A: : =. Ik solo per i simboli nell’insieme U=First( ) First( look(A)) OCCORRE ACCOPPIARE item LR(0) con insiemi U di lookahead A: : =. , U Ik Item LR(1)

Collezione canonica di LR(1) items: Coll(1) S’: : =. S, $ I 0 per definizione Clos(I) =min I Clos{B: : =. , U | A: : =. B , V Clos(I), U ={first( x)| x V}} B e’ un nonterminale Sia u U, allora: se u V, . B propaga su B: : =. se u V, . B genera spontaneamente su B: : =. Goto(I, x)=Closure{A: : = x. , U | A: : =. x , U I}

LR(1) proprieta’ 1: (No shift-reduce) ( Ik Coll(1)), ( A: : =. a , V , B: : = . , U Ik) a U proprieta’ 2: (No reduce-reduce) ( Ik Coll(0)), ( A: : =. , V , B: : = . , U Ik) V U = {} Th. Data una grammatica G: - G LR(1) se e solo se entranbe prop. 1 e prop. 2 - G ha parser a riduzione 1 -simbolo LR se e solo se entranbe prop. 1 e prop. 2

Calcolo delle tabelle ACTION e GOTO per LR(1) ACTION(i, a)=<shift, j> se goto(Ii, a)=Ij and a ACTION(i, a)= <reduce, p> se A: : =. , U Ii and p A: : = and a U ACTION(i, $)= <accept, -> se S’: : =S. , $ Ii GOTO(i, A)=j se goto(Ii, A)=Ij and A N N=insieme dei nonterminali

Complessita’ in spazio: LL(1) ordine N*T (dove N nonterminali ed T terminali) SLR ordine N*P*T (dove P dimensione parte destra prod) LR(1) ordine N*P*T*T LALR(1) come SLR

ESEMPIO: S: : =Sb | ca. Sd | c I 0: {S’: : =. S S: : =. Sb S: : =. ca. Sd S: : =. c} I 1=Goto(I 0, S)={S’: : =S. S: : =S. b} I 2=Goto(I 0, c)={S: : =c. a. Sd S: : =c. } I 3=Goto(I 1, b)={S: : =Sb. } I 4=Goto(I 2, a)={S: : =ca. Sd S: : =. Sb S: : =. ca. Sd S: : =. c} I 5=Goto(I 4, S)={S: : =ca. S. d S: : =S. b} Goto(I 4, c)=I 2 I 6=Goto(I 5, d)={S: : =ca. Sd. } kernel

I 0: {S’: : =. S, $ S: : =. Sb, $/b S: : =. ca. Sd, $/b S: : =. c, $/b} I 1=Goto(I 0, S)={S’: : =S. , $ S: : =S. b, $/b} I 2=Goto(I 0, c)={S: : =c. a. Sd, $/b S: : =c. , $/b} I 3=Goto(I 1, b)={S: : =Sb. , $/b} I 4=Goto(I 2, a)={S: : =ca. Sd, $/b S: : =. Sb, d/b S: : =. ca. Sd, d/b S: : =. c, d/b} I 5=Goto(I 4, S)={S: : =ca. S. d, $/b S: : =S. b, d/b} I 6=Goto(I 4, c)={S: : =c. a. Sd, d/b S: : =c. , d/b} I 7=Goto(I 5, d)={S: : =ca. Sd. , $/b}=Goto(I 10, b) I 8=Goto(I 5, b)={S: : =Sb. , d/b}= I 9=Goto(I 6, a)={S: : =ca. Sd, d/b S: : =. Sb, d/b S: : =. ca. Sd, d/b S: : =. c, d/b} I 10=Goto(I 9, S)={S: : =ca. S. d, d/b S: : =S. b, d/b} Goto(I 9, c)=I 6 I 11=Goto(I 10, d)={S: : =ca. Sd. , d/b}

Uno stato SLR {t 1 t 2. . . tk} e’ duplicato in n stati LR(1) {t 1, U 11 t 2, U 21. . . tk, Uk 1}. . . {t 1, U 1 n t 2, U 2 n… tk, Ukn} LALR(1) mettiamo insieme i duplicati {t 1, U 11. . . U 1 n t 2, U 21. . . U 2 n … tk, Uk 1. . . Ukn }

Collezione stati LALR: Coll. LALR Sia la relazione di equivalenza su Coll(1) cosi’ definita: Ij Ik se e solo se Ij 0 = Ik 0 dove I 0 ={A: : =. | A: : = . , U I} Coll. LALR = Coll(1)/ = {I/ | I Coll(1)} (partizione di su Coll(1)) dove I/ = h {J Coll(1) | J I} ( Ij, Ik Coll(1)), ( a N T), Ij=Goto(Ik, a) se e solo se Ij / =Goto(Ik / , a) La funzione Goto del riconoscitore LALR

Cosi facendo ritroviamo i conflitti di SLR ? shift/reduce A: : =. , U Ij and B: : = . a , v Ij and a U U=U 1. . . Un conflitto presente anche in LR(1) reduce/reduce LR(1) potrebbe non averlo

LALR(1) proprieta’ 1: (No shift-reduce) ( I Coll. LALR) ( A: : =. a , V , B: : = . , U I) a U proprieta’ 2: (No reduce-reduce) ( I Coll. LALR), ( A: : =. , V , B: : = . , U I) V U = {} Th. Data una grammatica G: - G LALR(1) se e solo se entranbe prop. 1 e prop. 2 - G ha parser a riduzione 1 -simbolo LALR se e solo se entranbe prop. 1 e prop. 2

Bottom-up: Conclusioni 1. Cosa significa l’inclusione stretta SLR(1) LALR(1) LR(1)? 2. Per ogni linguaggio T e’ decidibile esistenza G tale che: L(G) = T ed in piu’ G LALR(1) [oppure G LR(1)] ? 3. Perche’ cercando un parser 1 -simbolo bottom-up per G cerchiamo anzitutto di provare G SLR(1) ?

Bottom-up: Conclusioni (continua) 4. Perche’ se una grammatica G LALR(1) a causa della prop. 2 potrebbe nondimeno essere G LR ? 5. Perche’ SLR(1) LALR(1) ? Sapete mostrare che ogni G SLR(1) e’ anche G LALR(1) ? Conoscete una grammatica G che mostri che tale inclusione e’ stretta ? 6. Se una grammatica G e’ ambigua quale proprieta’ sara’ violata: prop. 1 o prop. 2 ? E perche’ proprio quella ?