2 - Teoria - Compilarii-Dragulici - Analiza Sintactica-123 - Pag

Teoria Compilării
Drăgulici Dumitru Daniel
Facultatea de matematică şi informatică,

Universitatea Bucureşti
2011
Cuprins
1 Analiza sintactică
Algoritmi de parsare top - down
Algoritmul de parsare general top - down
Algoritmi de parsare k-predictivi
Algoritmul de parsare pentru gramatici LL(k) tari
Analiza sintactică
Analiza sintactică (parsarea) are ca scop identificarea modului ı̂n care tokenii
(furnizaţi de analizorul lexical) se agregă pentru a forma structuri sintactice
(instrucţiuni şi expresii), ı̂ncuibate unele ı̂n altele, până ce formează structura
sintactică de la nivelul de vârf (programul).
Sintaxa limbajelor de programare se defineşte şi se investighează folosind

instrumente de limbaje independente de context - de exemplu gramatici
independente de context.
Gramatici independente de context
Definiţie:Gramatici independente de context (GIC):

O GIC este un sistem G = hVN , VT , S, Pi, unde:
VN este o mulţime finită nevidă (mulţimea neterminalelor);
VT este o mulţime finită nevidă (mulţimea terminalelor);
S ∈ VN este simbolul de start;
P ⊆ VN × (VN ∪ VT )? este o mulţime finită (mulţimea producţiilor).
Notăm VG = VN ∪ VT .
Uneori mulţimea {A → γ1 , . . . , A → γn } a tuturor producţiilor ce au ı̂n stânga

neterminalul A ∈ VN (i.e. mulţimea alternativelor) lui A va fi notată compact
A → γ1 | . . . |γn .
Definiţie: Pentru o GIC G definim:

• relaţia de derivare directă: 
 α = uNv
u, v , γ ∈ VG?

α, β ∈ V ? , α ⇒ β d.d. ∃ a.ı̂. β = uγv
N ∈ VN
N→γ∈P

(deci β se obţine din α prin ı̂nlocuirea unei apariţii a lui N cu γ, ı̂n baza
producţiei N → γ);
• relaţia de derivare stângă directă:
α, β ∈ V ? , α ⇒s β d.d. la fel ca la ⇒, dar u ∈ VT? (i.e. s-a derivat cel
mai din stânga neterminal);
• relaţia de derivare dreaptă directă:
α, β ∈ V ? , α ⇒d β d.d. la fel ca la ⇒, dar v ∈ VT? (i.e. s-a derivat cel
mai din dreapta neterminal).

? ? ?
• relaţia de derivare ⇒ / derivare stângă ⇒s / derivare dreaptă ⇒d :
ı̂nchiderea reflexivă şi tranzitivă a celei directe
?
(ex: α ⇒ β d.d. α = β sau ∃ α = α0 , α1 , . . . , αk = β ∈ VG? , k ≥ 1,
a.ı̂. α0 ⇒ α1 ⇒ . . . ⇒ αk );
+
• cu + ı̂n loc de ? (ex: ⇒) notăm ı̂nchiderea tranzitivă (i.e. ı̂n cel puţin un
pas) a relaţiei directe.
Observaţie:
Toate relaţiile definite mai sus sunt cazuri particulare ale relaţiei de derivare.

• o secvenţă de derivări directe α0 ⇒ · · · ⇒ αn s.n. derivare (a lui αn din α0 );
daca ”⇒” este tot timpul ”⇒s ”, resp. ”⇒d ”, ea s.n. derivare stângă,
resp. dreaptă.
• formă sentenţială: şir din VG? care apare ı̂n cel puţin o derivare din S.
Definiţie:
Fiind dată o GIC G , un arbore de derivare este un arbore a.ı̂. :
• nodurile sunt etichetate cu elemente din VG ∪ {λ};
• rădăcina este etichetată cu S;
• descendenţii direcţi (fii) ai oricărui nod, dacă există, formează o mulţime
total ordonată;
• dacă fii unui nod etichetat cu N au ı̂n ordine etichetele x1 , ..., xn , atunci
N → x1 . . . xn ∈ P.
Observaţie:
• Din definiţie rezultă că nodurile neterminale sunt etichetate cu elemente din
VN (doar ele pot apărea ı̂n membrii stângi ai producţiilor prin care se obţin fii
acestora) iar nodurile terminale (frunze) pot fi etichetate cu elemente atât din
VN cât şi din VT sau cu λ.
• Dacă w este cuvântul de pe frontiera arborelui (i.e. cuvântul obţinut prin
concatenarea etichetelor frunzelor ı̂n ordinea dată de parcurgerea depth first)
?
atunci S ⇒ w .
?
• Reciproc, dacă S ⇒ w ∈ VG? , atunci există cel puţin un arbore de derivare
care are pe frontieră w - el arată un mod de obţinere a lui w din S.
La rândul său, un arbore de derivare poate fi parcurs ı̂n general ı̂n mai multe
moduri (aplicăm producţiile ı̂n altă ordine) şi fiecare parcurgere defineşte câte o
derivare a lui w din S. Printre acestea ı̂nsă există o singură derivare stângă şi o
singură derivare dreaptă.
• Deci, pentru o GIC dată, există o bijecţie ı̂ntre arborii de derivare, derivările
stângi, derivările drepte.
Definiţie: Fie G o GIC.
?
• Limbajul generat de G este L(G ) = {w ∈ VT? : S ⇒ w }.
• G este ambiguă d.d. există w ∈ L(G ) care are ≥ 2 arbori de derivare
distincţi, i.e. are ≥ 2 derivări stângi distincte, i.e. are ≥ 2 derivări drepte
distincte.
• Două gramatici sunt echivalente dacă generează acelaşi limbaj.
Definiţie:
Un limbaj L este independent de context dacă există cel puţin o GIC G a.ı̂.
L = L(G ).
Observaţie:
• La fel ca ı̂n cazul limbajelor regulate, există şi alte caracterizări, echivalente,
ale limbajelor independente de context, de ex. să fie recunoscute de automate
stivă (push down).
• Clasa limbajelor regulate este strict inclusă ı̂n clasa limbajelor independente
de context.
Exemplu:
Fie GIC G dată de:
VN = {S, A}
VT = {a}
simbolul de start S
P = {1 : S → AA, 2 : A → AA, 3 : A → a} (am numerotat producţiile).
Fie w = aaa ∈ VT? . Atunci w ∈ L(G ), iar doi arbori de derivare pentru w
sunt:
S S
@ @
@ @
A RA
@ A RA
@
@ @
@ @
A @A
R A RA
@
a
? a
? a
? a
? a
? a
?
Deci G este ambiguă.

Exemplu:
Primul arbore defineşte următoarele derivări ale lui w din S (la fiecare pas
am subliniat neterminalul ı̂nlocuit şi am notat producţia aplicată):
S Producţii:
@ 1 : S → AA
A R
@ A 2 : A → AA
@ 3: A→a
A RA
@
a? a? a?
1 2 3 3 3
S → AA → AAA → aAA → aaA → aaa (derivare stângă)
1 2 3 3 3
S → AA → AAA → aAA → aAa → aaa
1 2 3 3 3
S → AA → AAA → AaA → aaA → aaa
1 2 3 3 3
S → AA → AAA → AaA → Aaa → aaa
1 2 3 3 3
S → AA → AAA → AAa → aAa → aaa
1 2 3 3 3
S → AA → AAA → AAa → Aaa → aaa
1 3 2 3 3
S → AA → Aa → AAa → aAa → aaa
1 3 2 3 3
S → AA → Aa → AAa → Aaa → aaa (derivare dreaptă).
Sintaxa limbajelor de programare se defineşte cu GIC neambigue, ı̂n care:

- neterminale sunt tipuri de structuri sintactice (program, declaraţie,
instrucţiune, instrucţiune while, expresie, termen, factor, etc.);
-terminalele sunt tipuri de tokeni 6= spaţiu (identificator, ı̂ntreg, operator aditiv,
operator multiplicativ, etc.);
- simbolul de start este neterminalul corespunzător structurii sintactice de la
nivelul cel mai ı̂nalt (program);
- producţiile sunt regulile/variantele de definire ale diverselor tipuri de structuri
sintactice (definiţia instrucţiunii while, definiţia expresiei, etc.).
Cuvintele-candidat la a fi programe corecte sintactic sunt şiruri de tipuri de
token (livrate de scanner).
Analizorul sintactic (parserul) verifică dacă acest cuvânt aparţine limbajului
generat de gramatică (i.e. este un program corect sintactic) şi dacă da,
construieşte arborele său de derivare (acesta descrie modul de construire a
programului). Arborele poate fi livrat de ex. sub forma şirului numerelor
producţiior aplicate ı̂n derivarea stângă (sau dreaptă) asociată.
Exemplu:
TODO
Verificarea faptului că un cuvânt format din terminale aparţine limbajului

