método lalr

Análisis sintáctico (Look ahead LR)Análisis sintáctico (Look ahead LR)

Este tipo de análisis se puede realizar

mediante 3 técnicas: LR(k): Leen la entrada de izquierda a derecha

(Left to rigth). SLR(1): Mejora el LR(1) pero hace uso de la

búsqueda hacia delante. LALR(1): Más potente que SLR(1) y más

sencillo que LR(1).

Análisis Sintáctico LR

Significa «lookahead LR« Esta técnica generalmente se usa en la practica. Este es un análisis sintáctico de búsqueda hacia

adelante. Esta técnica es mas larga de realizar, pero

también es la mas efectiva. Es una técnica intermedia entre SLR(1) y LR(k). Aquí básicamente lo que se hace la unión de los

conjuntos de elementos que tengan elementos comunes en sus goto(Ui, α), y que únicamente varíe la parte del lookahead de cada conjunto.

Análisis Sintáctico LALR

Conceptos

Simbolo First/Primero

Si x es terminal

F(x) ={x}

Si x ->e Anadir e al F(x)

X -> YZW Anadir F(U) al F(x)


Algoritmo

Simbolo Follow/Look a head

Si x es simbolo inicial

F(x) {$}

Si x -> αYM 1. F(Y) =F(M)2. Si el F(M) contiene e

entonces añadir el first(X) al F(Y)

Si x -> αY Anadir el F(x) al F(Y)

ENCONTRANDO FIRS Y FOLLOW

Por ejemplo si tenemos dos conjuntos Ui y Uj

Podemos hacer la unión de sus lookahead , creando así un conjunto Uij, así:


Algoritmo

Ui = X->Y ·Z {a}

Uj = X->Y ·Z {b}

Uij = X->Y ·Z {a,b}

Ui = X->Y ·Z {a}

Uj = X->Y ·Z {b}

Entrada: Gramática aumentada G’Método:

Construir la colección de conjuntos de elementos LR(1).

Para cada conjunto en LR(1), encontrar todos los conjuntos con los mismos elementos y sustituir todos por su unión de lookahead.

Construir las acciones de análisis sintáctico para cada nuevo estado (acción e ir_a iguales que el algoritmo de LR Canónico).


Algoritmo

Construiremos las transiciones de la siguiente gramática:

(1)S → A(2)S → xb(3)A → aAb(4)A → B(5)B → x• Necesitaremos aumentarla, asi:

(0)S’ → S$(1)S → A(2)S → xb(3)A → aAb(4)A → B(5)B → x


Ejemplo


Ejemplo

(0)S’ →• S(1)S → •A(2)S → •xb(3)A → •aAb(4)A →• B(5)B → •x

S1: Goto (So, S):

S’ -> S

• •{$}

S2: Goto (So, A)

S’ -> A

• •{$}

S3: Goto (So, B)

A’ -> B

• •{$}

S -> x b {$}A -> x {$}

• •• •

S4: Goto (So, x)

S5:Goto(S0, a)A -> a Ab {$}A -> •aAb {$}A -> •B {$}B -> •x {$}

• •

S5: Goto(So, a)

Creando Goto

Ahora hacemos los goto(Si, α), donde Si es el conjunto que vamos a crear y α es el terminal o no terminal a donde vamos a movernos; copiando sus lookahead de la producción padre.

S1:Goto(S0,S) S4:Goto (S0, x)S’ -> S • {$} S -> x •b {$}

A -> x • {$}S2:Goto(S0, A) S5:Goto(S0, a)S -> A • {$} A -> a •Ab {$}

A -> •aAb {$}S3:Goto (S0, B) A -> •B {$}A -> B • {$} A -> •x {$}


EjemploTendremos en

cuenta que cuando

movemos el • con un No

terminal y este es el ultimo

elemento este pasa a ser un

kernel.

S13:Goto (S4,b)S -> xb • {$}

S6:Goto (S5,A): S8:Goto (S5,B)(Goto S7,B)A -> a •Ab {$} A -> B • {$}A -> •aAb {b}A-> •B {b} S9:Goto (S5,x) Goto(S7,x):B -> •x {b} B -> x • {$}

S7:Goto (S5,a) Goto(S7,a):A -> a •Ab {b}A -> •aAb {b}A -> •B {b}B -> •x {b}


Ejemplo

S10:Goto (S6,b)S -> xb • {$}

S11:Goto (S7,A)S -> aA•b {b}

S12:Goto (S11,b)S -> aAb• {$}


Ejemplo

S’ -> •S

{$}S -> •A {$}

S -> •xb {$}

A -> •aAb {$}

