Análisis Sintáctico. Procesadores de Lenguaje I - GIAA

Análisis Sintáctico 

Cadena de 

tokens 

Analizador 

Sintáctico 

Árbol 


En realidad... 

Analizador 

Léxico 

Componente léxico 

Obtén otro 

componente léxico 

Analizador 


Árbol 

sintáctico 

Tabla de 

Símbolos

Análisis Sintáctico. Procesadores de Lenguaje I 


Funciones 

• Comprobar que la secuencia de componentes 

léxicos cumple las reglas de la gramática 

• Generar el árbol sintáctico 

Ventajas de utilizar gramáticas 

• Son especificaciones sintácticas y precisas de 

lenguajes 

• Se puede generar automáticamente un analizador 

• El proceso de construcción puede llevar a 

descubrir ambigüedades 

• Imparte estructura al lenguaje de programación, 

siendo más fácil generar código y detectar errores 

• Es más fácil ampliar y modificar el lenguaje 


Analizador Sintáctico, Tipos 

Tres tipos generales de analizadores sintácticos: 

• Métodos Universales: Cocke-Younger-Kasami y Earley 

• Sirven para cualquier gramática 

• Muy ineficientes 

• Descendentes (top-down) 

• Construyen el árbol de análisis sintáctico desde arriba (raíz, 

axioma) hasta abajo (hojas, terminales) 

• Analizadores Descendentes Recursivos 

• Analizadores LL(1) con tabla 

• Ascendentes (bottom-up) 

• Construyen el árbol de análisis sintáctico desde abajo hacia 

arriba 

• Analizadores de Precedencia de Operador 

• Analizadores LR(1)


Analizador Sintáctico 

Tanto para el análisis descendente como para el 

ascendente: 

• La entrada se examina de izquierda a derecha, un símbolo 

cada vez 

• Trabajan con subclases de gramáticas 

En general las gramáticas serán LL y LR 

• LR(k) ⊃ LL(k) 

• En la práctica solo se utilizan LR(1) y LL(1) 

Muchos compiladores se llaman “parser-driven” 

debido a que el analizador sintáctico es el que llama 

al léxico 

Existen herramientas para generar automáticamente 

analizadores sintácticos (YACC, Bison) 


Analizador Sintáctico 

Árbol sintáctico 

• Ejemplo: Id.*.Id.+.Id 

Expresión 

Gramática: 

Expresión::= 

Expresión.*.Término 

| Expresión.+.Término 

| Término 

Término ::= Id 

| Número 

Expresión 

+ 

Término 

Expresión 

* 

Término 

Id 

Término 

Id 

Id


Análisis Sintáctico Descendente 

Algoritmo 

1. Poner el axioma como raíz del árbol de derivación 

2. Hasta que solo haya símbolos terminales, derivar más a la 

izquierda 

Ejemplo 

• Entrada: Id.*.Id.+.Id 

• Gramática: 

Expresión::=Expresión.*.Término | Expresión.+.Término | 

Término 

Término ::= Id | Número 

• Derivación: 

Expresión → Expresión.+.Término → 

Expresión.*.Término.+.Término → 

Término.*.Término.+.Término → 

Id.*.Término.+.Término → 

Id.*.Id.+.Término → Id.*.Id.+.Id 


Análisis Sintáctico Ascendente 

Definición: Pivote 

• Secuencia más larga de símbolos (Σ T y Σ N ) en la parte más 

izquierda de la entrada que se puede encontrar en la parte 

derecha de una producción y tal que todos los símbolos a su 

derecha son terminales 

• Ejemplo: 

• Si entrada es: Expresión.*.Término.+.Id 

• el pivote es: Expresión.*.Término 

Algoritmo 

1. Empezar con la cadena de entrada 

2. Intentar llegar hasta el axioma, encontrando el pivote y 

reduciéndolo con la producción correspondiente 

Ejemplo 

Id.*.Id.+.Id → Término.*.Id.+.Id → Expresión.*.Id.+.Id → 

Expresión.*.Término.+.Id → Expresión.+.Id → 

Expresión.+.Término → Expresión


Analizadores Sintácticos, 

Problemas 

Descendentes 

• Mas de una opción: A::= α | β 

• Retroceso 

• Analizar los siguientes elementos de la entrada 

• Recursividad izquierda 

• Eliminación de la recursividad 

• Ambigüedad 

• Factorización por la izquierda 

Ascendentes 

• Más de una opción: A::= α y α es el pivote 

Otros 

• Problemas semánticos 


Análisis Sintáctico Predictivo 

No necesita realizar retroceso para analizar bien las 

sentencias del lenguaje 

Sólo con ver el siguiente carácter de la entrada 

puede decidir cuál va a ser la siguiente producción a 

emplear 

Condiciones 

• Diseñar bien la gramática 

• Eliminar la recursividad izquierda 

• Factorizar por la izquierda 

No está asegurado el tener una gramática predictiva 

Las gramáticas son difíciles de leer 

Para las partes de las gramáticas que no son 

predictivas se pueden utilizar otros analizadores


Análisis Sintáctico Predictivo: 

Descendente Recursivo 

Se ejecuta un conjunto de procedimientos recursivos para 

procesar la entrada 

A cada NO Terminal de una gramática se le asocia un 

procedimiento 

• Decide la producción que utilizará analizando el símbolo de 

preanálisis, 

• si está en PRIMERO(α) entonces se usa la producción con lado derecho α 

• si no está en ningún PRIMERO entonces se usa una producción λ 

• Usa una producción imitando al lado derecho 

• no terminal da como resultado una llamada a otro procedimiento 

• terminal (que coincide con el símbolo de preanálisis) produce otra lectura 

de otro token. Si el token no coincide entonces Error 

La secuencia de procedimientos llamados para procesar la 

entrada define implícitamente un árbol de análisis sintáctico 



Descendente Recursivo 

Ejemplo: 

S → if B then S | write B | i := B 

B → i = i | i i | true | false 

Procedure S() 

{ 

if (car== if) 

{ scan(); 

B(); 

if (car== then) {scan();} else error(); 

S(); 

} 

else if (car==write) 

{scan(); 

B(); 

} 

else if (car== i) 

{ scan(); 

if (car == asig) {scan();} else error(); 

B(); 

} 

else error() 

} 

Procedure B() 

{ 

if (car= i) 

{ scan(); 

if (car in [igual, noigual]) scan(); else error(); 

if (car == i) then scan else error; 

} 

elseif (car in [true, false]) 

scan(); 

else 

error(); 

}


Análisis Sintáctico Predictivo, 

DEFINICIONES: PRIMERO 

Si α es una cadena de símbolos gramaticales, 

PRIMERO(α) es el conjunto de terminales que inician las 

cadenas derivadas de α. 

• PRIMERO(α)={x | (α → * xβ), (x ∈ Σ T ∪ {λ}), (α, β ∈Σ * )} 

Conjunto PRIMERO(X) para todos los símbolos 

gramaticales X 

1. Repetir hasta que no se puedan añadir más terminales o λ a 

ningún conjunto PRIMERO 

2. Si X ∈ Σ T ⇒ PRIMERO(X) es { X } 