generat de o gramatică se face folosind un algoritm de analiză sintactică
(algoritm de parsare). În caz afirmativ, algoritmul produce şi o informaţie din
care să se poată reconstitui arborele de derivare al cuvântului, de ex. şirul
numerelor producţiior aplicate ı̂ntr-o derivare stângă (sau dreaptă) a acestuia
din simbolul de start.
Există algoritmi de parsare:
- top - down: ı̂ncearcă construirea arborelui de derivare de sus ı̂n jos (de la
rădăcină spre frontieră);
- bottom - up: ı̂ncearcă construirea arborelui de derivare de jos ı̂n sus (de la
frontieră spre rădăcină).
Pentru o GIC oarecare (fără proprietăţi suplimentare) ı̂n ambele cazuri
algoritmii sunt exponenţiali. Adăugând gramaticii proprietăţi suplimentare,
putem obţine algoritmi mai buni, chiar liniari. Astfel sunt gramaticile de tip LL,
LR, de precedenţă, etc. (toate sunt GIC cu proprietăţi suplimentare, care
permit elaborarea unor algoritmi de parsare liniari).
Cuprins
Algoritmii de parsare top - down ı̂ncearcă construirea arborelui de derivare de

sus ı̂n jos (de la rădăcină spre frontieră).
Cuprins
Algoritmul de parsare general top - down nu necesită proprietăţi suplimentare
ale GIC.
Pentru a lucra organizat, se numerotează producţiile şi la fiecare pas se
ı̂ncearcă aplicarea ı̂n ordine a acestora, pentru a găsi descendenţii corecţi ai
celui mai din stânga nod neprocesat (ı̂n sensul parcurgerii depth first). Odată
găsită producţia corectă, se reţine numărul acesteia.
Astfel, dacă cuvântul parsat aparţine limbajului generat de gramatică, se obţine
ı̂n final o derivare stângă a sa.
Constatăm totodată că partea finalizată (formată numai din terminale) din
stânga frontierei creşte progresiv, iar ı̂n final ea trebuie să coincidă cu cuvântul
parsat.
De aceea, pentru a eficientiza căutarea, la ı̂ncercarea fiecărei producţii se
verifică dacă terminalele generate de ea ı̂n stânga porţiunii nefinalizate din
frontieră coincid cu terminalele aflate ı̂n stânga porţiunii neconsultate ı̂ncă din
cuvânt, iar dacă nu, se respinge producţia respectivă (nu are sens să construim
arborele ı̂n continuare după această alegere).
Constatăm totodată că cuvântul parsat este consultat de la stânga la dreapta.
Dacă pentru un nod neterminal s-au ı̂ncercat fără succes toate producţiile
posibile, se revine la nodul anterior (ı̂n parcurgere depth first) pentru a se
ı̂ncerca acolo producţia următoare.
Astfel, algortimul general top - down efectuează backtracking, fiind deci
exponenţial.
Exemplu:
Fie G GIC dată de: VN = {E , T , F }, VT = {a, +, ?}, simbolul de start: E ,
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
(am numerotat producţiile). Pentru w = a + a avem succesiv:
E
a + a
Am scris cu roşu elementele nou adăugate, cu albastru potrivirile, cu
verde+ı̂ncercuire nepotrivirile.
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
?
a
B
B
B
B
B
B
Ba a
+
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
F ?h @
?
RT
B
?
a B
B B
B B
B B
B B
B B
B B
H +h
Ba HH
a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
?
a
B
B
B
B
B
B
Ba a
+
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
?
F ? @
RT
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
?
F
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
?
F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
?
F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
?
F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + R
@E
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
?
a
@
@
@
@
a + @a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
@
h@
? ?
a F ? RT
A
?
a A
@ A
@ A
@ A
A
a +
@ @a A h
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
?
a
@
@
@
@
a + @a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? @
?
a F ? RT
@
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
?
a
A
A
A
A
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
@
T +h @
? ?
F RE
? ? B
a F B
B
? B
a B
A B
A B
A B
A Bh
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
?
a
A
A
A
A
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
? ?
a F
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T + jE
? @
?
F T + @
RE
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? @T
R
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? RT
@
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? RT
@
?
a
A
A
A
AA
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
@
h
? ?
a F ? RT
@
? A
a A
A A
A A
A A
A
AA A h
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? RT
@
?
a
A
A
A
AA
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? RT
@
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? @
?
a F ? RT
@
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? ?
a F
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? ?
a F
?
a
a + a
Exemplu:
P: 1 : E → T + E 2 : E → T 3:T →F ?T 4:T →F 5:F →a
E
H
?HH
HH
T
+ jE
? ?
F T
? ?
a F
?
a
a + a
Observaţie:
Dacă ı̂n exemplul de mai sus am fi avut producţia 1 : E → E + T ı̂n loc de
1 : E → T + E , am fi intrat ı̂n recursie infinită:
E E E E
@ @ @
?R
@ ?@
R ?@
R
E + T E + T E + T
⇒ ⇒ @
⇒ @
⇒ ...
?@
R ?@
R
E + T E + T
@
?@
R
E + T
Deci gramatica trebuie să aibă proprietăţi suplimentare, pentru a evita

recursivitatea la stânga. Vom vedea ı̂nsă că cerând aceste proprietăţi nu
restrângem generalitatea, deoarece orice GIC poate fi transformată a.ı̂. să le
aibă.
Fie G = hVN , VT , S, Pi o GIC cu L(G ) 6= ∅.
Definiţie:
• A ∈ VG este inaccesibil dacă nu există nici o derivare de forma
?
S ⇒ αAγ cu α, γ ∈ VG? .
• A ∈ VG este neutilizat dacă nu există nici o derivare de forma
? ?
S ⇒ αAγ ⇒ αβγ cu α, β, γ ∈ VT? .
Propoziţie:
G este echivalentă cu o GIC G 0 = hVN0 , VT0 , S 0 , P 0 i fără simboluri inaccesibile.
Algoritm (A): Eliminarea simbolurilor inaccesibile
1) V0 ← {S}; i ← 1;
2) Vi ← Vi−1 ∪ {X : ∃ A → αX β ∈ P, A ∈ Vi−1 };
3) if Vi 6= Vi−1 then begin i ← i + 1; goto 2 end;
4) VN0 ← VN ∩ Vi ; VT0 ← VT ∩ Vi ; S 0 ← S;
P 0 ← mulţimea producţiilor din P cu ambii membri din Vi? .
Propoziţie:
G este echivalentă cu o GIC G 00 = hVN00 , VT , S, P 00 i a.ı̂.
?
∀A ∈ VN00 ∃α ∈ VT? a.ı̂. A ⇒
G 00
α.
Algoritm (B):
1) V0 ← ∅; i ← 1;
2) Vi ← Vi−1 ∪ {A : ∃ A → α ∈ P, α ∈ (Vi−1 ∪ VT )? };
3) if Vi 6= Vi−1 then begin i ← i + 1; goto 2 end;
4) VN00 ← Vi ; P 00 ← mulţimea producţiilor din P cu membrul stâng din Vi , şi
membrul drept din (Vi ∪ VT )? .
Observaţii:
• Ca un corolar, rezultă că e decidabil dacă L(G ) 6= ∅. Într-adevăr, aplicăm
algoritmul (B) şi ı̂n final verificăm dacă S ∈ Vi .
• Dacă nu ceream de la ı̂nceput L(G ) 6= ∅, la aplicarea algoritmului (B) putea
rezulta VN00 = ∅, deci să nu avem nici simbol de start, ı̂n contradicţie cu
definiţia GIC.
Această cerinţă nu este un impediment, deoarece gramaticile ce definesc
sintaxa limbajelor de programare generează limbaje nevide.
Algoritm (C): Eliminarea simbolurilor neutilizate

