Linguaggi context free. Analizzatori sintattici e alberi di analisi

Transcript

1 Linguaggi context free Analizzatori sintattici e alberi di analisi ( ) * id + id id

2 2 Grammatiche Context Free Una grammatica CF ha produzioni del tipo X α con X N e α (T N)* sono libere dal contesto perché la sostituzione di X è indipendente dal contesto in cui si trova. sempre possibile sostituire X con α βxγ βαγ G β,γ (T N)* permettono di definire linguaggi abbastanza espressivi come i linguaggi di programmazione, le espressioni aritmetiche e le espressioni regolari

3 3 Grammatiche CF espressioni artimetiche numero ( ) + * / T = { numero,(,),+,-,*,/} N = {} La grammatica definisce la struttura delle espressioni aritmetiche in modo ricorsivo Il simbolo terminale numero corrisponde ad un insieme di stringhe che si possono descrivere con una R A partire da simbolo si possono generare tutte le espressioni aritmetiche possibili

4 4 Grammatiche CF - esempio S ab A baa S ba B b A a B bs A as B abb T = {a,b} N = {S,A,B} In genere è complesso descrivere in modo compatto qual è il definito da una grammatica Nel caso dell esempio L(G) è il che in base alla scelta del simbolo di start * S w tale che w ha un ugual numero di a e b A * w tale che w ha un numero di a maggiore di 1 rispetto a quello di b * B w tale che w ha un numero di b maggiore di 1 rispetto a quello di a La dimostrazione si fa per induzione

5 5 Gramatiche CF esempio: dimostrazione Per w = 1 le uniche derivazioni possibili sono A * a e B * b Si suppone che le ipotesi siano vere per w =k-1 * S w può essere ottenuta da S ab dove ab = a w 1 con w 1 = k-1 e B w 1. Per ipotesi di induzione w 1 ha 1 b in più e quindi w ha lo stesso numero di a e b S ba dove ba = b w 1 con w 1 = k-1 e A w 1. Per ipotesi di induzione w 1 ha 1 a in più e quindi w ha lo stesso numero di a e b A w può essere ottenuta da A as dove as = a w 1 con w 1 = k-1 e S w 1. Per ipotesi di induzione w 1 ha lo stesso numero di a e b e quindi w ha 1 a in più A baa dove baa = b w 1 w 2 con w 1 < k-1 w 2 < k-1 e A w 1, A w 2. Per ipotesi di induzione w 1, w 2 hanno 1 a in più delle b e quindi in totale c è 1 a B w in più in w * si procede in modo analogo

6 6 Alberi di analisi (parse tree) La derivazione di ogni stringa appartenente ad un generato da una grammatica CF si può rappresentare con un albero id ( ) + * / * ( ) + id id id (id+id)*id

7 7 Parse tree - definizione I nodi dell albero di analisi sono etichettati dai simboli terminali o non terminali I simboli terminali si trovano nelle foglie I simboli non terminali si trovano nei nodi interni La radice corrisponde al simbolo non terminale di start Ogni nodo interno corrisponde esattamente ad una produzione Il nodo padre è il simbolo non terminale che viene espanso I nodi figli corrispondono ai simboli terminali e non terminali nella parte destra della produzione. I figli sono ordinati nello stesso modo dei rispettivi simboli nella stringa della produzione La struttura di analisi è un albero per il fatto che le produzioni hanno la struttura N α propria delle grammatiche CF La stringa analizzata è leggibile con una visita anticipata dell albero che considera solo i simboli terminali

8 8 Parse tree e derivazioni Un albero sintattico può essere visto come una rappresentazione di una serie di derivazioni α 1 α 2. α n dove α 1 = A N Per ciascuna stringa α i la derivazione che produce α i+1 corrisponde all applicazione di una produzione e quindi all espansione di un sottoalbero in corrispondenza di un simbolo non terminale in α i A tree X j β β=y 1 Y 2 Y r A tree α k-1 X 1 X 2 X j X k X 1 X 2 X j X k produzione usata per derivare α k α k Y 1 Y 2 Y r

9 9 Parse tree - esempio L albero di analisi risultante mostra quali sono le produzioni applicate per ottenere la derivazione α 1 * α n ma non l ordine con cui sono state applicate * () * ( + ) * (id + ) * (id + )* id (id + id)*id * * * * * * ( ) ( ) ( ) ( ) id ( ) id id id id id

