1 Implementazione di Linguaggi 2 PARTE 4 Implementazione di Linguaggi 2 PARTE 4 Massimo Ancona DISI Università di Genova Testo: A.V. Aho, R. Sethi, J.D.Ullman.

Presentazione sul tema: "1 Implementazione di Linguaggi 2 PARTE 4 Implementazione di Linguaggi 2 PARTE 4 Massimo Ancona DISI Università di Genova Testo: A.V. Aho, R. Sethi, J.D.Ullman."— Transcript della presentazione:

1 1 Implementazione di Linguaggi 2 PARTE 4 Implementazione di Linguaggi 2 PARTE 4 Massimo Ancona DISI Università di Genova Testo: A.V. Aho, R. Sethi, J.D.Ullman Compilers Principles,Techniques and Tools, Addison Wesley

2 2 PARSER LR PARSER LR

3 3 Algoritmo di Parsing LR Il parser usa uno stack su cui impila stringhe della forma: s 0 X 1 s 1 X 2 s 2 …X m s m s m sul top s 0 X 1 s 1 X 2 s 2 …X m s m con s m sul top dove X i N mentre s i rappresenta uno stato del parser. Il parser e di tipo shift-reduce e il suo comportamento e deciso dallinput corrente a i e dall top dello stack s m. Le tavole del parser sono formate da due funzioni dette action function f e goto function g. Il parser consulta [s m,a i ] che puo valere: shift shift reduce by Areduce by A acceptaccept errorerror

4 4 Algoritmo di Parsing LR La funzione goto g mappa stati e simboli grammaticali in stati g: S V S ed e la funzione di transizione di un DFA che accetta prefissi accessibili (PrAc) della grammatica G. Un PrAc di una grammatica G e un prefisso di una forma sentenziale canonica destra (FSCD) che puo comparire sul top dello stack. Piu formalmente un PrAc di G e una stringa tale che: S * rm Aw rm w e PREF( ) (*) S * rm Aw rm w e PREF( ) (*) Una maniglia/chiave (handle) di una FSCD di G e una coppia formata da una produzione e una posizione nella FSCD. Nell esempio (*) (A, ) o (A,n) dove n=| +1|. Lo handle esprime che la stringa

5 5 Algoritmo di Parsing LR Canonico alla posizione specificata dallo handle puo essere sostituita da A per ottenere la FSCD precedente in una derivazione canonica destra. alla posizione specificata dallo handle puo essere sostituita da A per ottenere la FSCD precedente in una derivazione canonica destra. Il DFA ha come stato iniziale quello impilato dal parser allinizio. Una configurazione del parser e una coppia formata da: il contenuto dello stackil contenuto dello stack linput non ancora lettolinput non ancora letto (s 0 X 1 s 1 X 2 s 3 …X m s m,a j a j+1 …a n ) La mossa corrente del parser e determinata da a j, da s m e dal valore di f[s m,a j ] (action[s m,a j ]) come segue:

6 6 Algoritmo di Parsing LR Canonico Se f[s m,a j ]=shift allora il parser esegue uno shift e passa alla configurazioneSe f[s m,a j ]=shift allora il parser esegue uno shift e passa alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m s m a j s,a j+1 …a n ) (s 0 X 1 s 1 X 2 s 3 …X m s m a j s,a j+1 …a n ) dove s=g[s m,a j ]. dove s=g[s m,a j ]. se f[s m,a j ]=reduce A allora il parser esegue una azione reduce passando alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m-r s m-r As,a j a j+1 …a n ) dove s=g[s m-r,A] ed r=| |. Cioe il parser spila 2r simboli dallo stack fino ad esporre sul top s m-r ; quindi impila A seguito da s=g[s m-r,A].se f[s m,a j ]=reduce A allora il parser esegue una azione reduce passando alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m-r s m-r As,a j a j+1 …a n ) dove s=g[s m-r,A] ed r=| |. Cioe il parser spila 2r simboli dallo stack fino ad esporre sul top s m-r ; quindi impila A seguito da s=g[s m-r,A]. Se f[s m,a j ]=accept allora il parser termina lanalisi con successo.Se f[s m,a j ]=accept allora il parser termina lanalisi con successo. Se f[s m,a j ]=error allora attiva una routine di errore.Se f[s m,a j ]=error allora attiva una routine di errore.

7 7 Struttura delle tavole di Parsing LR Si consideri lesempio (1) E E+T, (2) E T,(3) T T*F (4) T F, (5) F (E), (6) F id. La prima slide mostra le tavole canoniche. Il loro difetto e di avere la tavola f sparsa e spreca-spazio. Per questo la slide successiva sposta la parte delle azioni goto sui terminali nella tavola f. Ad esempio se f[s,a]=shift e g[s,a]=n allora f[s,a] diviene action[s,a]=shift n, mentre la funzione g(a) scompare restando solo g(A). Di conseguenza il parser va ridescritto come segue (le nuove funzioni f e g vengono chiamate action e goto):