Aplicăm (B), apoi (A).
Exemplu:
Să eliminăm simbolurile neutilizate pentru GIC dată de:
VN = {S, A, B, C }, VT = {a, b}, S,
P: S → A|B, A → aB|bS|b, B → AB|Ba, C → AS|b
algoritmul (B): V : | {z } A, C , |{z}
S
| {z }
pas 0 pas 1 pas 2
Reţinem: VN = {S, A, C }, VT = {a, b}, S, P: S → A, A → bS|b, C → AS|b
algoritmul (A): V : |{z}
S , A ,
|{z} b
|{z}
pas 0 pas 1 pas 2
Reţinem: VN = {S, A}, VT = {b}, S, P: S → A, A → bS|b.
Fie G = hVN , VT , S, Pi o GIC.
Definiţie:
• λ-producţie: producţie de forma A → λ.
• redenumire: producţie de forma A → B (A, B ∈ VN ).
Propoziţie:
G este echivalentă cu o GIC G 0 = hVN0 , VT0 , S 0 , P 0 i a.ı̂.:
• dacă λ 6∈ L(G ) atunci G 0 nu are λ-producţii.
• dacă λ ∈ L(G ) atunci singura λ-producţie a lui G 0 este S 0 → λ, iar S 0 nu
apare ı̂n membrul drept al nici unei producţii.
Algoritm (C): Eliminarea λ-producţiilor

+
1) cu un algoritm asemănător lui (A) sau (B) construim Nλ = {A : A ⇒ λ};
mai exact, folosim regulile:
V0 ← {A : A → λ ∈ P}
?
Vi ← Vi−1 ∪ {A : A → α ∈ P, α ∈ Vi−1 }
totodată, iniţializăm P 0 ← ∅;
2) Fie A → α0 B1 . . . αk−1 Bk αk ∈ P cu k ≥ 0 şi pentru orice i avem Bi ∈ Nλ
iar αi nu conţine simboluri din Nλ ;
if k = 0 then begin P 0 ← P 0 ∪ {A → α0 } \ {A → λ}; goto 4 end;
3) P 0 ← P 0 ∪ {A → α0 X1 . . . αk−1 Xk αk : Xi ∈ {Bi , λ} pt. orice i} \ {A → λ};
4) P ← P \ {A → α0 B1 . . . αk−1 Bk αk };
if P 6= ∅ then goto 2;
5) if S ∈ Nλ then G 0 ← hVN ∪ {S 0 }, VT , S 0 , P 0 ∪ {S 0 → S|λ}i
else G 0 ← hVN , VT , S, P 0 i.
Exemplu:
Să eliminăm λ-producţiile pentru G dată de: S → aSbS|bSaS|λ
(neterminalele sunt litere mari, terminalele litere mici, simbolul de start
este S, restul se deduce din context).
Nλ : | {z
S }
pas 0
producţia S → aSbS introduce ı̂n G 0 : S → aSbS|abS|aSb|ab
producţia S → bSaS introduce ı̂n G 0 : S → bSaS|baS|bSa|ba
producţia S → λ nu introduce nimic ı̂n G 0
cum S ∈ Nλ , ı̂n G 0 apare şi S 0 → S|λ, cu S 0 simbol de start nou
Aşadar, gramatica G 0 va fi dată de:
Neterminalele: S, S 0
Terminalele: a, b (aceleaşi ca ı̂n G )
Simbolul de start S 0 (simbol nou)
Producţiile: S → aSbS|abS|aSb|ab|bSaS|baS|bSa|ba, S 0 → S|λ
Propoziţie:
G este echivalentă cu o GIC G 0 fără redenumiri.
Algoritm (D): Eliminarea redenumirilor
?
1) Pentru orice A ∈ VN construim RA = {B ∈ VN : A ⇒ B} astfel:
a) R0 ← {A}; i ← 1;
b) Ri ← Ri−1 ∪ {C ∈ VN : B → C ∈ P, B ∈ Ri−1 };
c) if Ri 6= Ri−1 then begin i ← i + 1; goto b end;
d) RA ← Ri ;
Iniţializăm P 0 ← ∅;
2) Fie B → α ∈ P;
if α ∈ VN then goto 4;
3) P 0 ← P 0 ∪ {A → α : B ∈ RA };
4) P ← P \ {B → α};
if P 6= ∅ then goto 2;
5) G 0 se obţine din G ı̂nlocuind P cu P 0 .
Exemplu:
Să eliminăm redenumirile pentru G dată de:
E → E + T |T , T → T ? F |F , F → (E )|a
(cu aceleaşi convenţii de notare, simbolul de start fiind E ).
RE : | {z
E }, | {z
T }, | {z
F }
pas 0 pas 1 pas 2
RT : | {z
T }, | {z
F }
pas 0 pas 1
RF : | {z
F }
pas 0
producţia E → E + T generează E → E + T
producţia T → T ? F generează E → T ? F , T → T ? F
producţia F → (E ) generează E → (E ), T → (E ), F → (E )
producţia F → a generează E → a, T → a, F → a
(restul producţiilor din G sunt redenumiri şi nu generează nimic)
P 0 este format doar din producţiile generate, deci avem:
P 0 : E → E + T |T ? F |(E )|a, T → T ? F |(E )|a, F → (E )|a.
Definiţie:
O GIC G este proprie dacă este fără simboluri neutilizate, fără λ-producţii şi
fără redenumiri.
Propoziţie:
Orice GIC G cu L(G ) 6= ∅ este echivalentă cu o GIC proprie.
Algoritm: Aplicăm ı̂n ordine (B), (A), (C), (D).
Definiţie:
• A ∈ VN este recursiv la stânga (resp. imediat recursiv la stânga) dacă
+
A ⇒ Aα (resp. A ⇒ Aα) cu α 6= λ.
• G este recursivă la stânga dacă are cel puţin un neterminal recursiv la
stânga.
Algoritm: Eliminarea recursivităţii imediate la stânga

for [fiecare A ∈ VN ] do begin
Notăm alternativele lui A: A → Aα1 | . . . |Aαm |β1 | . . . |βn ,
unde αi 6= λ şi βi nu ı̂ncepe cu A, pt. orice i;
Introducem A0 neterminal nou;
Eliminăm producţiile A → Aα1 | . . . |Aαm |β1 | . . . |βn ;
Introducem producţiile A → β1 | . . . |βn |β1 A0 | . . . |βn A0
şi A0 → α1 | . . . |αm |α1 A0 | . . . |αm A0
end
Observaţii:
• Producţiile de forma A → A pot fi eliminate ı̂nainte, cu algoritmul de
eliminare a redenumirilor.
• Prin aplicarea algoritmului de mai sus pot apărea neterminale recursive la
dreapta.
Algoritm: Eliminarea recursivităţii la stânga
Presupunem că G este fără λ-producţii şi fără redenumiri.
Notăm VN = {A1 , . . . , An }, S = A1 (simbolul de start).
for i := 1 to n do begin
for j := 1 to i − 1 do begin
for [fiecare Ai → Aj γ ∈ P] do begin
if [Aj → δ1 | . . . |δk sunt alternativele lui Aj ] then
Introducem Ai → δ1 γ| . . . |δk γ;
Eliminăm Ai → Aj γ
end
end;
Eliminăm recursivitatea imediată la stânga pentru Ai
end
Obs: Algoritmul ı̂ncearcă să transforme gramatica a.ı̂. din orice Ai ∈ VN să nu
se poată deriva decât cuvinte α care ı̂ncep cu terminale sau cu neterminale Aj
cu j > i. Faptul că gramatica nu are λ-producţii şi nici redenumiri elimină riscul
ca un prefix al lui α să se deriveze ı̂n λ, expunând ı̂n stânga un neterminal Aj
cu j ≤ i, şi elimină existenţa unei ciclicităţi A ⇒ . . . ⇒ A, A ∈ VN , ceea ce ar
ı̂mpiedica eliminarea recursivităţii imediate la stânga pentru A.
Exemplu:
Să eliminăm recursivitatea la stânga pentru G dată de:
E → E + T |T , T → T ? F |F , F → (E )|a
(simbolul de start este E , ordinea neterminalelor este: F , T , E ).
pentru F : păstrăm F → (E )|a;
pentru T : eliminăm T → F şi introducem T → (E )|a;
avem deci T → T ? F |(E )|a;
eliminăm recursivitatea imediată la stânga pentru T :
introducem neterminalul nou T 0 ;
ı̂nlocuim T → T ? F |(E )|a cu
T → (E )|a|(E )T 0 |aT 0 ,
T 0 → ?F | ? FT 0 ;
pentru E : eliminăm E → T şi introducem E → (E )|a|(E )T 0 |aT 0 ;
avem deci E → E + T |(E )|a|(E )T 0 |aT 0 ;
eliminăm recursivitatea imediată la stânga pentru E :
introducem neterminalul nou E 0 ;
ı̂nlocuim E → E + T |(E )|a|(E )T 0 |aT 0 cu
E → (E )|a|(E )T 0 |aT 0 |(E )E 0 |aE 0 |(E )T 0 E 0 |aT 0 E 0 ,
E 0 → +T | + TE 0 ;
0 0
pentru T şi E nu avem nimic de transformat.
Exemplu:
Rezultă gramatica dată de:
E → (E )|a|(E )T 0 |aT 0 |(E )E 0 |aE 0 |(E )T 0 E 0 |aT 0 E 0 ,
E 0 → +T | + TE 0 ,
T → (E )|a|(E )T 0 |aT 0 ,
T 0 → ?F | ? FT 0 ,
F → (E )|a
(simbolul de start este tot E ).
Observaţie:
Algoritmul de mai sus elimină recursivitatea la stânga dar introduce
recursivitate la dreapta, ceea ce schimbă asociativitatea regulilor.
În contextul exemplului anterior, cuvântul a + a + a este generat de ambele
gramatici (iniţială şi transformată), dar arborele său de derivare ı̂n gram.
iniţială este: E iar ı̂n gram. transformată este: E
@ @
E + @T a @E 0
@ @
E + @T F + T @E 0
@
T F a a + @T
F a a
a
Într-adevăr, faptul că două gramatici sunt echivalente ı̂nseamnă că
generează aceleaşi cuvinte, dar nu este obligatoriu ca şi arborii lor de
derivare să arate la fel.
Observaţie:
Primul arbore de mai sus corespunde ordinii de calcul (a + a) + a, ı̂n timp
ce al doilea corespunde ordinii de calcul a + (a + a). În cazul lui + nu este
afectată semantica (operaţia matematică de adunare fiind asociativă), dar
ı̂n cazul lui − sau / ar fi.
O soluţie este introducerea de neterminale suplimentare pentru a forţa
modul de asociere şi precedenţa dorită.
Algoritmul de parsare general top - down se poate formaliza astfel:
Intrare: • G = hVN , VT , S, Pi o GIC fără simboluri neutilizate şi nerecursivă