3. Si X → λ⇒añadir λ a PRIMERO(X) 

4. Si X ∈ Σ N y X →Y 1 Y 2 ...Y K Y ⇒ a ∈ PRIMERO(X) si a ∈ PRIMERO(Y i ) 

y λ ∈PRIMERO(Y 1 ), PRIMERO(Y 2 ),..., PRIMERO(Y i-1 ) 

• Si Y 1 

deriva a λ ⇒se añade PRIMERO(Y 2 

) 

• Si Y 1 

no deriva a λ ⇒no se añade más a PRIMERO(X) 



DEFINICIONES: PRIMERO 

PRIMERO(α), Ejemplo: 

E ::= T.E’ 

E’ ::= +.T.E’ | λ 

T ::= F.T’ 

T’ ::= *.F.T’ | λ 

F ::= (.E.) | Id 

• PRIMERO(E) = { (, Id } PRIMERO(T.*.Id) = { (, Id } 

• PRIMERO(T) = { (, Id } PRIMERO(Id.+.Id) = { Id } 

• PRIMERO(F) = { (, Id } PRIMERO(Id) = { Id } 

• PRIMERO(E’) = { +, λ } PRIMERO(T’) = { *, λ }



DEFINICIONES: SIGUIENTE 

Conjunto SIGUIENTE(A) 

• SIGUIENTE(A)={x|(S→ * α·A·β), (A∈Σ N ), (α∈Σ * ), (β∈Σ + ), 

(x∈PRIMERO(β)-{λ})} 

• Conjunto de terminales que pueden aparecer 

inmediatamente a la derecha de A en alguna forma 

sentencial, si A es el último símbolo entonces se incluye el 

separador $ 

Algoritmo 

1. SIGUIENTE(S)={$} 

2. La regla A→αBβ ⇒ 

SIGUIENTE(B) = (PRIMERO(β)-{λ}) ∪ 

SIGUIENTE(B) 

3. La regla A→αBβ | β=λ, β→ * λ (λ ∈PRIMERO(β)) ⇒ 

SIGUIENTE(B) = SIGUIENTE(A) ∪ SIGUIENTE(B) 

4. Repetir hasta que no cambie ningún conjunto SIGUIENTE 



DEFINICIONES: SIGUIENTE 

SIGUIENTE(A), Ejemplo: 

E ::= T.E’ 

E’ ::= +.T.E’ | λ 

T ::= F.T’ 

T’ ::= *.F.T’ | λ 

F ::= (.E.) | Id 

Σ N 

SIGUIENTE 

E $, ) 

E’ $, ) 

F $, *, ), + 

T $, +, ) 

T’ $, +, )



Condiciones 

Pregunta: 

• ¿Que debe cumplir una gramática para que pueda ser 

reconocida sin retroceso, con solo mirar el siguiente elemento 

de la entrada, de forma descendente? 

Respuesta: 

• Si A::= α | β ⇒ 

• PRIMERO(α) ∩ PRIMERO(β) = ∅. para ningún terminal a 

tanto α y β derivan a la vez cadenas que comiencen con a 

• No puede ocurrir que α → * λ y β → * λ 

• Si β → * λ, entonces α no deriva ninguna cadena que 

comience con un terminal en SIGUIENTE(A) 

• Condición LL(1) 



Condiciones 

Condición LL(1) 

• No puede haber conflictos PRIMERO/PRIMERO 

• ∀N∈Σ N 

, el conjunto PRIMERO de todas sus alternativas debe 

ser disjunto 

• No puede haber múltiples alternativas nulas 

• ∀N∈Σ N 

, solo pueden tener una producción N→*λ 

• No puede haber conflictos PRIMERO/SIGUIENTE 

• ∀N∈Σ N 

, con una alternativa nula, SIGUIENTE(N) debe ser 

disjunto de los conjuntos PRIMERO de todas sus alternativas 

• No puede haber entradas con definiciones múltiples en la 

tabla de análisis



Tabla de Análisis Sintáctico 

Funcionamiento 

• Sea A→α con a∈Σ T | a∈PRIMERO(α). El analizador sintáctico 

expandirá A por α cuando el símbolo actual de la entrada sea a 

Algoritmo 

ForAll (A::= α) ∈ Ρdo 

ForAll a ∈ PRIMERO(α) do 

tabla(A,a)= α 

Si λ ∈PRIMERO(α) 

Entonces ForAll b ∈ SIGUIENTE(A) do 

tabla(A,b)= α 

ForAll A∈Σ N y c∈Σ T do 

If tabla(A,c)= ∅ 

Then tabla(A,c)= error 



Tabla de Análisis Sintáctico 

Ejemplo 

E ::= T.E’ 

E’ ::= +.T.E’ | λ 

T ::= F.T’ 

T’ ::= *.F.T’ | λ 

F ::= (.E.) | Id 

Id + * ( ) $ 

E T.E’ T.E’ 

E’ +.T.E’ λ λ 

T F.T’ F.T’ 

T’ λ *.F.T’ λ λ 

F Id (.E.)



No Recursivo; LL(1) 

Modelo de analizador sintáctico predictivo no 

recursivo 

ENTRADA 

a + b $ 

PILA 

X 

Y 

Z 

$ 

Programa de 


Predictivo 

Tabla de Análisis 

Sintáctico M 

SALIDA 



No Recursivo; LL(1) 

Los símbolos de la entrada actual “a” y cima de la 

pila “X” determinan la acción del analizador 

Hay tres posibilidades: 

• X=a=$, el analizador se detiene y anuncia el éxito del 

análisis 

• X=a≠$, el analizador saca X de la pila y mueve el apuntador 

de la entrada al siguiente símbolo de entrada 

• X∈Σ N , el programa consulta la entrada M[X,a] 

• Si M[X,a]=UVW, se sustituye la X de la pila por WVU (U queda 

como cima de la pila) 

• Si M[X,a]= error, se llama a la rutina de recuperación de error


Análisis Sintáctico LL(1) 

Algoritmo: 

pila =$; 

meter$ al final de la entrada; 

a:= GetToken; 

Push S; 

Repeat 

If X ∈Σ T 

or X=$ then 

If X=a then 

Pop; 

a:= GetToken; 

Else 

error; 

Else 

If M[X,a]=X→Y 1 

Y 2 

..Y k 

then 

Pop; 

Push Y k 

,Y k-1 

,...,Y 1 

Emitir la producción X 

else 

error(); 

until X=$ 

If X=$ and a=$ then 

Aceptar; 

else 

error(); 


Análisis Sintáctico LL(1) 

Ejemplo: 

Pila Entrada Producción 

$ ⋅ E Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ E::= T ⋅ E’ 

$ ⋅ E’ ⋅ T Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ T::= F ⋅ T’ 

$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ F::= Id 

$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ 

$ ⋅ E’ ⋅ T’ * ⋅ Id ⋅ + ⋅ Id ⋅ $ T’::= * ⋅ F ⋅ T’ 

$ ⋅ E’ ⋅ T’ ⋅ F ⋅ * * ⋅ Id ⋅ + ⋅ Id ⋅ $ 

$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ + ⋅ Id ⋅ $ F::= Id 

$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ + ⋅ Id ⋅ $ 