8 8 Algoritmo di Parsing LR libro Se action[s m,a j ]=shift s allora il parser esegue uno shift e passa alla configurazioneSe action[s m,a j ]=shift s allora il parser esegue uno shift e passa alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m s m a j s,a j+1 …a n ) (s 0 X 1 s 1 X 2 s 3 …X m s m a j s,a j+1 …a n ) se action[s m,a j ]=reduce A allora il parser esegue una azione reduce passando alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m-r s m-r As,a j a j+1 …a n ), s=goto[s m-r,A] e r=| |. Cioe il parser spila 2r simboli dallo stack fino ad esporre sul top s m-r ; quindi impila A seguito da s=goto[s m-r,A].se action[s m,a j ]=reduce A allora il parser esegue una azione reduce passando alla configurazione (s 0 X 1 s 1 X 2 s 3 …X m-r s m-r As,a j a j+1 …a n ), s=goto[s m-r,A] e r=| |. Cioe il parser spila 2r simboli dallo stack fino ad esporre sul top s m-r ; quindi impila A seguito da s=goto[s m-r,A]. Se action[s m,a j ]=accept allora il parser termina lanalisi con successo.Se action[s m,a j ]=accept allora il parser termina lanalisi con successo. Se action[s m,a j ]=error allora attiva una routine di errore.Se action[s m,a j ]=error allora attiva una routine di errore.

9 9 Algoritmo di Parsing LR Driver Routine PROC ParserLR; DO /* s TOS state, a next input and ip pointer to it */ IF action[s,a]=shift s THEN push a; push s; ip++ ELSIF action[s,a]=reduce A THEN pop 2| | symbols; /* s becomes TOS */ push A; push goto[s,A]; out A push A; push goto[s,A]; out A ELSIF action[s,a]=accept THEN RETURN ELSE Error() FIODEND.

10 10 Esempio di Parsing LR Step stack input action output 1 0 id*id+id$shift 1 0 id*id+id$shift 2 0id5 *id+id$reduce F id F id 2 0id5 *id+id$reduce F id F id 3 0F3 *id+id$reduce T F T F 3 0F3 *id+id$reduce T F T F 4 0T2 *id+id$shift 4 0T2 *id+id$shift 5 0T2*7 id+id$shift 5 0T2*7 id+id$shift 6 0T2*7id5 +id$reduce F id F id 6 0T2*7id5 +id$reduce F id F id 7 0T2*7F10 +id$reduce T T*F T T*F 7 0T2*7F10 +id$reduce T T*F T T*F 8 0T2 +id$reduce E T E T 8 0T2 +id$reduce E T E T 9 0E1 +id$shift 9 0E1 +id$shift 10 0E1+6 id$shift 11 0E1+6id5 $reduce F id F id

11 11 Esempio di Parsing LR cont. Step stack input action output 12 0E1+6F3 $reduce T F T F 13 0E1 +6E9 $ reduce E E+T E E+T 14 0E1 $ accept Da un punto di vista pratico sono state usate le grammatiche LR(0) ed LR(1) ed alcune sottoclassi di queste uktime: SLR(1) e LALR(1) benche le potenzialita dei processori di oggi permetta di prendere in considerazione le LR(1) ed anche le LR(k) con k>1 senza grossi problemi.

12 12 Tavole di Parsing Canoniche Tavole di Parsing Canoniche 0 1 2 3 4 5 6 7 8 9 10 11 Stato id + * ( ) $ E T F id + * ( ) $ ss s s ss ss s s ss s A 222 4 444 111 3333 5555 6666 1 2 3 823 39 10 5 4 6 7 5 54 4 4 611 7 5

13 13 Tavole di Parsing del Libro Tavole di Parsing del Libro 0 1 2 3 4 5 6 7 8 9 10 11 Stato id + * ( ) $ E T F s5s4 s6 s7 s5s4 s5s4 s5 s4 s6s 11 s7s7 A 222 4 444 111 3333 5555 6666 1 2 3 823 39 10

