Costruzione dell insieme dei Follow

Transcript

1 Costruzione dell insieme dei Follow E! T E - T E E! + T E - T E " T! F T T! *F T " F! (E) i Per evitare che alcuni insiemi siano vuoti si aggiunge per default il simbolo speciale $ che demarca la fine della stringa da esaminare Siccome l insieme dei FOLLOW(Y) comprende tutti i simboli terminali t che possono seguire immediatamente Y ovvero S # + u Y t v si ha: FOLLOW (E) = { $, )} FOLLOW (E ) = { $, )} FOLLOW (T) = { $, ),-, +} FOLLOW (T ) = { $, ). -, +} FOLLOW (F) = { $, ). -, +, *} per esempio: E # T E # F T E # F * F T E #F*FT # F*F # ( E ) *F # (T E ) * F # ( T ) *F #... #

2 Costruzione dell insieme dei Follow cont. Si considera il grafo dell insieme dei FIRST prima costruito, si aggiungono ulteriori nodi per i soli simboli non terminali (questi ultimi vengono indicati con un doppio rettangolo sul grafo e con X nelle regole seguenti). R1 -Si traccia l arco S! $ per il simbolo iniziale S R2 -Per ogni regola W! u X t v si traccia l arco X! t R3 -Per ogni regola W! u X si traccia l arco X! W -Per ogni regola W! u X Y 1, Y 2... Y n con Y 1, Y 2... Y n # + " Si tracciano gli archi X!W, X! Y 1... X! Y n Tutti i simboli terminali raggiungibili a partire da un simbolo non terminale X fanno parte del FOLLOW di X, pertanto: FOLLOW (E) = { $, )} FOLLOW (E ) = { $, )} FOLLOW (T) = { $, ),-, +} FOLLOW (T ) = { $, ). -, +} FOLLOW (F) = { $, ). -, +, *} E R3 E T R3 E! T E - T E E! + T E - T E " T! F T T! *F T " F! (E) i T T * F Si osservi come per motivi grafici non è stata indicata una parte del grafo dei FIRST in quanto non funzionale per il risultato finale (nodi del grafo dei FIRST non raggiungibili). R2 R1 ) $ E + -

3 Condizioni LL(1) Una grammatica si dice LL(1) se per ogni regola!! X! x 1 x 2... x n x i " V* sono soddisfatte le seguenti condizioni 1. FIRST (x i ) sono a due a due disgiunti 2. Esiste al più un solo x i #* $ e se esiste deve verificarsi!! FIRST(X) % FOLLOW (X) = &

4 Condizioni LL(1) cont. 1. FIRST (x i ) sono a due a due disgiunti! ciò significa che dato un non terminale X non devono esistere due derivazioni! S!* u X v! u " v!* u z v! S!* u X v! u " v!* u z v in cui " # " e i primi caratteri di z v e z v coincidono cioè!! FIRST (zv) = FIRST (z v ) oppure z v = z v = $ Es. la regola ricorsiva a sinistra E % E + T T viola la condizione 1.! E! E+T!T+T!* i +i! E! E+T!E+ T+T!* i + i + i mentre invece con E % T E!! E % +T E $ si avrebbe! E! TE!T+ TE!T+T!* i +i! E! TE!T+ TE!T+T+TE!* i + i + i Infatti FIRST (i+i ) = FIRST (i+i+i) e nella sequenza si ha che " # " anche in questo caso FIRST (zv) = FIRST (z v ) ma in ogni momento " = "

5 Condizioni LL(1) cont. 2. Esiste al più un solo x i!* " e se esiste deve verificarsi FIRST(X) # FOLLOW (X) = $ Es.! S % if E then S S a b!! S % else S " dove a, b sono espressioni aritmetiche o booleane p, q sono espressioni booleane & E % p q siccome:! FIRST(S) = {if, a, b}, FIRST (S ) = {else}, FIRST (E) ={ p, q }!! FOLLOW(S) = {else, $}, FOLLOW(S ) ={else, $}, FOLLOW(E) ={then} si ha che S! ", ma gli insiemi FIRST(S ) # FOLLOW(S ) '$ per cui la grammatica è ambigua Esercizio 1 data l espressione if p then if q then a else b costruire i due alberi sintattici relativi e dire quale albero corrisponde all interpretazione corretta. Esercizio 2 Scrivere una grammatica non ambigua equivalente a quella data.

6 Analizzatori sintattici a discesa ricorsiva E uno schema di analizzatore che sfrutta la descrizione grammaticale in EBNF adatto a grammatiche LL(1). Si basa sulla scrittura di procedure ricorsive ricavate direttamente dalle regole grammaticali. IDEA Ogni produzione viene interpretata come una procedura in cui la parte sinistra rappresenta il nome e la parte destra la definizione (corpo) della procedura. Lo stack risulta implementato implicitamente dal meccanismo di implementazione delle chiamate ricorsive. Data una generica regola X! x 1 x 2... x n! si distinguono due possibili strutture della procedura a seconda di quale delle due condizioni si verifichi 1. X # + " Cioé la variabile non genera " 2. X # + " Cioé la variabile genera " Inoltre, si deve supporre l esistenza di una routine che rende disponibile i caratteri che via via vengono scanditi. Questa routine in genere è associata ad un analizzatore lessicale.

7 Analizzatori lessicali Un analizzatore lessicale ha il compito di esaminare carattere per carattere la stringa in ingresso e produrre una forma standard degli item di volta in volta individuati. Tipicamente gli analizzatori lessicali vengono implementati con automi a stati finiti. Esempio: procedure somma (var S:integer);!var i:integer;! begin! S:=0;! for i:=1 to 10 do S:= S + i * 500; end; procedure somma ( var S : integer ) ; var i : integer ; begin! S := 0 ; for i := 1 to 10 do S := S + i * 500 ; end ; In pratica l analizzatore lessicale ha il compito di categorizzare le varie stringhe selezionate in modo che ciascuna stringa rappresenti un unico item. Ad esempio: alfa + pigreco * gamma è come dire i +i*i Al momento dell analisi sintattica interessa la struttura di una espressione e quindi la tipologia degli operandi indicati.

8 Analizzatori sintattici a discesa ricorsiva 1. X # + "! procedure X;! begin!! if cc in FIRST(x 1 ) then {codice di x 1 } - cc = carattere corrente!! else if cc in FIRST(x 2 ) then {codice di x 2 } - per l ipotesi $!!... FIRST(x i )% FIRST(x j ) = & $ $ $ viene attivata una sola!! else if cc in FIRST(x n ) then {codice di x n } parte destra!! else ERRORE! end; 2. X # + " procedure X;! begin! if cc in FIRST(x 1 ) then {codice di x 1 }!! else if cc in FIRST(x 2 ) then {codice di x 2 }!!...!! else if cc in FIRST(x n ) then {codice di x n }!! else if not [ cc in FOLLOW(X)] then ERRORE! end;