análisis sintáctico descendente sin retroceso - Blearning

Universidad de Oviedo - Departamento de Informática 

Escuela Politécnica Superior de Ingeniería 

ANÁLISIS SINTÁCTICO EN PROCESADORES DE LENGUAJE 

TEMA 5 

ANÁLISIS SINTÁCTICO DESCENDENTE 

Página 1

Objetivos 

Conocer el análisis descendente con / sin retroceso 

Estudiar la técnica de análisis descendente 

Establecer las condiciones LL(1) 

Transformar gramáticas que no cumplen la condición LL(1) 

Construir analizadores predictivos 

Tratar los errores sintácticos 

Página 2

Introducción 

Contenido 

El problema del retroceso 

Análisis sintáctico descendente con retroceso 

Análisis sintáctico descendente sin retroceso 

Construcción de analizadores sintácticos descendentes 

Tratamiento de errores sintácticos. 

Página 3

Introducción 

Clasificación métodos análisis sintáctico 

No Direccionales 

Direccionales 

A. Descendentes A. Ascendentes 

Algoritmo de Unger Algoritmo CYK 

No deterministas 

Predice / Concuerda 

1º Profundidad 

1º Anchura 

Deterministas 

Predice / Concuerda 

Gramática LL(k) - LL(1) 

Desplaza / Reduce 

1º Profundidad 

1º Anchura 

Desplaza / Reduce 

Gramática LR(k) 

LR(0), SLR(1), LALR(1) 

Página 4

Introducción 

A. Sintáctico Descendente: Características 

Los analizadores sintácticos descendentes son llamados predictivos y 

orientados hacia un fin, debido a la forma en que trabajan y construyen el 

árbol sintáctico. 

Construyen el árbol sintáctico de la sentencia a reconocer de una forma 

descendente, comenzando por el símbolo inicial o raíz, hasta llegar a los 

símbolos terminales que forman la sentencia. 

Los algoritmos de análisis descendente deben de cumplir al menos dos 

condiciones: saber en todo momento dónde se encuentra dentro del árbol 

sintáctico y debe poder elegir la regla de producción que aplicará. 

Página 5

Introducción 

A. Sintáctico Descendente: Características 

Los compiladores dirigidos por sintaxis, en la forma de análisis descendente 

recursivo fue propuesta por Lucas (1961), para describir un compilador 

simplificado de ALGOL 60 mediante un conjunto de subrutinas recursivas. 

Problema: La elegancia y comodidad de la escritura de compiladores 

dirigidos por sintaxis fue pagada en tiempo de compilación por el usuario. 

El análisis sintáctico descendente sin retroceso, por medio del uso de 

gramáticas LL(1), obtenidas por Foster (1965) y Knuth (1967). Generalizadas 

posteriormente por Lewis, Rosenkrantz y Stearns en 1969, dando lugar a las 

gramáticas LL(k). 

Página 6


Análisis Sintáctico con retroceso 

El problema se presenta cuando a partir del nodo raíz, el analizador 

sintáctico no elige las producciones adecuadas para alcanzar la 

sentencia a reconocer. 

Se tienen que deshacer las producciones aplicadas hasta encontrar otras 

producciones alternativas, volviendo a tener que reconstruir parte del 

árbol sintáctico (backtracking) . 

El retroceso puede afectar a otros módulos del compilador tales como 

tabla de símbolos, código generado, etc. teniendo que deshacerse 

también los procesos desarrollados en estos módulos. 

Página 7


Análisis Sintáctico con retroceso: Ejemplo 

VN={, , } 

VT={module, d, p, ;, end} 

S= 

Las reglas de producción: 

::= module ; 

end 

::= d | d; 

::= p | p; 

Analizar la cadena de entrada: module d ; d ; p ; p end 

Página 8



1. Se parte del símbolo inicial 

 

2. Aplicando la primera regla de producción de la gramática se obtiene 

 

module ; end 

3. Aplicando las derivaciones más a la izquierda, se tiene que: 

 

module ; end 

d p 

Página 9



Se deriva con la segunda alternativa 

Se debe volver atrás 

 

module ; end 

d p ; 

 

module ; end 

d ; 

d 

p 

Página 10



Se debe volver atrás 

 

module ; end 

d ; 

d 

p ; 

Los tiempos de reconocimiento de sentencias de un lenguaje pueden dispararse 

a causa del retroceso. 

p 

Página 11


Algoritmo de ASD con retroceso 

1. Se colocan las reglas de la gramática según un orden preestablecido. 

2. Se comienza el árbol sintáctico a partir del símbolo inicial, y se aplican 

las reglas en forma recursiva. Al nodo en expansión se le llama nodo activo. 

A → x1x2 ...xn crea n descendientes directos. 

A → x1 | x2 |...| xn se elegirá la alternativa de más a la izquierda. 

3. Si el nodo activo es un terminal se compara con el símbolo actual de la 

cadena. Si son iguales se avanza un token de entrada y el nuevo símbolo 