la stânga, cu producţiile numerotate 1, ..., |P|;
• w = a1 . . . an ∈ VT+ (deci n ≥ 1);
Ieşire: • dacă w ∈ L(G ), atunci o analiză stângă a lui w (i.e. şirul numerelor
producţiilor folosite ı̂ntr-o derivare stângă a sa din S);
• dacă w 6∈ L(G ), atunci eroare.
Notaţii: • pentru fiecare A ∈ VN indexăm alternativele lui A, adică considerăm

o ordine a producţiilor care au pe A ı̂n stânga: A → γ1 , ..., A → γkA ;
vom nota cu Ai indexul producţiei A → γi ;
• lucrăm cu configuraţii (descrieri instantanee) de forma (s; i; α; β),
unde:
- s ∈ {q, r , t, e} reprezintă starea algoritmului (stare curentă,
revenire, terminare, resp. eroare);
- i este poziţia curentă ı̂n w ; se consideră şi un delimitator $ aflat pe
poziţia n + 1;
- α este o stivă cu vârful la dreapta, ce reţine alternativele şi
drumurile parcurse pe ele;
- β este o stivă cu vârful la stânga, ce reţine forma sentenţială
curentă.
Configuraţia iniţială este: (q, 1, λ, S$).

Trecerea de la o configuraţie la alta se face ı̂n baza următoarelor reguli (ı̂n
fiecare moment se poate aplica cel mult una dintre ele):
1. (q; i; α; Aβ) ` (q; i; αA1 ; γ1 β), dacă A1 este indexul producţiei A → γ1 ca
primă alternativă a lui A;
2. (q; i; α; aβ) ` (q; i + 1; αa; β), dacă a = ai , 1 ≤ i ≤ n;
3. (q; i; α; aβ) ` (r ; i; α; aβ), dacă a ∈ VT , a 6= ai , 1 ≤ i ≤ n + 1;
4. (q; n + 1; α; $) ` (t; n + 1; α; $) şi STOP; avem w ∈ L(G ) iar o analiză
stângă pentru w se obţine aplicând lui α morfismul de monoizi
(i.e. extinderea la şiruri) generat de funcţia g (a) = λ, dacă a ∈ VT , şi
g (Ai ) = m, dacă Ai este indexul ca alternativă a lui A a producţiei
cu numărul m (ı̂n numerotarea iniţială de la 1 la |P|);
5. (r ; i; αa; β) ` (r ; i − 1; α; aβ), dacă a ∈ VT ;
6a. (r ; i; αAj ; γj β) ` (q; i; αAj+1 ; γj+1 β), dacă j + 1 ≤ kA ;
6b. (r ; i; αAj ; γj β) ` (e; n + 1; αAj ; λ), dacă i = 1, A = S, j = kS ;
6c. (r ; i; αAj ; γj β) ` (r ; i; α; Aβ), altfel.
Propoziţie:
? π
(q; 1; λ; S$) ` (t; n + 1; α; $) d.d. S ⇒s w , unde π = g (α).
π
Obs: cu ⇒s am notat relaţia de derivare stângă prin aplicarea succesivă a
producţiilor cu numerele din π.
Exemplu:
Să aplicăm algoritmul pentru aceeaşi gramatică şi cuvânt ca ı̂n exemplul
ilustrat grafic mai devreme:
Fie G GIC dată de: VN = {E , T , F }
VT = {a, +, ?}
simbolul de start: E
P: 1 : E → T + E (E1 )
2:E →T (E2 )
3 : T → F ? T (T1 )
4:T →F (T2 )
5:F →a (F1 )
(am scris ı̂n stânga numărul ca producţie şi ı̂n dreapta
numărul ca alternativă).
Fie w = a + a (am notat dedesubt poziţiile simbolurilor ı̂n cuvânt).
12 3
Atunci vom avea (am notat deasupra fiecărei ”`” numărul regulii aplicate):
Exemplu:
1 : E → T + E (E1 ), 3 : T → F ? T (T1 ), 5 : F → a (F1 ), w=a + a
2:E →T (E2 ), 4:T →F (T2 ) 1 2 3
1
(q; 1; λ; E $) `
1
(q; 1; E1 ; T + E $) `
1
(q; 1; E1 T1 ; F ? T + E $) `
2
(q; 1; E1 T1 F1 ; a ? T + E $) `
3
(q; 2; E1 T1 F1 a; ?T + E $) `
5
(r ; 2; E1 T1 F1 a; ?T + E $) `
6c
(r ; 1; E1 T1 F1 ; a ? T + E $) `
6a
(r ; 1; E1 T1 ; F ? T + E $) `
1
(q; 1; E1 T2 ; F + E $) `
2
(q; 1; E1 T2 F1 ; a + E $) `
2
(q; 2; E1 T2 F1 a; +E $) `
1
(q; 3; E1 T2 F1 a+; E $) `
Exemplu:
1 : E → T + E (E1 ), 3 : T → F ? T (T1 ), 5 : F → a (F1 ), w=a + a
2:E →T (E2 ), 4:T →F (T2 ) 1 2 3
1
(q; 3; E1 T2 F1 a + E1 ; T + E $) `
1
(q; 3; E1 T2 F1 a + E1 T1 ; F ? T + E $) `
2
(q; 3; E1 T2 F1 a + E1 T1 F1 ; a ? T + E $) `
3
(q; 4; E1 T2 F1 a + E1 T1 F1 a; ?T + E $) `
5
(r ; 4; E1 T2 F1 a + E1 T1 F1 a; ?T + E $) `
6c
(r ; 3; E1 T2 F1 a + E1 T1 F1 ; a ? T + E $) `
6a
(r ; 3; E1 T2 F1 a + E1 T1 ; F ? T + E $) `
1
(q; 3; E1 T2 F1 a + E1 T2 ; F + E $) `
2
(q; 3; E1 T2 F1 a + E1 T2 F1 ; a + E $) `
3
(q; 4; E1 T2 F1 a + E1 T2 F1 a; +E $) `
5
(r ; 4; E1 T2 F1 a + E1 T2 F1 a; +E $) `
6c
(r ; 3; E1 T2 F1 a + E1 T2 F1 ; a + E $) `
Exemplu:
1 : E → T + E (E1 ), 3 : T → F ? T (T1 ), 5 : F → a (F1 ), w=a + a
2:E →T (E2 ), 4:T →F (T2 ) 1 2 3
6c
(r ; 3; E1 T2 F1 a + E1 T2 ; F + E $) `
6a
(r ; 3; E1 T2 F1 a + E1 ; T + E $) `
1
(q; 3; E1 T2 F1 a + E2 ; T $) `
1
(q; 3; E1 T2 F1 a + E2 T1 ; F ? T $) `
2
(q; 3; E1 T2 F1 a + E2 T1 F1 ; a ? T $) `
3
(q; 4; E1 T2 F1 a + E2 T1 F1 a; ?T $) `
5
(r ; 4; E1 T2 F1 a + E2 T1 F1 a; ?T $) `
6c
(r ; 3; E1 T2 F1 a + E2 T1 F1 ; a ? T $) `
6a
(r ; 3; E1 T2 F1 a + E2 T1 ; F ? T $) `
1
(q; 3; E1 T2 F1 a + E2 T2 ; F $) `
2
(q; 3; E1 T2 F1 a + E2 T2 F1 ; a$) `
4
(q; 4; E1 T2 F1 a + E2 T2 F1 a; $) `
Exemplu:
1 : E → T + E (E1 ), 3 : T → F ? T (T1 ), 5 : F → a (F1 ), w=a + a
2:E →T (E2 ), 4:T →F (T2 ) 1 2 3
(t; 4; E1 T2 F1 a + E2 T2 F1 a; $) accept
π = g (E1 T2 F1 a + E2 T2 F1 a) = 145245.
Observaţie:
Dacă am fi numerotat producţiile ı̂n ordinea:
1 : E → T + E (E1 ), 3:T →F (T1 ), 5 : F → a (F1 )
2:E →T (E2 ), 4 : T → F ? T (T2 ),
am fi ajuns la succes după mai puţini paşi (exerciţiu).
În forma prezentată ı̂nsă algoritmul nu determina o numerotare optimă a
producţiilor (numerotarea se dă de la ı̂nceput). Determinarea unei
numerotări mai bune ar adăuga ı̂nsă complexitate suplimentară
algoritmului.
Cuprins
În algoritmul general top-down acceptarea unei producţii s-a bazat pe