10 10 Grammatiche ambigue Una grammatica è ambigua se è possibile costruire più di un albero sintattico per descrivere la derivazione di una stessa stringa appartenente al generazione di ()()() B ( B ) B B B B B B ( B ) ( B B B ( B ) B ) B ( B ) B B B ( B ) ( B B ) B ( B ) B B B ( B ) B ( B ) B ( B ) B grammatica ambigua grammatica non ambigua

11 11 Grammatiche ambigue problemi In genere è complesso provare se una grammatica è ambigua L ambiguità può portare problemi in alcuni casi quando l albero sintattico è usato per interpretare sematicamente la stringa id ( ) + * * id + * id + id * id + id * id id+id*id * + * id + * id + id * id + id * id

12 12 Grammatiche ambigue espressioni 1 + * id * + id OK id id id id KO La grammatica non modella la precedenza degli operatori aritmetici Se si usasse l albero a destra per valutare l espressione il valore non sarebbe corretto (si effettua prima la somma) Il problema può essere risolto con una modellazione più precisa ovvero definendo una grammatica che considera gli operatori in modo diverso Si introducono più categorie sintattiche per raggruppare le singole parti dell espressione nel modo corretto

13 13 Grammatiche ambigue espressioni 2 Si introducono tre categorie sintattiche F fattore: è un singolo operando o espressione fra () T termine: è un prodotto/quoziente di fattori espressioni: è la somma/sottrazione di termini + T T T T T * F T / F F F ( ) id L uso di produzioni del tipo + T impone che i termini siano raggruppati da sinistra a destra (es (1+2)+3 )

14 14 Grammatiche ambigue - espressioni id+id*id derivazione con sostituzione a sinistra + T T + T F + T id + T id + T * F id + F * F id + id * F id + id * id + T T T T T * F T / F F T + T T * F F ( ) id F F id id id OK

15 15 Ambiguità if then else <stmt> if <expr> then <stmt> <stmt> if <expr> then <stmt> else <stmt> <stmt> instruction. La grammatica è ambigua perché if 1 then if 2 then S 1 else S 2 ha due alberi di analisi validi <stmt> <stmt> if <expr> then <stmt> if <expr> then <stmt> else <stmt> 1 if <expr> then <stmt> else <stmt> 1 if <expr> then <stmt> S 2 2 S 1 S 2 2 S 1

16 16 Ambiguità if.. then.. else non ambiguo L ambiguità deriva dal fatto che la grammatica non permette una chiara associazione fra else e gli if presenti La regola normalmente usata è che l else si riferisca all if più vicino <stmt> <stmt_c> <stmt_u> <stmt_c> if <expr> then <stmt_c> else <stmt_c> <stmt_c> instruction. <stmt_u> if <expr> then <stmt> <stmt_u> if <expr> then <stmt_c> else <stmt_u> fra then-else possono solo trovarsi espressioni if-then-else complete <stmt> <stmt_u> if <expr> then <stmt> 1 <stmt_u> if <expr> then <stmt_c> else <stmt_u> 2 S 1 S 2

17 17 Produzioni equivalenti Si possono riscrivere alcune produzioni in modo da ottenere una grammatica * equivalente (che genera lo stesso ) ma in cui le produzioni rispettano tutte alcune strutture liminazione della ricorsione a sinistra Una grammatica è ricorsiva a sinistra se esiste un simbolo non terminale + A per il quale esiste una derivazione A Aα dove α (T N)* Produzione semplice A A α A β A β A A α A genera le stringhe A β α n

18 18 Ricorsione a sinistra La ricorsione a sinistra nelle produzioni si può eliminare semplicemente anche nel caso più generale A A α 1 Aα 2 Aα m A β 1 β 2 β n A β 1 A β 2 A. β n A A α 1 A α 2 A. α m A Per eliminare la ricorsione a sinistra che riguarda derivazioni a uno o più passi esiste comunque un algoritmo L eliminazione della ricorsione a sinistra semplifica la realizzazione di parser che analizzano la stringa da sinistra a destra La ricorsione a destra realizza un espansione delle stringhe verso destra

19 19 Ricorsione a sinistra - esempio Si elimina la ricorsione a sinistra per la grammatica delle espressioni aritmetiche + T T T T * F F F () id α = +T β = T α = *F β = F T + T T FT T * FT F () id

20 20 Fattorizzazione a sinistra La fattorizzazione a sinistra è una trasformazione delle produzioni che genera una grammatica equivalente A α β 1 α β 2 α β n A α A A β 1 β 2 β n Nelle produzioni si assume che β 1, β 2,,β n non abbiano un prefisso in comune Nell ottica di un analisi della stringa da sinistra a destra la fattorizzazione permette una prima decisione con l espansione di α rimandando la scelta di quale espandere fra β 1, β 2,,β n al passo successivo

