Automi e Linguaggi Formali - math.unipd.itsperduti/AUTOMI14/bottom-up_1.pdf · Automi e Linguaggi Formali Parsing Bottom-up A.A. 2014-2015 Alessandro Sperduti [email protected]

Automi e Linguaggi Formali

Parsing Bottom-up

A.A. 2014-2015

Alessandro Sperduti

[email protected]

Idea del parsing bottom-up

Costruisce l’albero sintattico iniziando dallefoglie e salendo verso la radice

Esempio

E ! T + E |TT ! int ⇤ T |int|(E )

Consideriamo la stringa int ⇤ int + int

Automi e Linguaggi Formali – A.A 2014-2015

Docente: Alessandro Sperduti

2 of 55

Idea del parsing bottom-up

Esempio

Il parsing bottom-up riduce una stringa al simboloiniziale invertendo le produzioni:

stringa produzione

int ⇤ int + int T ! int

int ⇤ T + int T ! int ⇤ TT + int T ! int

T + T E ! T

T + E E ! T + E

EAutomi e Linguaggi Formali – A.A 2014-2015


3 of 55

Osservazione

Leggiamo le produzioni in ordine inverso (dalbasso verso l’alto rispetto all’albero di parsing)

E’ una derivazione da destra (letta in ordineinverso, da destra a sinistra)

Esempio

E )rm

T+E )rm

T+T )rm

T+int )rm

int⇤T+int )rm

int⇤int+int



4 of 55

Esempio

int ⇤ int + intint ⇤ T + int

T + intT + TT + E

E

E

T

int ⇤ T

int

+ E

T

int



5 of 55

Costruzione dell’albero

int ⇤ int + int int ⇤ int + int



6 of 55


int ⇤ int + intint ⇤ T + int int ⇤

T

int + int



7 of 55



T + int

T

int ⇤ T

int + int



8 of 55



T + intT + T

T

int ⇤ T

int +

T

int



9 of 55



T + intT + TT + E

T

int ⇤ T

int +

E

T

int



10 of 55



T + intT + TT + E

E

E

T

int ⇤ T

int

+ E

T

int



11 of 55

Un algoritmo per il parsing bottom-up

Sia I la stringa in input

repeat

seleziona una sottostringa non vuota � di I

dove X ! � e una produzione

se non c’e alcun �, torna indietro

rimpiazza � con X in I

until I = S (simbolo iniziale) o tutte le possibilitasono state provate



12 of 55

Maniglie

Decisioni da prendere durante il parsingbottom-up:

quale sottostringa ridurreche produzione usare

Maniglia (handle): sottostringa � tale cheX ! � e una produzione che corrisponde ad unpasso in una derivazione da destra della stringain input

Nota: la sottostringa piu a sinistra che coincidecon la parte destra di una produzione non esempre una maniglia



13 of 55

Dove riduciamo ?

Sia ↵�! la stringa corrente durante un parsingbottom-up

Assumiamo che la prossima riduzione sia fattausando la produzione X ! �

Allora ! e una stringa di terminali, perche↵X! ! ↵�! e un passo di una derivazione dadestra



14 of 55

Notazione

Idea: Dividere la stringa in due sottostringhe

la sottostringa di destra deve essere ancoraesaminata (una stringa di terminali)la sottostringa di sinistra ha terminali e non-terminali (e inserita in una pila)

Il punto di divisione e marcato dal simbolo |il simbolo | non e parte della stringa

Inizialmente, tutto l’input e non esaminato:

|x1

x2

. . . xn



15 of 55

Operazioni di Shift e Reduce

Il parsing bottom-up usa solo due tipi di azioni (nonbanali):

Shift (scorri)

Reduce (riduci)



16 of 55

Shift

Muove | di un posto verso destraSposta un terminale nella stringa di sinistra

legge un terminale e lo inserisce sulla pila

ABC |xyz ) ABCx |yz



17 of 55

Reduce

Applica una produzione inversa nella parte finaledella stringa di sinistra

Rimpiazza una stringa di terminali in cimaalla pila con la parte sinistra di unaproduzione

Se A ! xy e una produzione, allora:

