20/11/2013 PARSER BOTTOM-UP EXAMPLE. V = {S, A, B, C} T = {a, b, d, e} P = { S aa. What means built the syntatic tree in a bottom-up fashion?

Transcript

1 PARSER BOTTOM-UP EXAMPLE V = {S, A, B, C} T = {a, b, d, e} P = { S aa A BaA A e B ac B AdC C b R6 R1 R2 R3 R4 R5 What means built the syntatic tree in a bottom-up fashion? 1

2 EXAMPLE aedbae aedbaa aedcaa aadcaa abaa aa S use R3 use R6 use R3 use R5 use R2 use R1 a S aa R1 A BaA R2 A e R3 B ac R4 B AdC R5 C b R6 S A B a A A d C e e b 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) 2

3 LR(K) PARSING BOTTOM UP Construct parse tree from leaves, reducing the string to the start symbol (and a single tree) During parse, we have a forest of trees Shift-reduce parsing Shift a new input symbol Reduce a group of symbols to a single non-terminal Choice is made using the k lookaheads LR(1) 5 EXAMPLE S a T R e T T b c b R d S a T R e Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e T b c d b LR parsing corresponds to the rightmost derivation in reverse. 6 3

4 SHIFT REDUCE PARSING S a T R e T T b c b R d Remaining input: abbcde Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 7 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Remaining input: bcde a b Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 8 4

5 SHIFT REDUCE PARSING S a T R e T T b c b R d Remaining input: bcde Shift a, Shift b Reduce T b T a b Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 9 SHIFT REDUCE PARSING S a T R e T T b c b R d Remaining input: de Shift a, Shift b Reduce T b Shift b, Shift c T a b b c Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 10 5

6 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Reduce T b Shift b, Shift c Reduce T T b c Remaining input: de T T a b b c Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 11 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Reduce T b Shift b, Shift c Reduce T T b c Shift d Remaining input: e a T b T b c d Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 12 6

7 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Reduce T b Shift b, Shift c Reduce T T b c Shift d Reduce R d Remaining input: e a T b T b c R d Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 13 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Reduce T b Shift b, Shift c Reduce T T b c Shift d Reduce R d Shift e Remaining input: a T b T b c R d e Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 14 7

8 SHIFT REDUCE PARSING S a T R e T T b c b R d Shift a, Shift b Reduce T b Shift b, Shift c Reduce T T b c Shift d Reduce R d Shift e Reduce S a T R e Remaining input: a T b T b S c R d e Rightmost derivation: S a T R e a T d e a T b c d e a b b c d e 15 SHIFT-REDUCE PARSING: LR(K) 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 8

9 PRO. & CONTRO LR parser is adequate for the syntax of programming language LR parser is the most general shift-reduce parser working without backtracking LR is more powerful than LL LR can detect a syntatic error as soon as possible LR parser is difficult to do by hand (unlike LL) USE OF PARSER GENERATOR Esempi di generatori di questo tipo sono Yacc o Bison Questi tools sono molto utili perché danno informazioni diagnostiche nel caso si presentino dei problemi sulla grammatica. Ad esempio, in caso di grammatica ambigua, il tool restituisce abbastanza informazioni per determinare dove è presente la situazione di ambiguità. 9

10 LESSON OUTLINE Introduction of LR algorithm Costruction of parsing table for K = 0 Costruction of parsing table for K = 1 1. Simple LR (abbreviato in SLR) 2. LR 3. lookahead LR (LALR) LR PARSER INPUT a 1... a i... a n $ STACK s m Parsing LR Output X m s m-1 X m-1... action goto s 0 10

11 EXAMPLE LR TABLE State a b c d e $ S T R 0 s1 1 s3 2 2 s5 s6 4 3 r3 r3 4 s7 5 s8 6 r4 7 acc 8 r2 r2 1: S a T R e 2: T T b c 3: T b 4: R d Action table Goto table s means shift to to some state r means reduce by some production 21 ALGORITHM: LR(1) push($,0); /* always pushing a symbol/state pair */ lookahead = nexttoken(); loop s = top(); /*always a state */ if action[s,lookahead] = shift s { s = goto[s,lookahead]; push(lookahead,s ); lookahead = nexttoken(); } else if action[s,lookahead] = reduce A b pop size of b pairs s = state on top of stack push(a,goto[s,a]); else if action[s,lookahead] = accept then return else error(); end loop; 22 11

12 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 23 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 $0,a1 b b c d e $ s

13 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 $0,a1 b b c d e $ s3 $0,a1,b3 b c d e $ r3 (T b) 25 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 $0,a1 b b c d e $ s3 $0,a1,b3 b c d e $ r3 (T b) $0,a1,T2 b c d e $ s5 $0,a1,T2,b5 c d e $ s8 $0,a1,T2,b5,c8 d e $ r2 (T T b c) goto(t,1)=

14 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 $0,a1 b b c d e $ s3 $0,a1,b3 b c d e $ r3 (T b) $0,a1,T2 b c d e $ s5 $0,a1,T2,b5 c d e $ s8 $0,a1,T2,b5,c8 d e $ r2 (T T b c) $0,a1,T2 d e $ s6 $0,a1,T2,d6 e $ r4 (R d) goto(t,1)=2 27 LR PARSING EXAMPLE 1 Stack Input Action $0 a b b c d e $ s1 $0,a1 b b c d e $ s3 $0,a1,b3 b c d e $ r3 (T b) $0,a1,T2 b c d e $ s5 $0,a1,T2,b5 c d e $ s8 $0,a1,T2,b5,c8 d e $ r2 (T T b c) $0,a1,T2 d e $ s6 $0,a1,T2,d6 e $ r4 (R d) $0,a1,T2,R4 e $ s7 $0,a1,T2,R4,e7 $ accept! goto(r,2)=

15 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 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 15

16 Una derivazione di un right sentential form è una produzione A b e una posizione in dove b 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 b dove {V T}*, b {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 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 16

17 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 $) AZIONI E GOTO Se action[s m, a i ] = reduce con A b allora la nuova configurazione diventa: dove: (s 0 X 1 s 1... X m-r s m-r A s, a i a i+1... a n $) r è la lunghezza di b (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 = b s = goto[s m-r, A] 17

18 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 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 18

19 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 19

20 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 20

21 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>

22 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 22

23 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 b 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 b 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 23

24 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 $ 24

25 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 25

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

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

28 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 28

29 ANALISI LR(0) Costruzione delle tabelle Goto e Action 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 il simbolo 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 29

30 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 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 30

31 CHIUSURA DI UNA CANDIDATA LR(0) E STATO DI PARSING SetCandidate chiusura (Candidata c) { Set.Create(); Set.add(C); for each (B A) in Set for each A nella grammatica Set.add(A ) 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. COSTRUZIONE TABELLA GOTO GOTO (I, X) { Detto J l insieme delle [A X b] tali che [A X b ] è in I return Chiusura (J) 31

32 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) } 32

33 ESEMPIO S E$ E E+T E T T id T (E) Tid id id E ( T SE $ 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 ( id $ 2 E 1 7 T T S S A R4 R3 9 4 S R5 R2 33

34 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 b 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 b 3. se action(s mi ) = accept il parser è completo 4. se action(s mi ) = error è segnalato un errore 34

35 ALGORITMO LR(0) push($,0); /* always pushing a symbol/state pair */ lookahead = nexttoken(); loop s = top(); /*always a state */ if action[s] = shift s { s = goto[s,lookahead]; push(lookahead,s ); lookahead = nexttoken(); } else if action[s,lookahead] = reduce A b pop size of b pairs s = state on top of stack push(a,goto[s,a]); else if action[s,lookahead] = accept then return else error(); end loop; 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 b look-aheads sono rappresentati da First(b ) per le candidate di riduzione A look-aheads sono rappresentati da Follow(A) 35

36 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 0 S 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 E T T T * P P P T 5 P ( 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 36

37 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) ) First ( ) ) Follow(T) = {+, *,)} ESEMPIO: AMBIGUITÀ SHIFT- REDUCE 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} 37

