Analisi sintattica

Analisi sintattica
Analisi sintattica
programma
scanner
tokens
parser
Errori sintattici
albero
sintattico
Un parser deve riconoscere la struttura di una stringa di ingresso,
la cui struttura è fornita in termini di regole di produzione di una
CFG, BNF, o diagrammi sintattici. Un parser è una macchina
“astratta” che raggruppa input in accordo con regole
grammaticali.
1

Sintassi
La sintassi è costituita da un insieme di regole che
definiscono le frasi formalmente corrette
permettono di assegnare ad esse una struttura (albero
sintattico) che ne indica la decomposizione nei costituenti
immediati.
Ad es. la struttura di una frase (ovvero di un programma) di
un linguaggio di programmazione ha come costituenti le
parti dichiarative e quelle esecutive. Le parti dichiarative
definiscono i dati usati dal programma. Le parti esecutive si
articolano nelle istruzioni, che possono essere di vari tipi:
assegnamenti, istruzioni condizionali, frasi di lettura, ecc. I
costituenti del livello più basso sono gli elementi lessicali
già considerati, che dalla sintassi sono visti come atomi
indecomponibili. Infatti la loro definizione spetta al livello
lessicale.
Grammatiche non contestuali:
vantaggi
La teoria formale dei linguaggi offre diversi modelli, ma
nella quasi totalità dei casi il tipo di sintassi adottata è
quello noto come sintassi libera o non-contestuale (contextfree)
che corrisponde al tipo 2 della gerarchia di Chomsky.
I metodi sintattici per il trattamento del linguaggio sono
semplici
efficienti
la definizione del linguaggio attraverso le regole delle sintassi
libere dal contesto è diretta ed intuitiva
gli algoritmi deterministici di riconoscimento delle frasi sono
veloci (hanno complessità lineare) e facili da realizzare
partendo dalla sintassi.
Tutti questi vantaggi hanno imposto le grammatiche libere
dal contesto come l’unico metodo pratico per definire
formalmente la struttura di un linguaggio.
2

Grammatiche non contestuali:
svantaggi
Non tutte le regole di un linguaggio di programmazione possono essere
espresse in termini nel modello noncontestuale. Ad esempio non puo
espremere le seguenti regole:
in un programma ogni identificatore di variabile deve comparire in
una dichiarazione
il tipo del parametro attuale di un sottoprogramma deve essere
compatibile con quello del parametro formale corrispondente
Un altro limite del modello sintattico libero tocca le esigenze di calcolo
della traduzione. Se si guardano le traduzioni definibili con i soli metodi
sintattici, esse sono
decisamente povere
inadeguate ai problemi reali (compilazione di un linguaggio
programmativo nel linguaggio macchina)
Da queste critiche sarebbe sbagliato concludere che i metodi sintattici
sono inutili: al contrario essi sono indispensabili come supporto
(concettuale e progettuale) su cui poggiare i più completi strumenti della
semantica.
Parser
• Il parser lavora con stringhe di tokens
Programa
sorgente
Scanne
r
token
get next token
Parse
r
Albero sintattico
3