actual será el situado más a la derecha del terminal analizado. Si no son 

iguales se retrocede hasta un nodo no terminal y se reintenta eligiendo la 

siguiente alternativa. 

Si se llega al símbolo inicial la cadena no pertenece al lenguaje 

Página 12


Corolario 

Una gramática de contexto libre, si es una gramática limpia y no es 

recursiva a izquierdas, para cualquier cadena de símbolos de su alfabeto 

terminal existe un número finito de posibles análisis a izquierda desde el 

símbolo inicial para reconocerla o no. 

Se pueden construir analizadores sintácticos descendentes con retroceso. Su 

principal problema es el tiempo de ejecución . 

Página 13


Gramáticas LL(k) 

Las gramáticas LL(k) son un subconjunto de las GLC. 

Permiten un análisis descendente determinista por medio del 

reconocimiento de la cadena de entrada de izquierda a derecha ("Left to 

right") y que va tomando las derivaciones más hacia la izquierda 

("Leftmost") con sólo mirar los k tokens situados a continuación de donde se 

halla. Si k=1 se habla de gramáticas LL(1). 

Las gramáticas LL(1) permiten construir un analizador determinista 

descendente con tan sólo examinar en cada momento el símbolo actual de la 

cadena de entrada para saber que producción aplicar. 

Página 14

Teorema 

S-gramáticas 



Una gramática LL(k) es no ambigua 

Una gramática LL(k) no es recursiva a izquierdas 

Son un subconjunto muy restringido de las gramáticas LL(1) 

Debe cumplir las siguientes dos condiciones: 

1. Todas las partes derechas de cada producción comienzan con un símbolo 

terminal. 

2. Si dos producciones tienen la misma parte izquierda, entonces su parte 

derecha comienza con diferentes símbolos terminales. 

A: A → a 1 α 1 | a 2 α 2 | ...| a m α m 

se debe cumplir que: 

a i ≠ a j ∀ i ≠ j a i ∈VT α i ∈V * 1 ≤ i ≤ m 

Página 15



Corolario de la definición de S-gramática 

Ejemplos: 

Toda S-gramática es LL(1), la inversa no es cierta. 

S → a T 

S → T b S 

T → b T 

T → b a 

No es S-gramática 

S → a b R 

S → b R b S 

R → a 

R → b R 

S → p X 

S → q Y 

X → a X b 

X → x 

Y → a Y d 

Y → y 

Página 16


Gramáticas LL(1) 

Conjunto de símbolos INICIALES 

Se define el conjunto de símbolos iniciales o cabecera de un símbolo 

α∈(VT ∪ VN) * , como el conjunto de símbolos terminales que pueden 

aparecer al principio de cadenas derivadas de α. La definición anterior se 

puede expresar como: 

INICIALES(α) = {a / α ⇒ a ... siendo a ∈ VT } 

* 

Si α ⇒ a σ1 ...σn entonces {a} ∈ INICIALES(α) con a ∈ VT 

* 

Si α ⇒ λ entonces {λ} ∈ INICIALES(α) 

Página 17



Algoritmo para calcular el conjunto de iniciales 

Repetir hasta que no se puedan añadir más símbolos terminales o λ al conjunto 

1. Si X es un terminal o λ, entonces INICIALES (X) = {X} 

2. Si X es un no-terminal, entonces para cada producción de la forma 

X→X 1 X 2 ...X n , INICIALES (X) contiene a INICIALES (X 1 ) – {λ}. Si 

también para algún i < n todos los conjuntos INICIALES (X 1 ) ... 

INICIALES (X i ) contienen a λ, entonces INICIALES (X) contiene a 

INICIALES (X i+1 ) – {λ}. Si todos los conjuntos INICIALES (X 1 ) ... 

INICIALES (Xn) contiene λ, entonces INICIALES (X) también contiene a 

λ. 

Página 18



Algoritmo para calcular el conjunto de iniciales 

3. Se define INICIALES (α), para cualquier cadena α = X 1 X 2 ...X n , de 

terminales y no-terminales, de la manera siguiente. INICIALES (α) contiene a 

INICIALES (X 1 ) – {λ}. Para cada i = 2, ...,n si INICIALES (X k ) contiene a λ 

para toda k = 1, ...i-1, entonces INICIALES(α) contiene a INICIALES (X i ) - 

{λ}. Finalmente, si para todo i = 1...n, INICIALES (X i ) contiene λ, entonces 

INICIALES (α) contiene a λ. 

Página 19



Seudocódigo del algoritmo para todo no terminal A 

for todo no terminal A do INICIALES(A) := {} 

while existan cambios en cualquier INICIALES(A) do 

for cada selección de producción A→X1X2 ...Xn do 

k :=1; continuar = verdadero; 

while contiuar = verdadero and k

Ejemplos: 

S → A B e 

A → d B 

A → a S 

A → c 

B → A S 

B → b 



Conjunto de Símbolos Iniciales 

exp → term exp´ 

exp´ → opsuma term exp´ | λ 

opsuma → + | - 

term → factor term´ 

term´ → opmult factor term´ | λ 

opmult → * 

factor → ( exp ) | numero 

INICIALES (A) = {d, a, c} 

INICIALES (S) = INICIALES(A)={d, a, c} 

INICIALES (B) = INICIALES(A) ∪ {b} ={d, a, c, b} 

INICIALES (exp) = {(, numero} 

INICIALES (exp´) = {+,-, λ} 

INICIALES (opsuma) = {+, -} 

INICIALES (term) = {(, numero} 

INICIALES (term´) = {*, λ} 

INICIALES (opmult) = {*} 

INICIALES (factor) = {(, numero} 

Página 21



Gramáticas LL(1) simples 

Las gramáticas LL(1) simples son un subconjunto de las gramáticas LL(1), con las 

dos restricciones siguientes: 

1. No se permiten símbolos no terminales que deriven a vacío. 

2. Las distintas producciones de cada no terminal A ∈ VN A → α 1 | α 2 | ...| α n 

deben cumplir que los conjuntos INICIALES(α 1 ), INICIALES(α 2 ),..., 

INICIALES(α n ) sean disjuntos entre sí. 

INICIALES(α i ) ∩ INICIALES(α j ) = ∅ ∀ i ≠ j 

Página 22



Corolario de las gramáticas LL(1) simples 

Toda gramática LL(1) simple es LL(1), lo contrario no es cierto. 

Teorema de equivalencia entre gramáticas LL(1) y S-gramáticas 

Dada una gramática LL(1) simple siempre es posible encontrar una 

S-gramática equivalente. 

Ejemplo: S → A B e 

A → d B 

A → a S 

A → c 

B → A S 

B → b 

Página 23



Conjunto de símbolos SEGUIDORES 

Se define el conjunto de símbolos seguidores o siguientes para un símbolo no 

terminal A como el conjunto de símbolos terminales que en cualquier 

momento de la derivación pueden aparecer inmediatamente a la derecha de (o 

después de) A 

SEGUIDORES (A) = { a / S ⇒ βAaδ con β, δ∈ (VT ∪ VN) * } 

Página 24



Algoritmo para calcular el conjunto de Seguidores 

Repetir hasta que no cambie el conjunto de seguidores 

1. Si A es el símbolo inicial, entonces $ está en SEGUIDORES (A). 

2. Si hay una producción B →αAγ, entonces 

INICIALES (γ) – {λ} ∈ SEGUIDORES (A) 

3. Si existe una producción B →αA ó B →αAγ tal que λ∈INICIALES (γ) 

entonces SEGUIDORES (B) ⊂ SEGUIDORES (A) 

Página 25



Seudocódigo del algoritmo para el cálculo de conjuntos de Seguidores 

SEGUIDORES (símbolo-inicial) := {$}; 

for todos los no terminales A ≠ símbolo-inicial do SEGUIDORES(A):={}; 

while existan cambios en cualquier conjunto SEGUIDORES do 

for cada producción A→X 1 X 2 ...X n do 

for cada X i que sea un no terminal do 

añadir INICIALES (X i+1 X i+2 ...X n ) - {λ} a SEGUIDORES (X i ) 

(* NOTA: si i=n, entonces X i+1 X i+2 ...X n = λ *) 

if λ está en INICIALES(X i+1 X i+2 ...X n ) then 

añadir SIGUIENTE (A) a SIGUIENTE (X i ) 

Página 26

Ejemplos: 



Conjunto de Símbolos Seguidores 

sentencia → sent-if | otra 

sent-if → if (exp) sentencia parte-else 

parte-else → else sentencia | λ 

exp → 0 | 1 SEGUIDORES (sentencia) = {$, else} 

SEGUIDORES (sent-if) = {$, else} 

SEGUIDORES (parte-else) = {$, else} 

SEGUIDORES (exp) = {)} 






opmult → * 


SEGUIDORES (exp) = {$, )} 

SEGUIDORES (exp´) = {$, )} 

SEGUIDORES (opsuma) = {(, numero} 

SEGUIDORES (term) = {$, ), +, -} 

SEGUIDORES (term´) = {$, ), +, -} 