14 14 Costruzione dell Tavole di Parsing LR Per questo vedremo in dettaglio le tavole LR(0), SLR(1) ed LR(1) trattando le LALR(1) marginalmente solo come meccanismo di semplificazione delle tavole LR. Item LR(0). Un item LR(0) e una produzione con un dot che ne marca una posizione nella parte destra. La produzione A XYZ origina quattro item: A.XYZ A X.YZ A XY.Z A XYZ.; A.XYZ A X.YZ A XY.Z A XYZ.; Mentre A genera il solo item A.. Lidea centrale alla base del metodo consiste nel costruire dalla grammatica un automa finito che riconosca i PrAc della grammatica G. Alla base dei metodi piu semplici (SLR LALR) vi e la Collezione Canonica di Stati LR(0) (CCS0).

15 15 Tavole LR(0): funzione closure Definizione. Data G=(N,T,P,S) definiamo grammatica estesa G=(N S,T,P S S,S) dove S N e un nuovo simbolo iniziale. Scopo: determinare esattamente la terminazione del parser. Definizione. Chiusura di un insieme di item I. Inizialmente Closure(I)=I.Inizialmente Closure(I)=I. Se A.B Closure(I) e B alllora aggiungere B. a closure(I).Se A.B Closure(I) e B alllora aggiungere B. a closure(I). Il significato intuitivo di Closure e il seguente: se A.B Closure(I) allora durante il parsing e possibile che si analizzi una sottostringa derivata da B. Se inoltre B allora e anche possibile analizzare una sottostringa derivabile da.

16 16 Tavole LR(0): chiusura Esempio di chiusura. Data la grammatica estesa G (0)E E; (1)E E+T; (2)E T; (3)T T*F; (4)T F; (5)F (E); (6)F id. Calcolo della chiusura di un insieme di item I. Se inizialmente I={E.E}Se inizialmente I={E.E} Allora Closure(I)={E.E, E.E+T, E.T, T.T*F, T.F, F.(E), F.id}.Allora Closure(I)={E.E, E.E+T, E.T, T.T*F, T.F, F.(E), F.id}.

17 17 Tavole LR(0): routine di chiusura FUNC Closure(I: ItemSet); VAR J:ItemSet; BEGINJ:=I;DO FOR each item A.B J & each B FOR each item A.B J & each B DO J:=J {B. } OD UNTIL J unchanged; RETURN J END.

18 18 Tavole LR(0): kernel item e item validi Definizione: Un kernel item e: S.SS.S Un item con il dot che non precede la parte destra della produzioneUn item con il dot che non precede la parte destra della produzione Definizione Valid item. Un item A 1. 2 e valido per per un PrAc 1 se esiste una derivazione Definizione Valid item. Un item A 1. 2 e valido per per un PrAc 1 se esiste una derivazione S rm * Aw rm * 1 2 w Sapere che un item A 1. 2 e valido per un PrAc permette di decidere tra unazione shift e reduce quando e al top dello stack. In particolare se A 1 e lo handle e lazione sara reduce. E chiaro che due item validi diversi possono suggerire due azioni contrastant per lo stesso PrAc. Sapere che un item A 1. 2 e valido per un PrAc 1 permette di decidere tra unazione shift e reduce quando 1 e al top dello stack. In particolare se 2 allora lo handle non si trova ancora sullo stack e lazione e shift. Se invece 2 = allora A 1 e lo handle e lazione sara reduce. E chiaro che due item validi diversi possono suggerire due azioni contrastant per lo stesso PrAc.

19 19 Tavole LR(0): funzione closure Definizione. Data G=(N,T,P,S) definiamo grammatica estesa G=(N S,T,P S S,S) dove S N e un nuovo simbolo iniziale. Scopo: determinare esattamente la terminazione del parser. Definizione. Chiusura di un insieme di item I. Inizialmente Closure(I)=I.Inizialmente Closure(I)=I. Se A.B Closure(I) e B alllora aggiungere B. a closure(I).Se A.B Closure(I) e B alllora aggiungere B. a closure(I). Il significato intuitivo di Closure e il seguente: se A.B Closure(I) allora durante il parsing e possibile che si analizzi una sottostringa derivata da B. Se inoltre B allora e anche possibile analizzare una sottostringa derivabile da.