consultarea simbolurilor aflate ı̂n stânga porţiunii rămase din cuvânt şi a formei
sentenţiale curente.
Backtrackingul ar putea fi eliminat dacă la fiecare pas consultarea unui număr
de k terminale aflate ı̂n stânga porţiunii rămase din cuvânt şi a simbolului din
stânga formei sentenţiale curente ar desemna direct, ı̂n mod unic, acţiunea
”potrivită”: producţia ”potrivită” care trebuie aplicată, finalizarea cu succes,
finalizarea cu eşec, etc.;
Cu alte cuvinte, ar fi bine dacă am avea o tabelă (numită tabelă k-predictivă)
care pentru orice cuvânt din terminale de lungime < k sau prefix de lungime k
al unui cuvânt mai lung şi pentru orice simbol care ar putea apărea ı̂n stânga
unei forme sentenţiale ar asocia acţiunea respectivă.
Obţinem astfel un algoritm de parsare de tip top-down fără revenire, numit
algoritm de parsare k-predictiv, care este liniar.
Definiţie:
Pentru orice α ∈ VG? notăm:
?
Firstk (α) = {w ∈ VT? : (|w | < k şi α ⇒ w )
?
sau (|w | = k şi ∃x ∈ VG? a.ı̂. α ⇒ wx)}.
În particular, First0 (α) = {λ}.
?
Followk (α) = {w ∈ VT? : ∃ x, β ∈ VG? a.ı̂. S ⇒ xαβ şi w ∈ Firstk (β)}.
Deci:
• Firstk (α) este mulţimea şirurilor de k terminale care pot apărea la ı̂nceputul
unui şir derivat din α, sau a şirurilor de < k terminale ce se pot deriva integral
din α.
• Followk (α) este mulţimea şirurilor de k sau < k terminale ca mai sus care
pot apărea după ceva derivat din α, ı̂n cadrul unui şir derivat din S.
Algoritm de calcul pentru Firstk (α), α ∈ VG? :

1) for [orice a ∈ VT ] do Firstk (a) ← {a};
2) for [orice A ∈ VN ] do Firstk (A) ← ∅;
repeat
 for [orice A → α ∈ P] do Firstk (A) ← Firstk (A) ∪ Firstk (α) 
unde : Firstk (λ) = {λ}
 n ) = Firstk (Firstk (X1 ) · . . . · Firstk (Xn )), Xi ∈ G
Firstk (X1 . . . XS
iar pt. M ⊆ VG? : Firstk (M) =
 
Firstk (α)
α∈M
until [mulţimile Firstk (A), A ∈ VN , nu se mai schimbă];
3) În general, pentru α ∈ VG? vom avea:
dacă α = λ, atunci Firstk (α) = {λ};
dacă α = X1 . . . Xn , Xi ∈ VG , atunci Firstk (α) = Firstk (Firstk (X1 ) · . . . · Firstk (Xn )).
Algoritm de calcul pentru Followk (A), A ∈ VN :

for [orice A ∈ VN \ {S}] do Followk (A) ← ∅;
Followk (S) ← {λ};
repeat
for [orice A → αBγ ∈ P, cu B ∈ VN şi α, γ ∈ VG? ] do
Followk (B) ← Followk (B) ∪ Firstk (Firstk (γ) · Followk (A));
until [mulţimile Followk (A), A ∈ VN , nu se mai schimbă];
Algoritmul de parsare k-predictiv se formalizează astfel:

Fie G = hVN , VT , S, Pi o GIC cu producţiile numerotate de la 1 la |P|.
Vom numi extensia sa GIC G 0 = hVN ∪ {S 0 }, VT ∪ {$}, S 0 , P ∪ {S 0 → S$}i,
unde S 0 şi $ sunt simboluri noi.
(i) (0)
Pt. orice i ∈ NI notăm VT = {w ∈ VT? : |w | = i}; ı̂n particular, VT = {λ}.
Presupunem defintă o aplicaţie (numită tabelă de parsare k-predictivă)
k−1
S (i) (k)
M : (( VT ){$} ∪ VT ) × (VG ∪ {$})
i=0
→ {accept, delete, error } ∪ {(β, i) : i : A → β ∈ P}
astfel ı̂ncât:
M(aα, a) = delete, pentru orice a ∈ VT ;
M($, $) = accept.
Algoritmul de parsare k-predictiv construit pe baza lui M este:

• Se lucrează cu configuraţii de forma (w $; α$; π), unde w ∈ VT? , α ∈ VG? ,
π ∈ {1, . . . , |P|}? ;
• Configuraţia iniţială este (w $; S$; λ), unde w este cuvântul de analizat;
• Trecerea de la o configuraţie la alta se face ı̂n baza următoarelor reguli:
1. (γ; Aδ; π) ` (γ; βδ; πi), dacă M(Firstk (γ), A) = (β, i), i : A → β;
2. (aγ; aδ; π) ` (γ; δ; π), a ∈ VT (corespunde cazului M(aγ, a) = delete,
a ∈ VT );
3. ($; $; π) ` accept (corespunde cazului M($, $) = accept);
4. (γ; δ; π) ` error , altfel (corespunde cazurilor când M(., .) = error ).
Definim funcţia
 parţială ΘM : VT? −→
◦ {1, . . . , |P|}? prin:
?
π, dacă (w $; S$; λ) ` ($; $; π) ` accept

