Parser bottom-up. Esempio. V = {S, A, B, C} T = {a, b, d, e} P = { S aa R1 A BaA R2 A e R3 B ac R4 B AdC R5

Transcript

1 Parser bottom-up Esempio V = {S, A, B, C} T = {a, b, d, e} P = { S aa R1 A BaA R2 A e R3 B ac R4 B AdC R5 C b R6 Come costruire l albero sintattico di aedbae in modo bottom-up? 1

2 Esempio aedbae aedbaa aedcaa aadcaa abaa as S applicando R3 S aa A BaA A e B ac B AdC C b applicando R6 applicando R3 applicando R5 a applicando R2 applicando R1 A R1 R2 R3 R4 R5 R6 S A B a A d C e e b Shift-reduce parsing: LR(k) Left scan, Right-most derivation sviluppata da Knuth (1965) genera una right most derivation Due operazioni centrali legge il successivo input: spostamento nella pila applica una produzione: riduce i terminali con un non terminale altre operazioni accettazione: sostituzione di tutta la stringa con l assioma error detection 2

3 LR parsing Introduciamo un metodo di parsing bottom-up efficiente che può essere usato per un ampia classe di grammatiche libere LR(k) parsing: L indica che l input viene letto da sinistra a destra (Left to right) R indica che viene ricostruita una derivazione Rightmost rovesciata (il non terminale più a destra viene sostituito per primo) k indica che vengono usati k simboli di lookahead (se k=1 spesso (1) viene omesso e quindi si parla semplicemente di LR parsing) Vantaggi Può essere costruito un parser LR per tutti i costrutti dei linguaggi di programmazione per i quali può essere scritta una grammatica libera (tipo 2) LR è il metodo di parsing shift-reduce senza backtracking più generale che si conosca e, nonostante ciò, può essere implementato in maniera efficiente tanto quanto altri metodi di parsing shift-reduce meno generali La classe di grammatiche che possono essere analizzate LR propriamente maggiore di quelle che che possono essere analizzate LL con un parser predittivo 3

4 Vantaggi e svantaggi Tutti i parser LR rilevano un errore di sintassi il prima possibile rispetto ad una scansione dell input da sinistra a destra Svantaggio: la costruzione di un parser LR per un linguaggio di programmazione tipico è troppo complicata per essere fatta a mano C è bisogno di un tool apposito, un generatore di parser LR, che applichi gli algoritmi che vedremo e definisca la tabella del parser. Esempi di generatori di questo tipo sono Yacc o Bison Questi tool sono molto utili anche perché danno informazione diagnostica se c è qualche problema (ad esempio, in caso di grammatica ambigua, il tool restituisce abbastanza informazione per determinare dove si crea l ambiguità) Programma 1. Introduciamo l algoritmo generale eseguito da un parser LR 2. K = 0 3. K = 1 1. Introduciamo il metodo più semplice per la costruzione della tabella di un parser LR: simple LR (abbreviato in SLR) 2. Studiamo il metodo LR canonico che è il metodo più potente, ma anche il più costoso, per costruire la tabella 3. Semplifichiamo un po e definiamo il metodo lookahead LR (LALR) che si trova ad un livello intermedio fra gli altri due 4

5 Il parser LR INPUT a 1... a i... a n $ STACK s m Programma di Parsing LR Output X m s m-1 X m-1... action goto s 0 Il parser LR Il programma è sempre lo stesso, cambia la tabella action + goto Ogni s i nello stack è uno stato che serve a riassumere i simboli di stack sottostanti In una reale implementazione è sufficiente lo stato, non c è bisogno di mettere anche i simboli della grammatica Ad ogni passo il parser decide se fare shift o reduce in base allo stato che si trova in cima allo stack e al simbolo di lookahead corrente 5

6 Tabelle Action e GoTo action[s m,a i ] =X X descrive l operazione che bisogna compiere: S = spostamento, R = riduzione, A = accettazione E = error s = stato a = input (simbolo terminale) GoTo(s, y) = s1 s1 e s stati y simbolo terminale o non terminale Una derivazione di un right sentential form γ è una produzione A βe una posizione in γ dove β può essere trovato e sostituito da A per produrre un forma di frase più alta (quando operiamo una riduzione di tipo bottom-up) S αa ω αβω dove α {V T}*, β {V T}*, ω {T}* tutti gli shift-reduce parser operano spostando simboli e esaminando i simboli di ingresso (look-aheads) fino a quando la derivazione viene trovata 6

7 Configurazioni In ogni istante il parser è in una configurazione: (s 0 X 1 s 1 X 2 s 2... X m s m, a i a i+1... a n $) È la stessa configurazione tipica di uno shiftreduce parser, ma in più ci sono gli stati Corrisponde alla forma sentenziale destra X 1 X 2... X m a i a i+1... a n Azioni e goto Se action[s m,a i ]= shift s allora il parser mette il simbolo a i sullo stack Per arrivare ad una configurazione corretta il parser deve inserire lo stato s sopra al simbolo appena impilato Tale stato s è stato determinato da goto[s m,a i ]=s La nuova configurazione è: (s 0 X 1 s 1... X m s m a i s, a i+1... a n $) 7

8 Azioni e goto Se action[s m, a i ] = reduce con A βallora la nuova configurazione diventa: (s 0 X 1 s 1... X m-r s m-r A s, a i a i+1... a n $) dove: r è la lunghezza di β (si eliminano dallo stack 2r simboli fino ad avere in testa s m-r ) Si ha che X m-r+1 X m-r+2... X m = β s = goto[s m-r, A] Azioni e goto Se action[s m, a i ] = accetta allora il parser annuncia che l analisi è terminata con successo Se action[s m, a i ] = errore allora c è un errore di sintassi e il parser chiama una procedura di gestione/recupero dell errore 8

9 Algoritmo Input: Una stringa di terminali (token) w ed una tabella di parsing LR (action + goto) per la grammatica considerata Output: Se w è in L(G) allora restituisce la traccia di una derivazione rightmost rovesciata di w da G, altrimenti dà una indicazione di errore Algoritmo ip punta al primo simbolo di w$; while true do begin s := top(stack); a:= simbolo puntato da ip; if action[s,a] = shift s then begin push(a); push(goto(s,a)); ip avanza di un simbolo end else if action[s,a] = reduce A βthen begin pop 2* β simboli dallo stack; s := top(stack); push(a); push(goto[s,a]); segnala in output la produzione A β end else if action[s,a] = accetta then return else errore() end 9

10 Esempio Consideriamo la seguente grammatica: 1. E E + T 2. E T 3. T T * F 4. T F 5. F (E) 6. F id La numerazione è importante per i riferimenti della tabella Una tabella LR per la grammatica action goto Stato id + * ( ) $ E T F 0 s5 s s6 acc 2 r2 s7 r2 r2 3 r4 r4 r4 r4 4 s5 s r6 r6 r6 r6 6 s5 s s5 s s6 s11 9 r1 s7 r1 r1 10 r3 r3 r3 r3 11 r5 r5 r5 r5 10

11 La tabella Nella tabella si sta per shift i, cioè fai lo shift del simbolo corrente di input e poi metti sullo stack lo stato i rj sta per reduce con la produzione numero j acc significa accetta vuoto significa errore Il valore goto[s,a] per un simbolo terminale a è il valore i di si, se indicato, altrimenti è errore Parsing della stringa: id * id + id Step STACK INPUT AZIONE 1 0 id * id + id $ Shift (s5) 2 0 id 5 * id + id $ Reduce con F id (r6) 3 0 F 3 * id + id $ Reduce con T F (r4) 4 0 T 2 * id + id $ Shift (s7) 5 0 T 2 * 7 id + id $ Shift (s5) 6 0 T 2 * 7 id 5 + id $ Reduce con F id (r6) 7 0 T 2 * 7 F 10 + id $ Reduce con T T * F (r3) 8 0 T 2 + id $ Reduce con E T (r2) 9 0 E 1 + id $ Shift (s6) 10 0 E id $ Shift (s5) 11 0 E id 5 $ Reduce con F id (r6) 12 0 E F 3 $ Reduce con T F (r4) 13 0 E T 9 $ Reduce con E E + T (r1) 14 0 E 1 $ Accetta 11

12 esempio S = <program> V = {<program>, <ist>} T = {begin, i, end, ;, $} P = { 1. <program> begin <ist>end $ 2. <ist> i ; <ist> 3. <ist> begin <ist>end ; <ist> 4 <ist> ε} Goto T begin end 3 8 ; 6 9 i $ <program> <ist>

13 Action T begin S S E E S E S E E S E end E R4 S E R4 E R4 S E R4 R2 ; E E E E E S E E S E E i E S E E S E S E E S E $ E E E A E E E E E E E 11 E R3 E E E Sulla base dei simboli letti si inseriscono stati nella pila e si cambia stato. Una configurazione di un parser LR è una coppia costituita da: s 0 x 1 s 1 x 2 s 3 x m s m a i a i+1 a i+2 a n $ gli elementi della pila s 0 x 1 s 1 x 2 s 3 x m s m l input non espanso a i a i+1 a i+2 a n $ Deve essere presente solo una produzione che ha come LHS l assioma 13

14 Algoritmo di parsing 1. Configurazione iniziale (s 0 a 1 a 2 a n $) 2. se action(s m, a i ) = s il parser esegue una mossa e va nella configurazione s 0 x 1 s 1 x 2 s 3 x m s m a i s a i+1 a i+2 a n $ cioè a i s sono inseriti nella pila e a i+1 è il successivo carattere 2. se action(s m, a i ) = reduce A βil parser esegue una riduzione e va nella configurazione s 0 x 1 s 1 x 2 s 3 x m-r s m-r A s a i a i+1 a n $ dove s = goto (s m-r, A) e r è la lunghezza di β 3. se action(s m, a i ) = accept il parser è completo 4. se action(s m, a i ) = error è segnalato un errore 0 begin i ; i ; end $ configurazione iniziale action(0, begin) = s goto(0,begin) = 1 0 begin 1 i ; i ; end $ nuova configurazione action(1, i) = s goto(1,i) = 5 0 begin 1 i 5 ; i ; end $ nuova configurazione action(5, ;) = s goto(5, ;) = 6 0 begin 1 i 5 ; 6 i ; end $ nuova configurazione action(6, i) = s goto(6,i) = 5 0 begin 1 i 5 ; 6 i 5 ; end $ nuova configurazione action(5, ;) = s goto(5,;) = 6 0 begin 1 i 5 ; 6 i 5 ; 6 end $ nuova configurazione action (6, end) = r4 <ist> ε r=0 goto(6,<ist>) = 10 0 begin 1 i 5 ; 6 i 5 ; 6 <ist> 10 end $ nuova configurazione 14

15 action (10, end) = r2 <ist> i ; <ist> r=3 goto(6,<ist>) = 10 0 begin 1 i 5 ; 6 i 5 ; 6 <ist> 10 end $ 0 begin 1 i 5 ; 6 <ist> 10 end $ action (10, end) = r2 <ist> i ; <ist> r=3 goto(1,<ist>) = 2 0 begin 1 i 5 ; 6 <ist> 10 end $ 0 begin 1 <ist> 2 end $ action (2, end) = s goto(2,end) = 3 0 begin 1 <ist> 2 end 3 $ action (3,$) = a <program> begin <ist>end $ r= 4 <program> 10 <ist> 6 ; 10 5 <ist> i 63 end ; 25 <ist> i 1 begin <program> 0 begin i ; i ; end $ 15

16 Costruzione delle tabelle di parsing LR Come costruiamo la tabella? Una grammatica per la quale possiamo costruirla si dice che è una grammatica LR Esistono grammatiche libere dal contesto che non sono grammatiche LR Possono essere evitate per i costrutti tipici dei linguaggi di programmazione Intuizione Una grammatica è LR quando un parser shiftreduce è in grado di riconoscere le stringa da sostituire quando appaiono in cima allo stack Un parser LR non deve guardare tutto lo stack: lo stato che in ogni momento si trova in testa ad esso contiene tutta l informazione di cui il parser ha bisogno 16

17 Intuizione Fatto importante: se è possibile riconoscere una operazione guardando solo i simboli della grammaticha che sono sullo stack allora esite un automa a stati finiti che, leggendo i simboli dello stack dal fondo alla testa, determina se una certa handle è presente in testa La funzione goto di un parser LR è essenzialmente questo automa a stati finiti L automa non ha bisogno di leggere tutto lo stack ad ogni mossa I simboli di lookahead Oltre allo stato in testa allo stack un parser LR prende le sue decisioni anche in base, in generale, a k simboli di lookhead Noi considereremo solo i casi k=0 e k=1 (che sono quelli di interesse pratico) 17

18 Grammatiche LL vs LR La condizione richiesta ad una grammatica per essere LR(k) è meno forte di quella richiesta alla stessa per essere LL(k) LR(k): dobbiamo essere in grado di riconoscere l occorrenza della parte destra di una produzione avendo visto tutto quello che è stato derivato dalla stessa parte destra e avendo k simboli di lookahead LL(k): dobbiamo essere in grado di decidere quale produzione applicare ad un simbolo non terminale potendo vedere solo k simboli di quello che la parte destra della produzione in questione deriva. Insiemi Grammatiche LR(k) Grammatiche LL(k) 18

19 Grammatiche LR(1) Grammatiche LALR(1) Grammatiche SLR(1) Grammatiche LR(0) Alcune note L analisi di tipo LR(K) richiede una grammatica che ha una sola produzione per l assioma Se la grammatica ha più di una produzione per l assioma viene aggiunta la produzione S S $ e il nuovo assioma è il non terminale S 19

20 Analisi LR(0) Costruzione delle tabelle Goto e Action Candidata LR(0) Un candidata LR(0) per una grammatica G è una produzione di G con un punto in qualche posizione della parte destra della produzione Es: la produzione A XYZ può dar luogo a quattro candidata LR(0): 1. A XYZ 2. A X YZ 3. A XY Z 4. A XYZ 20

21 Collezione canonica LR(0) G grammatica con simbolo iniziale S G grammatica G aumentata con un nuovo simbolo iniziale S e la produzione S S Questo accorgimento serve ad indicare al parser la fine del parsing: il parsing ha successo se e solo se l input è terminato e c è una riduzione con la produzione S S LR(0) I parser LR(0) sono basati su una configurazione con la seguente forma (candidata) A x 0 x 1 x 2 x i x i+1... x m dove il punto indica fino a che punto e stata riconosciuta la frase può comparire in qualsiasi punto nella parte destra di una produzione predict compare all estrema sinistra A x 0 x 1 x 2... x m reduce compare all estrema destrra A x 0 x 1 x 2... x m Noi considereremo tutte le produzioni applicabili in parallelo costruendo l insieme delle candidate La configurazione iniziale e il predict dell assioma 21

22 Candidata LR(0) La produzione A εdà luogo ad una sola candidata LR(0), cioè A Un candidata può essere rappresentata efficacemente con due numeri interi: il numero della produzione e la posizione del punto Una candidata indica quanto di una produzione è stato visto ad un certo punto del parsing Es: A X YZ indica che X è stato visto e ci si aspetta di vedere YZ Chiusura di una candidata LR(0) Do { if (B δ Aρ e nell insieme della chiusura) aggiungere tutte le candidate di forma A γ all insieme While (ci sono altre candidate da aggiungere) Lo stato iniziale per il parser LR coinvolge la chiusura di S γ $ A partire dalla configurazione iniziale costruiremo una FSA (che chiameremo CFSM cioè FSM caratteristica) che mostra tutte le transizioni a nuovi stati attraverso terminali e non terminali. 22

23 Chiusura for LR( 0) Chiusura (I){ Do For each (ogni argomento [A α B β] in I, ogni produzione B γ tale che [B γ ] non è in I) {add [B γ ] ad I While sono possibili nuovi inserimenti return I Costruzione tabella GOTO GOTO (I, X) { Detto J l insieme delle [A α X β] tali che [A α X β ] èin I return Chiusura (J) 23

24 Costruzione delle tabelle LR(0) void BUILD-LR(0) (){ C = Chiusura([ S S]) do for each (I C and X GOTO( I, X) and GOTO( I, X) C) add GOTO( I, X) to C While sono possibili inserimenti Esempio V = {E, T, S} T = {id, +, (, ), $} P = {E E + T E T T id T (E) S E$} stato 0 chiusura (S E$) = {S E$} chiusura(e E+T) chiusura(e T) = {S E$, E E+T, E T} chiusura(t id) chiusura(t (E)) = {S E$, E E+T, E T, T id, T (E) } 24

25 Esempio S E$ E E+T E T T id T (E) T id id id E ( T S E $ E E +T 4 6 E T T T ( E) E E+T E T T id T (E) ( + ( E $ 5 2 S E$ E E + T T id T (E) T T (E ) E E +T ) T (E) id 9 E E + T Goto e action T ) 8 ( 6 6 id 3 3 $ 2 E 1 7 T T S S A R4 R3 9 4 S R5 R2 25

26 LR(0) Una grammatica è LR(0) se ogni stato dellla CFSM contiene o una sola candidata di riduzione una o più candidate di spostamento Algoritmo di parsing 1. Configurazione iniziale (s 0 a 1 a 2 a n $) 2. se action(s m ) = s il parser esegue una mossa e va nella configurazione s 0 x 1 s 1 x 2 s 3 x m s m a i s a i+1 a i+2 a n $ cioè a i s sono inseriti nella pila e a i+1 è il successivo carattere 2. se action(s m ) = reduce A βil parser esegue una riduzione e va nella configurazione s 0 x 1 s 1 x 2 s 3 x m-r s m-r A s a i a i+1 a n $ dove s = goto (s m-r, A) e r è la lunghezza di β 3. se action(s mi ) = accept il parser è completo 4. se action(s mi ) = error è segnalato un errore 26

27 Algoritmo LR(0) ip punta al primo simbolo di w$; while true do begin s := top(stack); a:= simbolo puntato da ip; if action[s] = shift s then begin push(a); push(s ); ip avanza di un simbolo end else if action[s] = reduce A βthen begin pop 2* β simboli dallo stack; s := top(stack); push(a); push(goto[s,a]); segnala in output la produzione A β end else if action[s] = accetta then return else errore() end Parser SLR( 1) I parser LR( 0) generano una forma compatta di tabelle goto e action tables ma spesso non sono abbastanza potenti. SLR(1) usano un simbolo di look-ahead insieme alla CFSM di tipo LR(0) CFSM. I look-aheads sono aggiunti alle candidate (o configurazioni) nel seguente modo: per le candidate di spostamento A α β lookaheads sono rappresentati da First(β ) per le candidate di riduzione A α look-aheads sono rappresentati da Follow(A) 27

28 Esempio T = {+, *, (, id, )} V = {S, E, T, P} P = { S E E E + T T T T * P P P id ( E ) } S = S ( 10 T T * P 8 P (E) P 0S E E E + T E T T T * P T P P id P ( E ) id 1 P id 2 T P E T 7 T 3 S E E E + T 9 id 1 T T * P ( P id 5 P ( E ) 10 4 * P E T T T * P P T 5P ( E ) E E + T E T id T T * P T P P id P ( E ) E ( ) 6 P (E ) E E + T + 7 E E + T T T* P T P P id P ( E ) P id 1 28

29 First(P) = {id, (} First(T) = First(P) = {id, (} First(E) = First(T) = First(P) = {id, (} First(S) = First(E) = First(T) = First(P) = {id, (} Follow(T) = First(*P) Follow(E) = {+, *} Follow(P) = Follow(T) = {+, *} Follow(S) = {$} Follow(E) = First(+ T) Follow(T) = {+, *} Esempio: ambiguità shiftreduce S = S' V = {S', S, A} T = {a, b, $} P = { 0. S' S$ 1. S AS 2. S b 3. A SA 4. A a} 29

30 Esempio 0 S' S$ S AS S b A SA A a b 2 S b 2 b S b A 3 a a S a S 1 S' S $ $ A S A A Sa A A a S AS S b a a 3 4 S Α S S AS S b A SA A a A 5S' S $ 6A SA S A S S AS S b A SA A a A 2 b 7 A S a 8 a A S a 9 S S Α S A S A S First( S') = First(S) = {a, b} First(S) = First(A) {b} = {a, b} First( A) = First(S) {a} = {a, b} Follow( S') = Follow( S) = {$} First(A) = {$, a, b} Follow( A) = First(S) = {a, b} 30

31 Risoluzione dell ambiguità S6 6A SA riduzione Follow( A) = First(S) = {a, b} S A S S AS spostamento S b First(S) First(A) First(b) First(A) A SA = {a, b} A a L ambiguità non può essere risolta Grammatiche non SLR(1) Sappiamo già che nessuna grammatica ambigua può essere LR, quindi tantomeno SLR Ci sono grammatiche non ambigue che però non sono SLR. Ad esempio: S L = R R L * R id R L 31

32 Tabelle LR(1) Costruzione delle tabelle di parsing LR canoniche Perché utilizzare parser LR(1)? Nel metodo SLR, lo stato i chiama per la riduzione A α un simboli di ingresso a se l insieme delle candidate contiene A α e a appartiene al Follow(A). Talvolta quando i appare in cima alla pila, un prefisso βα può essere in cima alla pila ma β A non puo essere seguito da a nelle frasi corrette, quindi la riduzione dovrebbe essere invalida Per evitare tale invalida riduzione che causa una ambiguità shift-reduce, noi possiamo cercare più informazioni dividendo lo stato in piu stati se necessario. L uso dell insieme Follow per stimare i look-aheads che predicono azioni di riduzioni sono meno precise rispetto ad incorporare gli esatti lookaheads nelle configurazioni. I parser LR(1) usano una informazione lookahead più precisa alla scopo di gestire una maggior quantità di linguaggi. 32

33 LR(1) Parsers Un candidata LR(1) è una candidata LR(0) con informazioni look-ahead: [A α β, a]. Il look-ahead non ha effetto sulla candidata di forma [A α β, a], dove β ε, ma una candidata di forma [A α, a] è una riduzione solo quando il successivo ingresso è in a. I parsers LR(1) usa configurazioni (con informazioni di lookahead): A x 1... x i x i x j, l, where l T $. l è il look-ahead dopo che l intera parte destra della regola è ritrovata. $ appare come look-ahead per l assioma. Chiusura for LR( 1) Chiusura (I){ Do For each (ogni argomento [A α B β, a] in I, ogni produzione B γ, e ogni terminale b First(βa) tale che [B γ, b] non è in I) {add [B γ, b] ad I While sono possibili nuovi inserimenti return I 33

34 Costruzione tabella GOTO GOTO (I, X) procedure GOTO (I, X) { Detto J l insieme delle [A α X β, a] tali che [A α X β, a] è in I return Chiusura (J) Costruzione delle tabelle LR(1) void BUILD-LR(1) (){ C = Chiusura([ S S, $]) do for each (I C and X GOTO( I, X) and GOTO( I, X) C) add GOTO( I, X) to C While sono possibili inserimenti 34

35 Example: S = S' V = {S', S, C} T = {c, d} P = { 0. S' S 1. S CC 2. C cc 3. C d} [S' S, $] è la configurazione iniziale I 0 La chiusura di questa configurazione è [A α Bβ, a], A = S', α = ε, B = S, β = ε, a = $ aggiungere [B γ, b] B γ e b First(βa) cioè : S CC e First(βa) = First(a) = $: [S CC, $] 35

36 [S CC, $]. La chiusura di questa configurazione è [A α Bβ, a], A = S', α = ε, B = S, β = ε, a = $ aggiungere [B γ, b] B γ e b First(βa) cioè : C cc e C d, con First(βa) = First(Ca) = {c, d}, [C cc, c d] [C d, c d] Calcolare GOTO(I 0,X) per i vari valori di X. Per X = S, noi dobbiamo effettuare la chiusura di [S' S, $], ma in questo caso nessun altra chiusura è possibile Quindi I 1 è[s' S, $]. Per X = C, noi dobbiamo effettuare la chiusura di [S C C, $]. Noi dobbiamo aggiunge tutte le produzioni di C con lookahead di $ poiché β è. Quindi I 2 is [S C C, $] [C cc, $] [C d, $] 36

37 Per X = c, noi dobbiamo effettuare la chiusura di [C c C, c d]. Quindi noi abbiamo le produzioni di C con lookahead c d. Pertanto I 3 : [C c C, c d] [C cc, c d] [C d, c d] Per X = d, noi dobbiamo effettuare la chiusura di [C d, c d], per la quale non e possibile aggiungere nulla. Quindi I 4 è[c d, c d]. Calcolare GOTO(I 2,X) per i vari valori di X Per X = C, chiusura [S CC, $], non è possibile aggiungere altre candidate, pertanto I 5 is [S CC, $] Per X = c, chiusura [C c C, $]. Dobbiamo aggiungere tutte le candidate di predizione di C con lookahead $, pertanto I 6 : [C c C, $] [C cc, $] [C d, $] For X = d, chiusura [C d, $], non è possibile aggiungere altre candidate, pertanto I 7 is [C d, $] 37

38 Calcolare GOTO(I 3,X) per i vari valori di X Per X = c, chiusura [C c C, c d]. Dobbiamo aggiungere tutte le candidate di predizione di C con lookahead c d, ottenendo I 3 Per X = d, chiusura [C d, c d]. Si ottiene I 4 For X = C, chiusura [C cc, c d], non è possibile aggiungere altre candidate, pertanto I 8 è[c cc, c d] Calcolare GOTO(I 6,X) per i vari valori di X Per X = c, chiusura [C c C, $]. Dobbiamo aggiungere tutte le candidate di predizione di C con lookahead $, ottenendo I 6 Per X = d, chiusura [C d, $]. Si ottiene I 7 For X = C, chiusura [C cc, $], non è possibile aggiungere altre candidate, pertanto I 9 è[c cc, $] 38

39 d S' S, {$} S CC, {$} C cc, {c d} C d, {c d} C C d, {c d} S c c S C C, {$} C cc, {$} C d, {$} C S' S, {$} S C C, {$} C C c C, {c d} C cc, {c d} C d, {c d} d c C C c C, {$} C c C, {c d} d C d, {$} d C c C, {$} C cc,{$} C d,{$} C Esempio T = {+, *, (, id, )} V = {S, E, T, F} P = { S E E E + T T T T * P P P id ( E ) } S = S 39

40 [S Ε, {$}] è la configurazioni iniziale I 0 Per chiudere con [A α B β, a], A = S, α =, B = E, β =, a = $ add [B γ, b] for each B γ εterminale b FIRST( β a), that is : E E + T and E TwithFIRST( β a) FIRST( a) = $: [S Ε, $] [E E + T, $] [E T, $] Chiusura[E E + T, {$}] = [E E + T, {$, +}] [E T, {$, +}] Chiusura [E Τ * P, {$, +}] = [P id, {$, +,*}] [P (E), {$, +,*}] Chiusura [E T, {$, +}] = [T Τ * P, {$, +}] [T P, {$, +}] Chiusura [T Τ * P, {$, +}] = [T Τ * P, {$, +,*}] [T P, {$, +,*}] id pertanto I 0 E [S Ε, {$}] [E E + T, {$, +}] [E T, {$, +}] [T Τ * P, {$, +,*}] [T P, {$, +,*}] [P id, {$, +,*}] [P (E), {$, +,*}] T P I 1 I 2 I 3 I 4 ( I 5 40

41 Calcolo di I 1 [S Ε, {$}] [E E + T, {$, +}] + I 6 [S Ε, {$}] [E E + T, {$, +}] Calcolo di I 2 [E T, {$, +}] [T Τ * P, {$, +,*}] * I 7 [E T, {$, +}] [T Τ * P, {$, +,*}] 41

42 Calcolo di I 3 [T P, {$, +,*}] [T P, {$, +,*}] Calcolo di I 4 [P id, {$, +,*}] [P id, {$, +,*}] 42

43 Considerazioni Ogni grammatica SLR(1) è anche LR(1), ma per una grammatica SLR(1) il parser LR canonico può avere molti più stati rispetto a quelli del parser SLR Ad esempio, la grammatica che abbiamo usato come esempio è SLR e un parser SLR per la stessa ha 7 stati invece dei 10 del parser LR canonico appena costruito Tabelle LALR Costruzione delle tabelle LALR 43

44 Metodo LALR Introduciamo l ultimo metodo di costruzione di tabelle per il parsing LR Nome: lookahead-lr abbreviato in LALR Questo metodo è usato spesso dato che le tabelle che si ottengono sono sensibilmente più piccole di quelle ottenute con l LR canonico I tipici costrutti dei linguaggi di programmazione possono venire facilmente catturati da una grammatica LALR Metodo LALR Lo stesso discorso valeva anche per le grammatiche SLR Tuttavia ci sono un certo numero di costrutti per i quali è meglio usare grammatiche LALR Le tabelle SLR e LALR hanno sempre lo stesso numero di stati Numero: alcune centinaia di stati per un linguaggio tipo il Pascal Per lo stesso linguaggio una tabella LR canonica ha alcune migliaia di stati 44

45 Idea Consideriamo la grammatica usata come esempio per illustrare la costruzione di tabelle LR canoniche: S S S CC C cc d Idea Alcuni insiemi di candidate LR(1) che abbiamo costruito per questa grammatica avevano lo stesso insieme di candidate LR(0) ma differivano per i simboli di lookahead I 4 = {[C d, c], [C d, d] } I 7 = {[C d, $]} 45

46 Idea Osserviamo meglio il comportamento di questi due stati durante il parsing La grammatica genera il linguaggio c*dc*d Durante la lettura di un input cc cdcc cd il parser fa lo shift di tutto il primo gruppo di c e della prima d che le segue entrando nello stato 4 dopo aver letto questa d A questo punto il parser ordina una riduzione con C d se il simbolo successivo è c o d Idea È giusto: sia c che d possono essere l inizio di c*d D altra parte, se $ segue la prima d c è un errore: ad esempio la stringa ccd non è nel linguaggio E giustamente lo stato 4 segnala errore se il simbolo di input è $ 46

47 Idea Dopo la prima d il parser appila tutte le c seguenti e anche la seconda d entrando infine nello stato 7 A questo punto il simbolo di input deve essere $ altrimenti la stringa data non è nel linguaggio (errore) È giusto che lo stato 7 comandi una riduzione con C d se l input è $ e dia errore se l input è c o d. Idea Rimpiazziamo ora gli insiemi I 4 e I 7 con un unico insieme di candidate LR(1) I 47 I 47 è l unione degli candidate di I 4 e di I 7 I 47 = C d, c/d/$ goto(i i,d)=i 47 per i=0,2,3,6 Le azioni dello stato 47 sono: riduci con C d per ogni input 47

48 Conseguenze Il parser così modificato si comporta quasi allo stesso modo di quello di partenza Potrebbe ridurre con C d in alcune circostanze nelle quali il parser originale avrebbe segnalato un errore (es: ccd o ccdcdc) L errore però viene comunque rilevato in seguito (in effetti prima che venga appilato un altro simbolo terminale sullo stack) In generale Cerchiamo gli insiemi di candidate LR(1) che hanno lo stesso core, cioè lo stesso insieme di prime componenti Accorpiamo gli insiemi di candidate LR(1) con lo stesso core in un unico insieme di candidate LR(1) Nell esempio precedente I 4 e I 7 avevano lo stesso core C d 48

49 In generale Ad esempio anche gli insiemi I 3 ed I 6 dell esempio precedente hanno lo stesso core {C c C, C cc, C d} Anche I 8 ed I 9 hanno lo stesso core {C cc } In generale un core è un insieme di candidate LR(0) In generale Il core di goto(i,x) dipende solo dal core di I Questo significa che i goto degli stati accorpati possono essere anche essi accorpati Quindi non c è problema nella ridefinizione della funzione goto La tabella action va modificata in accordo ai nuovi candidate LR(1) (con gli accorpamenti) 49

50 Conseguenze Supponiamo di avere una grammatica LR(1) I suoi insiemi di candidate LR(1) non producono conflitti Se accorpiamo gli insiemi con lo stesso core ci dovremmo aspettare che i nuovi insiemi producano conflitti E invece non è così, almeno per i conflitti shift/reduce Conseguenze Supponiamo infatti di avere un conflitto shift/reduce in uno stato accorpato Più precisamente c è una candidata [A α, a] che indica una riduzione per a e anche una candidata [B β aγ, b] che invece indica uno shift per a Se questo è vero allora almeno un insieme di candidate (non accorpato) aveva nel core la candidata [A α, a] e, visto che il core deve essere uguale per tutti gli stati che sono stati accorpati, anche una candidata [B β aγ, c] per qualche c 50

51 Conseguenze Ma questo significherebbe che c era lo stesso conflitto anche sull insieme di candidate LR(1) di partenza Ciò non è possibile perché siamo partiti dall ipotesi che la grammatica fosse LR(1) Quindi l accorpamento non produrrà mai conflitti shift/reduce Conseguenze Tuttavia è possibile che l accorpamento provochi conflitti reduce/reduce Esempio: S S S aad bbd abe bae A c B c 51

52 Questa grammatica genera le quattro stringhe acd, ace, bcd, bce La grammatica è LR(1) Costruendo gli insiemi di candidate LR(1) si trova {[A c, d], [B c, e} le cui candidate sono valide per ac {[A c, e], [B c, d} le cui candidate sono valide per bc Nessun conflitto Esempio Proviamo ad accorpare gli stati e vediamo se la grammatica è LALR {[A c, d/e], [B c, d/e]} Conflitto reduce/reduce: sugli input d ed viene indicato di ridurre sia con A c che con B c Quindi la grammatica è LR(1), ma non è LALR 52

53 Costruzione tabella LALR Esistono due modi 1. Il primo è basato sulla costruzione preliminare delle candidate LR(1) e successivo accorpamento. È il metodo più semplice, ma anche il più costoso Il secondo, che non faremo, genera direttamente gli stati del parser LALR senza passare per gli stati del parser LR Algoritmo Input: una grammatica aumentata G Output: le funzioni action e goto della tabella di parsing LALR 1. Costruisci C={I 0,...,I n }, la collezione di insiemi di candidate LR(1) 2. Per ogni core degli insiemi di candidate LR(1) accorpa tutti gli insiemi con quel core nello stesso insieme 3. Sia C ={J 0,...,J m } la collezione risultante. I valori della tabella action per lo stato i sono costruiti a partire dall insieme J i utilizzando lo stesso algoritmo visto per la tabella LR canonica. Se ci sono conflitti allora la grammatica non è LALR(1) 4. La tabella goto è costruita come segue: Sia J l unione di uno o più insiemi di candidate LR(1): J = I 1 I 2... I k Allora i core di goto(i 1,X), goto(i 2,X),...,goto(I k,x) sono gli stessi, dato che I 1, I 2,...,I k hanno lo stesso core Sia K l unione di insiemi di candidate che hanno lo stesso core di goto(i 1,X) Allora goto(j,x)=k 53

54 Esempio Riprendiamo la grammatica per c*dc*d che abbiamo usato per illustrare la costruzione della tabella LR canonica Abbiamo visto sopra che si possono accorpare gli stati 4 e 7 Inoltre accorpiamo 3 e 6 E anche 8 e 9 I47 = C d, c/d/$ I36= C c C, c/d/$ C cc, c/d/$ C d, c/d/$ I89= C cc, c/d/$ Tabella LALR STATO action goto c d $ S C 0 s36 s acc 2 s36 s s36 s r3 r3 5 r1 89 r2 r2 54

55 Considerazioni Se presentiamo al parser LALR una stringa corretta (nel nostro esempio una stringa di c*dc*d) il parser LALR esegue esattamente le stesse mosse del parser LR canonico Se presentiamo una stringa che non appartiene al linguaggio i due parser hanno un comportamento differente, ma entrambi segnalano l errore Provare con l input ccd$ 55