21 21 Analisi discendente (top-down) L analisi discendente è un algoritmo che mira a costruire l albero di analisi a partire dalla radice, creando i nodi in ordine anticipato L analisi discendente ricorsiva In genere necessità di backtracking quando ci sono più opzioni nella scelta della produzione da applicare, si prova con la prima e si tentano quelle seguenti in caso di fallimento La grammatica definisce un insieme di funzioni mutuamente ricorsive ciascuna delle quali corrisponde ad una delle categorie sintattiche (simboli non terminali) La chiamata di una delle funzioni corrisponde all applicazione di una produzione (espansione del simobolo non terminale) La funzione per il simbolo di start S legge una sequenza di ingresso e produce il puntatore all albero di analisi generato (nullo se la stringa in ingresso non appartiene al e si genera un errore di analisi)

22 22 Analisi top-down - esempio S cad S() A ab a A() w = cad c S() S A d A() c backtracking S A d c S() S A d A() c S A d cad a cad Una grammatica ricorsiva a sinistra può generare un numero infinito di espansioni in un parser top-down ricorsivo (si espande all infinito lo stesso simbolo) b cad a cad

23 23 Analisi top-down procedura di analisi 1 Si tiene traccia del prossimo simbolo della stringa di ingresso che deve essere generato nell albero di analisi Si restringe il numero di produzioni che possono essere applicate per espandere un simbolo non terminale Si espandono i nodi da sinistra a destra un simbolo terminale soddisfa l obiettivo se coincide col prossimo simbolo della sequenza di ingresso un simbolo non terminale soddisfa l obiettivo se lo soddisfa la chiamata alla funzione ricorsiva corrispondente Stringa in ingresso x 1 x 2..x n $ Cursore di ingresso (simbolo di previsione)

24 24 Analisi top-down procedura di analisi 2 Quando si espande una produzione (si chiama la funzione ricorsiva corrispondente) e si genera un simbolo terminale si verifica se corrisponde a quello puntato dal cursore in ingresso Sì si sposta il cursore in avanti e si procede nell analisi No si fallisce e si prova a soddisfare l obiettivo precedente con una nuova ipotesi (backtracking) Se l espansione introduce un simbolo non terminale T si chiama la funzione ricorsiva corrispondente che crea il sottoalbero di analisi che ha T come radice

25 25 Analisi top-down - esempio B ( B ) B Node *B(int *lh, char *s) { } Node *b1,*b2; if(s[*lh]== ( ) { (*lh)++; b1 = B(lh,s); if((s[*lh]== ) )&&(b1!=null)){ (*lh)++; b2 = B(lh,s); if(b2==null) { freetree(b1); return(null); } else } else { } } else return tree4( B,tree0( ( ),b1,tree0( ) ),b2); freetree(b1); return NULL; return tree1( B,tree0( e )); B cursore di ingresso stringa da analizzare B ( ) b 1 b 2

26 26 Analizzatori predittivi Si elimina la ricorsione a sinistra Si fattorizzano a sinistra le produzioni Per alcune grammatiche si può costruire un parser predittivo che non effettua il backtracking durante l analisi Il simbolo terminale di previsione permette sempre di selezionare una sola produzione da applicare a A A α 1 α 2. α n simbolo in ingresso non terminale da espandere produzioni per A

27 27 Analisi predittiva Per riconoscere quale pruduzione si applica si possono usare diagrammi a stati che rappresentano le sequenze nel lato destro delle produzioni Le transizioni fra gli stati possono avvenire in corrispondenza di un simbolo terminale (si legge l input) o non terminale (si chiama la procedura corrispondente) T + T T FT T * FT F () id 0 T T F 8 T 9 T * F T ( ) 17 id T F

28 28 Analisi guidata da tabella Si utilizza esplicitamente uno stack invece delle chiamate ricorsive a + b $ stringa da analizzare simboli della grammatica T N X Y Z $ stack albero sintattico Tabella di analisi Tabella bidimensionale M[A,s] non terminale terminale o $

29 29 Analisi con tabella - funzionamento Lo stack inzialmente contiene il simbolo S Il controllo determina l azione da eseguire in base al simbolo in testa allo stack (X) e al simbolo terminale in ingresso (a) Se X=a=$ il parser termina con successo Se X=a $ il parser estrae X dallo stack e avanza il cursore di ingresso di una posizione (match del simbolo di previsione) X è un simbolo non terminale si controlla M[X,a] Se corrisponde a una produzione si fa il push nello stack degli elementi della stringa a destra X UVW push(w); push(v); push(u) Altrimenti si genera un errore di analisi Se X a e X è un simbolo terminale, allora si genera un errore di analisi