ΘM (w ) = ?
 nedefinită, dacă (w $; S$; λ) ` error .
?
(prin ` am notat ı̂nchiderea reflexivă şi tranzitivă a relaţiei `).
Definiţie:
Spunem că (Θ, M) este un algoritm de parsare k-predictiv valid pentru G
şi că M este o tabelă de parsare validă pentru G , dacă
?
L(G ) = {w ∈ VT? : ∃π a.ı̂. (w $; S$; λ) ` ($; $; π) (i.e. ΘM (w ) = π)}.
π
Obs: În acest caz va rezulta şi că S ⇒s w .
Nu pentru orice GIC se poate construi o tabelă de parsare k-predictivă.
O asemena tabelă se poate construi pentru gramatici de tip LL(k) sau LL(k)
tari.
Cuprins
Alg. de parsare pt. gramatici LL(k) tare
G = hVN , VT , S, Pi o GIC.
Definiţie:
• G este de tip LL(k), k ∈ NI, dacă pentru orice derivare stângă
?
S ⇒s wAα (w ∈ VT? , A ∈ VN , α ∈ VG? )
şi pentru orice producţii A → β, A → γ ∈ P a.ı̂.
?
S ⇒s wAα ⇒s w βα ⇒s wx
? (x, y ∈ VT? )
S ⇒s wAα ⇒s w γα ⇒s wy
cu Fistk (x) = Firstk (y ), avem β = γ.
• G este de tip LL dacă există k ∈ NI a.ı̂. G este de tip LL(k).
Observăm deci că pentru o gramatică de tip LL, la orice pas al unei derivări
stângi, şirul de terminale generat până la momentul curent w , neterminalul
curent A şi primele k terminale care urmează ı̂n cuvântul analizat (acele
”Firstk ”, care conţin fiecare doar câte 1 element) determină ı̂n mod unic
producţia care se aplică din A, adică ce doream.
Denumirea LL (left-left) provine de la faptul că ı̂n algoritmul de parsare
cuvântul analizat este parcurs de la stânga la dreapta (primul ”left”), iar ı̂n
final se obţine o derivare stângă a sa (al doilea ”left”).
Definiţie:
• Un limbaj este de tip LL(k), k ∈ NI, dacă există o gramatică de tip LL(k)
care ı̂l generează.
• Un limbaj este de tip LL dacă există k ∈ NI a.ı̂. limbajul este de tip LL(k).
G = hVN , VT , S, Pi o GIC.
Definiţie:
G este de tip LL(k) tare, k ∈ NI, dacă pt. orice producţii A → β, A → γ ∈ P
cu β 6= γ avem Firstk (βFollowk (A)) ∩ Firstk (γFollowk (A)) = ∅.
Propoziţie:
• Dacă G nu are simboluri neutilizate şi este de tip LL,
atunci G este neambiguă.
• Dacă G nu are simboluri neutilizate şi este recursivă la stânga,
atunci G nu este de tip LL.
• Pentru orice k ∈ NI, dacă G este de tip LL(k), atunci G este de tip LL(k + 1).
• Pentru orice k ∈ NI, dacă G este de tip LL(k) tare, atunci G este de tip LL(k).
• Dacă G nu are simboluri neutilizate, atunci G este de tip LL(1) tare d.d.
G este de tip LL(1).
• (Caracterizare) G fără simboluri neutilizate este LL(k), k ≥ 1, d.d.
?
pentru orice derivare stângă S ⇒s wAα cu w ∈ VT?
şi orice producţii A → β, A → γ ∈ P
avem Firstk (βα) ∩ Firstk (γα) = ∅.
Exemplu:
Să verificăm, cu proprietatea de caracterizare, că următoarea gramatică
este LL(1): S → aAS|b, A → bSA|a.

? ? First1 (aASα) = {a}
Dacă S ⇒s wSα, w ∈ VT , atunci avem ,
First1 (bα) = {b}
deci First1 (aASα) ∩ First1 (bα) = ∅.
? First1 (bSAα) = {b}
Dacă S ⇒s wAα, w ∈ VT? , atunci avem ,
First1 (aα) = {a}
deci First1 (bSAα) ∩ First1 (aα) = ∅.
Exerciţiu: verificaţi aceeaşi proprietate folosind definiţia.
Pentru o GIC G = hVN , VT , S, Pi de tip LL(k) tare, k ∈ NI putem construi o

tabelă de parsare k-predictivă astfel:
• Numerotăm producţiile sub forma i : A → α, i ∈ {1, . . . , |P|}.
• Considerăm extensia G 0 = hVN ∪ {S 0 }, VT ∪ {$}, S 0 , P ∪ {S 0 → S$}i a lui
G , unde S 0 şi $ sunt simboluri noi.
k−1
S (i) (k)
• Definim M : (( VT ){$} ∪ VT ) × (VG ∪ {$})
i=0
→ {accept, delete, error } ∪ {(β, i) : i : A → β ∈ P}
astfel:
◦ pentru orice producţie i : A → β ∈ P şi orice u ∈ Firstk (βFollowk (A)),
definim M(u, A) = (β, i);
◦ M(aα, a) = delete, pentru orice a ∈ VT ;
◦ M($, $) = accept;
◦ M(., .) = error , ı̂n rest;
(mulţimile Firstk , Followk sunt calculate relativ la G 0 ).
Observaţie:
• În cazul k = 1, prima proprietate din definiţia lui M se poate ı̂nlocui cu:
◦ pentru orice i : A → β ∈ P efectuăm următoarele:
− pentru orice a ∈ First1 (β) \ {λ} definim M(a, A) = (β, i);
− dacă λ ∈ First1 (β), atunci pentru orice b ∈ Follow1 (A) definim
M(b, A) = (β, i).
• Pentru o GIC G oarecare (nu neapărat LL(k) tare) construcţia lui M de
mai sus ar putea să nu se facă corect, ı̂n sensul că regulile indicate ar putea
da mai multe valori diferite pentru un acelaşi M(., .) (i.e. M să aibă intrări
multiple). Asemenea intrări multiple se mai numesc şi conflicte.
Pericol este doar ı̂n cazurile M(u, A), A ∈ VN , deoarece pentru un u şi A
fixate ar putea exista mai multe producţii A → β cu u ∈ Firstk (βFollowk (A)).
Vom prezenta mai tărziu câteva tehnici de transformare a unei GIC a.ı̂.
să nu mai apară conflicte.
Propoziţie:
• Pentru o GIC G tabela M construită ca mai sus nu are intrări multiple d.d. G
este de tip LL(k) tare.
• Dacă G este de tip LL(k) tare, atunci algoritmul de parsare k-predictiv
construit pe baza tabelei M construită ca mai sus este valid pentru G .
Exemplu:
Aplicaţie pentru o GIC fără simboluri neutilizate ı̂n cazul LL(1) (i.e. LL(1)
tare):
Fie GIC următoare (care defineşte expresii aritmetice):
1 : E → TX 4 : T → FY 7 : F → (E )
2 : X → +TX 5 : Y → ?FY 8:F →a
3:X →λ 6:Y →λ
(deci VN = {E , T , X , F , Y }, VT = {+, ?, (, ), a}, simbol de start este E şi am

numerotat producţiile).
Să aplicăm algoritmul pentru a parsa cuvântul w = (a ? a).
Începem prin a construi tabela de parsare 1-predictivă M.
Conform observaţiei anterioare, avem nevoie să calculăm
First1 (β), pentru orice producţie A → β
Follow1 (A), pentru orice neterminal A.
În acest scop, vom aplica algoritmii de calcul pentru Firstk , Followk
prezentaţi mai ı̂nainte, pentru GIC extinsă (notăm noul simbol de start E 0 ).
În loc de First1 , Follow1 vom scrie prescurtat Fi, resp. Fo.
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
Mai ı̂ntâi calculăm Fi(β), pentru orice producţie A → β.
În tabelul următor, liniile corespund terminalelor, neterminalelor şi
membrilor drepţi ai producţiilor, iar coloanele corespund paşilor din
algoritm.
În celula corespunzătoare liniei α şi coloanei i scriem ce se adaugă la pasul i
ı̂n Fi(α).
Coloanele se construiesc succesiv spre dreapta până nu se mai adaugă nimic
pe nici o linie.
În final, pe linia fiecărui α vom găsi elementele lui Fi(α).
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
α pas 1 pas 2 pas 3 pas 4 pas 5 pas 6

