Está en la página 1de 27

Análisis Sintáctico LR(0)

ALCALDE GARRIDO JEAN PIERRE


CHAVEZ GONZALES FAVIO
GERONIMO SANES ALAN
LUIS VISITACION JHONATAN
Introducción

 El tipo más frecuente de analizador sintáctico ascendentes en la


actualidad se basa en un concepto conocido como análisis sintáctico
LR(k); la “L” indica la exploración de izquierda a derecha de la
entrada, la “R” indica la construcción de una derivación por la
derecha a la inversa, y la k para el número de símbolos de entrada de
preanálisis que se utilizan al hacer decisiones del análisis sintáctico.
Los casos k = 0 o k = 1 son de interés práctico, en esta oportunidad
trataremos los casos k=0.
Introducción

 Los analizadores sintácticos LR son controlados por tablas, en forma


muy parecida a los analizadores sintácticos LL no recursivos. Se dice
que una gramática para la cual podemos construir una tabla de
análisis sintáctico, usando LR es una gramática LR
Ventajas

 Pueden construirse analizadores sintácticos LR para reconocer


prácticamente todas las construcciones de lenguajes de
programación para las cuales puedan escribirse gramáticas libres de
contexto. Existen gramáticas libres de contexto que no son LR, pero
por lo general se pueden evitar para las construcciones comunes de
los lenguajes de programación
Ventajas

 El método de análisis sintáctico LR es el método de análisis sintáctico


de desplazamiento reducción sin rastreo hacia atrás más general que
se conoce a la fecha, y aún así puede implementarse con la misma
eficiencia que otros métodos más primitivos de desplazamiento-
reducción (vea las notas bibliográficas).
 Un analizador sintáctico LR puede detectar un error sintáctico tan
pronto como sea posible en una exploración de izquierda a derecha
de la entrada.
Ventajas

 La clase de gramáticas que pueden analizarse mediante los métodos


LR es un superconjunto propio de la clase de gramáticas que pueden
analizarse con métodos predictivos o LL. Para que una gramática sea
LR(k), debemos ser capaces de reconocer la ocurrencia del lado
derecho de una producción en una forma de frase derecha, con k
símbolos de entrada de preanálisis. Este requerimiento es mucho
menos estricto que para las gramáticas LL(k), en donde debemos ser
capaces de reconocer el uso de una producción, viendo sólo los
primeros símbolos k de lo que deriva su lado derecho. Por ende, no
debe sorprender que las gramáticas LR puedan describir más
lenguajes que las gramáticas LL
Desventaja

 La principal desventaja del método LR es que es demasiado


trabajo construir un analizador sintáctico LR en forma manual
para una gramática común de un lenguaje de programación.
Se necesita una herramienta especializada: un generador de
analizadores sintácticos LR uno de los que se utilizan con más
frecuencia es Yacc. Dicho generador recibe una gramática libre de
contexto y produce de manera automática un analizador para esa
gramática. Si la gramática contiene ambigüedades u otras
construcciones que sean difíciles de analizar en una exploración de
izquierda a derecha de la entrada, entonces el generador de
analizadores sintácticos localiza estas construcciones y proporciona
mensajes de diagnóstico detallados
Analizador sintáctico LR

 Usa una pila y un puntero a la cadena de entrada.


 Se basa en cuatro operaciones:
 Desplazar: Poner un símbolo de la entrada en el tope de la pila.
 Reducir: Desapila algunos símbolos que son el cuerpo de una
producción y los reemplaza por la cabeza.
 Aceptar.
 Detectar error.
Analizador sintáctico LR

 Un analizador sintáctico LR realiza las decisiones de desplazamiento-


reducción mediante el mantenimiento de estados, para llevar el
registro de la ubicación que tenemos en un análisis sintáctico. Los
estados representan conjuntos de “elementos”. Un elemento LR(0)
(elemento, para abreviar) de una gramática G es una producción de
G con un punto en cierta posición del cuerpo. Por ende, la producción
A → XYZ produce los siguientes cuatro elementos:
Cerradura de conjuntos de
elementos
 Si I es un conjunto de elementos para una gramática G, entonces
CERRADURA(I) es el conjunto de elementos que se construyen a
partir de I mediante las siguientes dos reglas:
1. Al principio, agregar cada elemento en I a CERRADURA(I).
2. Si A → α·Bβ está en CERRADURA(I) y B → γ es una producción,
entonces agregar el elemento B → γ a CERRADURA(I), si no se encuentra
ya ahí. Aplicar esta regla hasta que no puedan agregarse más
elementos nuevos a CERRADURA(I).
Cerradura de conjuntos de
elementos
 Considérese la gramática de expresiones aumentada