20 20 Tavole LR(0): funzione goto Definizione. Funzione goto(I,X) definita su insiemi di item e simboli grammaticali: goto(I,X)=Closure({ A X. | A.X I} Intuitivamente se I e linsieme degli item validi per un PrAc allora goto(I,X) e linsieme degli item validi per il PrAc X. Esempio: goto({E E.,E E.+T},+)=Closure({E E+.T})= {E E+.T, T.T*F, T.F, F.(E), F.id} {E E+.T, T.T*F, T.F, F.(E), F.id}

21 21 Tavole LR(0): funzione goto cont. Per ogni G la funzione goto definisce un DFA che riconosce PrAc di G. Il DFA e costruibile tramite un NFA che usa gli insiemi di item come stati e transizioni da A.X a A X. etichettate X e da A.B a B. etichettate. Ne segue che Closure(I) coincide con la -closure di un insiemi di stati di un NFA come visto a suo tempo. La funzione goto(I,X) realizza la transizione da da I tramite linput X nel DFA ottenuto dal NFA tramite la costruzione basata sui sottoinsiemi di stati gia vista. Per ogni G la funzione goto definisce un DFA che riconosce PrAc di G. Il DFA e costruibile tramite un NFA che usa gli insiemi di item come stati e transizioni da A.X a A X. etichettate X e da A.B a B. etichettate. Ne segue che Closure(I) coincide con la -closure di un insiemi di stati di un NFA come visto a suo tempo. La funzione goto(I,X) realizza la transizione da da I tramite linput X nel DFA ottenuto dal NFA tramite la costruzione basata sui sottoinsiemi di stati gia vista.

22 22 Insiemi di item canonici LR(0) Algoritmo: Costruzione della Collezione Canonica degli item LR(0) per una grammatica (augmented) G. PROC Items(G); BEGIN C=Closure({s.s}); DO FOR ( I) I C & ( X) X V: goto(I,X) FOR ( I) I C & ( X) X V: goto(I,X) DO C:=C goto(I,X) C:=C goto(I,X) UNTIL C unchanged END;

23 23 Insiemi di item canonici LR(0) di G G: (0)E E;(1)E E+T;(2)E T;(3)T T*F;(4)T F; (5)F (E); (6)F id. I 0 : E.E I 3 : T F. T.F I 11 : F (E). E.E+T I 4 : F (.E) F.(E) goto(I 0,E)=I 1 E.E+T I 4 : F (.E) F.(E) goto(I 0,E)=I 1 E.T E.E+T F.id goto(I 0,T)=I 2 E.T E.E+T F.id goto(I 0,T)=I 2 T.T*F E.T I 7 : T T*.F goto(I 0,F)=I 3 T.T*F E.T I 7 : T T*.F goto(I 0,F)=I 3 T.F T.T*F F.(E) goto(I 0,()=I 4 T.F T.T*F F.(E) goto(I 0,()=I 4 F.(E) T.F F.id goto(I 0,id)=I 5 F.(E) T.F F.id goto(I 0,id)=I 5 F.id F.(E) I 8 : F (E.) goto(I 1,+)=I 6 F.id F.(E) I 8 : F (E.) goto(I 1,+)=I 6 I 1 : E E. F.id E E.+T goto(I 2,*)=I 7 E E.+T I 5 : F id. I 9 : E E+T. goto(I 4,+)=I 8 E E.+T I 5 : F id. I 9 : E E+T. goto(I 4,+)=I 8 I 2 : E T. I 6 : E E+.T T T.*F goto(I 4,T)=I 2 T T.*F T.T*F I 10 : T T*F. goto(I 4,F)=I 3 T T.*F T.T*F I 10 : T T*F. goto(I 4,F)=I 3

24 24 Insiemi di item canonici LR(0) di G G: (0)E E;(1)E E+T;(2)E T;(3)T T*F;(4)T F; (5)F (E); (6)F id. I 0 : E.E I 3 : T F. T.F I 11 : F (E). E.E+T I 4 : F (.E) F.(E) goto(I 4,()=I 4 E.E+T I 4 : F (.E) F.(E) goto(I 4,()=I 4 E.T E.E+T F.id goto(I 4,id)=I 5 E.T E.E+T F.id goto(I 4,id)=I 5 T.T*F E.T I 7 : T T*.F goto(I 6,T)=I 9 T.T*F E.T I 7 : T T*.F goto(I 6,T)=I 9 T.F T.T*F F.(E) goto(I 6,F)=I 3 T.F T.T*F F.(E) goto(I 6,F)=I 3 F.(E) T.F F.id goto(I 6,()=I 4 F.(E) T.F F.id goto(I 6,()=I 4 F.id F.(E) I 8 : F (E.) goto(I 6,id)=I 5 F.id F.(E) I 8 : F (E.) goto(I 6,id)=I 5 I 1 : E E. F.id E E.+T goto(I 7,F)=I 10 E E.+T I 5 : F id. I 9 : E E+T. goto(I 7,()=I 4 E E.+T I 5 : F id. I 9 : E E+T. goto(I 7,()=I 4 I 2 : E T. I 6 : E E+.T T T.*F goto(I 7,id)=I 5 T T.*F T.T*F I 10 : T T*F. goto(I 8,))=I 11 T T.*F T.T*F I 10 : T T*F. goto(I 8,))=I 11

25 25 Insiemi di item canonici LR(0) di G G: (0)E E;(1)E E+T;(2)E T;(3)T T*F;(4)T F; (5)F (E); (6)F id. I 0 : E.E I 3 : T F. T.F I 11 : F (E). E.E+T I 4 : F (.E) F.(E) goto(I 8,+)=I 46 E.E+T I 4 : F (.E) F.(E) goto(I 8,+)=I 46 E.T E.E+T F.id goto(I 9,*)=I 7 E.T E.E+T F.id goto(I 9,*)=I 7 T.T*F E.T I 7 : T T*.F T.T*F E.T I 7 : T T*.F T.F T.T*F F.(E) T.F T.T*F F.(E) F.(E) T.F F.id F.(E) T.F F.id F.id F.(E) I 8 : F (E.) F.id F.(E) I 8 : F (E.) I 1 : E E. F.id E E.+T E E.+T I 5 : F id. I 9 : E E+T. E E.+T I 5 : F id. I 9 : E E+T. I 2 : E T. I 6 : E E+.T T T.*F T T.*F T.T*F I 10 : T T*F. T T.*F T.T*F I 10 : T T*F.

26 26 Diagrammi LR(0) esempio Diagrammi LR(0) esempio

27 27 Tavole di parsing S LR(1) Si costruisce a partire dalla collezione C di insiemi di item LR(0) di G calcolando action e goto come segue: 1.Costruire C={I 0,I 1,…I n } Collezione di insiemi di item LR(0) di G 2.La tavola (stato) i deriva da I i con azioni: a)A.a I i & goto(I,a)=I j action[i,a]=shift j b)A. I i a FOLlOW(A) &A S action[i,a]=reduce A b)A. I i a FOLlOW(A) &A S action[i,a]=reduce A c)S S I i action[I,$]=accept Se le regole precedenti generano azioni in conflitto allora G non e SLR(1).

28 28 Tavole di parsing SLR(1) 3. A N goto[I i,A]=I j goto(i,A)=j 4.Ogni entry non definita in 1. 2. 3. e posta a error 5.Lo stato iniziale del parser e costruito da I 0 ={S.S,…} Una grammatica che possieda una tavola di parsing SLR(1) e detta SLR(1). Ogni grammatica SLR(1) e non ambigua. Esistono grammatiche non ambigue che non sono SLR(1), Es: S L=R S R L *R L id R L

29 29 Tavole di Parsing Tavole di Parsing 0 1 2 3 4 5 6 7 8 9 10 11 Stato id + * ( ) $ E T F id + * ( ) $ ss s s ss ss s s ss s A 222 4 444 111 3333 5555 6666 1 2 3 823 39 10

30 30 Item LR(1) Un item LR(1) e una coppia [A.,a] con a T {$} e A. Il secondo componente di un item e chiamato stringa di lookahead. Essa non si usa quando β. Se invece β= la stringa di lookahead a specifica una riduzione A solo quando il token in input è a. Definizione. Un item LR(1) [A.,a] è valido per un PrAc a se esiste una derivazione canonica destra, con = e w=aw o w= & a=$. Definizione. Un item LR(1) [A.,a] è valido per un PrAc a se esiste una derivazione canonica destra S rm * Aw rm * w, con = e w=aw o w= & a=$. In relazione alle grammatiche SLR(1) va notato che l insieme di stringhe di lookahead a che formano gli item LR(1) [A.,a] validi per un prefisso verifica FOLLOW(A) ma in generale FOLLOW(a)

31 31 Tavole LR(1): funzione closure Definizione. Chiusura di un insieme di item I per una G estesa: Inizialmente Closure(I)=I.Inizialmente Closure(I)=I. Se [A.B,a] Closure(I) e B alllora aggiungere [B.,b] a closure(I) per ogni b FIRST( a)Se [A.B,a] Closure(I) e B alllora aggiungere [B.,b] a closure(I) per ogni b FIRST( a) Il significato intuitivo di Closure e il seguente: se A.B Closure(I) allora durante il parsing e possibile che si analizzi una sottostringa derivata da B. Se inoltre B allora e anche possibile analizzare una sottostringa derivabile da per tutti gli input b tali che b FIRST( a)

32 32 Tavole LR(1): routine di chiusura FUNC Closure(I: ItemSet); VAR J:ItemSet; BEGINJ:=I;DO FOR each item [A.B,a] J & each B & each b FIRST( a) DO J:=J {[B.,b]} OD UNTIL J unchanged; RETURN J END.

33 33 Tavole LR(1): funzione goto Definizione. Funzione goto(I,X) definita su insiemi di item e simboli grammaticali: goto(I,X)=Closure({ [A X.,a]| [A.X,a] I} Ancora se I e linsieme degli item validi per un PrAc allora goto(I,X) e linsieme degli item validi per il PrAc X.

34 34 Insiemi di item canonici LR(1) Algoritmo: Costruzione della Collezione Canonica degli item LR(1) per una grammatica (augmented) G. PROC Items(G); BEGIN C=Closure({[s.s,$]}); DO FOR each I C & each X V such that goto(I,X) FOR each I C & each X V such that goto(I,X) DO C:=C goto(I,X) /* INCL(C,goto(I,X)) */ UNTIL C unchanged END;

35 35 Insiemi di item canonici LR(1) di G 2 Insiemi di item canonici LR(1) di G 2 G 2 : (0)S S;(1)S CC;(2)C cC;(3)C d; I 0 : [S.S,$] I 3 : [C c.C,c] [C.d,$] goto(I 2,d)=I 7 [S.CC,$] [C c.C,d] I 7 : [C d.,$] goto(I 3,C)=I 8 [S.CC,$] [C c.C,d] I 7 : [C d.,$] goto(I 3,C)=I 8 [C.cC,c] [C.cC,c] I 8 : [C cC.,c] goto(I 3,c)=I 8 [C.cC,c] [C.cC,c] I 8 : [C cC.,c] goto(I 3,c)=I 8 [C.cC,d] [C.cC,d] [C cC.,d] goto(I 3,d)=I 4 [C.cC,d] [C.cC,d] [C cC.,d] goto(I 3,d)=I 4 [C.d,c] [C.d,c] I 9 : [C c.,$] goto(I 6,C)=I 9 [C.d,c] [C.d,c] I 9 : [C c.,$] goto(I 6,C)=I 9 [C.d,d] [C.d,d] goto(I 0,S)=I 1 goto(I 6,c)=I 6 [C.d,d] [C.d,d] goto(I 0,S)=I 1 goto(I 6,c)=I 6 I 1 : [S S.,$] I 4 : [C d.,c] goto(I 0,C)=I 2 goto(I 6,d)=I 7 I 2 : [S C.C,$] [C d.,d] goto(I 0,c)=I 3 [C.cC,$] I 5 : [S CC.,$] goto(I 0,d)=I 4 [C.cC,$] I 5 : [S CC.,$] goto(I 0,d)=I 4 [C.d,$] I 6 : [C c.C,$] goto(I 2,C)=I 5 [C.d,$] I 6 : [C c.C,$] goto(I 2,C)=I 5 [C.cC,$] goto(I 2,c)=I 6 [C.cC,$] goto(I 2,c)=I 6

36 36 Insiemi di item canonici LR(0) di G 2 Insiemi di item canonici LR(0) di G 2 G 2 : (0)S S;(1)S CC;(2)C cC;(3)C d; I 0 : [S.S] I 4 : [C d.] goto(I 0,S)=I 1 goto(I 3,c)=I 3 [S.CC] I 5 : [C CC.] goto(I 0,C)=I 2 goto(I 3,d)=I 4 [S.CC] I 5 : [C CC.] goto(I 0,C)=I 2 goto(I 3,d)=I 4 [C.cC] I 6 : [C cC.] goto(I 0,c)=I 3 [C.cC] I 6 : [C cC.] goto(I 0,c)=I 3 [C.d] goto(I 0,S)=I 1 goto(I 0,d)=I 4 [C.d] goto(I 0,S)=I 1 goto(I 0,d)=I 4 I 1 : [S S.] goto(I 0,C)=I 2 I 2 : [S C.C] goto(I 0,c)=I 3 [C.cC] goto(I 0,d)=I 4 [C.cC] goto(I 0,d)=I 4 [C.d] goto(I 2,C)=I 5 [C.d] goto(I 2,C)=I 5 I 3 : [C c.C] goto(I 2,c)=I 3 [C.cC] goto(I 2,d)=I 4 [C.cC] goto(I 2,d)=I 4 [C.d] goto(I 3,C)=I 6 [C.d] goto(I 3,C)=I 6

37 37 Insiemi di item canonici LR(0) di G 2 Insiemi di item canonici LR(0) di G 2 G 2 : (0)S S;(1)S CC;(2)C cC;(3)C d; I 0 : [S.S] I 4 : [C d.] goto(I 3,c)=I 3 I 0 : [S.S] I 4 : [C d.] goto(I 3,c)=I 3 [S.CC] I 5 : [C CC.] goto(I 3,d)=I 4 [S.CC] I 5 : [C CC.] goto(I 3,d)=I 4 [C.cC] I 6 : [C cC.] [C.cC] I 6 : [C cC.] [C.d] goto(I 0,S)=I 1 [C.d] goto(I 0,S)=I 1 I 1 : [S S.] goto(I 0,C)=I 2 I 1 : [S S.] goto(I 0,C)=I 2 I 2 : [S C.C] goto(I 0,c)=I 3 I 2 : [S C.C] goto(I 0,c)=I 3 [C.cC] goto(I 0,d)=I 4 [C.cC] goto(I 0,d)=I 4 [C.d] goto(I 2,C)=I 5 [C.d] goto(I 2,C)=I 5 I 3 : [C c.C] goto(I 2,c)=I 3 I 3 : [C c.C] goto(I 2,c)=I 3 [C.cC] goto(I 2,d)=I 4 [C.cC] goto(I 2,d)=I 4 [C.d] goto(I 3,C)=I 6 [C.d] goto(I 3,C)=I 6

38 38 Insiemi di Item LR(1): diagramma Insiemi di Item LR(1): diagramma

39 39 Costruzione delle Tavole LR(1) Input: una grammatica estesa G. Output: tavole canoniche LR(1) di G. 1.Costruire C={I 0,I 1,...,I n } CCII LR(1) 2.La tavola i deriva da I i con action seguente: a)se [A.a,b] I i e goto(I i,a)=I j allora action[i,a]=shift j b)se [A.,a] I i e AS allora action[i,a]=reduce A b)se [A.,a] I i e AS allora action[i,a]=reduce A c)se [S S,$] I i allora action[i,$]= accept 3.Se goto(I i,A)=I j allora goto[i,$]=j 4.Porre tutte le entry non definite in 1),2) e 3) a error 5.Lo stato iniziale del parser è quello contenente [S.S,$] Se le tavole non presentano conflitti shift-reduce o reduce-reduce allora la grammatica G è LR(1).