38 ESEMPIO 0 S' S$ S AS S b A SA A a b 2 S b 2 b S b A a a 3 S a S S' S 1 $ $ 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 5 S' S $ 6 A 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} 38

39 RISOLUZIONE DELL AMBIGUITÀ S6 6 A 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 39

40 EXAMPLE S a T R e T T b c b R d I 0 : S. a T R e Goto({S. a T R e },a) = I 1 I 1 : S a. T R e Goto({S a. T R e, T. T b c},t) T. T b c = I 2 a I0 T. b Goto({T. b },b) = I 3 I 2 : S a T. R e goto 4 T T. b c goto 5 R. d goto 6 I4 R T I2 b I5 d I1 b I3 I6 kernel of each item set is in blue EXAMPLE S a T R e T T b c b R d I 3 : T b. reduce I 4 : S a T R. e goto state 7 I 5 : T T b. c goto state 8 I 6 : R d. reduce I 7 : S a T R e. reduce I 8 : T T b c. reduce e I0 a I1 T I2 R b I4 c d I5 b I3 I6 80 I7 I8 40

41 EXAMPLE Grammar: S S, S A S b, A S A c I 0 : S. S S. A S S. b A. S A A. c I 1 : S S. A S. A A. S A A. c S. A S S. b 81 EXAMPLE Grammar: S S, S A S b, A S A c I 2 : S A. S S. A S S. b So far: I0 c b S A I1 c b A S I5 82 A. S A A. c I 3 : A c. I 4 : S b. I3 c I4 b I2 A S I6 I7 41