SEGUIDORES (opmult) = {(, numero} 

SEGUIDORES (factor) = {$, ), +,-,*} 

Página 27



Conjunto de símbolos DIRECTORES 

Los símbolos directores de una producción A → αson los que dirigen al 

analizador sintáctico para elegir la alternativa adecuada. 

Se definen como el conjunto de símbolos terminales que determinarán que 

expansión de un no terminal se ha de elegir en un momento dado, con solo 

mirar un símbolo hacia delante. 

SD (A, α ) 

INICIALES (α) si α es no anulable 

INICIALES (α) ∪ SEGUIDORES (A) si α es anulable 

Página 28

Definición 



La condición necesaria y suficiente para que una gramática limpia sea LL(1), 

es que los símbolos directores correspondientes a las diferentes expansiones 

de cada símbolo no terminal sean conjuntos disjuntos. 

La condición es necesaria, puesto que si un símbolo aparece en dos 

conjuntos de símbolos directores, el analizador sintáctico descendente no 

puede decidir que expansión aplicar. 

La condición es suficiente, puesto que el analizador siempre puede escoger 

una alternativa correcta. Si el símbolo no está contenido en ninguno de los 

conjuntos, la cadena de entrada no pertenece al lenguaje. 

Página 29


Condiciones de las gramáticas LL(1) 