40 40 Grammatiche LR definizione non algoritmica Definizione: una grammatica G e LR(k) se detta G la versione estesa di G, allora G e LR(k), k 0 se le tre condizioni seguenti: 1.S * rmG Aw rmG w 2.S * rmG Bx rmG y 3.FIRST k (w)=FIRST k ( ) Implicano che Ay= Bx ( cioè = A=B x=y)

41 41 Tavole di Parsing LR(1) esempio Tavole di Parsing LR(1) esempio 0 1 2 3 4 5 6 7 8 9 Stato c d $ S C s3s41 2 A s6s75 8 r3 r1 s3 s4 s6s79 r3 r2 G2: (0)S S;(1)S CC;(2)C cC;(3)C d;

42 42 Tavole di Parsing LR(1) esempio Tavole di Parsing LR(1) esempio 0 1 2 3 4 5 6 7 8 9 Stato c d $ S C s3s41 2 A s6s75 8 r3 r1 s3 s4 s6s79 r3 r2 G2: (0)S S;(1)S CC;(2)C cC;(3)C d; goto (I 0,c)=I 3 goto(I 0,d)=I 4 goto(I 0,S)=I 1 goto(I 0,C)=I 2 goto(I 2,c)=I 6 goto(I 2,d)=I 7 goto(I 2,C)=I 5 goto(I 3,c)=I 3 goto(I 3,d)=I 4 goto(I 3,C)=I 8 goto(I 6,c)=I 6 goto(I 6,d)=I 7 goto(I 6,C)=I 9

