Cursul 9

Gramatici LR(0)
Automatul LR(0)
Test LR(0)
Analizor sintactic LR(0)
Generatoare de analizoare
sintactice - YACC
Gramatici i analizoare SLR(1)
Test SLR(1)
Tabela de analiza SLR(1)
Analizor sintactic SLR(1)

lfac Gh Grigoras 1
 Automatul LR(0)
Algoritmul 1 (procedura nchidere(t))
Intrare: Gramatica G = (V, T, S, P);
Mulimea t de articole din gramatica G;
Ieire: t = nchidere( t ) = {q Q | p t, q (p, ) } = (t, )
Metoda:
t = t ; flag = true;
while( flag ) {
flag = false;
for ( A B t ) {
for ( B P )
if ( B t ) {
t = t {B };
flag = true;
}//endif
}//endforB
}//endforA
}//endwhile
return t;

lfac Gh Grigoras 2
 Automatul LR(0)
Algoritmul 2 Automatul LR(0)
Intrare: Gramatica G = (N, T, S, P) la care s-a adugat S S;
Ieire: Automatul determinist M = (T, , g, t0, T) echivalent cu M.
Metoda:
t0=nchidere(SS); T={t0}; marcat(t0)=false;
while(tT && !marcat(t)) { // marcat(t) = false
for( X ) { // = N T
t = ;
for( A X t )
t = t {B X | B X t};
if( t ){
t = nchidere( t );
if( t T ) {
T = T { t };
marcat( t ) = false;
}//endif
g(t, X) = t;
}//endif
}//endfor
}//endfor
marcat( t ) = true;
}// endwhile

lfac Gh Grigoras 3
 Automatul LR(0)
Exemplu S S, S aSa | bSb | c
S S
S aSa S
S S
S bSb
S c
a
a b
c b

S aSa c S c c S bSb
S aSa S aSa
S bSb S bSb
b
S c S c

S a S

S aSa S bSb

a b

S aSa S bSb

lfac Gh Grigoras 4
 Test LR(0)
Definiie Fie G o gramatic i M automatul LR(0) ataat
lui G. Spunem c o stare a lui M are un conflict
reducere/reducere dac ea conine dou articole
complete distincte A , B . Spunem c o stare a
lui M are un conflict deplasare/reducere dac ea
conine un articol complet A i un articol cu
terminal dup punct de forma B a. Spunem c o
stare este consistent dac ea nu conine conflicte i
este inconsistent n caz contrar.
Teorema Fie G o gramatic i M automatul su LR(0).
Gramatica G este LR(0) dac i numai dac automatul
M nu conine stri inconsistente

lfac Gh Grigoras 5
 Automatul LR(0)
Exemplu S aAd | bAB A cA | c Bd

S S
S aAd S S S
S bAB

a b

S aAd A cA S bAB
A cA c A c c A cA
A c A cA S c
A c

c
A A
A
S bAB
S aAd A cA B d

d B d

S aAd S bAB B d

lfac Gh Grigoras 6
 Algoritm de analiz sintactic LR(0)
Intrare

a1 ai an #

Stiva

TABELA
tm CONTROL DE
PARSARE

tm-1

.
.
p1 p2

t0
Ieire

lfac Gh Grigoras 7
 Algoritm de analiz sintactic LR(0)