Cbxy |ijk ) CbA|ijk



18 of 55

L’esempio con le due operazioni Shift-Reduce

|int ⇤ int + int shift

int| ⇤ int + int shift

int ⇤ |int + int shift

int ⇤ int|+ int reduce T ! int

int ⇤ T |+ int reduce T ! int ⇤ TT |+ int shift

T + |int shift

T + int| reduce T ! int

T + T | reduce E ! T

T + E | reduce E ! T + E

E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55






int ⇤ T |+ int reduce T ! int ⇤ T

T |+ int shift

T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55







T + |int shift




E |



19 of 55

La pila

La stringa di sinistra puo essere implementatacon una pila

La cima della pila e il simbolo |Un’operazione di Shift inserisce un terminale incima alla pila

Un’operazione di Reduce toglie 0 o piu simbolidalla pila (parti destre di produzioni) e aggiungeun non-terminale sulla pila (parti sinistre diproduzioni)



20 of 55

Conflitti

Il parsing shift-reduce non funziona con tutte legrammatiche libere da contestoPer alcune grammatiche, qualunque parser shift-reducearriva a dei conflitti

Anche conoscendo tutta la pila e i prossimi k simboliin input

Conflitto shift-reduce: il parser non sa decidere se fareuno shift o una reduce

Conflitto reduce-reduce: il parser non sa quale riduzionefareGrammatiche non LR(k) (o non LR)

Una grammatica ambigua non e LR

Di solito i compilatori usano grammatiche LR(1)



21 of 55

Parsing Shift-Reduce

Due azioni:

ShiftABC |xyz ) ABCx |yz

Reduce (con A ! xy)Cbxy |ijk ) CbA|ijk



22 of 55

Come decidere se applicare shift o reduce

Esempio

E ! T + E |TT ! int ⇤ T |int|(E )

Consideriamo int| ⇤ int + int

Potremmo ridurre tramite T ! intarrivando a T | ⇤ int + intErrore: non potremo arrivare al simboloiniziale E



23 of 55

Maniglie

Intuizione: vogliamo ridurre solo se il risultatopuo ancora essere ridotto fino al simbolo iniziale

Prendiamo una derivazione da destra:

S⇤)rm

↵X! )rm

↵�!

Allora ↵� e una maniglia di ↵�!

In un parsing shift-reduce, le maniglie appaionosolo in cima alla pila, mai nel mezzo

Perche ?



24 of 55

Maniglie



S⇤)rm

↵X! )rm

↵�!



Perche ?



24 of 55

Maniglie



S⇤)rm

↵X! )rm

↵�!



Perche ?



24 of 55

Maniglie solo in cima alla pila

Induzione informale sul numero di passi di riduzione:

All’inizio e vero, e la pila e vuotaDopo aver ridotto una maniglia

Il nonterminale piu a destra e in cima allapilaLa prossima maniglia deve essere alla destradel nonterminale piu a destra, perche e unaderivazione da destraLa sequenza di mosse shift raggiunge laprossima maniglia



25 of 55

Sommario sulle maniglie

In un parsing shift-reduce, le maniglie appaionosempre in cima alla pila

Le maniglie non sono mai alla sinistra delnonterminale piu a destra

Quindi non dobbiamo mai muovere versosinistra il simbolo |Gli algoritmi di parsing bottom-up si basano sulriconoscimento delle maniglie



26 of 55

Riconoscere le maniglie

Non esistono algoritmi e�cienti per riconoscerele maniglie

Soluzione: usare delle euristiche che cercano diindovinare quali pile sono delle maniglie

Per alcune grammatiche, le euristicheindovinano sempre correttamente

Per le euristiche che useremo, si tratta dellegrammatiche SRL



27 of 55

Grammatiche e conflitti

generano conflittigenerano conflitti

SLR CFG

CFG non-ambigue

Tutte le CFG



28 of 55

Documents

Automi e Linguaggi Formali - math.unipd.itsperduti/AUTOMI14/bottom-up_1.pdf · Automi e Linguaggi Formali Parsing Bottom-up A.A. 2014-2015 Alessandro Sperduti [email protected]