30 30 Analisi con tabella - esempio T + T T FT T * FT F () id id + * ( ) $ T T +T T FT FT T *FT F id () stack input output $ $ T $ T F $ T id $ T $ $ T+ $ T $ T F $ T id $ T $ T F* $ T F $ T id $ T $ $ id+id*id$ id+id*id$ id+id*id$ id+id*id$ +id*id$ +id*id$ +id*id$ id*id$ id*id$ id*id$ *id$ *id$ id$ id$ $ $ $ T T FT F id T +T T FT F id T *FT F id T

31 31 Analisi con tabella costruzione 1 Si considerano due funzioni FIRST(α) è l insieme dei simboli terminali che inziano le stringhe generate a partire da α (T N)* FOLLOW(A) è l insieme dei simboli terminali che possono apparire subito alla destra del simbolo A N in una stringa derivata da S (esiste una derivazione S αaaβ con a T) Calcolo di FIRST(x) x T N se x T allora FIRST(x) = {x} se x N ed esiste la produzione x allora FIRST(x) se x N ed esiste la produzione x Y 1 Y 2 Y k a FIRST(x) se a FIRST(Y i ) e FIRST(Y j ) j=1,..,i-1 (Y 1 Y i-1 ) FIRST(x) se FIRST(Y j ) j=1,..,k In pratica si aggiungono a FIRST(x) gli elementi di FIRST(Y i ) fino a che non si incontra un Y i per il quale FIRST(Y i )

32 32 Analisi con tabella costruzione 2 Calcolo di FIRST(α) α (T N)* con α = Y 1 Y 2 Y k F = FIRST(Y 1 ) for(i=1; i<k && FIRST(Y i );i++) F = F FIRST(Y i+1 ) Calcolo di FOLLOW(A) $ FOLLOW(S) Se esiste la produzione B αaβ tutti i simboli in FIRST(β) eccetto sono in FOLLOW(A) Se esiste una produzione B αa o B αaβ e FIRST(β) contiene allora tutto ciò che è in FOLLOW(A) è anche in FOLLOW(B)

33 33 Analisi con Tabella esempio FIRST/FOLLOW T + T T FT T * FT F () id FIRST() = {(,id} FIRST(T) = {(,id} FIRST(F) = {(,id} FIRST( ) = {+,} FIRST(T ) = {*,} FOLLOW() = {),$} FOLLOW(T) = {),+,$} FOLLOW(F) = {),*,+,$} FOLLOW( ) = {),$} FOLLOW(T ) = {),+,$}

34 34 Analisi con tabella costruzione Gli elementi della tabella di analisi sono definiti da Se esiste la produzione A α allora per ogni simbolo a in FIRST(α) M[A,a] = {A α} Infatti se si è nello stato A e si legge a si dve espandere la produzione A in α perché garantisce che venga generato il simbolo a Se FIRST(α) allora M[A,b] = {A α} per ogni simbolo b in FOLLOW(A) Tiene conto del fatto che se α allora il simbolo a deve essere generato da qualche produzione in cui A compare seguito da un altra espressione che può generare a

35 35 Analisi con tabella grammatiche ambigue Il procedimento per la costruzione della tabella d analisi può portare a generare elementi della matrice M che contengono più alternative S i t S S a S es b grammatica per if-then-else FIRST(S) = {i,a} FIRST(S ) = {e, } FIRST() = {b} FOLLOW(S) = {e,$} FOLLOW(S ) = {e,$} FOLLOW() = {t} a b e i t $ S a itss S es b

36 36 Grammatiche LL(1) Una grammatica che non ha definizioni multiple nella tabella di analisi discendente si dice LL(1) Left-to-right nella scansione dell ingresso Leftmost si espande sempre il simbolo più a sinistra 1 si usa un simbolo di previsione Non tutte le grammatiche CF sono LL(1) Si deve eliminare la ricorsione a sinistra Si deve fattorizzare a sinistra Non è comunque detto di ottenere una grammatica LL(1)