+ +
? ?
( (
) )
a a
$ $
E0 (, a
E (, a
X +, λ
T (, a
F (, a
Y ?, λ
TX (, a
+TX +
λ λ
FY (, a
?FY ?
(E ) (
E$ (, a
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
În final reţinem:

Fi(TX ) = {(, a}
Fi(+TX ) = {+}
Fi(λ) = {λ}
Fi(FY ) = {(, a}
Fi(?FY ) = {?}
Fi((E )) = {(}
Fi(a) = {a}
Fi(E $) = {(, a}
Vom avea ı̂nsă nevoie şi de:
Fi(E ) = {(, a}
Fi(X ) = {+, λ}
Fi(Y ) = {?, λ}
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
Acum calculăm Fo(A), pentru orice neterminal A.

La Fo(E ) se adaugă la fiecare pas:
Fi(Fi())Fo(F )) = {)} (cf. prod. F → (E ))
Fi(Fi($)Fo(E 0 )) = {$} (cf. prod. E 0 → E $)
La Fo(X ) se adaugă la fiecare pas:
Fi(Fi(λ)Fo(E )) = Fo(E ) (cf. prod. E → TX )
Fi(Fi(λ)Fo(X )) = Fo(X ) (cf. prod. X → +TX ) - este
nerelevant
La Fo(T ) se adaugă la fiecare pas:
Fi(Fi(X )Fo(E )) = Fi({+, λ}Fo(E )) = {+} ∪ Fo(E )
(cf. prod. E → TX )
Fi(Fi(X )Fo(X )) = Fi({+, λ}Fo(X )) = {+} ∪ Fo(X )
(cf. prod. X → +TX )
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
La Fo(F ) se adaugă la fiecare pas:

Fi(Fi(Y )Fo(T )) = Fi({?, λ}Fo(T )) = {?} ∪ Fo(T )
(cf. prod. T → FY )
Fi(Fi(Y )Fo(Y )) = Fi({?, λ}Fo(Y )) = {?} ∪ Fo(Y )
(cf. prod. Y → ∗FY )
La Fo(Y ) se adaugă la fiecare pas:
Fi(Fi(λ)Fo(T )) = Fo(T ) (cf. prod. T → FY )
Fi(Fi(λ)Fo(Y )) = Fo(Y ) (cf. prod. Y → ?FY ) - este
nerelevant
Fo(E 0 ) rămâne {λ} (ca la iniţializare).
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
În tabelul următor, liniile corespund neterminalelor iar coloanele paşilor;

tabel(N, i) conţine ce se adaugă la Fo(N) la pasul i; coloanele se
completează spre dreapta, iar algoritmul se opreşte când nu se mai adaugă
nimic pe nici o linie (atunci pe linia fiecrărui N vom găsi elementele lui
Fo(N)):
Neterminal pas 1 pas 2 pas 3
E0 λ
E ), $
X ), $
T +, ), $
F ?, +, ), $
Y +, ), $
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
În final reţinem:

Fo(E 0 ) = {λ}
Fo(E ) = {), $}
Fo(X ) = {), $}
Fo(T ) = {+, ), $}
Fo(F ) = {?, +, ), $}
Fo(Y ) = {+, ), $}
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
Acum construim tabela de parsare 1-predictivă M : ({$} ∪ VT ) × (VG ∪ {$})

→ {acc, del, err } ∪ {(β, i) : i : A → β producţie ı̂n G }
Pentru 1 : E → TX avem Fi(TX Fo(E )) = {(, a} (deoarece Fi(TX ) = {(, a}),
deci M((, E ) = (TX , 1), M(a, E ) = (TX , 1).
Asemănător:
Pentru 2 : X → +TX avem Fi(+TX Fo(X )) = {+}.
Pentru 3 : X → λ avem Fi(λFo(X )) = {), $}.
Pentru 4 : T → FY avem Fi(FY Fo(T )) = {(, a} (deoarece Fi(FY ) = {(, a}).
Pentru 5 : Y → ?FY avem Fi(?FY Fo(Y )) = {?}.
Pentru 6 : Y → λ avem Fi(λFo(Y )) = {+, ), $}.
Pentru 7 : F → (E ) avem Fi((E )Fo(F )) = {(}.
Pentru 8 : F → a avem Fi(aFo(F )) = {a}.
Exemplu:
1 : E → TX 3:X →λ 5 : Y → ?FY 7 : F → (E ) 9 : E0 → E$
2 : X → +TX 4 : T → FY 6:Y →λ 8:F →a
Pentru 1 : E → TX avem Fi(TX Fo(E )) = {(, a}.

Pentru 2 : X → +TX avem Fi(+TX Fo(X )) = {+}.
Pentru 3 : X → λ avem Fi(λFo(X )) = {), $}.
Pentru 4 : T → FY avem Fi(FY Fo(T )) = {(, a}.
Pentru 5 : Y → ?FY avem Fi(?FY Fo(Y )) = {?}.
Pentru 6 : Y → λ avem Fi(λFo(Y )) = {+, ), $}.
Pentru 7 : F → (E ) avem Fi((E )Fo(F )) = {(}.
Pentru 8 : F → a avem Fi(aFo(F )) = {a}.
Obţinem tabela (nu am mai trecut intrările err ):

E X T F Y + ? ( ) a $
$ λ, 3 λ, 6 acc
+ +TX , 2 λ, 6 del
? ?FY , 5 del
( TX , 1 FY , 4 (E ), 7 del
) λ, 3 λ, 6 del
a TX , 1 FY , 4 a, 8 del
Să analizăm cuvântul w = (a ? a) (la fiecare tranziţie am subliniat prefixele

care devin argumente pentru funcţia M):
Exemplu:
E X T F Y + ? ( ) a $
$ λ, 3 λ, 6 acc
+ +TX , 2 λ, 6 del
? ?FY , 5 del
( TX , 1 FY , 4 (E ), 7 del
) λ, 3 λ, 6 del
a TX , 1 FY , 4 a, 8 del
((a ? a)$; E $; λ) `
((a ? a)$; T X $; 1) `
((a ? a)$; F YX $; 14) `
((a ? a)$; (E )YX $; 147) `
(a ? a)$; E )YX $; 147) `
(a ? a)$; T X )YX $; 1471) `
(a ? a)$; F YX )YX $; 14714) `
(a ? a)$; aYX )YX $; 147148) `
(?a)$; Y X )YX $; 147148) `
(?a)$; ?FYX )YX $; 1471485) `
(a)$; F YX )YX $; 1471485) `
(a)$; aYX )YX $; 14714858) `
()$; Y X )YX $; 14714858) `
Exemplu:
E X T F Y + ? ( ) a $
$ λ, 3 λ, 6 acc
+ +TX , 2 λ, 6 del
? ?FY , 5 del
( TX , 1 FY , 4 (E ), 7 del
) λ, 3 λ, 6 del
a TX , 1 FY , 4 a, 8 del
()$; X )YX $; 147148586) `

()$; )YX $; 1471485863) `
($ ; Y X $; 1471485863) `
($ ; X $; 14714858636) `
($ ; $ ; 147148586363) `
accept
Analiza rezultată este: 147148586363.
Observăm că parsarea s-a făcut fără revenire.
Exerciţiu: desenaţi arborele de derivare.
Am văzut că pentru GIC oarecare, dacă ı̂ncercăm să construim tabela de
parsare k-predictivă M ca mai sus, pot apărea intrări multiple (conflicte), dacă
gramatica nu este de tip LL(k) tare.
Riscul să apară conflicte există doar la intrările M(u, A), cu A neterminal -
anume pentru un u şi un A fixate ar putea exista mai multe producţii A → β
a.ı̂. u ∈ Firstk (βFollowk (A)).
Uneori ı̂nsă conflictele pot fi rezolvate - gramatica poate fi transformată
ı̂ntr-una echivalentă de tip LL(k) tare.
Prezentăm ı̂n continuare tipurile posibile de conflicte şi câteva metode de
rezolvare a lor. Vom ilustra doar pentru cazul k = 1.
Am văzut că ı̂n acest caz 
 u ∈ First1 (β) \ {λ}
u ∈ Firstk (βFollowk (A)) ⇔ sau
λ ∈ First1 (β) şi u ∈ Follow1 (A)

• Conflicte First/First:
Presupunem că avem două producţii i1 : A → β1 , i2 : A → β2 , β1 6= β2 , şi

u ∈ (First1 (β1 ) ∩ First1 (β2 )) \ {λ}.
Atunci ı̂n M(u, A) ajunge şi (β1 , i1 ) şi (β2 , i2 ).
O soluţie: factorizarea la stânga
Exemplu:
A → XA0 (A0 neterminal nou)
A→X
producţiile: se ı̂nlocuiesc cu: A0 → λ
A → XYZ
A0 → YZ
• Conflicte First/Follow :
Exemplu:
1 : S → Aab
Dacă avem producţiile: 2:A→a (S şi A neterminale, a şi b terminale).
3:A→λ

 (a, 2), pentru că a ∈ First1 (a)
atunci M(a, A) poate fi: sau
(λ, 3), pentru că λ ∈ First1 (λ) şi a ∈ Follow1 (A)