Primera condición de Knuth 

No se permitirán producciones de la forma A → A α donde A ∈ a VN y α ∈ V * . 

Esta condición equivale a no admitir la recursividad a izquierdas. 

Segunda condición de Knuth 

Los símbolos terminales que pueden encabezar las distintas alternativas de una 

regla de producción deben formar conjuntos disjuntos. 

No debe ocurrir que: 

A → Bβ | Cγ A,B,C ∈ VN 

β, γ ∈ V * 

* 

* 

B → dS d ∈ VT 

C → dψ S, ψ ∈ V * 

* 

Página 30



Tercera condición de Knuth 

Si una alternativa de un símbolo no terminal origina la cadena vacía, entonces: 

(INICIALES (A) ∩ SEGUIDORES(A) = ∅ ) 

Sea la cadena A 1 ... A 2 ... A 3 A 4 A 5 y sea A 3 el símbolo que se está analizando, 

además se tienen las producciones: 

A 3 →ax | λ 

A 4 →A 3 ay 

Dado que A3 puede derivar a la cadena vacía, puede darse el caso de que: 

INICIALES(A3 )= { a } 

INICIALES(A4 )= { a } 

y no puede determinarse si se ha de elegir la producción de A3 o de A4 Página 31



Cuarta condición de Knuth 

Ningún símbolo no terminal puede tener dos o más alternativas que conduzcan 

a la cadena vacía. Esta condición deriva de la anterior. 

Así por ejemplo no se permite . 

X → A | B 

A → λ | C 

B → λ | D 

Página 32


Transformación de gramáticas 

No se puede saber si un determinado lenguaje puede 

ser generado o no por una gramática LL(1), hasta que 

no se encuentre esta gramática. 

No existe ningún algoritmo general que transforme 

una gramática a LL(1). 

En algunos casos, se puede obtener una gramática 

equivalente por medio de las transformaciones. 

GRAMÁTICAS LIBRES 

DE CONTEXTO 

NO AMBIGUAS 

LL(1) 

Página 33



Eliminación de la recursividad a izquierdas 

Se dice que una gramática tiene recursividad a izquierdas, si existe un no terminal 

A, tal que para algún α ∈ V * existe una derivación de la forma: 

EJEMPLO 

S → aAc 

A → Ab | λ 

Reconocer la cadena abbc 

(1) 

S 

Α ⎯ ⎯→ Α α 

+ 

(2) 

S 

a A c 

(3) 

S 

a A c 

A b 

(4) 

S 

a A c 

A b 

A b 

S 

a A c 

A b 

A b 

A b 

(5) 

Página 34

1ª) Transformación 

S → aAc 

A → λ | Ab 

2ª) Transformación 

S → aAc 

A → λ | bA 



(1) 

S 

(1) 

S 

(2) 

S 

a A c 

(2) 

S 

a A c 

(3) 

S 

a A c 

(3) 

S 

a A c 

b A 

(4) 

S 

a A c 

(4) 

S 

A b 

a A c 

b A 

b A 

(5) 

S 

a A c 

A b 

A b 

(5) 

S 

a A c 

b A 

b A 

Página 35



Eliminación de la recursividad a izquierdas directa 

Se sustituye por: 

Caso general 

β i no comienza por A 

A → A α ⏐ β 

A → β C 

C → αC ⏐ λ 

A 

A 

A 

Bucle infinito 

A → A α 1 | A α 2 | ... | A α n | β 1 | β 2 | β 3 | ... | β n 

A → β 1 C | β 2 C | ... | β n C 

C → α 1 C | α 2 C | ... | α n C | λ 

A 

ß 

A 

C 

C 

C 

Página 36



Eliminación de la recursividad a izquierdas indirecta 

El método para resolver las recursividades indirectas es convertirlas a 

recursividades directas por medio de sustituciones. 

Ejemplo: 

::= . 

::= ; 

::= return | end 

::= exit 

Gramática equivalente 

::= . 

::= ; 

::= return | end 

::= end ; exit 

::= return ; exit | λ 

::= exit 

::= ; exit 

::= return ; exit 

::= end ; exit 

Página 37



Factorización y sustitución 

Trata de agrupar las producciones que comienzan por el mismo símbolo no anulable, 

realizar sustituciones de reglas o incluir nuevos símbolos no terminales. 

Algoritmo A → αβ 1 | αβ 2 | ... αβn|γ 

Primer paso: para cada no terminal A buscar el prefijo más largo común a 

dos o más alternativas de dicho no terminal. 