$ ⋅ E’ ⋅ T’ + ⋅ Id ⋅ $ T’::= λ 

$ ⋅ E’ + ⋅ Id ⋅ $ E’::= + ⋅ T ⋅ E’ 

$ ⋅ E’ ⋅ T ⋅ + + ⋅ Id ⋅ $ 

$ ⋅ E’ ⋅ T Id ⋅ $ T::= F ⋅ T’ 

$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ $ F::= Id 

$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ $ 

$ ⋅ E’ ⋅ T’ $ T’::= λ 

$ ⋅ E’ $ E’::= λ 

$ $


Análisis Sintáctico Ascendente 

Análisis por desplazamiento y reducción 

• Por precedencia de operadores 

• LR 

Construir un árbol de análisis sintáctico para una 

cadena de entrada que comienza por las hojas y 

avanza hacia la raíz. 

Reducir una cadena de entrada w al símbolo inicial 

de la gramática (axioma) 

En cada paso de reducción se sustituye una 

subcadena que concuerde con el lado derecho de 

una producción por el símbolo del lado izquierdo, se 

traza una derivación por la derecha en sentido 

inverso 


Análisis Sintáctico Ascendente: 

Gramática de Operadores 

Para una pequeña clase de gramáticas se puede construir 

con facilidad, a mano, eficientes analizadores sintácticos 

por desplazamiento y reducción 

Gramática de operadores 

• No tiene reglas de producción del tipo A::=λ 

• No tiene dos no terminales adyacentes A::=α·B·C·β | A,B,C ∈Σ N 

Ejemplo 

No es G. de operadores 

Si es G. de operadores 

E→EAE | (E) | -E | id 

A→+ | - | * | / 

E→E+E | E-E | E*E | E/E | (E) | -E | id


Precedencia de Operador: 

Relaciones de Precedencia 

Se definen tres relaciones de precedencia 

disjuntas 

• ab si a tiene más precedencia que b 

Algoritmo 

Sustituir todos los símbolos no terminales por un único símbolo 

Insertar $ al principio y al final de la cadena de entrada 

Insertar las relaciones de precedencia en la cadena de entrada 

Mientras entrada≠$S$ hacer 

Recorrer entrada desde la izquierda hasta encontrar •> 

Buscar a la izquierda, a partir de ese punto, el primer •> •> •> 

Id •> •> •> •> 

* •> •> 

+ 

