PARSER LR(0)

Es un parser ascendente basado en un autómata a Pilas, el cual es guiado por la función ACCION la
cual esta dentro de una Tabla de Análisis.

x1x2 … xn$ es la cadena candidata. xi es el token actual. El símbolo $ es el fin de cadena.

La pila contiene alternadamente estados si y símbolos xi. Al tope de la pila se encuentra el

estado Sm, el cual es el estado actual.

La tabla de analisis comprende a la función ACCION y a la función GOTO

Dicha tabla de análisis es obtenida a partir de la gramática que define al lenguaje.

Ejem.
Dado: (1) S -- > ( S )
(2) S -- > ID donde ID es un identificador, es decir un nombre cualesquiera.

La tabla de análisis es:

Funcion Acción GOTO
Estado ( ) ID $ S
0 d2 d3 1
1 Aceptar
2 d2 d3 4
3 r2 r2 r2 r2
4 d5
5 r1 r1 r1 r1

Algoritmo:
1. Precondicion: Empilar S0, llamar al scanner.
2. Obtener acción(Sm, token), el cual puede ser:
a) d n == > desplazamiento == > empilar(token), empilar(Sn), llamar al scanner.
b) r m == > reducción == > desempilar pivote
reducir usando la regla m: A -- > pivote
empilar(A)
obtener nuevo estado = GOTO(Sj, A ),
 donde Sj es el estado que quedo al tope cuando se saco el pivote.
empilar nuevo estado
c) Aceptar == > Pertenece
d) Error == > No pertenece. Error es una celda vacía.

Verificacion: para la cadena (( ID )) del lenguaje ultimo tenemos:

PILA CADENA ACCION

0 ( ( ID ) ) $ acción(0, ’(’ ) = d2
0(2 ( ID ) ) $ acción(2, ’(’ ) = d2
0(2(2 ID ) ) $ acción(2, ID ) = d3
0 ( 2 ( 2 ID 3 ))$ acción(3, ’)’ ) = r2 GOTO (2, S) = 4
0(2(2S4 ))$ acción(4, ’)’ ) = d5
0(2(2S4)5 )$ acción(5, ’)’ ) = r1 GOTO(2, S ) = 4
0(2 S4 )$ acción(4, ’)’ ) = d5
0(2 S4)5 $ acción(5, $ ) = r1 GOTO(0, S ) = 1
0S1 $ accion(1, $ ) = Aceptar

Construccion de la Tabla de Analisis.

Empezamos definiendo el concepto de Item, el cual es básicamente un indicador del estado de

avance en el proceso de reconocimiento. Este avance lo marcamos con un punto.

Ejm, dada la Regla de Producción X -- > AB se tienen los siguientes ítems:

X -- > •AB // se va a iniciar el reconocimiento
X -- > A•B // se reconocio A, nos falta reconocer B
X -- > AB• // se reconocio B, se completo el reconocimiento.

Luego definimos la Cerradura de un Item

Dado el item X --> A•W B , entonces dependiendo de si W es terminal o No terminal.
- Si W es terminal, entonces no añade nada
- Si W es No Terminal, entonces hay que añadir todas las reglas de producción para W con el
punto por delante.
- Repetir hasta que no se puedan agregar más ítems a la cerradura.

Luego construiremos el diagrama de estados, a partir del cual llenaremos la tabla. Lo haremos a
través de un ejemplo:

Ejemplo: Obtener un Parser LR(0) para la siguiente gramatica

(1) S -- > AB
(2) A -- > a
(3) B -- > b
Consideramos temporalmente un nuevo símbolo distinguido Z, el cual lo definimos como Z S.
Ademas hay que recordar que Seguidor (S) = { $ }

Empezamos con el ítem 0: Z -- > • S

y obtenemos la cerradura del ítem 0, lo cual nos da el estado 0

0: Z -- > • S
S -- > • AB
A -- > • a

Ahora vemos que simbolos nos permiten avanzar el punto. Estos definen transiciones hacia
nuevos estados, los cuales empiezan con el ítem siguiente, el que tiene el punto avanzado y luego
le calculamos la cerradura de ese siguiente item.

Desde el estado 0 cuando viene S entonces pasamos al estado 1.

1: Z -- > S • como el punto llego al final, ahi termina ese estado.

Desde el estado 0 cuando viene A entonces pasamos al estado 2 y calculamos la cerradura

2: S -- > A • B
: B -- > • b

Desde el estado 0 cuando viene a entonces pasamos al estado 3

3: B -- > a • como el punto llego al final, ahi termina ese estado.

Vemos que aun podemos avanzar desde el estado 2.

Desde el estado 2 cuando viene B entonces pasamos al estado 4

4: S -- > A B • como el punto llego al final, ahi termina ese estado.

Desde el estado 2 cuando viene b entonces pasamos al estado 5

5: B -- > b • como el punto llego al final, ahi termina ese estado.

El diagrama de estados final seria el siguiente:

Luego llenamos la tabla de la siguiente forma:

En las filas colocamos los estados. En las columnas para la función ACCION colocamos los
terminales y para la función GOTO colocamos los No Terminales.

Los desplazamientos son cambios de estado con un terminal. Por ejem del estado 0 al estado 3
hay una transición con el símbolo a. Entonces en la fila de estado 0 y en la columna del terminal a
colocamos d3. Esto significa que si estamos en el estado 0 y llega el símbolo a entonces hacemos
un desplazamiento hacia el estado 3.

Las reducciones son cuando dentro de un estado hay un ítem con el punto al final. Por ejem. En el
estado 4 hay una reducción S AB • es decir en la fila del estado 4 colocaremos en toda la fila
r1, es decir reduccion usando la regla 1.

Hay que notar que en el estado 1 se tiene una reduccion del simbolo distinguido, eso es Aceptar y
ocurre solo cuando se tiene el fin de cadena, por lo cual Aceptar debera ir en esa columna.

Los cambios de estado con un No Terminal, son parte de la function GOTO. Por ejemplo del estado
0 con el No terminal A pasamos al estado 2.

La Tabla de Analisis es entonces:

Funcion Acción GOTO

Estado a B $ S A B
0 d3 1
1 Aceptar 2
2 d5 4 4
3 r2 r2 r2
4 r1 r1 r1
5 r3 r3 r3

Ejem.
Para la siguiente gramatica:

Tenemos el siguiente diagrama de estados:

Y la correspondiente Tabla de Analisis

Y la correspondiente verficacion para la cadena candidata abcde es:

Conflictos en la construcción del Parser LR(0)
Al llenar la Tabla de Símbolos observamos que hay celdas vacias (lo cual significa que la cadena
candidata no pertenece al lenguaje) o bien hay un solo valor contenido (desplazamiento,
reducción o Aceptar). Pero a veces al llenar la tabla puede suceder que en una celda hay 2 valores.
A esto lo llamamos conflictos, los cuales deben ser resueltos, y el parser ya no seria un Parser
LR(0).

Hay 2 tipos de conflictos.

Conflicto desplazamiento-reducción

En el estado 2 vemos que hay una reducción

A --> a B • pero tambien hay un desplazamiento
con el simbolo e hacia el estado 3.

Si dicha reducción corresponde a la RP numero 4

entonces en la fila 2, columna e habrán dos valores:
r4 / d3

Conflicto reducción-reducción.

En el estado 4 vemos que hay dos reducciones. Si estas

correspondiesen a las RP 2 y 3 entonces en la fila 4, en
cada celda tendríamos dos valores:
r2 / r3

PARSER SLR(1)

Cuando en un parser LR(0) se produce un conflicto Desplazamiento-Reduccion o Reduccion-

Reduccion, se puede resolver usando el conjunto de seguidores(A) para descartar o validar una
reducción A-- > α.

Al hacer esto ya no estaremos con un parser LR(0) sino con un parser SLR(1).

Ejemplo: Obtener un Parser LR(0) para la siguiente gramatica

(1) S → E
(2) E → 1 E
(3) E → 1
Si hubiese conflictos, entonces resolverlos para obtener un parser SLR(1)

El diagrama de estados es el siguiente:

y la Tabla de Analisis es:

Funcion Acción GOTO

Estado 1 $ S E
0 3 1 2
1 Aceptar
2 r1 r1
3 d3 / r3 r3 4
4 r2 r2

Observamos que hay una celda con conflicto desplazamiento-reduccion: d3 / r3

Entonces en la regla de producción (3) E → 1 obtenemos los seguidores de E

Seguidores ( E ) = { $ }

Entonces solo dejamos la reduccion r3 en las columnas bajo los seguidores de E. Esto elimina el
conflicto. Sin embargo, para completar el proceso, también debemos realizar lo mismo sobre las
otras reducciones.

r1: S → E Seguidores ( S ) = { $ }
r2: E → 1 E Seguidores ( E ) = { $ }

Finalmente la Tabla de Analisis queda de la siguiente forma:

Funcion Acción GOTO

Estado 1 $ S E
 0 3 1 2
1 Aceptar
2 r1
3 d3 r3 4
4 r2

Donde ya no observamos conflictos, pero hay que notar que este es un parser SLR(1).

Observacion: En el caso de un conflicto reduccion-reduccion se debe igualmente obtener los

seguidores de cada No Terminal y quedar solo las columnas bajo esos seguidores.

Por ejemplo si tuviésemos:

Funcion Acción GOTO

Estado 1 $
…
2 r3 / r4 r3 / r4
,,,

y supongamos:

(3) A → x seguidores ( A ) = { 1 }
(4) B → y seguidores ( B ) = { $ }

Entonces la tabla quedaría:

Funcion Acción GOTO

Estado 1 $
…
2 r3 r4
,,,

Se debe observar que para que el conflicto desaparezca ambos conjuntos de seguidores deben
ser disjuntos.

Tipos de Parser LR
Existen 3 tipos:
1. SLR(K), es el parser LR simple
2. LALR(k), Look Ahead LR.
3. LR(k) canonico