Segundo paso: Si α≠ε, sustituir todas las producciones de A por: 

A → α C | γ 

C → β 1 | β 2 |...|β n 

Página 38



Ejemplo: Factorización y sustitución 

::= + | 

- | 

 

::= * | 

/ | 

 

::= ^ | 

 

::= - | 

 

::= ( ) | 

identificador | 

constante 

Aplicando factorización y sustitución 

::= + | - 

::= * | / 

::= ^ | 

::= | 

::= | 

 

::= 

::= - | 

 

::= ( ) | 

identificador | constante 

Página 39



::= 

::= + 

::= - 

::= 

::= 

::= * 

::= / 

::= 

::= 

::= ^ 

::= 

::= - 

::= 

::= ( ) 

::= identificador 

::= constante 

::= λ 

Página 40



Transformación mediante aspectos semánticos 

En algunos lenguajes de programación es necesario conocer más información 

que la estrictamente sintáctica, para elegir el símbolo director en cada momento . 

Ejemplo: 

::= begin end 

(1) aa: x:= 5 

::= 

::= identificador : 

| λ 

(2) yy:= 5 

::= while DO 

| := 

| repeat until 

| for := do 

| goto constante 

| case of end 

... 

::= identificador 

... 

Página 41


Técnicas de construcción 

Métodos basados directamente en la sintaxis. 

Analizadores sintácticos descendentes recursivos. 

Analizadores sintácticos descendentes dirigidos por tabla. 

Analizadores sintácticos descendentes basados en máquinas 

de tipo 2 o de pila. 

Analizadores sintácticos descendentes dirigidos por estructuras de datos. 

Página 42


Métodos basados directamente en la sintaxis 

Reglas de construcción de diagramas sintácticos 

Operación BNF Diagrama Conway 

Secuencial AB 

Alternativa 

Repetitiva 

A | B 

λ | B 

{B} 1 o más 

[B] 0 o más 

A B 

A 

B 

B 

B 

B 

Métodos sencillos para dar 

los primeros pasos entre 

teoría e implementación. 

Toda gramática reconocible 

mediante el método de los 

diagramas de Conway es 

LL(1). 

Página 43



Traducción de reglas sintácticas a programas 

Los símbolos no terminales son procedimientos, funciones o métodos. 

Los símbolos terminales son tokens enviados por el analizador léxico. 

Las reglas de producción se traducen a estructuras de control. 

Página 44



Ejemplo 1: Factor 

La regla de producción A → S 1 | S 2 | S 3 | ... | S n se traduce a una sentencia multialternativa 

factor ( ){ 

switch (token) { 

case ID : get_token ( ); break; 

case NUM : get_token ( ); break; 

case NOT : get_token ( ); factor ( ); break; 

case AB_PAR : get_token ( ); expresion ( ); 

if (token != CE_PAR) 

{Error: Paréntesis de cierre} 

else get_token ( ); 

break; 

default : Error : Expresión no válida. 

} 

} 

donde token ∈ Símbolos Directores (A, S 1 | S 2 | ... | S n ) 

identificador 

numero 

NOT 

factor 

( expresion ) 

Página 45



Ejemplo 2: Expresión-simple 

La regla de producción A → SA | λ o A → SA | S se traduce a una sentencia repetitiva 

+ 

- 

termino 

expr_simple ( ) { 

OR 

if ((token == MAS) || (token == MENOS)) { 

get_token( ); 

} 

termino ( ); 

while ((token == MAS) || (token == MENOS) || (token == OR)) { 

get_token( ); 

termino ( ); 

} 

} 

+ 

- 

termino 

Página 46


Analizadores sintácticos descendentes recursivos 

La condición necesaria para que un analizador descendente recursivo 

opere correctamente es que la gramática del lenguaje fuente sea LL(1). 

Se considera a cada regla de la gramática como la definición de una 

función o método que reconocerá al no terminal de la parte izquierda. 

El lado derecho de la regla especifica la estructura del código para ese 

método o función. 

Los símbolos terminales corresponden a concordancias con la entrada. 

Los símbolos no terminales con llamadas a funciones o métodos. 

Las diferentes alternativas a casos condicionales en función de lo que 

se esté examinando en la entrada. 

Página 47



Implementación de un analizador sintáctico descendente recursivo 

Una función denominada Match 

Funcion Match(terminal) 

inicio 

si (token-actual == terminal) entonces 

obtener siguiente token 

sino 

error sintáctico 

fin 

Una función para cada no terminal con la siguiente estructura: 

Para las reglas de la forma A → α 1 | α 2 | ... | α n decidir la producción 

a utilizar en función de los conjuntos INICIALES(α i ). . 

Página 48


Analizadores sintácticos recursivos descendentes 

Funcion A() 

inicio 

segun token-actual está en: 

INICIALES(α 1 ): { proceder según alternativa α 1 } 

INICIALES(α 2 ): { proceder según alternativa α 2 } 

... 

INICIALES(α n ): { proceder según alternativa α n } 