37 37 Analisi ascendente (bottom-up) L albero di analisi viene costruito a partire dalle foglie verso la radice Si riduce una stringa di ingresso al simbolo non terminale di scopo S Ad ogn passo una sottostringa che corrisponde al lato destro di una produzione è rimpiazzata col simbolo terminale a sinistra si genera il corrispondente nodo dell albero di analisi collegando i nodi figli al padre S aabe A Abc b B d abbcde aabcde aade aabe S sottostringhe a cui si può applicare A b B d

38 38 Analisi bottom-up scelta delle riduzioni S aabe A Abc b B d S aabe aade aabcde abbcde Nell esempio le riduzioni sono sempre scelte tenendo conto di una derivazione della stringa in cui si sostituisce sempre il non terminale più a destra l approccio bottom-up riduce da sinistra a destra Come si sceglie la sottostringa da ridurre? Si può prendere la più a sinistra che fa il match con il lato destro di una produzione Non è detto che si riesca ad arrivare ad S (occorre il backtracking)

39 39 Analisi bottom-up scelta delle riduzioni Nell esempio la scelta di ridurre al primo passo la sottostringa più a sinistra ha permesso di completare l analisi Non è in genere detto che questo accada. Se si sceglie in modo sbagliato si arriva ad un risultato intermedio in cui non esistono sottostringhe che fanno match con almeno un lato destro di una produzione S aabe A Abc b B d abbcde aabcde se al secondo passo si sceglie A b aaacde aaacbe non è più riducibile.

40 40 Sottostringhe handle Una sottostringa handle corrisponde al lato destro di una produzione A β si può rimpiazzare con A nella stringa di partenza γ ottenendo un passo della derivazione destra di γ da S S * rm αaw αβw (w contiene solo simboli terminali perché la derivazione è destra - right most) Se la grammatica è ambigua la stessa sottostringa può appartenere a più di un handle S α β A handle w ridurre β in A corrisponde ad eliminare tutti i figli di A dall albero

41 41 Riduzione La procedura di riduzione mira a sostituire progressivamente sottostringhe handle con il corrispondente simbolo non terminale Si parte dalla stringa di soli simboli terminali da analizzare S = γ 0 γ 1 γ 2.. γ n-1 γ n = w rm rm rm rm rm Si sotituisce l handle β n in γ n utilizzando la produzione A n β n in modo tale che γ n-1 = α n-1 Aw n-1 Si ripete il processo fino ad ottenere S Questa procedura ha due problemi correlati da risolvere Come determinare la sottostringa da ridurre Come scegliere la produzione corretta per la riduzione

42 42 Analizzatore bottom-up con stack Si utilizza uno stack per i risultati intermedi (frontiera dell albero) il parser inserisce simboli nello stack a partire dalla stringa in ingresso w fino a che non viene individuato un handle β in cima allo stack Il parser riduce l handle β al simbolo non terminale A corrispondente L analisi si ferma con successo quando lo stack contiene solo il simbolo S e la stringa in ingresso è vuota Le azioni che il parser può eseguire sono SPOSTA (shift) il prossimo simbolo di w è inserito nello stack RIDUCI (reduce) viene riconosciuta una stringa handle in testa allo stack e si rimpiazza col simbolo non terminale corrispondente ACCTTA fine con successo dell analisi RROR l analizzatore genera un errore di sintassi

43 43 Analisi bottom-up - esempio id stack input output ( ) + * id+id*id $ $id $ $+ $+id $+ $+* $+*id $+* $+ $ id+id*i$ +id*id$ +id*id$ id*id$ *id$ *id$ id$ $ $ $ $ SHIFT RDUC id SHIFT SHIFT RDUC id SHIFT (*) SHIFT RDUC id RDUC * RDUC + ACCPT La grammatica è ambigua ed esiste un altra riduzione possibile siste un conflitto SHIFT/RDUC in (*) che è stato risolto con SHIFT Si poteva anche applicare RDUC +

44 44 Analizzatori bottom-up - conflitti Il parsing ascendente con stack senza backtracking non può essere applicato a tutte le grammatiche CF Noto il contenuto dello stack e il prossimo simbolo in ingresso C è un conflitto SHIFT/RDUC Non si riesce a decidere quale riduzione fare in un insieme di riduzioni possibili Le azioni del parser ascendente con stack si possono determinare in modo univoco solo se la grammatica ha date proprietà Analizzatori con operatori a precedenza Corrispondono a grammatiche molto particolari (grammatiche ad operatori) in cui non esistono produzioni del tipo A e per qualsiasi produzione A β in β non esistono due simboli non terminali adiacenti (esiste sempre un operatore in mezzo). s. espressioni aritmetiche. Analizzatori LR (Left-to-right Right-most-derivation)