42 EXAMPLE Grammar: S S, S A S b, A S A c I 5 : S A. S I 6 : A S. A I 7 : S A S. A S A. A. S A A S. A S. A S A. c A. S A S. b S. A S A. c A. S A S. b S. A S A. c S. b 83 EXAMPLE Grammar: S S, S A S b, A S A c I 0 : S. S I 1 : S S. A S. A I 2 : S A. S I 3 : A c. I 4 : S b. I 5 : S A. S A S A. I 6 : A S. A I 7 : S A S. A S. A So far: I0 S A I1 c A c b b S I2 I3 I4 A b c S I5 A A A S I6 S S I7 I5 I7 also have connections to I3 and I

43 EXAMPLE 2 Grammar: S S, S A S b, A S A c 85 First Follow S cb $ S cb $cb A cb cb EXAMPLE 2 I 0 : S. S goto 1 S. A S goto 2 S. b goto 3 A. S A goto 1 A. c goto 4 I 1 : S S. reduce A S. A goto 5 A. S A goto 6 A. c goto 4 S. A S goto 5 S. b goto 3 State c b $ S A 0 s4 s s4 s3 acc

44 EXAMPLE 2 Grammar: S S, S A S b, A S A c I 2 : S A. S S. A S S. b So far: I0 c b S A c I1 b A S I5 87 A. S A A. A I 3 : S b. I 4 : A c. I4 c I3 b I2 A S I6 I7 CS 540 Spri ng 2009 GMU LR TABLE FOR EXAMPLE 2 State c b $ S A 0 s4 s s4 s3 acc s4 s r3 r3 r3 4 r5 r : S S 2: S A S 3: S b 4: A S A 5: A c 88 44

45 EXAMPLE 2 Grammar: S S, S A S b, A S A c I 5 : S A. S I 6 : A S. A I 7 : S A S. A S A. A. S A A S. A S. A S A. c A. S A S. b S. A S A. c A. S A S. b S. A S A. c S. b 89 LR TABLE FOR EXAMPLE 2 State c b $ S A 0 s4 s s4 s3 acc s4 s r3 r3 r3 4 r5 r5 5 s4/r4 s3/r s4 s s4/r2 s3/r2 r : S S 2: S A S 3: S b 4: A S A 5: A c 90 45

46 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 b può essere in cima alla pila ma b 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 look-aheads nelle configurazioni. I parser LR(1) usano una informazione look-ahead più precisa alla scopo di gestire una maggior quantità di linguaggi. 46

47 LR(1) PARSERS Un candidata LR(1) è una candidata LR(0) con informazioni look-ahead: [A b, a]. Il look-ahead non ha effetto sulla candidata di forma [A b, a], dove b, 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 b, a] in I, ogni produzione B, e ogni terminale b First(ba) tale che [B, b] non è in I) {add [B, b] ad I While sono possibili nuovi inserimenti return I 47

48 COSTRUZIONE TABELLA GOTO GOTO (I, X) procedure GOTO (I, X) { Detto J l insieme delle [A X b, a] tali che [A X b, 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 48

49 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 Bb, a], A = S', =, B = S, b =, a = $ aggiungere [B, b] B e b First(ba) cioè : S CC e First(ba) = First(a) = $: [S CC, $] 49

50 [S CC, $]. La chiusura di questa configurazione è [A Bb, a], A = S', =, B = S, b =, a = $ aggiungere [B, b] B e b First(ba) cioè : C cc e C d, con First(ba) = 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é b è. Quindi I 2 is [S C C, $] [C cc, $] [C d, $] 50

51 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, $] 51

52 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, $] 52

53 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 53

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

55 CALCOLO DI I 1 [S E, {$}] [E E + T, {$, +}] + I 6 [S E, {$}] [E E + T, {$, +}] CALCOLO DI I 2 [E T, {$, +}] [T T * P, {$, +,*}] * I 7 [E T, {$, +}] [T T * P, {$, +,*}] 55

56 CALCOLO DI I 3 [T P, {$, +,*}] [T P, {$, +,*}] CALCOLO DI I 4 [P id, {$, +,*}] [P id, {$, +,*}] 56

57 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 57

58 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 58

59 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, $]} 59

60 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 cccdcccd 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 Cd 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 è $ 60

61 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 Cd 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 = Cd, c/d/$ goto(i i,d)=i 47 per i=0,2,3,6 Le azioni dello stato 47 sono: riduci con Cd per ogni input 61

62 CONSEGUENZE Il parser così modificato si comporta quasi allo stesso modo di quello di partenza Potrebbe ridurre con Cd 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 Cd 62

63 IN GENERALE Ad esempio anche gli insiemi I 3 ed I 6 dell esempio precedente hanno lo stesso core {CcC, CcC, Cd} Anche I 8 ed I 9 hanno lo stesso core {CcC} 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) 63

64 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 [Bba, 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 [Bba, c] per qualche c 64

65 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 65

66 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 {[Ac, d/e], [B c, d/e]} Conflitto reduce/reduce: sugli input d ed viene indicato di ridurre sia con Ac che con Bc Quindi la grammatica è LR(1), ma non è LALR 66

67 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 67

68 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 cc, 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 68

69 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$ 69