A -> •B {$}B -> •x {$}

S’ -> S • {$}

S0

S -> A • {$}

A -> B • {$}

A -> a •Ab {$}

A -> •aAb {b}

A-> •B {b}B -> •x {b}

A -> aA •b {$}

A -> aAb • {$}

S -> x•b {$}

B -> x • {$}

S -> xb • {$}

B -> x • {b}

S1 S3

S

S2

S10

S6

S5

S13S4A -> B •

{b}

S9

S8

A -> a •Ab {b}

A -> •aAb {b}

A-> •B {b}B -> •x {b}

S7

A -> aA• b {b}

A -> aAb• {b}

S11

S12

B

A

a

x

A

a

x

B

b

B

x

b

a

A

b

Ahora trataremos de unir todos los conjuntos que tengan elementos en común y también uniendo sus lookahead. Con estos Conjuntos: S3 con S8S5 con S7S6 con S11S10 con S12

Teniendo S3={A→B• {$}}S8={A→B• {b}

Pasaremos a:S3_8={A→B• {$,b}

Y así con todos los demás..

Nota: al unir estos conjuntos tenemos que unir también sus transiciones.

S’ -> •S

{$}S -> •A {$}

S -> •xb {$}

A -> •aAb {$}

A -> •B {$}B -> •x {$}

S’ -> S • {$}

S0

S -> A • {$}

A -> B • {b,$}

A -> a •Ab {$,b}

A -> •aAb {b}

A-> •B {b}B -> •x {b}

A -> aA •b {$, b}

A -> aAb • {$,b}

S -> x•b {$}

B -> x • {$}

S -> xb • {$}

B -> x • {b}

S1 S3_8

S

S2

S10_12

S6_11

S5_7

S13S4

S9

B

A

a

x

A

a

x

b

b

B

1. Construir la colección de conjuntos de elementos.2. Ui es el estado i. Las acciones se determinan:

1. Si A -> α · aβ está en Ui e ir_a(Ui, a) = Uj entonces “desplazar j” en acción[i, a].

2. Si A -> α · está en Ui entonces “reducir A -> α” en acción [i, a] para toda a en Look a head(A).

3. Si S´ -> S · está en Ui entonces “aceptar” en acción[i,$].

3. Si ir_a(Ui, A) = Uj, entonces ir_a(i, A) = j4. Todas las entradas no definidas por 2 y 3 son error.5. El estado inicial del analizador es el que contiene [S´ -> · S]

Construcción de la Tabla de AS

a b x $ S’ S A B

0 d5_7 d4 1 2 3_8

1 Acepta

2 r1

3_8 r4 r4

4 d13 r5

5_7 d5_7 d9 6_11 3_8

6_11 d10_12

9 r5

10_12

r3 r3

13 r2

Construcción de Tabla de AS

Terminales No terminalesEstados SiEvaluar Cadena

Los Goto son desplazar y los kernel son reducir

Cadena de entrada: aaxbbPara iniciar en nuestra pila tenemos 0 y a la par tenemos

nuestra cadena de entrada. Vamos evaluando (0,a)=S5_7, movemos a la pila a, seguido

de 5_7

Cuando encontramos un ri en la tabla, nos vamos al numero de producción que lo produjo y reemplazamos la producción por el no terminal.

Evaluar una cadena de entrada.

Pila Entrada

Tabla LALR

0 aaxbb$


(0,a) =S5_7

(5_7,a)=S5_7axbb$0a5_7

Pila Entrada

Tabla LALR

0


Ver Tabla

(0,a)= S5_7

(5_7,a)= S5_7(5_7,x)= S9

(9,b) = r5 -> B -> x

(5_7,B) = 3_8

(3_8,b) = r4 -> A -> B

(5_7,A)= 6_11

(6_11,b) =S10_12

(10_12,b)=r3 -> A -> aAb

(5_7, A)= 6_11

(6_11,b)=S10_12

(10_12,$)=r3-> A->aAb

(0,A)=2

(2,$)=r1 -> S->A(0,S)=1(1,$)= ACEPTADA

0a5_7a5_7x9

0a5_7a5_70a5_7

0a5_7a5_7B3_8

0a5_7a5_7A0a5_7a5_7A6_11

0a5_7a5_7A6_11b10_12

0a5_7A

0a5_7A6_110a5_7A6_11b10_12

0A

0A2

0S0S1

aaxbb$

axbb$

xbb%$bb$

bb$

bb$

bb$bb$

b$

b$

b$$

$$

$

$

0a5_7a5_7B

*Si la casilla esta vacia es error

Cadena Aceptada

FIN

método lalr

Documents