43 43 Tavole di Parsing LR(0) esempio Tavole di Parsing LR(0) esempio 0 1 2 3 4 5 6 7 8 9 Stato act c d $ S C s 4 1 A s6s75 8 r3 r1 s3 s4 s6s79 r3 r2 G2: (0)S S;(1)S CC;(2)C cC;(3)C d; G2: (0)S S;(1)S CC;(2)C cC;(3)C d; goto (I 0,c)=I 3 goto(I 0,d)=I 4 goto(I 0,S)=I 1 goto(I 0,C)=I 2 goto(I 2,c)=I 6 goto(I 2,d)=I 7 goto(I 2,C)=I 5 goto(I 3,c)=I 3 goto(I 3,d)=I 4 goto(I 3,C)=I 8 goto(I 6,c)=I 6 goto(I 6,d)=I 7 goto(I 6,C)=I 9 32

44 44 Costruzione delle Tavole LA LR(1) Definiamo core(I)={[A. ] | [A.,u] I} Poichè il core di goto(I,X) dipende dal core di I, ne segue che goto( H I i )= H goto(I i ). Quindi i goto di stati immersi sono a loro volta tra loro immergibili. Le tavole ottenute in questo modo, come ottimizzazione della collezione di stati canonici LR(1) sono tuttavia anche ottenibili a partire dalla collezione canonica di stati LR(0). Questo ne fa un algoritmo molto efficiente.