n cazul k = 0, tabela de parsare coincide cu automatul
LR(0), M.
Configuraie: (, u#, ) unde t0T*, u T*, P*.
Configuraia iniial este (t0, w#, ),
Tranziiile:
Deplasare: ( t, au#, ) ( tt, u#, ) dac g (t, a) = t.
Reducere: ( tt, u#, ) ( tt, u#, r) dac A t,
r = A , |t | = || i t= g (t, A).
Acceptare: (t0t1, #, ) este configuraia de acceptare dac
S S t1, este parsarea acestuia (irul de reguli care s-a
aplicat, n ordine invers, n derivarea extrem dreapt a lui w).
Eroare: o configuraie creia nu i se poate aplica nici o tranziie
este configuraie de eroare. Analizorul se oprete cu respingerea
cuvntului de analizat.

lfac Gh Grigoras 8
Algoritmul de analiz sintactic LR(0)
Intrare: Gramatica G (cu S S), Automatul LR(0) notat M = (T, , g, t0, T ), Cuvntul de intrare w T*.
Ieire: Analiza sintactic (parsarea) ascendent a lui w dac w L(G); Eroare, n caz contrar.
Metoda: Fie STIVA o stiv, a simbolul curent,
char ps[] = w#; //ps este sirul de intrare w
i = 0; // pozitia in sirul de intrare
STIVA.push(t0); // se initializeaza stiva cu t0
while(true) { // se repeta pana la succes sau eroare
t = STIVA.top();
a = ps[i] // a este simbolul curent din intrare
if( g(t, a) { //deplasare
STIVA.push(g(t, a));
i++; //se inainteaza in intrare
}
else {
if(A X1X2Xm t){
if(A == S)
if(a == #)exit( acceptare);
else exit(eroare);
else // reducere
for( i = 1; i m; i++) STIVA.pop();
STIVA.push(g(top(STIVA), A));
} //endif
else exit(eroare);
}//endelse
}//endwhile

lfac Gh Grigoras 9
Exemplu S S S E$ E E+T T (E) ET Ta
3 0 1

E T S S S S
T S E$ S
T E E+T
4 E T 2
T (E)
T (E) T a E S E$
E E+T ( E E+T
E T
T (E)
T a
a $
( (
5 + 6
a
E T a S E$
8

T (E) a
E E+T 7
+
E E+T 9
) T (E) T
T a E E+T
10

T (E)

lfac Gh Grigoras 10
Exemplu S S S E$ E E+T T (E) ET Ta

G a + ( ) $ S E T
0 5 4 1 2 3
1
2 7 6
3
4 5 4 8 3
5
6
7 5 4 9
8 7 10
9
10

lfac Gh Grigoras 11
Exemplu S S S E$ E E+T T (E) ET Ta
STIVA INTRARE ACIUNE IEIRE

0 a+(a+a)$# deplasare

5 +(a+a)$ # reducere Ta

03 +(a+a)$ # reducere ET

02 +(a+a)$ # deplasare

027 (a+a)$ # deplasare

0274 a+a)$ # deplasare

02745 +a)$ # reducere Ta

02743 +a)$ # reducere ET
02748 +a)$ # deplasare

lfac Gh Grigoras 12
Exemplu S S S E$ E E+T T (E) ET Ta
027487 a)$ # deplasare

0274875 )$ # reducere Ta
0274879 )$ # reducere E E+T

02748 )$ # deplasare

02748(10) $# reducere T (E)

0279 $# reducere E E+T

02 $# deplasare

026 # reducere S E$
01 # acceptare

lfac Gh Grigoras 13
 Corectitudinea parserului LR(0)
Lema 1 Fie G = (N, T, S, P) o gramatic LR(0), t0, t0 drumuri n
automatul LR(0) etichetate cu respectiv i u, v T*. Atunci, dac n
parserul LR(0) are loc (t0, uv#, ) + (t0, v#, ), atunci n G are loc
~

derivarea u.
dr
Lema 2 Fie G = (N, T, S, P) o gramatic LR(0) i + o form
~

propoziional a lui G astfel nct u, cu * i dac este nenul
dr
atunci :1 este neterminal. Atunci n parserul LR(0) are loc calculul
(t0, uv#, ) * (t0, v#, )
unde t0 i t0 sunt drumuri n automatul LR(0) etichetate cu respectiv
, pentru orice cuvnt v T*.

Teorema Dac G este gramatic LR(0) atunci, oricare ar fi cuvntul de

intrare w T*, parserul LR(0) ajunge la configuraia de acceptare pentru
~

w, adic (t0, w#, ) + (t0t1, #, ), dac i numai dac S w.

dr

lfac Gh Grigoras 14
 Generatoare de analizoare sintactice
YACC (Yet Another Compiler Compiler)
conceput i realizat n 1975 de S. C. Johnson la
Bell Laboratory
Bison, compatibil n ntregime cu YACC, scris de
Robert Corbett i Richard Stallmann (2006
versiunea 2.3)
http://dinosaur.compilertools.net/
http://epaperpress.com/lexandyacc/index.html
http://www.gnu.org/software/bison/

lfac Gh Grigoras 15
 Utilizarea generatorului de parsere YACC
yacc nume_fisier.y

Structura fiierului de intrare:

Declaraii
%%
Reguli
%%
Rutine C

lfac Gh Grigoras 16
 Declaraii
%{ Declaraii C %}
Declararea token-urilor:
%token <nume _unitate _lexical>
Declararea simbolului de start al gramaticii:
%start <nume _simbol _de _start>
Alte declaraii:
type - pentru definirea tipului;
left - pentru asociativitate stnga a operatorilor;
right - pentru asociativitate dreapta a operatorilor;
prec - pentru precizarea precedenei operatorilor;
nonassoc - pentru declaraiile de neasociativitate

lfac Gh Grigoras 17
 Reguli
Forma unei reguli:
<neterminal> : <parte dreapta> {cod C}

expr : NUMAR {$$ = $1;}

| expr + expr {$$ = $1+$3;}
| expr - expr {$$ = $1-$3;}
| expr * expr {$$ = $1*$3;}
| expr / expr {$$ = $1/$3;}
| ( expr) {$$ = $2;}
;
lfac Gh Grigoras 18
 Exemplu
%token a b c d
%%
S : A a {printf( S -> Aa \n);}
| b A c {printf( S -> bAc \n);}
| B c {printf( S -> Bc \n);}
| b B a {printf( S -> bBa \n);}
A : d {printf( A -> d \n);}
B : d {printf( B -> d \n);}
%%
int main(void) {
yyparse();
}
lfac Gh Grigoras 19
 Exemplu
%token CINT VAR
%left '+' '-'
%left '*' '/
%%
program:
program statement '\n'
| /* NULL */
;
statement:
expression {printf("%d\n", $1);}
| VAR '=' expression { sym[$1] = $3; }
;
expression:
CINT
| VAR { $$ = sym[$1]; }
| expression '+' expression { $$ = $1 + $3; }
| expression '-' expression { $$ = $1 - $3; }
| expression '*' expression { $$ = $1 * $3; }
| expression '/' expression { $$ = $1 / $3; }
| '(' expression ')' { $$ = $2; }
;
%%

lfac Gh Grigoras 20
 Gramatici i analizoare SLR(1)
Definiia 5.4.1 Fie G o gramatic pentru care automatul LR(0)
conine stri inconsistente (deci G nu este LR(0)). Gramatica G este
gramatic SLR(1) dac oricare ar fi starea t a automatului LR(0)
sunt ndeplinite condiiile:
Dac A , B t atunci FOLLOW(A) FOLLOW(B) = ;
Dac A , B a t atunci a FOLLOW(A).

Modelul de algoritm de analiz sintactic SLR(1) este acelai ca cel

LR(0); tabela de analiz sintactic se construiete astfel:
Prima, numit ACIUNE, determin dac parserul va face deplasare
respectiv reducere, n funcie de starea ce se afl n topul stivei i de
simbolul urmtor din intrare
Cea de a doua, numit GOTO, determin starea ce se va aduga n
stiv n urma unei reduceri.

lfac Gh Grigoras 21
 Construcia tabelei de parsare SLR(1)
Intrare: Gramatica G = (N, T, S, P) augmentat cu S S;
Automatul M = (Q, , g, t0, Q );Mulimile FOLLOW(A), A V
Ieire: Tabela de analiz SLR(1) compus din dou pri:
ACIUNE(t, a), t Q, a T { # }, GOTO(t, A), t Q, A V.
Metoda:
for(t Q)//Se initializeaza tabela de parsare
for (a T) ACTIUNE(t, a) = eroare;
for (A V) GOTO(t, A) = eroare;
for(t Q}{
for(A a t)
ACTIUNE(t,a)=D g(t, a);//deplasare in g(t, a)
for(B t ){ // acceptare sau reducere
if(B == S) ACTIUNE(t, a) = acceptare;
else
for(aFOLLOW(B))ACTIUNE(t,a)=R B;
}// endfor
for (A V) GOTO(t, A) = g(t, A);
}//endfor
lfac Gh Grigoras 22
 Algoritmul de analiz sintactic SLR(1)
Deplasare: ( t, au#, ) ( tt, u#, ) dac ACTIUNE(t, a) = Dt ;

Reducere: ( tt, u#, ) ( tt, u#, p) dac ACTIUNE(t, a) = Rp

unde p = A , |t | = || i t= GOTO(t, A);

Acceptare: (t0t, #, ) dac ACTIUNE(t,a) = acceptare; Analizorul se

oprete cu acceptarea cuvntului de analizat iar este parsarea
acestuia (irul de reguli care s-a aplicat, n ordine invers, n
derivarea extrem dreapt a lui w).

Eroare: (t, au#, ) eroare dac ACTIUNE(t,a) = eroare;

Analizorul se oprete cu respingerea cuvntului de analizat.

lfac Gh Grigoras 23
 Algoritmul de analiz sintactic SLR(1)
Intrare:
Gramatica G = (V, T, S, P) care este SLR(1) ;
Tabela de parsare SLR(1) ( ACTIUNE, GOTO);
Cuvntul de intrare w T*.
Ieire:
Analiza sintactic (parsarea) ascendent a lui w dac
w L(G);
eroare, n caz contrar.
Metoda: Se folosete stiva St pentru a
implementa tranziiile deplasare/reducere

lfac Gh Grigoras 24
 Algoritmul de analiz sintactic SLR(1)
char ps[] = w#; //ps este cuvantul de intrare w
int i = 0; // pozitia curenta in cuvantul de intrare
St.push(t0); // se initializeaza stiva cu t0
while(true) { // se repeta pana la succes sau eroare
t = St.top();
a = ps[i] // a este simbolul curent din intrare
if(ACTIUNE(t,a) == acceptare) exit(acceptare);
if(ACTIUNE(t,a) == Dt){
St.push(t);
i++; // se inainteaza in w
}//endif
else {
if(ACTIUNE(t,a) == R A X1X2Xm){
for( i = 1; i m; i++) St.pop();
St.push(GOTO(St.top, A));
} //endif
else exit(eroare);
}//endelse
}//endwhile

lfac Gh Grigoras 25
Exemplu: Fie gramatica expresiilor aritmetice:
0.S E, 1.E E+T, 2.E T, 3.T T*F, 4.T F, 5.F (E), 6.F a

0 1 3 4

S E S E T F F (E)
E E+T E E+T E E+T
E T 5 E T
T T*F T T*F
T F 2 F a T F
F (E) F (E)
F a E T F a
T T*F 8

F (E)
6 7 10
E E+T
E E+T T T*F T T*F
T T*F F (E)
T F F a 9
F (E) 11
F a E E+T
T T*F F (E)

lfac Gh Grigoras 26
 Tabela de tranziie a automatului LR(0)
g a + * ( ) E T F
0 5 4 1 2 3
1 6
2 7
3
4 5 4 8 2 3
5
6 5 4 9 3
7 5 4 10
8 11
9 7
10
11

lfac Gh Grigoras 27
 Tabela de analiz SLR(1)
ACIUNE GOTO
STARE a + * ( ) # E T F
0 D5 D4 1 2 3
1 D6 accepta

2 R2 D7 R2 R2
3 R4 R4 R4 R4
4 D5 D4 8 2 3
5 R6 R6 R6 R6
6 D5 D4 9 3
7 D5 D4 10
8 D11
9 R1 D7 R1 R1
10 R3 R3 R3 R3
11 R5 R5 R5 R5

lfac Gh Grigoras 28
 Test SLR(1)
Din automatul construit se deduce c G nu este LR(0): strile 1, 2, 9
conin conflict de deplasare/reducere. Pentru a verifica dac
gramatica este SLR(1) avem nevoie de mulimile FOLLOW(S) i
FOLLOW(E).
NETERMINAL FOLLOW

S #
E #, +, )
T #, +, *, )
F #, +, *, )

Gramatica este SLR(1) pentru c:

n starea 1: + FOLLOW(S);
n starea 2: * FOLLOW(E);
n starea 9: * FOLLOW(E).

lfac Gh Grigoras 29
 STIVA INTRARE ACIUNE IEIRE

0 a*(a+a)# deplasare

5 *(a+a)# reducere Fa

3 *(a+a)# reducere TF

2 *(a+a)# deplasare

27 (a+a)# deplasare

274 a+a)# deplasare

2745 +a)# reducere Fa

02743 +a)# reducere TF

02742 +a)# reducere ET

lfac Gh Grigoras 30
 STIVA INTRARE ACIUNE IEIRE

02748 +a)# deplasare

027486 a)# deplasare

0274865 )# reducere Fa
0274863 )# reducere TF
0274869 )# reducere E E+T

02748 )# reducere
02748(11) # reducere F (E)

027(10) # reducere T T*F

02 # reducere ET
01 # acceptare

lfac Gh Grigoras 31
Exemplu: 1.S L=R, 2.S R, 3.L *R, 4.L a, 5.R L
0
1 3
S S
S S S S L=R R S R
S R
L *R
L a
L
R L
*

2 4

S L=R L *R
R L a a R L
5 L *R
L a
L a
=
6 a *

S L=R *
R L
L
L *R
R
L a 8
L

R L
7
R
9 L *R

S L=R

lfac Gh Grigoras 32