(



Evaluador de Expresiones 

El análisis recorre la entrada de izquierda a derecha y 

se encuentra en dos posibles estados: 

• Esperando un operando (variables o constantes) 

• Esperando un operador (resto de terminales) 

El análisis mantiene dos pilas 

• Pila de Operadores 

• Pila de Operandos 

Cuando un operador en la cima de su pila es de más 

precedencia que el siguiente leído, entonces arranca 

la reducción del pivote, hasta encontrar la relación de 

precedencia mayor. Cada operador extraído se aplica 

a los operandos más arriba de la pila de operandos 


Evaluación de Expresiones 

Algoritmo de evaluación de expresiones: 

pilaOperadores = $; 

poner $ al final de la entrada; 

a:= GetToken; 

repeat 

if a=$ y cimaOperadores=$ then return 

if a es Operando then PushOperando (a); a:=GetToken; 

else 

if (cimaOperandos



Precedencia de Operador 

Entrada: 

• Id·+·Id·*·Id 

Gramática 

• E:=E·+·E | E·*·E | (·E·) | Id 

La gramática es ambigua pero este tipo de análisis 

proporciona una única derivación 

Entrada Pila Operadores Pila Operandos 

Id a·+·Id b·*·Id c 

$ $ ∅ 

+·Id b·*·Id c 

$ $ Id a 

Id b·*·Id c 

$ $ + Id a 

*·Id c 

$ $ + Id a 

, Id b 

Id c 

$ $ + * Id a 

,Id b 

$ $ + * Id a 

,Id b 

,Id c 

$ $ + Id a 

, Id b 

*Id c 

$ $ Id a 

+Id b 

*Id d 




Entrada: Id*(Id+Id*Id) 


Id a 

.*.(Id b·+·Id c 

.*. Id d 

)$ $ ∅ 

.*.(Id b·+·Id c 

.*.Id d 

)$ $ Id a 

(Id b·+·Id c 

.*.Id d 

)$ $ * Id a 

Id b·+·Id c 

.*.Id d 

)$ $ * ( Id a 

·+·Id c 

.*.Id d 

)$ $ * ( Id a 

, Id b 

Id c 

.*.Id d 

)$ $ * ( + Id a 

,Id b 

.*.Id d 

)$ $ * ( + Id a 

,Id b 

,Id c 

Id d 

)$ $ * ( + * Id a 

,Id b 

,Id c 

)$ $ * ( + * Id a 

,Id b 

,Id c 

, Id d 

)$ $ * ( + Id a 

,Id b 

,Id c 

*Id d 

)$ $ * ( Id a 

,Id b 

+Id c 

*Id d 

$ $ * ( ) Id a 

,Id b 

+Id c 

*Id d 

$ $ Id a 

*(Id b 

+Id c 

*Id d 

)




Entrada: Id*(Id+Id)+Id 


Id a 

.*.(Id b·+·Id c 

).+. Id d 

$ $ Id a 

.*.(Id b·+·Id c 

).+. Id d 

$ $ Id a 

(Id b·+·Id c 

).+. Id d 

$ $ * Id a 

Id b·+·Id c 

).+. Id d 

$ $ * ( Id a 

.+·Id c 

).+. Id d 

$ $ * ( Id a 

Id b 

Id c 

).+. Id d 

$ $ * ( + Id a 

Id b 

).+. Id d 

$ $ * ( + Id a 

Id b 

Id c 

).+. Id d 

$ $ * ( Id a 

Id b 

+Id c 

.+. Id d 

$ $ * ( ) Id a 

Id b 

+Id c 

.+. Id d 

$ $ * Id a 

Id b 

+Id c 

.+. Id d 

$ $ Id a 

*(id b 

+Id c 

) 

Id d 

$ $ + Id a 

*(id b 

+Id c 

) 

$ $ + Id a 

*(id b 

+Id c 

) Id d 

$ $ Id a 

*(id b 

+Id c 

)+Id d 



Construir la Tabla de Precedencia 

Si el operador θ 1 tiene mayor precedencia que θ 2 

entonces hacer θ 1 •>θ 2 y θ 2 θ 2 y θ 2 •> θ 1 si son asociativos por la izquierda 

• θ 1



Operadores Unarios (¬) 

Manejo de Operadores Unarios (¬) 

• Operador Unario que no es además Binario 

• θ θ ∀ θ si ¬ tiene mayor precedencia que θ 

• ¬



Calcular la Tabla de Precedencia 

Definiciones: 

• Cabecera(A) = { x | (A→ * α·x·β) 

∧ (x ∈Σ T ) ∧ (A ∈Σ N ) ∧ (α ∈Σ N* ) ∧ (β ∈Σ * )} 

• Último(A) = { x | (A→ * α·x·β) 

∧ (x ∈Σ T ) ∧ (A ∈Σ N ) ∧ (α ∈Σ * ) ∧ (β ∈Σ N* )} 

Ejemplo: 

E::=E·+·T | T 

Cabecera(E)={+, *, (, Id} 

T::=T·*·F | F 

Último(E)={+, *, ), Id} 

F::=(·E·) | Id 

Propiedad: 

• ∀(A::= α·B·a·C·β) ∈ P, a ∈Σ T , A, B, C ∈Σ N , α, β∈Σ * , a siempre 

aparece en un nivel superior a los símbolos terminales de 

Cabecera(C) y Último(B) en el árbol de derivación 



Calcular la Tabla de Precedencia 

Reglas: 

(A::= α·B·a·C·β) ∈ P, a ∈ Σ T , A, B, C ∈ Σ N , α, β ∈Σ * 

1. ∀c ∈ Cabecera(C), a a 

3. ∀ (A::= α·a·β·b·γ) ∈ P, a, b ∈Σ T , a=b , β∈Σ * 

Si existe más de una relación de precedencia entre dos 

símbolos terminales, no es una gramática de 

precedencia 

Algoritmo 

ForAll (A::= α·B·a·C·β) ∈ P do 

Calcular Cabecera(C) 

Calcular Último(B) 

Calcular las precedencias usando las reglas 1, 2 y 3 

ForAll a ∈ Cabecera(S) do $ $


Ejemplo Calculo de Tabla de 

Precedencia 

Gramática 

E::=E·+·T | T 

T::=T·*·F | F 

F::=(·E·) | Id 

Cabecera y Último 

Σ N Cabecera Último 

E +, *, (, Id +, *, ), Id 

T *, (, Id *, ), Id 

F (, Id ), Id 

Tabla 

Regla Precedencias(R 2 ) Precedencias (R 1 ) 

E::=E+T +, *, ), Id •> + + * * g(b) 

Para encontrar la relación de precedencia entre a y b 

se realiza una comparación entre f(a) y g(b) 

No todas las relaciones de precedencia tienen 

funciones de precedencia



Funciones de Precedencia 

Construcción de las Funciones de Precedencia 

1. Crear los símbolos f a y g a ∀ a∈Σ T ∪ {$} 

2. Se dividen los f a y g a en tantos grupos como sea posible: 

• Si a=b entonces f a 

y g b 

están en el mismo grupo 

3. Crear un grafo dirigido cuyos nodos son los grupos 

encontrados en el paso 2, los arcos se etiquetan: 

• si ab, a 

f → g b 

4. Ciclos en el grafo: 

• Respuesta SI, entonces no existen funciones de precedencia 

• Respuesta NO, entonces f(a) y g(a) son los caminos más 

largos que comienzan en a 

f y g a 




Ejemplo 

Id + * $ 

Id •> •> •> 

+ 

* •> •> 

$




No hay ciclos, entonces existen las funciones de 

precedencia. 

Como las funciones de $ no tienen arcos 

entonces f($)=g($)=0 

El camino más largo desde g + tiene longitud 1, 

entonces g(+)=1 

El camino más largo desde g Id a f * a g * a f + a f $ 

por tanto g(id)=5 

Id + * $ 

f 4 2 4 0 

g 5 1 3 0 




Inconvenientes 

• Es difícil de manejar componentes léxicos con dos 

precedencias distintas, como el signo menos (unario y 

binario) 

• No se puede tener la seguridad de que el analizador acepta 

exactamente el lenguaje deseado 

• Sólo una pequeña clase de gramáticas puede analizarse 

Ventajas 

• Sencillez 

• Se pueden establecer relaciones de precedencia (* precede 

a +) 

Se aplican con otros analizadores para la parte que 

no son de operador


Análisis Ascendente LR 

LR(k): Left-to-right, rightmost derivation, k símbolos 

de entrada son necesarios para tomar las decisiones 

de análisis sintáctico 

• Ventajas 

• Es el método de análisis por desplazamiento y reducción sin 

retroceso más general, a pesar de esto es igual de eficiente 

• La clase de gramáticas que pueden analizarse es un 

supraconjunto de la clase de gramáticas que pueden analizarse 

con analizadores sintácticos predictivos 

• Detectan los errores sintácticos tan pronto como es posible en 

un examen de izquierda a derecha de la entrada 

• Se pueden reconocer prácticamente todas las construcciones 

de los lenguajes de programación descritos por una gramática 

G2 

• Inconvenientes 

• La construcción “a mano” requiere mucho trabajo 


Tipos de Análizadores LR 

LR simple (SLR) 

• Fácil de implementar 

• Menos poderoso, hay algunas gramáticas que los 

otros métodos pueden analizar y este no puede 

LR canónico 

• Es muy costoso de implementar 

• El más potente 

LALR (LR con símbolo de preanálisis) 

• Intermedio entre los dos métodos anteriores


Modelo de un Analizador LR 

ENTRADA 

a 1 

... a 1 

... a n 

$ 

Pila 

s m 

X m 

s m-1 

Programa de 


LR 

SALIDA 

X m-1 

... 

s 0 

Acción Ir_a 

Tabla de Análisis 

Sintáctico LR 


Modelo de Analizador LR 

El programa es el mismo para todos los analizadores 

LR 

X i es un símbolo gramatical y cada s i es un símbolo 

llamado estado 

Se utiliza el símbolo de estado y el símbolo de la 

entrada para indexar la tabla y determinar la acción 

siguiente 

La tabla de análisis sintácticos tiene dos partes: 

• Acción[s m , a ]= i 

• Error: 

• Aceptar: 

• Desplazar: 

• Reducción: 

• Ir_a[s m , X i ]= s k 

error de sintaxis 

acepta la entrada, el análisis sintáctico finaliza 

introduce en la pila el símbolo a i y el estado s m 

extrae símbolos de la pila, ejecuta la acción 

semántica correspondiente a una producción


Modelo de Analizador LR 

Configuración de un analizador sintáctico LR 

• Tupla con el contenido de la pila y la entrada que 

resta por procesar 

(s 0 X 1 s 1 X 2 s 2 ... X m s m , a i a i+1 ... a n $) 

Acción[s m , a ] i = desplazar s 

(s 0 X 1 s 1 X 2 s 2 ... X m s m a i s, a i+1 ... a n $) 

Acción[s m , a ] i = reducir A →β 

(s 0 X 1 s 1 X 2 s 2 ... X m-r s m-r A s, a i a i+1 ... a n $) 

donde s=Ir_a[s m-r , A] y r=|β| (se extraen r 

símbolos no terminales y r símbolos de estados 

de la pila) 


Algoritmo de Análisis LR 

apuntar ae al primer símbolo de w$ (s está en la cima y ae apunta al símbolo a) 

repetir 

case Acción[s, a] 

Desplazar s’ 

push a 

push s’ 

leer en la entrada 

Reducir A → β 

pop 2*|β| símbolos 

s’ símbolo en la cima de la pila 

s= Ir_a[s’, A] 

push A 

push s 

Aceptar 

Error 

fincaso 

hasta Aceptar o Error


Ejemplo de Análisis LR 

Gramática 

1. E::= E·+·T 

2. E::= T 

3. T::= T·*·F 

4. T::= F 

5. F::= (·E·) 

6. F::= Id 

Tabla de análisis sintáctico 

Acción 

Ir_a 

Estado Id + * ( ) $ E T F 

0 d5 d4 1 2 3 

1 d6 ACP 

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 d6 d11 

9 r1 d7 r1 r1 

10 r3 r3 r3 r3 

11 r5 r5 r5 r5 


Ejemplo de Análisis LR 

Pila Entrada Acción 

0 Id·*·Id·+·Id·$ d5 

0 Id 5 *·Id·+·Id·$ r6 

0 F 3 *·Id·+·Id·$ r4 

0 T 2 *·Id·+·Id·$ d7 

0 T 2 * 7 Id·+·Id·$ d5 

0 T 2 * 7 Id 5 +·Id·$ r6 

0 T 2 * 7 F 10 +·Id·$ r3 

0 T 2 +·Id·$ r2 

0 E 1 +·Id·$ d6 

0 E 1 + 6 Id·$ d5 

0 E 1 + 6 Id 5 $ r6 

0 E 1 + 6 F 3 $ r4 

0 E 1 + 6 T 9 $ r1 

0 E 1 $ ACP


Construcción de Tabla de Análisis 

SLR 

Definiciones: 

• Elemento del análisis sintáctico LR(0) de una 

gramática G (elemento, ítem) 

• Producción de G con un “punto” en alguna posición del lado 

derecho 

• El punto indica hasta donde se ha visto la producción en un 

momento del análisis 

Ejemplo: La producción A→XYZ tiene cuatro elementos: 

A→•XYZ 

A→X•YZ 

Pregunta: 

¿Qué elemento genera la 

producción A→λ? 

A→XY•Z 

A→XYZ• 


Construcción de Tabla de Análisis 

SLR 

Definiciones: 

• Prefijo viable 

• Item válido para prefijo viable: 

A→β 1 

•β 2 

es item válido de αβ 1 

sii: 

S →* αAw→*αβ 1 

β 2 

w (A∈Σ N, 

, α,β 1 

,β 2 

∈Σ * , w∈Σ * T ) 

rm rm 

• Estado 

• Conjunto de ítems 

• Dan lugar a los estados del analizador sintáctico SLR 

• El conjunto de estados: colección canónica LR(0) 

Los ítems son los estados de un AF que reconoce los 

prefijos viables 

Los estados son las agrupaciones de estados, (¡La 

minimización del AF!)


Algoritmo: crear conjunto 

canónico LR(0) 

Entrada: 

• Gramática ampliada G’ 

• Función cierre(I) (clausura o cerradura), I≡ítem + 

• Función goto(I, X) (ir_a), X∈(Σ T ∪Σ N ) 

Salida 

• Conjunto canónico LR(0) 

Gramática ampliada G’ de G 

• Añadir S’, Σ N = (Σ N ∪ S’ ’) | S’ es el axioma 

• Añadir S’→ S, P= (P ∪ S’→ S) 


Construir el conjunto canónico 

LR(0) 

Función cierre(I) 

function cierre(I); 

begin 

J:=I; 

repeat 

for ∀ J i (A →α•Bβ) ∈ J , ∀ p (B →γ) ∈ P | (B → • γ) ∉ J 

do J := J ∪ (B → • γ) ; 

until no pueden añadirse ítems a J ; 

return J 

end 

• Ejemplo: 

A→ B 

B → id | Cnum| ( D ) 

C → + D 

D → id | num 

¿ cierre(A→ • B) ? 

A→ • B 

B → • id | • Cnum| •( D ) 

C → •+ D



LR(0) 

Función goto(I, X) 

• Si I son items válidos de γ, goto(I, X) son los 

items válidos de γX 

function goto(I, X); 

begin 

J:=∅; 

∀ I i | (B →α•X β) ∈ I, J := J ∪ cierre(B →αX • β) ; 

return J 

end 

• Ejemplo: 

A→ B 

B → id | Cnum| ( D ) 

C → + D 

D → id | num 

I = {B→ • id, B→ •( D )} 

¿ goto {I, ( }? 

B → (•D ) 

D → • id 

D → • num 




La función elementos proporciona la 

colección canónica de conjuntos de 

elementos de LR(0) 

function elementos(G’); 

begin 

C:=cierre(S’ → • S); 

repeat 

for ∀ I ∈ C , ∀ X | goto(I, X) ≠∅, goto(I, X) ∉ C 

do C := C ∪ goto(I, X); 

until no pueden añadirse más conjuntos de ítems a C; 

return C 

end



LR(0) 

Ejemplo: 

• G 

1. S → A B end 

2. A → tipo 

3. A → id A 

4. B → begin C 

5. C → código 

• G’ 

1. S’ → S 

2. S → A B end 

3. A → tipo 

4. A → id A 

5. B → begin C 

6. C → código 

items LR(0): 

I 0 : 

I 1 : 

I 2 : 

I 3 : 

S’ → •S 

S → •A B end 

A → •tipo 

A → •id A 

S’ → S• 

S → A•B end 

B → •begin C 

A → tipo• 

I 4 : A → id•A 

A → •tipo 

A → •id A 

I 5 : S → A B•end 

I 6 : B → begin•C 

I 7 : 

C → •código 

A → id A• 

I 8 : S → A B end• 

I 9 : B → begin C• 

I 10 : C → código• 



LR(0) 

El conjunto canónico define un AFD que reconoce los prefijos 

viables de G, con I 0 estado inicial e I j ∀j ≠ 0 estados finales 

S 

I 0 I 1 

A 

tipo 

id 

I 2 

I 3 

B 

end 

I 5 I 8 

begin 

C 

I 6 I 9 

tipo 

código 

A 

I 4 I 7 

id 

I 10 

Para cada prefijo alcanzado, I i define sus prefijos viables!


Construir la tabla SLR (por fin) 

Entrada: 

• Gramática aumentada G’ 

Salida 

• Tabla SLR, funciones de acción e ir_a 

Algoritmo 

1. Construir C={I 0 , I 1 , ..., I n } LR(0) de G’ 

2. El estado i se construye a partir de I , i poner las 

operaciones adecuadas del analizador sintáctico 

3. Las entradas no definidas son ERROR 

4. El estado inicial es el del conjunto con [S’→•S] 


Construir la tabla SLR 

Operaciones asociadas a los ítems 

• Desplazar 

• Si [A→α•aβ] ∈ I i , a ∈Σ T , goto(I , i a) = I j ⇒ acción[i, a] = 

desplazar j 

• Reducir 

• Si [A→α•] ∈ I i , A ≠ S’ ⇒∀a ∈ SIGUIENTE(A), 

acción[i, a] = reducir A→α 

• Aceptar 

• Si [S’→S•] ∈ I i ⇒ acción[i,$] = aceptar 

• Ir_a 

• Si goto(I i , A) = I j , A ∈ Σ N ⇒ ir_a[i, A] = j


Construir la tabla SLR 

ccLR(0) 

I 0 : 

S’ →•S ir_a[0,S]=1 

S → •A B end ir_a[0,A]=2 

A → •tipo acción[0,tipo]=d3 

A → •id A acción[0,id]=d4 

I 1 : 

S’ → S• acción[1,$]=aceptar 

I 2 : 

S → A•B end ir_a[2,B]=5 

B → •begin C acción[2,begin]=d6 

I 3 : 

A → tipo• acción[3,begin]=r(A → tipo) 

I 4 : 

A → id•A ir_a[4,A]=7 

A → •tipo acción[4,tipo]=d3 

A → •id A acción[4,id]=d4 

I 5 : 

S → A B•end acción[5,end]=d8 

I 6 : 

B → begin•C ir_a[6,C]=9 

C → •código acción[6,código]=d10 

I 7 : 

A → id A• acción[7,begin]=r(A → id) 

I 8 : 

S → A B end• acción[8,$]=r(S → A B end) 

I 9 : 

B → begin C• acción[9,end]=r(B → begin C) 

I 10 : 

C → código• acción[10,end]=r(C → código) 

Σ N Siguiente 

S $ 

A begin 

B end 

C end 


Tabla SLR Resultante 

acción 

ir_a 

tipo id begin código $ end S A B C 

0 d3 d4 1 2 

1 ACP 

2 d6 5 

3 r(A → tipo) 

4 d3 d4 7 

5 d8 

6 d10 9 

7 r(A → id) 

8 r(S →AB end) 

9 r(B →begin C) 

10 r(C →código)


Resumen 

El análisis sintáctico LR 

• El análisis ascendente sin retroceso más general 

• Utiliza una pila y una tabla de análisis 

• Desplazamiento/Reducción 

• La tabla SLR se obtiene haciendo el conjunto 



Analizador canónico LR 

Motivación 

• Tabla SLR tiene info insuficiente y pueden aparecer 

conflictos desplazamiento/reducción 

• Si el estado I i contiene [A->β•] No es adecuada 

siempre la reducción A->a para todos los terminales en 

Siguiente(A) 

• Dado prefijo viable αβ con items válidos en I i puede ser que no 

existan formas sentenciales αAa, con a∈Siguiente(A) 

Ejemplo: 

S → L=R 

S → R 

L → *R 

L → id 

R → L


Conjunto LR(0) 

Ejemplo: 

• G 

1. S → L=R 

2. S → R 

3. L → *R 

4. L → id 

5. R → L 

• G’ 

1. S → L=R 

2. S → R 

3. L → *R 

4. L → id 

5. R → L 

6. S’ → S 

items LR(0): 

I 0 : 

I 1 : 

S’→ •S 

S → •L=R 

S → •R 

R → •L 

L →•*R 

L →•id 

S’ → S• 

I 2 : S → L • =R 

I 3 : 

R → L • 

S → R• 

I 4 : L → * • R 

R → •L 

L →•*R 

L →•id 

I 5 : L → id • 

I 6 : S → L = •R 

R → •L 

L →•*R 

L →•id 

I 7 : L → * R • 

I 8 : R → L• 

I 9 : S → L = R• 


Tabla de análisis LR(0) 

S 

I 0 I 1 

L 

R 

* 

id 

I 2 

= 

I 3 

I 6 

I 7 

I 9 

* R 

id 

L 

R 

I 5


Conflicto en la tabla SLR! 

ccLR(0) 

acción 

.... 

I 2 

: S → L • =R 

acción[2,=]=d6 

R → L • acción[2,=]=r5 

... 

Σ N Siguiente 

S $ 

L $, = 

R $, = 

$ está en 

Siguiente(R) pero no 

hay ninguna 

derivación donde 

reducir L por R 

seguido de $ 

Esta información de 

contexto no se usa en 

el analizador SLR 


Items en LR(1) 

Ítems: estados de AF que reconoce los 

prefijos viables junto a símbolos posibles tras 

pivote 

• Elementos con más información: 

[A→β 1 •β 2 , a] con A→β 1 •β 2 ∈P, a∈Σ T 

• Definición: 

[A→β 1 •β 2 , a] es item válido de γ=αβ 1 sii: 

-S →* αAw→αβ 1 β 2 w 

rm 

rm 

- 

a es el primer símbolo de w (o si w es λ, a es $) 

• Estado: 

• Conjunto de estados: colección canónica LR(1) 

• Se aumentan los estados LR(0)


Items en LR(1) 

Construcción: varía la función cierre(I) 

• [A→α•Bβ, a]∈I 

[A→α•Bβ, a] es item válido de γ=δα: 

S →* δAax→δαΒβax=γΒβax 

rm 

• Para cada item B→η: 

S →* γηby, ∀b|b∈Primero(βa) 

rm 

[B→ • η, b] ∈ cierre(I) 



LR(1) 

Ejemplo: 

Función cierre(I) 

function cierre(I); 

begin 

J:=I; 

repeat 

for ∀ J i [A →α•Bβ,a] ∈ J , ∀ p (B →γ) ∈ P , ∀ b∈Primero(βa) | 

[B → • γ, b] ∉ J 

do J := J ∪ [B → • γ, b] ; 

until no pueden añadirse ítems a J ; 

return J 

end 

S’→ S 

S → CC 

C → cC | d 

¿ cierre([S’→ •S,$])? 

[S’→ •S,$] 

[S→ •CC,$] 

[C→ •cC,c/d] 

[C→ •d,c/d] 

Primero 

$ $ 

C$ c, d



LR(1) 

Función goto(I, X) 

• Si I son items válidos de γ, goto(I, X) son los items 

válidos de γX 

function goto(I, X); 

begin 

J:=∅; 

∀ I i | [B →α•X β, a] ∈ I, J := J ∪ cierre([B →αX • β, a]) ; 

return J 

end 

Ejemplo: 

S’→ S 

S → CC 

C → cC | d 

¿ goto([C→ •cC,c/d],c)? 

[C→ c•C,c/d] 

[C→ •cC,c/d] 

[C→ •d,c/d] 

(λ) c 

(λ) d 

Primero 

c 

d 




La función elementos proporciona la 

colección canónica de conjuntos de 

elementos de LR(1) 

function elementos(G’); 

begin 

C:=cierre([S’ → • S, $]); 

repeat 

for ∀ I ∈ C , ∀ X | goto(I, X) ≠∅, goto(I, X) ∉ C 

do C := C ∪ goto(I, X); 

until no pueden añadirse más conjuntos de ítems a C; 

return C 

end


Conj. LR(1) 

• G’ 

1. S → L=R 

2. S → R 

3. L → *R 

4. L → id 

5. R → L 

6. S’ → S 

items LR(1): 

I 0 : 

[S’→•S,$] 

[S →•L=R,$] 

[S →•R,$] 

[L →•*R,=|$] 

[L →•id,=|$] 

[R →•L,$] 

I 1 : [S’ → S•,$] 

I 2 : [S → L• =R,$] 

[R → L•,$] 

I 3 : [S → R•,$] 

I 4 : [L → * • R,=|$] 

[R →•L,=|$] 

[L →•*R,=|$] 

[L →•id, =|$] 

I 5 : [L → id•,=|$] 

I 6 : [S →L=•R,$] 

[R →•L,$] 

[L →•*R,$] 

[L →•id, $] 

I 7 : [L → *R•,=|$] 

I 8 : [R → L•,=|$] 

I 9 : [S → L = R•,$] 

I 10 : [R → L•,$] 

I 11 : [L → id•,$] 

I 12 : [L → * • R,$] 

[R →•L,$] 

[L →•*R, $] 

[L →•id, $] 

I 13 : [L → *R•,$] 


Estados de analizador canónico LR(1) 

S 

I 0 I 1 

L 

R 

* 

id 

I 4 I 8 I 13 

L 

R 

I 9 

I 2 

= 

I 6 

R 

L 

I 10 

id 

L 

I 3 R 

I 7 I 11 

* 

* 

id 

I 5 

I 12


Construir la tabla canónica LR 

Entrada: 

• Gramática aumentada G’ 

Salida 

• Tabla LR, funciones de acción e ir_a 

Algoritmo 


2. El estado i se construye a partir de I , i poner las 

operaciones adecuadas del analizador sintáctico 

3. Las entradas no definidas son ERROR 

4. El estado inicial es el del conjunto con [S’→•S, $] 


Construir la tabla canónica LR 

accLR(1) 

I 0 : [S’→•S,$] ir_a(0,S)=1 

[S →•L=R,$] ir_a(0,L)=2 

[S →•R,$] ir_a(0,R)=3 

[L →•*R,=] acc(0,*) =d4 

[L →•id,=] acc(0,id)=d5 

[R →•L,$] 

I 1 : [S’ → S•,$] acc(1,$)=ACP 

I 2 : [S → L• =R,$] acc(2,=)=d6 

[R → L•,$] acc(2,$)=r(R→L) 

I 3 : [S → R•,$] acc(3,$)=r(S→R) 

I 4 : [L → * • R,=] ir_a(4, R)=7 

[R →•L,=] ir_a(4, L)=8 

[L →•*R,=] acc(4,*)=d4 

[L →•id, =] acc(4,id)=d5 

I 5 : [L → id•,=] acc(5,=)=r(L→id) 

I 6 : [S →L=•R,$] ir_a(6,R)=9 

[R →•L,$] ir_a(6,L)=10 

[L →•*R,$] acc(6,*)= d12 

[L →•id, $] acc(6,id)=d11 

I 7 : [L →*R•,=] acc(7,=)=r(L →*R) 

I 8 : [R → L•,=] acc(8,=)=r(R →L) 

I 9 : [S → L = R•,$] acc(9,$)=r(S→L=R) 

I 10 : [R →L •,$] acc(10,$)=r(R→L) 

I 11 : [L → id•,$] acc(11,$)=r(L→id) 

I 12 : [L → * • R,$] ir_a(12,R)=13 

[R → •L,$] ir_a(12,L)=10 

[L →•*R, $] acc(12,*)=d12 

[L →•id, $] acc(12,id)=d11 

I 13 : [L → *R•,$] acc(13,$)=r(L →*R)


Analizador LALR 

Motivación 

• Utilizado en la práctica al reducir el número de estados 

del analizador canónico LR (mismo número que SLR) 

Forma estados a partir de la unión de estados de 

LR(1) con el mismo núcleo 

• Si estado I i contiene [A->α • β, α], estado I j contiene 

[A->α • β, b] forma estado unión I ij con [A->α • β, a/b] 

Las gramáticas LALR(1) son un subconjunto de 

LR(1). 

• Pueden inducirse conflictos reducción/reducción pero 

nunca desplazamiento/reducción 

• Algunos errores se manifiestan más tarde 


Analizador LALR 

Dos principios del analizador LALR(1) 

• El núcleo de cualquier estado del AFD LR(1) es un 

estado del AFD LR(0) 

• Si dos estados de LR(1), (s1, s2) tienen el mismo 

núcleo 

• Si goto(x1, X)=t1 ⇒∃t2,| goto(x2,X)=t2 y (t1,t2) mismo 

núcleo 

Corolario: el número de estados del AFD del 

analizador LALR(1) coincide con el AFD LR(0)


Construir la tabla LALR 

Algoritmo 


2. Para cada núcleo en el conjunto de items LR(1), 

buscar todos los conjuntos con ese núcleo y 

reemplazarlos por su estado unión 

3. C’={J 0 , J 1 , ..., J m } pasan a ser los nuevos estados. 

Hacer transiciones. Las acciones se generan igual 

que en el analizador LR. Si hay conflictos, la 

gramática no es LALR(1) 

4. La tabla ir_a se forma sobre los conjuntos 

resultantes de efectuar las uniones de elementos 

LR(1) con el mismo núcleo 


Ejemplo 

Unir estados: 

‣ 4,12 

‣ 8,10 

‣ 5,11 

‣ 7,13 

estados LALR(1): 

I 0 : [S’→•S,$] 

[S →•L=R,$] 

[S →•R,$] 

[L →•*R,=] 

[L →•id,=] 

[R →•L,$] 

I 1 : [S’ → S•,$] 

I 2 : [S → L• =R,$] 

[R → L•,$] 

I 3 : [S → R•,$] 

I 4_12 : 

[L → * • R,=/$] 

[R →•L,=/$] 

[L →•*R,=/$] 

[L →•id, =/$] 

I 5_11 : 

[L → id•,=/$] 

I 6 : [S →L=•R,$] 

[R →•L,$] 

[L →•*R,$] 

[L →•id, $] 

I 7_13 : 

[L → *R•,=/$] 

I 8_10 : 

[R → L•,=/$] 

I 9 : [S → L = R•,$]


Estados de analizador LALR(1) 

S 

I 0 I 1 

L 

R 

* 

id 

I 4 I 8 

L 

I 9 

I 2 

= 

I 6 

R 

L 

id 

I 3 R 

I 7 a I 5 

* 

* 

id 

I 5 

10 estados, igual que SLR(1) 

a I 8 

a I 4 


Construir la tabla LALR 

accLR(1) 

I 0 : [S’→•S,$] ir_a(0,S)=1 

[S →•L=R,$] ir_a(0,L)=2 

[S →•R,$] ir_a(0,R)=3 

[L →•*R,=] acc(0,*) =d4 

[L →•id,=] acc(0,id)=d5 

[R →•L,$] 

I 1 : [S’ → S•,$] acc(1,$)=ACP 

I 2 : [S → L• =R,$] acc(2,=)=d6 

[R → L•,$] acc(2,$)=r(R→L) 

I 3 : [S → R•,$] acc(3,$)=r(S→R) 

I 4 : [L → * • R,=/$] ir_a(4, R)=7 

[R →•L,=/$] ir_a(4, L)=8 

[L →•*R,=/$] acc(4,*)=d4 

[L →•id, =/$] acc(4,id)=d5 

I 5 : [L → id•,=/$] acc(5,=)=r(L→id) 

acc(5,$)=r(L→id) 

I 6 : [S →L=•R,$] ir_a(6,R)=9 

[R →•L,$] ir_a(6,L)=10 

[L →•*R,$] acc(6,*)= d12 

[L →•id, $] acc(6,id)=d11 

I 7 : [L →*R•,=/$] acc(7,=)=r(L →R) 

acc(7,$)=r(L →R) 

I 8 : [R → L•,=/$] acc(8,=)=r(R →L) 

acc(8,$)=r(R→L) 

I 9 : [S → L = R•,$] acc(9,$)=r(S→L=R)


Uso de gramáticas ambiguas 

Una gramática ambigua nunca puede ser LR 

A veces es útil emplear una gramática ambigua: 

• Construcciones más naturales y concisas 

• Aislar casos particulares que puede ser útil tenerlos 

separados 

Una gramática ambigua puede generar lenguaje 

con reglas para “deshacer la ambigüedad” 

• Idea similar a las reglas de prioridad en gramáticas de 

operador 

• Las gramáticas ambiguas sólo deben usarse de forma 

escasa y controlada, para asegurar qué lenguaje se 

reconoce 


Ejemplo 1ª gramática ambigua 

Sintaxis de condicional: 

• S→ if E then S else S 

• S→ if E then S 

• S→ other 

Gramática ambigua. Versión no Ambigua: 

• S→ S_emparejada | S_no_emparejada 

• S_emparejada→ if E then S_emparejada else S_emparejada 

• S_emparejada→ other 

• S_no_emparejada→ if E then S 

• S_no_emparejada→ if E then S_emparejada else 

S_no_emparejada


Conj. LR(0) 

• G’ 

1. S → iSeS 

2. S → iS 

3. S → a 

4. S’ → S 

items LR(0): 

I 0 : [S’ →•S] 

[S →•iSeS] 

[S →•iS] 

[S →•a] 

I 1 : [S’ → S•] 

I 2 : [S → i •SeS] 

[S → i •S] 


[S →•iS] 

[S →•a] 

I 4 : [S → iS•eS] 

[S → i S•] 

I 5 : [S → iSe•S] 


[S →•iS] 

[S →•a] 

I 6 : [S → iSeS •] 

I 3 : [S → a •] 


Acciones analizador SLR(1) 

Items LR(0)-acciones SLR (1): 

I 0 : [S’ →•S] 

[S →•iSeS] acc(0,i)=d2 

[S →•iS] 

[S →•a] acc(0,a)=d3 

I 1 : [S’ → S•] 

I 2 : [S → i •SeS] 

acc(1,$)=ACP 

[S → i •S] 


[S →•iS] 

[S →•a] acc(2,a)=d3 

I 3 : [S → a •] 

acc(3,$)=r3 

acc(3,e)=r3 

I 4 : [S → iS•eS] 

acc(4,e)=d5 

[S → i S•] acc(4,e)=r2 

acc(4,$)=r2 

I 5 : [S → iSe•S] 


[S →•iS] 

[S →•a] acc(5,i)=d3 

I 6 : [S → iSeS •] 

Σ N 

S 

Siguiente 

$,e 

acc(6,e)=r1 

acc(6,$)=r1


Tabla SLR sin conflictos 

Resolución conflicto: en estado 4, desplazamiento 

sobre “else” (prioridad para if más anidado) 

acción 

ir_a 

i e a $ S 

0 d2 d3 1 

1 ACP 

2 d2 d3 4 

3 r3 r3 

4 d5 r2 

5 d2 d3 

6 r1 r1 6 

G: 

1. S → iSeS 

2. S → iS 

3. S → a 



Gramática de expresiones con sumas y productos: 

E::=E·+·T | T 

T::=T·*·F | F 

F::=(·E·) | Id 

Versión ambigua: 

E:=E·+·E | E·*·E | (·E·) | Id 

Dos ventajas: 

• Más intuitiva 

• Analizador más rápido al evitar reducciones F→Id, T→F 

Deshacer la ambigüedad con LR equivale aquí a fijar 

externamente la tabla de precedencia con analizador de 

precedencia


Conj. LR(0) 

• G’ 

1. E→ E+E 

2. E→E * E 

3. E→(E) 

4. E →Id 

5. E’→E 

I 0 : [E’→•E] 

[E→•E+ E] 

[E→•E * E] 

[E→• (E)] 

[E →•Id] 

I 1 : [E’→E•] 

[E→E•+ E] 

[E→E•* E] 

I 2 : [E→(•E)] 

[E→•E+ E] 

[E→•E * E] 

[E→• (E)] 

[E →•Id] 

I 3 : [E→Id•] 

I 4 : [E→E+•E] 

[E→•E+ E] 

[E→•E * E] 

[E→•(E)] 

[E→•Id] 

I 5 : [E→E *•E] 

[E→•E+ E] 

[E→•E * E] 

[E→•(E)] 

[E→•Id] 

I 6 : [E→(E •)] 

[E→E•+ E] 

[E→E• * E] 

I 7 : [E→E+E•] 

[E→E•+ E] 

[E→E• * E] 

I 8 : [E→E *E •] 

[E→E•+ E] 

[E→E•* E] 

I 9 : [E→(E) •] 


Conflictos en analizador SLR 

Σ N 

• G’ 

1. E→ E+E 

2. E→E * E 

3. E→(E) 

4. E →Id 

5. E’→E 

Siguiente 

S $,+,*,) 

I 7 : [E→E+E•] 

[E→E•+ E] 

[E→E• * E] 

I 8 : [E→E*E•] 

[E→E•+ E] 

[E→E• * E] 

acc(7,$)=r1 

acc(7,+)=r1 

acc(7,*)=r1 

acc(7,))=r1 