45 45 Costruzione delle Tavole LA LR(1) Se nella collezione canonica di insiemi di item LR(1) di G 2 uniamo gli stati I 4 e I 7 in un nuovo stato I 47 con 3 item [C d.,c/d/$] allora il parser ha azione reduce_C d su ogni input, anche su quelli su cui loriginale dichiara error (es. ccd cdcdc). La primo token in input errato. Lottimizzazione consiste nell immergere gli stati con lo stesso core, cioè stati che differiscono solo per il token di lookahead (idem per I 3 -I 6 e I 8 -I 9 ).

46 46 Corrispondenti Item LALR(1) Corrispondenti Item LALR(1)

47 47 Corrispondenti Item LALR(1) Corrispondenti Item LALR(1)

48 48 Corrispondenti Item LR(0) Corrispondenti Item LR(0)

49 49 Insieme LALR(1) e LR(0) Insieme LALR(1) e LR(0)

50 50 Tavole di Parsing LR(1) esempio Tavole di Parsing LR(1) esempio 0 1 2 3 4 5 6 7 8 9 Stato c d $ S C s3s41 2 A s6s75 8 r3 r1 s3 s4 s6s79 r3 r2 G2: (0)S S;(1)S CC;(2)C cC;(3)C d; goto (I 0,c)=I 3 goto(I 0,d)=I 4 goto(I 0,S)=I 1 goto(I 0,C)=I 2 goto(I 2,c)=I 6 goto(I 2,d)=I 7 goto(I 2,C)=I 5 goto(I 3,c)=I 3 goto(I 3,d)=I 4 goto(I 3,C)=I 8 goto(I 6,c)=I 6 goto(I 6,d)=I 7 goto(I 6,C)=I 9