45 45 Analizzatori LR(k)

46 46 Analizzatori LR(k) - struttura ToS a a 1 a i.. a n $ stringa da analizzare stato - simbolo S m X m S m-1 albero sintattico X m AZION $ stack GOTO Tabelle di analisi AZION[S,a] GOTO[S,A]

47 47 Analizzatori LR schema di funzionamento 1 Nello stack è memorizzata una stringa di coppie simbolo-stato S 0 X 1 S 1 X 2 S 2.X m S m Ciascun stato riassume l informazione contenuta nello stack al di sotto di esso ai fini del riconoscimento degli handle L azione del parser è determinata dallo stato in testa allo stack e dal simbolo corrente (Tos,a) Nell implementazione i simboli del X i (T N) non sono strettamente necessari (lo stato già memorizza l elaborazione della loro sequenza) La configurazione del parser è data dal contenuto dello stack e dalla parte di ingresso ancora da espandere S 0 X 1 S 1 X 2 S 2.X m S m a i a i+1..a n $

48 48 Analizzatori LR schema di funzionamento 2 La configurazione rappresenta una stringa derivata con sostituzione a destra X 1 X 2.X m a i a i+1..a n $ da espandere già espanso Il controllo dell analizzatore LR termina l azione da compiere in base allo stato S m in testa allo stack e al simbolo corrente a i 1. AZION[S m,a i ]=SHIFT S (PUSH a i, PUSH S) La nuova configurazione è S 0 X 1 S 1 X 2 S 2.X m S m a i S a i+1..a n $ ToS a

49 49 Analizzatori LR schema di funzionamento 3 2. AZION[S m,a i ]=RDUC A β Si opera una riduzione che corrisponde alla nuova configurazione S 0 X 1 S 1 X 2 S 2.X m-r S m-r AS a i..a n $ dove S = GOTO[S m-r,a] e r= β β=x m-r+1.x m 3. AZION[S m,a i ]=ACCPT L analisi è completata con successo 4. AZION[S m,a i ]=RROR Si è rilevato un errore e si chiama la procedura di gestione degli errori ToS a

50 50 Analisi LR un esempio 1 AZION GOTO 1 +T 2 T 3 T T*F 4 T F 5 F () 6 F id s# = shift #nuovo stato r# = reduce #produzione stato id + * ( ) $ T F s5 s5 s5 s5 s6 r2 r4 r6 s6 r1 r3 r5 s7 r4 r6 s7 r3 r5 s4 s4 s4 s4 r2 r4 r6 s11 r1 r3 r5 Ac r2 r4 r6 r1 r3 r

51 51 Analisi LR un esempio 2 stack input AZION riduzione GOTO 0 0 id 5 0 F 3 0 T 2 0 T 2 * 7 0 T 2 * 7 id 5 0 T 2 * 7 F 10 0 T id F T id*id+id$ *id+id$ *id+id$ *id+id$ id+id$ +id$ +id$ +id$ +id$ id$ $ $ $ $ SHIFT 5 RDUC 6 RDUC 4 SHIFT 7 SHIFT 5 RDUC 6 RDUC 3 RDUC 2 SHIFT 6 SHIFT 5 RDUC 6 RDUC 4 RDUC 1 ACCPT F id T F F id T T*F T F id T F +T G[0,F]=3 G[0,T]=2 G[7,F]=10 G[0,T]=2 G[0,]=1 G[6,F]=3 G[6,T]=9 G[0,]=1

52 52 Grammatiche LR - definizione Una grammatica LR è una grammatica per la quale si riescono a costruire le tabelle AZION e GOTO per un analizzatore LR sistono grammatiche CF che non sono LR Una grammatica è LR se il parser SHIFT/RDUC riesce a riconoscere le sottostringhe handle quando compaiono in testa allo stack (per fare questo basta lo stato) Per riconoscere un handle sullo stack si può usare un automa a stati finiti che analizza i simboli contenuti nello stack e dice quale è l handle in testa Questo meccanismo è implementato nella tabella GOTO Lo stato nella testa dello stack è lo stato di questo automa riconoscitore dopo aver elaborato la stringa di simboli dalla base alla testa dello stack

53 53 Grammatiche LR - proprietà Le grammatiche LR(k) sono più generali di quelle LL(k) Le grammatiche LR(k) richiedono di riconoscere, con k simboli di previsione, il lato destro di una produzione (l handle) A β dopo aver visto tutto quello che è derivato da β Le grammatiche LL(k) richiedono di riconoscere una produzione in base ai primi k simboli di ciò che si può derivare dalla sua parte destra Come si costruiscono le tabelle di analisi? Si considera un caso semplice, quello delle Simple LR (SLR) che non copre tutte le grammatiche LR