Grammatiche di tipo Context-Free
Le strutture ricorsive presenti nei linguaggi di
programmazione sono definite da una grammatica
context-free.
Una grammatica context-free (CFG) è definita come
Un insieme finito di terminali V (sono i token prodotti
dallo scanner)
Un insieme di non terminali V.
Un assioma o simbolo iniziale (uno dei non terminali.
Un insieme di produzioni (dette anche “rewriting rules”
con la seguente forma
A → X1 ... Xm dove X1 to Xm possono essere terminali o non
terminali.
Se m =0 si ha A → ε che è una produzione valida
Grammatiche di tipo Context-Free
Le strutture ricorsive presenti nei linguaggi di
programmazione sono definite da una grammatica
context-free.
Una grammatica context-free (CFG) è definita come
Un insieme finito Esempio di terminali V (sono i token prodotti
dallo scanner) T = { (, ), id , + , * , / , -}
Un insieme di non terminali V = {E} V.
E → E + E
Un assioma o simbolo
E →
iniziale
E – E
(uno dei non terminali.
Un insieme di produzioni E → E (dette * E anche “rewriting rules”
con la seguente forma E → E / E
E → -E
A → X1 ... XmE → ( E )
dove X1 to Xm possono E →essere id
terminali o non
terminali.
Se m =0 si ha A → ε che è una produzione valida
4

E ⇒ E+E
Derivazioni
E+E deriva da E
Possiamo sostituire E con con E+E
Perr poter fare questo deve esistere una produzione E→E+E nella
grammatica.
E ⇒ E+E ⇒ id+E ⇒ id+id
Una sequenza di sostituzioni di non-terminali e chiamata una derivazione di
id+id da E.
In generale un passo di derivazione è
αAβ ⇒αγβ se ∃ A→γ in G α ∈(V ∪ T)* e β ∈ (V ∪ T)*
α 1 ⇒α 2 ⇒ ... ⇒ α n
⇒ one step
⇒* zero o più steps
⇒+ 1 o più steps
V = { Prog, Seq, Istr, Expr}
T = {; , id , + }
Assioma = Prog
Prog → { Seq }
Seq →Seq ; Istr
Seq → ε
Istr →Seq
Istr →id = Expr
Expr →id
Expr →Expr + id
(α n deriva da α 1 o α 1 è derivato da α n )
V = { Prog, Seq, Istr, Expr}
T = {; , id , + }
Assioma = Prog
Prog → { Seq }
Seq →Seq ; Istr | ε
Istr →Seq | id = Expr
Expr →id | Expr + id
5

Per esempio partendo da Prog possiamo generate,
aplicando ripetutamente le produzione le seguenti
stringhe:
Prog
{ Seq }
{ Seq ;Istr}
{Istr;Istr}
{ id = Expr ;Istr}
{ id = id ;Istr}
{ id = id ; id = Expr }
{ id = id ; id = Expr + id}
{ id = id ; id = id + id}
Le produzioni devono avere le seguenti
proprietà:
no produzioni inutili o ridondanti (i.e., A → A),
no non-terminali senza produzioni
(e.g., A → Ba dove B non è definito),
no cicli infiniti (e.g., A → Aa senza altre
produzioni per A),
no ambiguita’: una grammatica con più alberi
sintattici per la stessa espressione è ambigua
descrivere correttamente il linguaggio.
6

CFG - Terminologia
L(G) è il linguaggio generato da G.
Una frase di L(G) è una stringa di simboli terminali di G.
Se S è l’assioma o start symbol di G allora
+
ω è una frase di L(G) iff S ⇒ ω dove ω ∈T*.
• Se G è una grammatica context-free, L(G) è un
linguaggio context-free.
• Due grammatiche sono equivalenti se producono lo
stesso linguaggio.
• * S ⇒ α Se α contiene non-terminali, è chiamata forma di frase di G.
Se α non contiene no-terminali è chiamata frase di G.
Derivazioni Left-Most e Right-Most
Left-Most Derivation
E ⇒ -E ⇒ -(E) ⇒ -(E+E) ⇒ -(id+E) ⇒ -(id+id)
Right-Most Derivation
E ⇒ -E ⇒ -(E) ⇒ -(E+E) ⇒ -(E+id) ⇒ -(id+id)
top-down parser cerca una left-most derivation del
programma sorgente
bottom-up parser cerca una right-most derivation del
programma sorgente
7

Parse Tree (Abstract Sintax Tree)
I nodi non foglie dell’albero sintattico sono simboli non-terminal, le foglie simboli
terminali.
E ⇒ -E
-
-
E
E
E
E
⇒ -(E) E
⇒ -(E+E)
- E
( E )
⇒ -(id+E) ⇒ -(id+id)
( E )
E +
id
E
-
E
E
( E )
E +
id
E
id
-
E
( E )
Un albero sintattico è una rappresentazione grafica di una derivazione.
Per esempio partendo da Prog possiamo generate,
aplicando ripetutamente le produzione le seguenti
stringhe:
Prog
{ Seq }
{ Seq ;Istr}
Seq
{Istr;Istr}
{ id = Expr ;Istr}
Seq Istr
{ id = id ;Istr}
{ id = id ; id = Expr }
{ id = id ; id = Expr + id}
{ id = id ; id = id + id}
Istr
E
E
+
E
8

Parser
Esempio: Consideriamo l’analisi della frase
1 + 2 * 3
secondo la seguente grammatica
::= +
| *
L’analisi sintattica può essere vista come un processo | numberper
costruire gli alberi sintattici (parse tree).
La sintassi di un programma è descritto da un agrammatica
libera dal contesto (CFG). La notazione BNF (Backus-Naur
Form) è una notazione per la descrzione di una CFG.
Il parser verifica se un programma sorgente soddisfa le regole
implicate da una grammatica context-free o no.
Se le soddisfa, il parser crea l’albero sintattico (del programma
Altrimenti genera un messaggio di errore.
Una grammatica non contestuale
Da una specifica rigorosa della sintassi dei linguaggi di
programmazione
Il progetto della grammatica e la fase iniziale del progetto del
compilatore
Esistono strumenti automatici per costruire automaticamente il
compilatore dalla grammatica
Ambiguita
• Una grammatica è ambigua se esistono più alberi sintattici per la
stessa frase.
E ⇒ E+E ⇒ id+E ⇒ id+E*E
⇒ id+id*E ⇒ id+id*id
Esempio
T = { (, ), id , + , * , / , -}
E V ⇒= {E} E*E ⇒ E+E*E ⇒ id+E*E
E
⇒
→
id+id*E
E + E
⇒ id+id*id
E → E – E
E → E * E
E → E / E
E → -E
E → ( E )
E → id
E +
id
E
E
* E
E
id
id
E
E +
id E
E
* E
id id
9

Esempio
T = { Ambiguita
(, ), id , + , * , / , -}
V = {E}
E → E + E
E → E – E
•E Una → E grammatica * E è ambigua se esistono più alberi sintattici per la
stessa E → E frase. / E
E
E → -E
E + E
E E → ⇒( E E+E ) ⇒ id+E ⇒ id+E*E
E → ⇒id id+id*E ⇒ id+id*id
id E * E
E ⇒ E*E ⇒ E+E*E ⇒ id+E*E
⇒ id+id*E ⇒ id+id*id
E +
id
E
E
* E
E
id
id
id id
Per poter costruire un parser la grammatica
non deve essere ambigua
Grammatica non ambigua ∃ un unico
albero sintattico per ogni frase del linguaggio
Le ambiguità nella grammatica devono
essere eliminate durante il progetto del
compilatore
10

Ambiguità
istr → if expr then istr |
if expr then istr else istr | otheristrs
istr
if E 1 then if E 2 then S 1 else S 2
if expr then istr else istr
E 1 if expr then istr S 2
1
E 2
Ambiguità
S 1
istr
if expr then istr
E 1 if expr then istr else istr
E 2 S 1 S
• Noi preferiamo il secondo albero sintattico (else corrisponde al
if più vicino).
• Dobbiamo eliminare l’ambiguità con tale obiettivo
• La grammatica non-ambigua sarà:
istr → matchedistr | unmatchedistr
matchedistr → if expr then matchedistr else matchedistr
| otheristrs
unmatchedistr → if expr then istr |
if expr then matchedistr else unmatchedistr
2
11

Ambiguita – Precedenza degli
operatori
Grammatiche ambigue possono essere rese non-ambigue
in accordo alle precedenze degli operatori e alle regole di
associativià degli operatori.
E → E+E | E*E | E^E | id | (E)
E → E+T | T
T → T*F | F
F → G^F | G
G → id | (E)
precedenze: ^ (right to left)
* (left to right)
+ (left to right)
Ricorsione sinistra (Left Recursion)
Una grammatica è “left recursive” se ha un non
terminale A tale che
+
A ⇒ Aα per qualche stringa α
Le tecniche di parser Top-down non possono gestire
grammatiche left-recursive.
Una grammatica left-recursive deve esssere
convertita in una non left-recursive.
La ricorsione sinistra può comparire in un singolo
passo della derivazione (immediate left-recursion), o
può comparire in più che un passo.
12

Immediate Left-Recursion
A → A α | β dove β ≠ Aγ e γ∈(V ∪ T)*
⇓
A →βA ’
A ’ →αA ’ | ε grammatica equivalente
In generale
A → A α1 | ... | A αm | β1 | ... | βn dove βi ≠ Aγ e γ∈(V ∪ T)*
⇓
A →β 1 A ’ | ... | β n A ’
A ’ →α 1 A ’ | ... | α m A ’ | ε grammatica equivalente
Esempio
E → E+T
E → T
T → T*F
T → F
eliminate immediate left recursion
F → id
F →(E)
E → T E ’
E ’ → +T E ’
E’ → ε
T → F T ’
T ’ → *F T ’
T’ → ε
F → id
F → (E)
13

Left-Recursion – Problema!!
• Una grammatica che non e direttamente left-recursive, ma lo è in
modo indirettp.
• Anche in questo caso va eliminata la ricorsione sinistra
Esempio
S → Aa | b
A → Sc | d
S ⇒ Aa ⇒ Sca
A ⇒ Sc ⇒ Aac
Algoritmo per l’eliminazione della
ricorsione sinistra
- Ordinare I non-terminali A1 ... An -fori from 1 to n do {
- for j from 1 to i-1 do {
sostituire ogni produzione
Ai → Aj γ
con
Ai →α1 γ | ... | αk γ
dove Aj →α1 | ... | αk }
- eliminare la ricorsione sinistra nelle produzioni di Ai }
14

Esempio
S → Aa | b
A → Ac | Sd | f
- Ordinare I non-terminali: S, A
per S:
- non c’e una ricorsione sinistra diretta.
for A:
- sostituiamo A → Sd con A → Aad | bd
Cosi avremoA → Ac | Aad | bd | f
- Eliminiamo la ricorsione sinistra in A
A → bdA ’ | fA ’
A ’ → cA ’ | adA ’ | ε
Avremo la grammatica non ricorsiva equivalente:
S → Aa | b
A → bdA ’ | fA ’
A ’ → cA ’ | adA ’ | ε
Esempio
S → Aa | b
A → Ac | Sd | f
- Ordinare I non-terminali : A, S
per A:
Eliminamo la ricorsione sinistra in A
A → SdA ’ | fA ’
A ’ → cA ’ | ε
per S:
- Sostituiamo S → Aa with S → SdA ’ a | fA ’ a
Così avremo S → SdA ’ a | fA ’ a | b
- Eliminamo la ricorsione sinistra in S
S → fA’aS’ | bS ’
S ’ → dA ’ aS’ | ε
Avremo la grammatica non ricorsiva equivalente:
S → fA’aS’ | bS ’
S ’ → dA ’ aS’ | ε
A → SdA ’ | fA ’
A ’ → cA ’ | ε
15

Left-Factoring (fattorizzazione
sinistra)
Un parser top down deterministico richiede
una grammatica left-factored.
grammatica grammatica equivalente
istr → if (expr ) istr else istr |
if (expr) istr
Left-Factoring (cont.)
In generale,
A → αβ1 | αβ2 dove α∈(V∪T)* - {ε}, β1∈ (V∪T)* - {ε}, β2∈ (V∪T)* -
{ε}
e β1≠. Noi possiamo riscrivere la grammatica come segue
A → αA ’
A’ →β 1 | β 2
16

Algoritmo
Per ogni non-terminale A con due o più
alternative (produzioni) con una parte non
vuota comune
A → αβ1 | ... | αβn | γ1 | ... | γm diventa
A → αA ’ | γ 1 | ... | γ m
A ’ →β 1 | ... | β n
Esempio
A → abB | aB | cdg | cdeB | cdfB
⇓
A → aA ’ | cdg | cdeB | cdfB
A ’ → bB | B
⇓
A → aA ’ | cdA ’’
A ’ → bB | B
A ’’ → g | eB | fB
17

Esempio
A → ad | a | ab | abc | b
⇓
A → aA’ | b
A’ → d | ε | b | bc
⇓
A → aA’ | b
A’ → d | ε | bA’’
A’’ →ε | c
istr → if (expr ) istr else istr |
if (expr) istr
istr → if (expr ) istr X
X → else istr
X →ε 18

Le frasi possono essere analizzate da
sinistra a destra (L parser), possono
essere costruite con derivazioni left-most
(LL(k) parser) o right-most (LR(k) parser)
utilizzando k symboli di look-ahead!
LL è più conosciuta come top-down parser.
LR è più conosciuta come bottom-up
parser.
Per ragioni pratiche k deve essere piccolo.
Per un compilatore è auspicabile l’uso di
grammatiche che possono essere analizzate in
modo deterministico con al più k symboli di lookahead.
L’assenza di ambiguità è condizione
necessaria per un analisi determinstica
Consideriamo un bottom up parse per abbcde
generato dalla seguente grammatica con assioma
S, eseguento un approccio “left-most matches
First”.
S → aAcBe
A → Ab|b
B → d
19

abbcde applicando B → d
aAbcBe applicando A → b
aAcBe applicando A → Ab
S applicando S → aAcBe
Parser
Due differenti metodi di analisi sintattica
A 1
A 2
S 4
B 3
a b b c d e
top-down: l’albero sintattico è creato dalla radice alle foglie
bottom-up: l’albero sintattico è creato dalle foglie alla radice
Il parser può lavorare in una varietà di modi ma esso
tipicamente processa l’ input da sinistra a destra.
Parser sia top-down che bottom-up possono essere
implmentati in modo efficente solo per alcune sottoclassi di
gramatiche context-free:
LL per top-down
LR per bottom-up
Una “left-most (right-most) derivation” è una derivazione nella
quale durante ogni passo viene sostituito solo il non-terminale
più a sinistra (destra).
20

Definzione di First(α)
Data una grammatica non contestuale G(V,T,P,S) si definisce
First(α) = {a in T | α⇒* aβ}
Quindi First(α) è il seguente sottoinsieme di T:
•se α = aβ con a ∈ T allora a ∈ First(α)
•se α = Aβ con A ∈ T allora
• se ∃ una produzione A → γallora First(γ) ⊆ First(α)
• se ∃ una produzione A →εallora First(β) ⊆ First(α)
First(α) è l’insieme di tutti i terminali con cui può iniziare una
stringa derivata da α.
Se α →*ε allora ε∈First(α).
First(α) = {a ∈ T | α →* a β} ∪ if a → *ε then {ε} else ∅
Esempio
T = {a, b, c, d, e},
V = {S, B, C}
P = { S → aSe | B,
B → bBe | C,
C → cCe | d }
S = S
First(aSe) = {a}
First(B) = First(bBe) ∪ First(C) = {b} ∪ First(cCe) ∪ First(d) =
{b} ∪ {c} ∪ {d} = {b, c, d}
First(bBe) = {b}
First(C) = First(cCe) ∪ First(d) = {c} ∪ {d} = {c, d}
First(cCe) = {c}
21

Esempio
T = {a, b, c, d, e}
V = {A, B, C, D}
P = { A → B | Ce | a
B → bC,
C → Dc
D → d | ε}
S = A
First(B) = First(b) ={b}
First(C e) = First (Dc) = First(d) ∪ First(ε) = {d} ∪{ε} = {d,
ε }
First(a) = {a}
First(bC )= {b}
Esempio
T = {(, +, ), v, f}
V = {E, Prefix, Tail}
P = { E → Prefix(E) | v Tail
Prefix → f | ε
Tail → + E | ε }
S = E
First(Prefix(E) ) = {f} ∪{ε}
First(v Tail) = {v}
First(f) = {f}
First(ε )= {ε}
22

Esempio
T = {a, (, ), +, ","}
V = {E, T, L, P}
P = { E → E + T | T
T → a | (E) |
a(L)
E}
S = E
L → P | ε ,
P → E | P ","
First(E) = {a, (}
First(T) = {a, (}
First(L) = {ε , a, (}
T = {a, b, c, d, e}
V = {A, B, C, D}
P = { A → B | C | Ce | a
B → bC
Definizione di Follow(A)
C → Dc | D
D → d | ε }
S = A
First(A) = {a, b, d, c, e, ε }
First(B) = {b}
First(C) = {d, c, ε }
Data una grammatica non contestuale G(V,T,P,S) si definisce
Follow(A) l’insieme dei terminali che seguono in una qualsiasi frase
Esso è definito come segue:
Follow(A) = {a ∈ T | S → +… Aa ….} ∪
(if S ⇒* … A then {ε} else ∅}
23

T = {a, b, c, d, e},
V = {S, B, C}
P = { S → aSe | B,
B → bBe | C,
C → cCe | d }
S = S
Follow(S) = {e, $}
Follow(B) = {e, $}
Follow(C) = {e, $}
T = {(, +, ), v, f}
V = {E, Prefix, Tail}
P = { E → Prefix(E) | v
Tail
Prefix → f | ε
Tail → + E | ε }
S = E
Follow(Prefix ) = { ( }
Follow(E) = {$}
Follow(Tail) = { $ }
T = {a, (, ), +, ","}
V = {E, T, L, P}
P = { E → E + T | T
T → a | (E) | a(L)
L → P | ε ,
P → E | P "," E}
S = E
Follow(E) = {+, ) , “,“ , $}
Follow(T) = {+, ) , “,“ , $}
Follow(L) = { ) }
Follow(P) = {) , “,”}
T = {a, b, c, d, e}
V = {A, B, C, D}
P = { A → B | Ce | a
B → bC,
C → Dc
D → d | ε}
S = A
Follow(A) = {$}
Follow(B) = {$}
Follow(C) = {$, e}
Follow(D) = {c}
24

T = {a, b, c, d, e}
V = {A, B, C, D}
P = { A → B | C | Ce | a
B → bC
C → Dc | D
D → d | ε }
S = A
Follow(A) = {$}
Follow(B) = Follow(A) = {$}
Follow(C) = Follow(A) ∪ Follow(B) ∪ {e} = {e , $}
Follow(D) = {c } ∪ Follow(C) = {c, e , $}
25