Fin-segun 

si token-actual no pertenece a ningún INICIALES (α n ) 

entonces 

Fin 

error sintáctico, excepto si existe la alternativa 

A → ε en cuyo caso no se hace nada. 

Página 49



Para cada alternativa α i del no terminal, proceder analizando 

secuencialmente cada uno de los síımbolos que aparece en la parte derecha. 

Si es un no terminal entonces 

hacer una llamada a su función 

Si es un terminal entonces 

hacer una llamada a la función Match con ese terminal 

como argumento. 

Para lanzar el analizador sintáctico se hace una llamada a la función 

asociada al símbolo inicial de la gramática. No olvidar hacer una llamada 

previa al analizador léxico para inicializar la variable con el primer token 

del fichero de entrada. 

Página 50



Ejemplo: Construir un ASD recursivo para la siguiente gramática 

instruccion → identificador = exp ; 

exp → termino mastermino 

mastermino → + termino mastermino| λ 

termino → identificador | constante 

#include 

#include"tokens.h“ 

int tokenActual; 

... /* otras declaraciones */ 

void main(){ 

tokenActual=yylex(); 

instruccion(); 

} 

SDescendente.c 

Página 51



void terminal(int token, char *mensCasoError){ 

if(tokenActual==token) 

tokenActual=yylex(); 

else hayError(mensCasoError); 

instruccion → 

} 

identificador = exp ; 

void instruccion(){ 

terminal(IDENTIFICADOR,”Se esperaba ID”); 

terminal(ASIGNACION,”Se esperaba ‘=‘”); 

expresion(); 

terminal((int) ‘;’,”Se esperaba ‘;’”); 

} 

void expresion(){ exp → termino 

termino(); 

mastermino 

mastermino(); 

} 

Página 52 

SDescendente.c