acc(7,+)=d4 

acc(7,*)=d5 

acc(8,$)=r2 

acc(8,+)=r2 

acc(8,*)=r2 

acc(8,))=r2 

acc(8,+)=d4 

acc(8,*)=d5



Resolución conflictos (desplaz/reducción) sobre 

+,* 

{+,*} asociativos por la izquierda 

“*” más prioridad que “+” 

• estado I 7 : 

• acc(7,+)=r1 (“+” es asociativo por izda) 

• acc(7,*)=d5 (“*” mayor prioridad que “+”) 

• estado I 8 : 

• acc(8,+)=r2 (“*” mayor prioridad que “+”) 

• acc(8,*)=r2 (“*” es asociativo por izda) 



acción 

ir_a 

id + * ( ) $ E 

0 d3 d2 1 

1 d4 d5 ACP 

2 d3 d2 6 

3 r4 r4 r4 r4 

4 d3 d2 7 

5 d3 d2 8 

6 d4 d5 d9 

7 r1 d5 r1 r1 

8 r2 r2 r2 r2 

9 r3 r3 r3 r3 

G: 

1. E→ E+E 

2. E→E * E 

3. E→(E) 

4. E →Id



Gramática de EQN, editor gráfico de ecuaciones: 

E::=E·sub·E ·sup·E 

E::=E·sub·E 

E::=E·sup·E 

E::={·E ·} 

E::=c 

Gramática intencionadamente ambigua por doble motivo: 

• “sub” y “sup” tendrán conflictos desp/reducción: se resuelve con 

asociatividad (a derecha) 

• Justificado por simplicidad en la gramática y eficiencia en el análisis 

• La primera producción entra en conflicto desp/reducción con la 

segunda 

• Justificación de producción “extra” porque tiene sentido 

semántico: 

E sub a sup b representa E b , en lugar de E 

b 

a 

a

Análisis Sintáctico. Procesadores de Lenguaje I - GIAA

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?