E’ -> E
E -> E + T | T
T -> T * F | F
F -> (E) | id
Cerradura de conjuntos de
elementos
 Si I es el conjunto de un elemento {[E’ -> .E]}, entonces
cerradura (I) contiene los elementos
E’ -> .E
E -> .E + T | F
E -> .T
T -> .T * F
T -> .F
F -> .(E)
F -> .id
Cerradura de conjuntos de
elementos
 Una manera conveniente de implementar la función cerradura es
mantener un arreglo booleano llamado agregado, indexado mediante
los no terminales de G, de tal forma que agregado[B] se establezca a
true si, y sólo si agregamos el elemento B → ·γ para cada producción
B de la forma B → γ.
La función ir_A (go_to)

 La segunda función útil es ir_A(I, X ), en donde I es un conjunto de


elementos y X es un símbolo gramatical. ir_A(I, X ) se define como la
cerradura del conjunto de todos los elementos [A → αX·β], de tal
forma que [A → α·Xβ] se encuentre en I. De manera intuitiva, la
función ir_A se utiliza para definir las transiciones en el autómata
LR(0) para una gramática. Los estados del autómata corresponden a
los conjuntos de elementos, y ir_A(I, X ) especifica la transición que
proviene del estado para I, con la entrada X.
colección canónica de conjuntos de
elementos LR(0)
 Ahora estamos listos para que el algoritmo construya a C, la