51 51 Grammatiche LL ed LR Teorema (decidibilita): date due grammatiche LL(k), G 1 e G 2, il problema L(G 1 )=L(G 2 ) e decidibile. La seguente grammatica: S A|B, A aAb|0, B aBbb|1 e LR(0) ma non LL(k) per ogni k 0. Teorema. Ogni grammatica LL(k) e anche LR(k), k 0. Definizione. Um linguaggio CFG e deterministico se esite un DPDA (Deterministic PushDown Automaton) che lo accetta.

52 52 Linguaggi LL ed LR Definizione. Un linguaggio L tale che nessuna w L e della forma w=xy con x L e detto avere la proprieta del prefisso (prefix-free). Teorema. L linguaggio deterministico: G LR(1): L=L(G). L linguaggio deterministico: G LR(1): L=L(G). Se inoltre L e prefix-free allora: G LR(0): L=L(G). Altrimenti detto L T* CFG deterministico e G LR(0): L Altrimenti detto L T* CFG deterministico e T G LR(0): L =L(G).

53 53 Linguaggi LL ed LR cont. Teorema. Dato un linguaggio L per cui esiste una grammatica G, LL(k) e priva di -produzioni, tale che L=L(G) e k>1, allora esiste una grammatica G, LL(k-1) tale che L=L(G). Teorema. Per ogni k 0 la classe dei linguaggi LL(k) e propriamente inclusa in quella dei linguaggi LL(k+1).

54 54 Rapporto tra grammatiche LL, LR,... Rapporto tra grammatiche LL, LR,...

55 55 Rapporto tra linguaggi LL, LR,... Rapporto tra linguaggi LL, LR,...

56 56 FINE LR FINE LR Le slide che seguono devono essere ignorate. Sono solo un pattern per future modifiche

57 57 Corrispondenti Item LALR(1) Corrispondenti Item LALR(1)

58 58 Seminari su grammatiche e linguaggi LL, LR,... Seminari su grammatiche e linguaggi LL, LR,... 1.Linguaggi e grammatiche LL, LR e deterministici. 2.Teoremi di inclusione tra tali linguaggi, eventuali controesempi 3.PDA non deterministici e non: linguaggi relativi.

59 59 Seminari su rapporti tra XML e scanner, parser, grammatiche e linguaggi Seminari su rapporti tra XML e scanner, parser, grammatiche e linguaggi 1.Confronto tra XML BNF EBNF come strumenti per descrivere linguaggi e grammatiche. Aspetti teorici associati per la costruzione automatica di parser. 2.Uso di XML e strumenti associati come standard di scambio dati tra parser scanner compiler ecc. 3.Problemi di parsing di documenti XML e strumenti associati applicazioni e teoria.

60 60 Tavole di Parsing LR(1) esempio Tavole di Parsing LR(1) esempio 0 1 2 3 4 5 6 7 8 9 10 11 Stato id + * ( ) $ E T F id + * ( ) $

61 61 Tavole di Parsing LR(1): esempio Tavole di Parsing LR(1): esempio stato 0 1 2