void termino(){ 

if(tokenActual==IDENTIFICADOR) 

terminal(IDENTIFICADOR, "Se esperaba ID"); termino → 

else if(tokenActual==CONSTANTE { 

identificador | 

terminal(CONSTANTE, "Se esperaba CTE"); constante 

else hayError("Se esperaba un ID o CTE"); 

} 

void mastermino(){ 

mastermino → + termino 

mastermino | λ 

if(tokenActual=='+'){ 

terminal((int) ‘+‘,”Se esperaba ‘+‘”); 

termino(); 

mastermino(); 

} /* el else: corresponde a la producción λ */} 

/* ... funcion hayError */ 

SDescendente.c 

Página 53


Analizadores sintácticos dirigidos por tabla 

El hecho de que haya reglas recursivas hace que el analizador predictivo 

implementado directamente sea recursivo. Sin embargo, la recursividad se puede 

evitar mediante el uso explícito de una pila. 

Esquema general 

Entrada 

... b c a...$ 

Matriz bidimensional. 

Es lo único que cambia 

de un analizador a otro. 

Analizador 

Sintáctico 

Tabla de análisis 

M[X,a] 

Z 

Y 

K 

$ 

Pila de símbolos 

(a reconocer) 

Salida 

A → X 

X → Z Y k 

Producciones utilizadas en 

el análisis de la secuencia 

de entrada. 

. 

Página 54



Construcción de la tabla de análisis sintáctico 

Entrada: una gramática G 

Salida: la tabla de análisis sintáctico, con una fila para cada 

no-terminal, una columna para cada terminal y otra para $ 

Método: 

Ampliar la gramática con una producción S’→ S$ 

Para cada producción de la gramática A → α hacer: 

– Para cada terminal a ∈ PRIMEROS(α), añadir la producción A → α 

en la casilla M[A,a]. 

– Si λ ∈ PRIMEROS(α), añadir A → α en la casilla M[A,b] 

∀b ∈ SIGUIENTES(A). 

Las celdas de la tabla que hayan quedado vacías se definen como 

error. 

Las gramáticas LL(1) garantizan que solo aparezca una producción por casilla 

Página 55



Ejemplo: 

E ::= T E’ 

E’ ::= + T E’ | λ 

T ::= F T’ 

T’ ::= * F T’ | λ 

F ::= ( E ) | Id 

INIC (T E’) = {(, id} 

INIC (+T E’) = {+} 

INIC (λ ) = {λ} 

INIC (F T’) = {(,id} 

INIC (* F T’) = {*} 

INIC ( ( E ) ) = {(} 

INICIALES (id) = {id} 

E 

E’ 

T 

T’ 

F 

SEG (E’) = {$, )} 

SEG (T’) = {+,$,)} 

id 

TE’ 

FT’ 

id 

+ 

+TE’ 

λ 

* 

*FT’ 

( 

TE’ 

FT’ 

(E) 

Tabla de análisis sintáctico 

) 

λ 

λ 

$ 

λ 

λ 

Página 56



Pila Entrada Producción 

$ E 

$ E’ T 

$ E’ T’ F 

$ E’ T’ Id 

$ E’ T’ 

$ E’ T’ F * 

$ E’ T’ F 

$ E’ T’ Id 

$ E’ T’ 

$ E’ 

$ E’ T + 

$ E’ T 

$ E’ T’ F 

$ E’ T’ Id 

$ E’ T’ 

$ E’ 

$ 

Id * Id + Id $ 




* Id + Id $ 

* Id + Id $ 

Id + Id $ 

Id + Id $ 

+ Id $ 

+ Id $ 

+ Id $ 

Id $ 

Id $ 

Id $ 

$ 

$ 

$ 

E::= T E’ 

T::= F T’ 

F::= Id 

T’::= * F T’ 

F::= Id 

T’::= λ 

E’::= + T E’ 

T::= F ⋅ T’ 

F::= Id 

T’::= λ 

E’::= λ 

Página 57


Analizadores sintácticos basados en AP 

Si la gramática es LL(1) el autómata de pila será determinista. 

Entrada: La cadena w$ a reconocer y una 

gramática G. 

Salida: Si w$ ∈ L(G), la derivación más a la 

izquierda de la cadena de entrada, sino una 

indicación de error. 

Método: Como configuración inicial se tiene 

en el fondo de la pila el símbolo $, el símbolo 

inicial de la gramática S en la cima y la cadena 

w$ en el buffer de entrada. 

CONTROL 

DE 

ESTADOS 

entrada 

token1 token2 token3 ... tokenN-1 tokenN 

cabeza de 

lectura 

tope 

Z 

Y 

X 

. 

A 

$ 

Pila 

apila 

desapila 

Página 58


Analizadores sintácticos basados en AP 

Algoritmo para el análisis sintáctico descendente determinista 

REPETIR 

SEGÚN sea el símbolo del tope de la pila 

Terminal: Si el símbolo de entrada (token) coincide con el terminal entonces 

Coger siguiente token 

Extraer el símbolo de la pila 

Sino 

Error 

No-Terminal: Utilizar el símbolo no-terminal y el símbolo de entrada (token) 

para determinar la producción correspondiente 

Si se encuentra la producción X → Y1Y2 ... Yk entonces 

Extraer el símbolo no-terminal X 

Introducir Yk, Yk-1 , ... Y1 en la pila 

(Y1 estaría en el tope de la pila) 

Sino 

Error 

HASTA (Pila vacía o error) 

Si la pila está vacía entonces 

Aceptar la cadena de entrada 

Sino 

Error 

Página 59


Analizadores sintácticos dirigidos por ED 

Se supone que una gramática está formada por un conjunto determinista de 

grafos sintácticos. 

Cada nodo se puede representar por: 

Símbolo 

Secuencial 

- Símbolo terminal 

- Símbolo no terminal → puntero a la estructura 

de datos que representa el símbolo. 

S 1 S 2 S 3 S n 

Alternativa Sucesor 

NIL 

S 1 

S 2 

S n 

Alternativa 

S 3 

Fueron propuestos por 

Wirth con el objetivo 

de construir 

analizadores genéricos 

Repetitiva 

S 

vacío 

NIL 

Página 60

Tratamiento de errores sintácticos 

Los errores en programación pueden ser: 

Léxicos: producidos al escribir mal un identificador, una palabra clave, un 

operador, etc 

Sintácticos: cuando la secuencia de tokens enviados por el analizador léxico 

no son reconocidos por la gramática que describe el lenguaje. Pueden ser 

producidos por una expresión aritmética o paréntesis no equilibrados, etc. 

Semánticos: producidos como consecuencia de la aplicación de un operador a 

un operando incompatible, etc. 

Página 61


Un gestor de errores debe proporcionar las siguientes funciones: 

Determinar si el programa es sintácticamente correcto. 

Proporcionar un mensaje de error significativo: 

parser error: linea 10 columna 4, simbolo encontrado f símbolo esperado ; 

Declarar que ha ocurrido un error tan pronto como sea posible. Esperar demasiado 

tiempo significa que la ubicación real del error puede haberse perdido. 

Reanudar el análisis tan pronto como sea posible. Debería intentar analizar tanto código 

como fuera posible para detectar los errores reales. 

Evitar errores en cascada. Un error genera una secuencia de mensajes de error falsos. 

Evitar bucles infinitos en los que se genera una cascada sin fin de mensajes de error. 

Para evitarlo se debe ignorar parte de la entrada. 

Realizar una reparación del error. El analizador intenta inferir un programa correcto de 

uno incorrecto. 

Página 62


Recuperación de errores 

Los métodos de recuperación de errores suelen ser métodos “ad-hoc”, en el 

sentido de que se aplican a lenguajes específicos y a métodos concretos de análisis 

Sintáctico (descendente, ascendente. etc), con muchas situaciones particulares. 

Existen varias estrategias para corregir errores, una vez detectados 

Recuperación en modo de alarma (Panic mode ): Consiste en ignorar el 

resto de la entrada hasta llegar a una condición de seguridad, un token 

especial (por ejemplo un ‘;’ o un ‘END’). 

Error 

id ‘=’ id ‘[‘ id ‘]’ id ’[‘ id ‘]’ ’=’ id ’[‘ id ‘]’ ‘;’ id ’[‘ id ‘]’ ‘=’ id ‘;’ 

Token especial utilizado para continuar 

la compilación a partir de él 

Ejemplo: 

aux = a[i] 

a[i] = a[j]; 

a[j] = aux; 

Página 63



Recuperación a nivel de frase: Intenta recuperar el error una vez 

descubierto. En el caso anterior, por ejemplo, podría haber sido lo 

suficientemente inteligente como para insertar el token ‘;’. Hay que tener 

cuidado con este método ya que caben varias posibilidades. 

Reglas de producción adicionales para el control de errores:La gramática 

se puede aumentar con las reglas que reconocen los errores más comunes. 

sent_errónea → sent_sin_acabar sentencia_acabada 

sentencia_acabada → sentencia ‘;’ 

sent_sin_acabar → sentencia 

Corrección Global: el analizador sintáctico le pide toda la secuencia de 

tokens al léxico, y lo que hace es devolver lo más parecido a la cadena de 

entrada pero sin errores, así como el árbol que lo reconoce. 

Página 64


Recuperación de errores en ASD recursivos 

Una forma estándar de recuperación de errores en los ASD recursivos se 

denomina Modo de alarma. 

Consiste en proporcionar a cada procedimiento (cada no-terminal de la 

gramática) un parámetro extra, un conjunto de tokens de sincronización. 

Según se va efectuando el análisis, los tokens que pueden funcionar como 

tokens de sincronización se agregan según se vayan realizando las llamadas. 

Si se encuentra un error, el analizador explora hacia delante, desechando 

tokens hasta encontrar uno que pertenezca al conjunto reanudándose así el 

análisis. 

Las cascadas de error se evitan al no generar nuevos errores mientras tiene 

lugar esta exploración. 

Página 65



¿ Qué tokens se agregan al conjunto de sincronización en cada punto 

del análisis sintáctico ? 

Los conjuntos de SEGUIDORES 

Los conjuntos de INICIALES para evitar que el manejador de errores omita 

tokens importantes que inicien nuevas construcciones (sentencias, expresiones) 

Ejemplo: Sea la gramática de expresiones: 






opmult → * 


Página 66



Además del procediemiento Match y los correspondientes a cada símbolo no terminal 

se añaden dos procedimientos nuevos: checkInput y scanTo. 

Esquematizado en seudocódigo quedaría de la siguiente forma: 

procedimiento scanTo(synchset); 

begin 

while not (token in synchset ∪ {$}) do 

getToken; 

end scanTO; 

procedimiento checkInput(FIRSTSet, FOLLOWSet); 

begin 

if not (token in FIRSTSet) then 

error; 

scanTo (FIRSTSet ∪ FOLLOWSet); 

end if; 

end checkInput; 

Es el consumidor de 

tokens en modo de 

alarma 

Realiza la 

verificación temprana 

en modo de alarma 

Página 67



Estos procedimientos se utilizan como sigue en los procedimientos exp y factor: 

procedimiento exp(synchset); 

begin 

checkInput ({(,numero}, synchset); 

if not (token in synchset) then 

term (synchset); 

while token = + or token = - do 

match (token); 

term (synchset); 

end while; 

checkInput(synchset, {(,numero}); 

end if; 

end exp; 

procedimiento factor(synchset); 

begin 

checkInput ({(,numero}, synchset); 

if not (token in synchset) then 

case token of 

( : match ((); 

exp ({)}); 

match ()); 

numero: 

match(numero); 

else error; 

end case; 

checkInput(synchset, {(,numero}); 

end if; 

end factor; 

Página 68



checkInput es llamado dos veces en cada procedimiento: 

Para verificar que un token en el conjunto Iniciales sea el token 

siguiente en la entrada. 

Para verificar que un token en el conjunto Siguiente sea el token 

siguiente en la salida. 

En general synchset se pasa en las llamadas recursivas con nuevos tokens 

de sincronización agregados de manera apropiada. 

Para obtener los mejores mensajes de error y recuperación de errores, toda 

prueba de token se debe examinar por la probabilidad de que una prueba más 

general o más temprana mejore el comportamiento del error. 

Página 69



Wirth especifica las características de un buen analizador sintáctico: 

1. Ninguna sentencia debe dar lugar a que el analizador sintáctico pierda el 

control. 

2. Todos los errores sintácticos deben de ser detectados y señalados. 

3. Los errores muy frecuentes e imputables a verdaderos fallos de comprensión 

o descuido del programador, habrán de ser diagnosticados correctamente 

(evitar los llamados mensajes de rebote). Esta tercera característica es la más 

difícil de lograr, ya que incluso compiladores de gran calidad emiten dos o más 

mensajes para un determinado error. 

Página 70

análisis sintáctico descendente sin retroceso - Blearning

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

Delete template?

Save as template?