colección canónica de conjuntos de elementos LR(0) para una
gramática aumentada G ; el algoritmo se muestra en la figura.
Ejemplo práctico
I0
S’ -> .E
E->T + E E -> .T +
E -> T E
T -> int * E -> .T
T T -> .int *
T -> int T
T -> (E) T -> .int
T -> .(E)
Ejemplo práctico
I1
I0 E S’ ->
E.
S’ -> .E I2
E->T + E E -> .T +
E -> T T E -> T. +
E E
T -> int * E -> .T
T E ->I T.
T -> .int * 3
T -> int T int T -> int. *
T -> (E) T -> .int T
T -> .(E) T -> int.
I4
( T -> (.E)
E -> .T +
E
E -> .T
T -> .int *
T
T -> .int
T -> .(E)
Ejemplo práctico I6
I1 E -> T + .E
I0 E S’ -> E -> .T + E
E. E-> . T
S’ -> .E I2 + T -> .int *
E->T + E E -> .T +
E -> T T E -> T. + T
E E T -> .int
T -> int * E -> .T
T E ->I T. T -> .(E)
T -> .int * 3
I5
T -> int T int T -> int. *
T -> (E) T -> .int T * T -> int * .
T -> .(E) T -> int. T
I4 T -> . Int *
( T -> (.E) T
E -> .T + T-> .int
E T -> .(E)
E -> .T
T -> .int *
T
T -> .int
T -> .(E)
Ejemplo práctico I6
E
I7

I1 E -> T + .E E -> T +
E -> .T + E E.
I0 E S’ ->
E. E-> . T
S’ -> .E I2 + T -> .int *
E->T + E E -> .T +
E -> T T E -> T. + T
E E T -> .int
T -> int * E -> .T
T E ->I T. T -> .(E)
T -> .int * 3
I5
T -> int int T -> int. * I8
T T
T -> (E) T -> .int T * T -> int * . T -> int *
T -> .(E) T -> int. T T.
I4 T -> . Int *
( T -> (.E) T
E -> .T + T-> .int
E T -> .(E)
E -> .T
T -> .int * I9
E
T T ->
T -> .int (E .)
T -> .(E)
Ejemplo práctico I6
E
I7

I1 E -> T + .E E -> T +
E -> .T + E E.
I0 E S’ ->
E. E-> . T
S’ -> .E I2 + T -> .int *
E->T + E E -> .T +
E -> T T E -> T. + T
E E T -> .int
T -> int * E -> .T
T E ->I T. T -> .(E)
T -> .int * 3
I5
T -> int in I8
T T -> int. * T
T -> (E) T -> .int t T * T -> int * . T -> int *
T -> .(E) T -> int. T T.
I4 T -> . Int *
( T -> (.E) T
E -> .T + T-> .int
E T -> .(E)
E -> .T
T -> .int * I9 I10
E )
T T -> T ->
T -> .int (E .) (E).
T -> .(E)
Ejemplo práctico I6
E
I7

I1 E -> T + .E E -> T +
E -> .T + E T E.
I0 E S’ -> I2
E. E-> . T
S’ -> .E I2 + T -> .int * int
E->T + E I3
E -> .T + E -> T. + T
E -> T E T (
T -> int * E T -> .int I4
E -> .T E ->I T. T -> .(E)
T T -> .int * 3
I5 I8
T -> int T in T -> int. *
T -> (E) T -> int * . T
T -> .int t T * T -> int * T
T -> .(E) T -> int. T .
I4 T -> . Int *
( T -> (.E) T
E -> .T + T-> .int
E T -> .(E)
E -> .T
T -> .int * I9 I10
E )
T T -> T ->
T -> .int (E .) (E).
T -> .(E)
Ejemplo práctico I6
E
I7

I1 E -> T + .E E -> T +
E -> .T + E T E.
I0 E S’ -> I2
E. E-> . T
S’ -> .E I2 + T -> .int * in
E->T + E I3
E -> .T + E -> T. + T t
E -> T E T (
T -> int * E T -> .int I4
E -> .T E ->I T. T -> .(E)
T T -> .int * 3
I5 I8
T -> int T int T -> int. *
T -> (E) T -> int * . T
T -> .int T * T -> int *
T -> .(E) T -> int. T T.
I4 in I
T -> . Int * 3
( t
T -> (.E) T
( I4
E -> .T + T-> .int
E T -> .(E)
E -> .T
T -> .int * I9 I10
E )
T T -> T ->
T -> .int (E .) (E).
T -> .(E)
Ejemplo práctico I6
E
I7

I1 E -> T + .E E -> T +
E -> .T + E T E.
I0 E S’ - I2
> .E E-> . T
S’ -> .E I2 + T -> .int * in
E->T + E I3
E -> .T + E -> T. + T t
E -> T E T (
T -> int * E T -> .int I4
E -> .T E ->I T. T -> .(E)
T T -> .int * 3
I5 I8
T -> int T int T -> int. *
T -> (E) T -> int * . T
T -> .int T * T -> int * T
T -> .(E) T -> int. T .
I4 int I
T -> . Int * 3
( T -> (.E) T
( I4
E -> .T + T-> .int
T E T -> .(E)
I2
E -> .T
in T -> .int * I9 I10
I3 E )
t T T -> T ->
T -> .int (E .) (E).
T -> .(E)
Ejemplo práctico

INT ( ) + * $ E T
0 S3 S4 1 2
1 Aceptació
n
2 R2 R2 R2 R2/S6 R2
3 R4 R4 S5 R4
4 S3 S4 9 2
5 S3 S4 8
6 S3 S4 7 2
7 R1 R1
8 R3 R3 R3 R3 R3 R3
9 S10
10 R5 R5 R5 R5 R5 R5
Conflictos R(0)

 Los conflictos aparecen cuando una determinada celda de la sección


Acción de la tabla puede rellenarse con varios valores
 Estos conflictos significan que la gramática no es LR(0). Puede que la
gramática sea ambigua, o que sea LALR o LR(1).
Ejemplo práctico
TABLA PARSING
E’ -> E
E -> BB I1
B -> cB/ I5 c d $ E B
d E E’ -> I0 S3 S3 1 2
E ->
E. B BB . I1 Aceptació
I2
I0 n
B E -> B . B
E’ -> . E I2 S3 S3 5
B -> . cB/.
E -> . BB I6
d c I3 S3 S3 6
B -> . cB/. I3 B B ->
d c I4 r3 r3 r3
B -> c.B/. cB.
D I5 r3 r3 r3
d
B -> . cB/.
dd c I6 r3 r3 r3
d
B ->
d.
I4
Ejemplo práctico Analizar ccdd$

TABLA PARSING

Pila Entrad Acción


c d $ E B a
I0 S3 S4 1 2 $0 ccdd$ Cambiar C en la pila e Ir_A
estado3
I1 Aceptació
n $0c3 cdd$ Cambiar C -> S3
I2 S3 S4 5 $0c3c3 dd$ Cambiar D -> S4
I3 S3 S4 6 $0c3c3d d$ Reducir r3 B –> d
I4 r3 r3 r3 4

I5 r1 r1 r1 $0c3c3 d$ Reducir B -> cB


B6
I6 r2 r2 r3
$0B2 d$ Cambiar d -> S4
$0B2d4 $ Reducir B -> d
E0b2b5 $ Reducir E->BB
$0E1 $ Aceptacion