54 54 Grammatiche SLR Un elemento LR(0) di una grammatica G è una produzione annotata con un punto ( ) che individua una posizione nel lato destro #i A xyz A xyz (i,0) A x yz (i,1) A xy z (i,2) A xyz (i,3) Un elemento è individuato dalla coppia di indici (#produzione,posizione) Un elemento tiene traccia di quanta parte del lato destro di una produzione è stata vista fino ad un certo punto dell analisi La costruzione delle tabelle di analisi parte dalla costruzione di un automa a stati finiti che riconosce i prefissi associabili alle produzioni in una derivazione destra

55 55 Grammatiche SLR elementi Gli elementi definiti a partire da ciascuna produzione possono essere visti come stati di un automa a stati finiti A α xβ x A αx β si accetta l input x per avanzare di un passo nel riconoscimento di αxβ A α Bβ B γ soddisfare B significa applicare ogni sua espansione Si introduce un nuovo simbolo di partenza S e la produzione S S (è la riduzione che determina l accettazione della stringa) Si costruisce l automa che riconosce i lati destri delle produzioni

56 56 Grammatiche SLR esempio 1 +T + +T + T +T T T T 4-5 T T*F F 6-7 F () id T T 3 T 5 T F F T F T T*F T T T *F * T T* F F F id F () id ( 6 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

57 57 Grammatiche SLR esempio 2 eliminazione delle -transizioni 1 I 0 ={[ ],[ T], [ +T],[T F], [T T*F],[F id], [F ()]} +T T T 3 T 5 +T + T +T T F F T F T T*F T T T *F * T T* F F + F id F () T id ( 6 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

58 58 Grammatiche SLR esempio 3 I 0 ={[ ],[ T], [ +T],[T F], [T T*F],[F id], [F ()]} F T F I 3 ={[T F ]} +T I 1 I 1 ={[ +T],[ ]} dagli stati in I 1,I 2, I 3, I 5 non ci sono -transizioni I 0 T T I 2 id T T *F I 2 ={[ T ],[T T *F]} I 5 ( I 3 F id I 4 I 5 ={[F id ]} I 4 va determinato con eliminazione di -transizioni

59 59 Grammatiche SLR esempio 4 eliminazione delle -transizioni per lo stato F ( ) 1 I 4 ={[F ( )],[ +T], [ T],[T F], [T T*F],[F id], [F ()]} +T T T 3 T 5 +T + T +T T F F T F T T*F T T T *F * T T* F F + F id F () T id ( 6 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

60 60 Grammatiche SLR esempio 5 transizioni da +T + +T + T +T T I 1 ={[ +T],[ ]} 1 La transizione con + definisce I 6 ={ [ + T],[T F], [T T*F],[F id], [F ()]} T T T T F F T F T T*F T T T *F * T T* F F T T*F F id F () id ( 6 F id F ( ) F ( ) ) 2 7 F ()

61 61 Grammatiche SLR esempio 6 transizioni da I 6 ={ [ + T],[T F], [T T*F],[F id], [F ()]} 1 La transizione con T definisce I 9 ={ [ +T ],[T T *F]} +T T T 3 T 5 I 3 +T + T +T T F F T F T T*F T T T *F * T T* F F + F id F () T id ( 6 I 5 I 4 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

62 62 Grammatiche SLR esempio 7 transizioni da +T + +T + T +T T I 2 ={[ T ],[T T *F]} 1 La transizione con * definisce I 7 ={ [T T* F],[F id], [F ()]} T T 3 T 5 T F F T F T T*F T T T *F * T T* F F F id F () id ( 6 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

63 63 Grammatiche SLR esempio 8 La transizione con definisce +T I 8 + +T + T +T T I 8 ={ [ +T],[F ( )]} 1 transizioni da I 4 ={[F ( )],[ +T], [ T],[T F], [T T*F],[F id], [F ()]} T T 3 T I I 3 T F F T F T T*F T T T *F * T T* F F T T*F F id F () 6 id ( I 8 I 5 I 4 F id F ( ) F ( ) ) 2 7 F ()

64 64 Grammatiche SLR esempio 9 transizioni da +T + +T + T +T T I 7 ={ [T T* F],[F id], [F ()]} 1 La transizione con F definisce I 10 ={ [T T*F ]} T T 3 T 5 I 10 4 T F F T F T T*F T T T *F * T T* F F T T*F F id F () id ( 6 I 5 I 4 F id F ( ) F ( ) ) 2 7 F ()

65 65 Grammatiche SLR esempio 10 transizioni da +T + +T + T +T T I 8 ={ [ +T],[F ( )]} 1 La transizione con ) definisce I 11 ={ [F () ]} T T 3 T 5 T F F T F T T*F T T T *F * T T* F F I 6 F id F () 6 id ( I 11 F id F ( ) F ( ) ) 2 7 F () 4 T T*F

66 66 Grammatiche SRL esempio 11 I 0 ={[ ],[ T],[ +T],[T F],[T T*F],[F id],[f ()]} I 1 ={[ +T],[ ]} I 2 ={[ T ],[T T *F]} I 3 ={[T F ]} I 4 ={[F ( )],[ +T],[ T],[T F],[T T*F],[F id],[f ()]} I 5 ={[F id ]} I 6 ={ [ + T],[T F],[T T*F],[F id],[f ()]} I 7 ={ [T T* F],[F id],[f ()]} I 8 ={ [ +T],[F ( )]} I 9 ={ [ +T ],[T T *F]} I 10 ={ [T T*F ]} I 11 ={ [F () ]}

67 67 Grammatiche SRL esempio 12 stato id + * ( ) T F Tabella di transizione di stato

68 68 Tabelle di analisi costruzione AZION A partire dall automa deterministico che riconosce i prefissi dei lati destri delle produzioni è possibile ottenere le tabelle di analisi AZION e GOTO Gli stati dell automa C={I 0,I 1,,I n } corrispondono agli stati 0,1,..n usati dall analizzatore Le azioni per lo stato i sono definite come segue Se [A α aγ] I i e nell automa esiste la transizione I i I j per ingresso a T allora AZION[i,a]=SHIFT j (si passa nel nuovo stato dell automa e non è ancora completato il match con il lato destro di una produzione) Se [A α ] I i allora AZION[i,a]=RDUC A α per ogni simbolo a in FOLLOW(A) Se [S S ] I i allora AZION[i,$]=ACCPT

69 69 Tabelle di analisi costruzione GOTO La tabella GOTO è costruita considerando per ogni stato le transizioni per simboli non terminali Se esiste la transizione I i I j per ingresso A N allora GOTO[i,A]=j Lo stato iniziale è quello contenente [S S] Le componenti non definite corrispondono ad errori Le tabelle costruite con questo algoritmo si dicono SLR(1) Una grammatica che ammette un parser SLR(1) si dice SLR(1)

70 70 Tabelle di analisi - esempio I 0 ={[ ], [ T], [ +T], [T F], [T T*F], [F id], [F ()]} I 0 T F ( id I 1 I 2 I 3 I 4 I 5 AZION[0,id] = SHIFT 4 AZION[0,(] = SHIFT 5 GOTO[0,] = 1 GOTO[0,T] = 2 GOTO[0,F] = 3 I 1 ={[ +T],[ ]} + I 1 I 6 AZION[1,$] = ACCPT AZION[1,+] = SHIFT 6 I 2 ={[ T ],[T T *F]} * I 2 I 7 FOLLOW()={$,+,)} AZION[2,*] = SHIFT 7 AZION[2,$] = RDUC T AZION[2,)] = RDUC T AZION[2,+] = RDUC T

71 71 Grammatiche non SLR(1) La costruzione delle tabelle per un analizzatore SLR(1) fallisce quando c è un conflitto nella definizione di una componente Per linguaggi più generali di SLR(1) si possono costruire Tabelle canoniche LR Tabelle LALR (LookAhead LR) I problemi nascono quando ci sono più riduzioni possibili e si deve evitare di applicare riduzioni errate che richiederebbero il backtracking Una soluzione è usare uno stato più informativo che memorizza esplicitamente i simboli che possono seguire un handle α per cui è ammessa la riduzione A α

72 72 Grammatiche LR Si definiscono gli elementi LR(1) come coppie [A α β,a] L elemento di lookahead a ha effetto solo per gli elementi della forma [A α,a] dove si prevede la riduzione solo se il prossimo simbolo è a Infatti non è detto che la riduzione sia applicabile per tutti gli elementi in FOLLOW(A) come ipotizzato nella costruzione delle tabelle SLR Un analizzatore canonico LR ha molti più stati degli analizzatori SLR e LALR I generatori automatici di parser sintattici generano analizzatori LALR