O soluţie: substituţia
Exemplu:
S → aab
Înlocuim producţiile 1, 2, 3 cu: (dispare A).
S → ab
Obs. că ı̂n urma substituţiei pot apărea conflicte First/First - atunci facem ı̂n
S → aA
continuare factorizare la stânga şi ı̂nlocuim aceste producţii cu: A → ab
A→b
(reapare A, dar producţiile sunt altele).
• Recursivitatea la stânga:
Am spus că o GIC G = hVN , VT , S, Pi este recursivă la stânga dacă există

+
A ∈ VN a.ı̂. A ⇒ Aα cu α 6= λ.
Recursivitatea la stânga generează conflicte First/First cu toate alternativele
neterminalului recursiv.
Exemplu:
i0 : E → E + T
i1 : E → α1
Dacă avem producţiile:
i2 : E → α2
···
atunci pentru orice j şi orice u ∈ First1 (αj ) \ {λ} avem u ∈ First1 (E + T ), deci
ı̂n intrarea M(u, E ) va ajunge şi (αj , ij ) şi (E + T , i0 ).
Soluţia: eliminarea recursivităţii la stânga (am prezentat algoritmul mai

devreme).
Exerciţii seminar:
La exerciţiile 1 - 6 neterminalele sunt litere mari, terminalele litere mici,
simbolul de start este S; mulţimile neterminalelor, terminalelor, resp.
producţiilor se deduc din context.
1. Eliminaţi simbolurile neutilizate pentru următoarele GIC:
a) S → AB|CA, A → a, B → BC |AB, C → aB|b;
b) S → AB|a, A → bB|cC , B → SA|A, C → aA|bB|S;
c) S → SS|AAa, A → aAB|aS|b.
2. Determinaţi dacă L(G ) = ∅ pentru următoarele GIC:
a) S → AS|A, A → aB|bA;
b) S → ABC , A → BB|λ;
c) B → CC |a, C → AA|b.
3. Eliminaţi λ-producţiile pentru următoarele GIC:
a) S → ABC , A → BB|λ, B → CC |a, C → AA|b
b) S → aSb|bSa|SS|λ.
4. Eliminaţi redenumirile şi apoi simbolurile inaccesibile pentru următoarea
GIC: S → A, A → bS|b.
Exerciţii seminar:
5. Caracterizaţi gramaticile de tip LL(0).
6. Arătaţi că GIC: S → aAaa|bAba, A → b|λ
este LL(2) dar nu LL(2) tare.
7. Aplicaţi algoritmul de parsare pentru gramatici LL(1) (tare) pentru GIC:
1 : S → F , 2 : S → (S + F ), 3 : F → 1
şi cuvântul w = (1 + 1).
Teme laborator:
1. Scrieţi un program care citeşte o GIC, apoi construieşte şi afişază GIC
proprie şi fără recursivitate la stânga echivalentă cu ea.
Algoritmii componenţi (B), (A), (C), (D), eliminarea recursivităţii la stânga vor
fi implementaţi ca proceduri/funcţii separate, care vor primi gramaticile sursă şi
destinaţie ca parametri.
2. Implementaţi algoritmul de parsare general top - down.
Programul va citi o GIC (presupusă a fi fără simboluri neutilizate şi nerecursivă
la stânga), apoi ı̂ntr-un ciclu va citi diverse cuvinte şi va determina dacă fac
parte din limbajul generat de gramatică; ı̂n caz afirmativ, va afişa şi producţiile
aplicate ı̂ntr-o derivare stângă a sa.
3. Implementaţi algoritmul de parsare general top - down folosind o
procedură/funcţie recursivă, care la fiecare apel să facă o derivare. Celelalte
detalii sunt ca la problema 2.
Teme laborator:
4. Implementaţi algoritmul de parsare pentru gramatici de tip LL(1) (tare).
Detaliile sunt asemănătoare celor din problema 2.
5. Implementaţi o variantă recursivă a algoritmului de parsare pentru gramatici
de tip LL(k) tare, pentru o gramatica fixată prin cod:
Pentru fiecare neterminal A se asociază o procedură/funcţie, care consultă k
simboluri din cuvântul de intrare ı̂ncepând de la poziţia curentă (reţinută ı̂ntr-o
variabilă globală sau transmisă ca parametru), determină (unic) producţia lui A
care trebuie aplicată, ı̂i afişază numărul, iar pentru fiecare simbol din membrul
său drept, dacă e terminal avansează poziţia curentă ı̂n cuvântul de intrare, iar
dacă e neterminal apelează procedura/funcţia acestuia. Tabela de parsare este
implementată prin codul acestor proceduri/funcţii.
Alternativ, se poate folosi o singură procedură/funcţie recursivă, care
primeşte neterminalul ca parametru. De asemenea, gramatica poate să nu fie
fixată prin cod, ci programul să o citească, să construiască tabela de parsare
ı̂ntr-o structură de date (de ex. o matrice), iar procedura/funcţia unică să fie
un cod general, care lucrează pe această structură de date.
Alte detalii sunt asemănătoare celor din problema 2.

2 - Teoria - Compilarii-Dragulici - Analiza Sintactica-123 - Pag

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

2 - Teoria - Compilarii-Dragulici - Analiza Sintactica-123 - Pag

Încărcat de

Drepturi de autor:

Formate disponibile

Teoria Compilării

Drăgulici Dumitru Daniel

Facultatea de matematică şi informatică,

Sintaxa limbajelor de programare se defineşte şi se investighează folosind

Definiţie:Gramatici independente de context (GIC):

Uneori mulţimea {A → γ1 , . . . , A → γn } a tuturor producţiilor ce au ı̂n stânga

Definiţie: Pentru o GIC G definim:

Definiţie: Pentru o GIC G definim:

Definiţie: Pentru o GIC G definim:

Deci G este ambiguă.

Sintaxa limbajelor de programare se defineşte cu GIC neambigue, ı̂n care:

Verificarea faptului că un cuvânt format din terminale aparţine limbajului

Algoritmii de parsare top - down ı̂ncearcă construirea arborelui de derivare de

Deci gramatica trebuie să aibă proprietăţi suplimentare, pentru a evita

Fie G = hVN , VT , S, Pi o GIC cu L(G ) 6= ∅.

Algoritm (C): Eliminarea simbolurilor neutilizate

Fie G = hVN , VT , S, Pi o GIC.

Algoritm (C): Eliminarea λ-producţiilor

Fie G = hVN , VT , S, Pi o GIC.

Algoritm: Eliminarea recursivităţii imediate la stânga

Algoritmul de parsare general top - down se poate formaliza astfel:

Intrare: • G = hVN , VT , S, Pi o GIC fără simboluri neutilizate şi nerecursivă

Notaţii: • pentru fiecare A ∈ VN indexăm alternativele lui A, adică considerăm

Configuraţia iniţială este: (q, 1, λ, S$).

În algoritmul general top-down acceptarea unei producţii s-a bazat pe

Fie G = hVN , VT , S, Pi o GIC.

Algoritm de calcul pentru Firstk (α), α ∈ VG? :

Algoritm de calcul pentru Followk (A), A ∈ VN :

Algoritmul de parsare k-predictiv se formalizează astfel:

Algoritmul de parsare k-predictiv construit pe baza lui M este:

Nu pentru orice GIC se poate construi o tabelă de parsare k-predictivă.

Pentru o GIC G = hVN , VT , S, Pi de tip LL(k) tare, k ∈ NI putem construi o

(deci VN = {E , T , X , F , Y }, VT = {+, ?, (, ), a}, simbol de start este E şi am

α pas 1 pas 2 pas 3 pas 4 pas 5 pas 6

În final reţinem:

Acum calculăm Fo(A), pentru orice neterminal A.

La Fo(F ) se adaugă la fiecare pas:

În tabelul următor, liniile corespund neterminalelor iar coloanele paşilor;

În final reţinem:

Acum construim tabela de parsare 1-predictivă M : ({$} ∪ VT ) × (VG ∪ {$})

Pentru 1 : E → TX avem Fi(TX Fo(E )) = {(, a}.

Obţinem tabela (nu am mai trecut intrările err ):

Să analizăm cuvântul w = (a ? a) (la fiecare tranziţie am subliniat prefixele

()$; X )YX $; 147148586) `

Presupunem că avem două producţii i1 : A → β1 , i2 : A → β2 , β1 6= β2 , şi

O soluţie: factorizarea la stânga

Am spus că o GIC G = hVN , VT , S, Pi este recursivă la stânga dacă există

Soluţia: eliminarea recursivităţii la stânga (am prezentat algoritmul mai

S-ar putea să vă placă și