Análisis Sintáctico

1

INSTITUTO TECNOLÓGICO DE FELIPE
CARRILLO PUERTO
Ingeniería en sistemas computacionales
Semestre VI
Aula J1
Grupo A
Unidad 6
(Análisis Sintáctico)
LENGUAJES Y AUTOMATAS 1
NOMBRE DEL ALUMNO: Erwin Alexander Villegas tun
Ezer Abisai Ayala Mutul
Wilberth Abigael Balam Yam
NOMBRE DEL PROFESOR (A): ISC. Paloma Góngora Sabido
Felipe Carrillo Puerto, Quintana Roo a 20 de Junio del 2016
2

INDICE
Contenido
Introducción ............................................................................................................................... 4
Gramáticas libre de contexto .................................................................................................. 5
BNF .............................................................................................................................................. 8
Árbol de derivación ................................................................................................................ 11
Propiedades de un árbol de derivación. ............................................................................. 12
Formas Normales de Chomsky ............................................................................................ 15
Variables accesibles ................................................................................................................. 15
Variables generativas ......................................................................................................... 15
Variables útiles .................................................................................................................... 16
Diagramas de sintaxis ............................................................................................................ 18
Descripción .......................................................................................................................... 18
Como se constituyen .......................................................................................................... 19
Características ..................................................................................................................... 20
Ambigüedad ............................................................................................................................. 22
Eliminación de Ambigüedad ............................................................................................. 23
Tipos de Ambigüedad ........................................................................................................ 23
Generación de matriz predictiva (FIRS y FOLLOW) ......................................................... 25
Construcción de la Tabla ................................................................................................... 27
Tipos de analizadores ............................................................................................................ 34
Algoritmo .............................................................................................................................. 35
Manejo de errores ................................................................................................................... 41
Estrategias para recuperarse de los errores ..................................................................... 43
Generadores de analizadores sintácticos .......................................................................... 46
Generador sintáctico GNU BISON ....................................................................................... 47
Conclusión ............................................................................................................................... 48
Bibliografías ............................................................................................................................. 49
3

Introducción
Aquí encontrara temas relacionados con el análisis sintáctico, como primer tema
encontrará la definición formal de GLC (Gramáticas Libres de Contexto), así como
la definición de Árbol de derivación su representación gráfica, propiedades de un
árbol de derivación y sus respectivos ejemplos. Otro tema importante son las formas
normales de Chomsky nos menciona que si una gramática formal esta en forma
normal de Chomsky si todas sus reglas de producción son de algunas de las
siguientes formas ABC o Aa entre otras que se muestran en el documento. Los
diagramas de sintaxis también conocidas como diagramas de ferrocarril, son la
forma de representar una gramática libre de contexto, para la mayoría de las
personas se les hace más comprensible representarlos en diagramas, de igual
forma podrá apreciar varios ejemplos relacionados con este tema. Una gramática
libre de contexto es ambigua si existe cierta cadena que tiene más de una derivación
por la izquierda o más de una derivación por la derecha o si tiene dos o más árboles
de derivación; existe dos tipos de ambigüedad, la Inherentes y ambigua; los
ejemplos mostrados son sobre la eliminación de ambigüedad. El siguiente tema
trata sobre la generación de matriz predictiva aquí se utiliza first y follow para la
generación de estas matrices con los ejemplos que se mostraran se explicara más
a detalle cómo se utiliza estos dos tipos de cálculos. Hay dos tipos de analizadores
sintácticos, los descendentes que se construye el árbol de análisis sintético
partiendo del símbolo inicial aplicando las producciones mediante derivaciones por
la izquierda; y las Ascendentes estas construye el árbol de análisis sintético
partiendo de la frase a reconocer y aplicando las producciones mediantes
reducciones hasta llegar al símbolo inicial de la gramática. Un compilador es un
sistema que en la mayoría de los casos maneja una entrada incorrecta, sobre todo
en las primeras etapas de la creación de un programa. Uno de los errores más
complicados que se pueden encontrar, es el manejo de errores de sintaxis y como
objetivo tiene que indicar los errores e forma clara y precisa, aclarar el tipo de error
y su localización también debe de recuperarse del error para poder seguir
examinando la entrada. Como último tema tenemos los generadores de
analizadores sintácticos, se agregaron varios programas de generadores entre ellos
4

Gramáticas libre de contexto
Estas gramáticas, conocidas también como gramáticas de tipo 2 o gramáticas
independientes del contexto, son las que generan los lenguajes libres o
independientes del contexto. Los lenguajes libres del contexto son aquellos que
pueden ser reconocidos por un autómata de pila determinístico o no determinístico.
Estas gramáticas producen los lenguajes Libres de Contexto (abreviado “LLC”)
Capturan la noción de constituyente sintáctico y la noción de orden.
Herramienta formal que puede ser vista tanto desde un punto de vista
generador como estructurador.
Propiedades computacionales interesantes: se puede reconocer en tiempo
polinómico.
Como toda gramática se definen mediante una cuádrupla G = (N, T, P, S), siendo
‣ N es un conjunto finito de símbolos no terminales
‣ T es un conjunto finito de símbolos terminales
‣ P es un conjunto finito de producciones
‣ S es el símbolo distinguido o axioma S ∉ (N ∪ T)
N ∩ T = ∅
En una gramática libre del contexto, cada producción de P tiene la forma
A ∈ N ∪ {S}
A → ω
ω ∈ (N ∪ T) * - {ε}
Es decir, que en el lado izquierdo de una producción pueden aparecer el símbolo
distinguido o un símbolo no terminal y en el lado derecho de una producción
cualquier cadena de símbolos terminales y/o no terminales de longitud mayor o igual
que 1. La gramática puede contener también la producción S → ε si el
lenguaje que se quiere generar contiene la cadena vacía.
5

1. Los terminales son los símbolos básicos a partir de los cuales se forman las
cadenas. El término “nombre de token” es un sinónimo de “terminal”; con
frecuencia usaremos la palabra “token” en vez de terminal, cuando esté claro
que estamos hablando sólo sobre el nombre del token. Asumimos que las
terminales son los primeros componentes de los tokens que produce el
analizador léxico. Los terminales son las palabras reservadas if y else, y los
símbolos “(” y “)”.
2.
Los no terminales son variables sintácticas que denotan conjuntos de
cadenas. En (4.4), instr y expr son no terminales. Los conjuntos de cadenas
denotados por los no terminales ayudan a definir el lenguaje generado por la
gramática. Los no terminales imponen una estructura jerárquica sobre el
lenguaje, que representa la clave para el análisis sintáctico y la traducción.
3.
En una gramática, un no terminal se distingue como el símbolo inicial, y el
conjunto de cadenas que denota es el lenguaje generado por la gramática.
Por convención, las producciones para el símbolo inicial se listan primero.
4.
Las producciones de una gramática especifican la forma en que pueden
combinarse los terminales y los no terminales para formar cadenas. Cada
producción consiste en:
a) Un no terminal, conocido como encabezado o lado izquierdo de la
producción; esta producción define algunas de las cadenas denotadas por el
encabezado.
b) El símbolo →. Algunas veces se ha utilizado ::= en vez de la flecha.
c) Un cuerpo o lado derecho, que consiste en cero o más terminales y no
terminales.
d) Los componentes del cuerpo describen una forma en que pueden construirse
las cadenas del no terminal en el encabezado.
6

Ejemplo 1:
La siguiente gramática genera las cadenas del lenguaje L 1 = {wcw R / w ∈ {a, b}
* }
G 1 = ({A}, {a, b, c}, P 1 , S 1 ), y P 1 contiene las siguientes producciones
S 1 → A
A
A
A
→ aAa
→ bAb
→ c
Ejemplo 2:
La siguiente gramática genera las cadenas del lenguaje L 2 = {0 i 1 i+k 2 k 3 n+1
/ i, k, n ≥ 0 }
Casos Cadenas de L 2
si n, i, k > 0 0 i 1 i+k 2 k 3 n+1
si n=0 y i, k > 0 0 i 1 i+k 2 k 3
si i=0 y n, k >0 1 k 2 k 3 n+1
si k=0 y n, i >0 0 i 1 i 3 n+1
si n, i=0 y k >0 1 k 2 k 3
si n, k=0 y i >0 0 i 1 i 3
si i, k =0 y n >0 3 n+1
si n,i,k=0 3
G 2 = ({A, B, C}, {0, 1, 2, 3}, P 2 , S 2 ), y P 2 contiene las producciones
7

S 2 → ABC B → 1B2
S 2 → AC B → 12
S 2 → BC C → 3C
S 2 → C C → 3
A
→ 0A1
A → 01
BNF
Las gramáticas libres del contexto se escriben, frecuentemente, utilizando una
notación conocida como BNF (Backus-Naur Form). BNF es la técnica más
común para definir la sintaxis de los lenguajes de programación.
En esta notación se deben seguir las siguientes convenciones:
‣ los no terminales se escriben entre paréntesis angulares < >
‣ los terminales se representan con cadenas de caracteres sin paréntesis
angulares
‣ el lado izquierdo de cada regla debe tener únicamente un no terminal
(ya que es una gramática libre del contexto)
‣ el símbolo ::=, que se lee “se define como” o “se reescribe como”, se utiliza
en lugar de →
‣ varias producciones del tipo
::=
8

::=
.
.
.
::=
se pueden escribir como ::= ...
Ejemplo 3:
La siguiente es una definición BNF del lenguaje que consiste de cadenas de
paréntesis anidados:
:: =
::= ( ) ( )
Por ejemplo las cadenas ( ) ( ( ) ) y ( ) ( ) ( ) son cadenas válidas. En cambio las
cadenas ( ( ) y ( ) ) ) no pertenecen al lenguaje.
9

10

Árbol de derivación
Un árbol de análisis sintáctico es una representación gráfica de una derivación que
filtra el orden en el que se aplican las producciones para sustituir los no terminales.
Cada nodo interior de un árbol de análisis sintáctico representa la aplicación de una
producción.
Es una representación gráfica (en forma de árbol invertido) de un proceso de
derivación en una gramática. Se define el árbol de derivación como sigue:
la raíz del árbol será el símbolo inicial de la gramática
los nodo interiores del árbol están etiquetados por los símbolos no terminales
las hojas están etiquetadas por símbolos terminales
si un nodo interior etiquetado por A, posee como hijos los nodos etiquetados
por X1,X2, …Xn , entonces A→ X1,X2, …Xn es una producción de la
gramática, en donde Xi , representa símbolo terminal o no terminal.
Sea la siguiente gramática:
G=( Σ={a, b}, N={S,A,B},S P ) P: S→aABAa , A→ε |aA , B→ε|bB la construcción de
un árbol de derivación en el proceso de la generación de la palabra aa es el
siguiente:
11

Propiedades de un árbol de derivación.
Sea G = (N, T, S, P) una gramática libre de contexto, sea A Є N una variable.
Diremos que un árbol TA= (N, E) etiquetado es un árbol de derivación asociado a G
si verifica las propiedades siguientes:
La raíz del árbol es un símbolo no terminal
Cada hoja corresponde a un símbolo terminal o λ.
Cada nodo interior corresponde a un símbolo no terminal.
Para cada cadena del lenguaje generado por una gramática es posible construir (al
menos) un árbol de derivación, en el cual cada hoja tiene como rótulo uno de los
símbolos de la cadena.
Árbol de derivación.
12

Ejemplo:
Sea G=(N, T, S, P) una GLC con P: S→ ab|aSb
La derivación de la cadena aaabbb será: S → aSb → aaSbb → aaabbb y el árbol
de derivación:
En lo que sigue, realizaremos con frecuencia el análisis sintáctico produciendo una
derivación por la izquierda o por la derecha, ya que hay una relación de uno a uno
entre los árboles de análisis sintáctico y este tipo de derivaciones. Tanto las
derivaciones por la izquierda como las de por la derecha eligen un orden específico
para sustituir símbolos en las formas de las oraciones, por lo que también filtran las
variaciones en orden. No es difícil mostrar que todos los árboles sintácticos tienen
asociadas una derivación única por la izquierda y una derivación única por la
derecha.
13

14

Formas Normales de Chomsky
Una gramática formal está en Forma normal de Chomsky si todas sus reglas de
producción son de alguna de las siguientes formas:
A → BC o
A → a o
donde A, B y C son símbolos no terminales (o variables) y α es un símbolo terminal.
Todo lenguaje independiente del contexto que no posee a la cadena vacía, es
expresable por medio de una gramática en forma normal de Chomsky (GFNCH) y
recíprocamente. Además, dada una gramática independiente del contexto, es
posible algorítmicamente producir una GFNCH equivalente, es decir, que genera el
mismo lenguaje.
Una gramática sin reglas de producción unitarias, sin símbolos inútiles ni anulables
puede expresarse en la FNC, en la cual todas las reglas de producción tienen del
lado derecho un terminal o bien 2 variables, es decir, las reglas de producción son
de la forma
Variables accesibles:
Si existe una derivación desde el símbolo inicial que contiene X, es decir,
existe $ → * α Xβ donde α, β Є∑*
Variables generativas:
Si existe una derivación desde el la variable que produce una sentencia, es
decir, existe X →* ω donde ω Є *T.
15

Variables útiles:
Si existe una derivación desde el símbolo inicial usando que produce una sentencia
ω, es decir, existe $ →* α X β →*ω donde α, β Є ∑* y ω Є ∑*T.
Ejemplo, convirtamos la gramática siguiente a la FNC
A 0A0 | 1A1|
0 | 1
Solución:
La primera regla de producción
A 0A0 la podemos cambiar por las tres siguientes
A CB
B AC
C 0
La segunda regla de producción A 1A1
la podemos cambiar por las tres
siguientes
A UD
D AU
U 1
Las últimas dos reglas sí cumplen con la FNC, entonces la gramática normalizada
queda:
A CB |UD | 0 | 1
B AC
C 0
D AU
U 1
16

17

Diagramas de sintaxis
Los diagramas sintácticos, de sintaxis o diagramas del ferrocarril son una forma de
representar una gramática libre de contexto. Representan una alternativa gráfica
para la Forma de Backus-Naur (BNF, por sus siglas en inglés) o la Forma Extendida
de Backus-Naur (EBNF, por sus siglas en ingles).
Los diagramas de ferrocarril son más comprensibles para la mayoría de la gente.
Alguna parte de la popularidad del formato de intercambio de datos JSON se debe
a su representación en los diagramas de ferrocarril.
Descripción
A grandes rasgos es un grafo dirigido en el que los nodos representan los símbolos
terminales y no terminales de la gramática, y los arcos expresan las secuencias en
que pueden combinarse tales símbolos para formar frases aceptables según la
gramática.
18

Como se constituyen
Cada diagrama de sintaxis representa un símbolo no terminal (que se puede
expandir), de manera que la gramática completa estará formada por tantos
diagramas distintos e interrelacionados como no
terminales se quieran incluir en su descripción.
19

Características
‣ Los símbolos terminales (palabras o tokens) se dibujan como círculos o
elipses etiquetadas con el nombre del token
‣ Los no terminales que aparecen en un grafo se dibujan como rectángulos
etiquetados
con
su nombre correspondiente.
‣ Todo diagrama posee un punto de entrada (generalmente situado a la
izquierda)
y un punto de salida (a la derecha), y que están representados por un arco
sin origen y un arco sin destino respectivamente.
Ejemplos
Diagrama de sintaxis que muestra las diferentes instrucciones que pueden utilizarse
en un algoritmo.
20

Diagrama de sintaxis para la instrucción de asignación de un valor a una variable.
Diagrama de sintaxis para la instrucción sí.
Identificadores
21

Ambigüedad
Una gramática ambigua es aquella que produce más de una derivación por la
izquierda, o más de una derivación por la derecha para el mismo enunciado.
Ejemplo: La gramática de expresiones aritméticas permite dos derivaciones por la
izquierda distintas para el enunciado id + id ∗ id:
Para la mayoría de los analizadores sintácticos, es conveniente que la gramática no
tenga ambigüedades, ya que de lo contrario, no podemos determinar en forma única
qué árbol de análisis sintáctico seleccionar para un enunciado. En otros casos, es
conveniente usar gramáticas ambiguas elegidas con cuidado, junto con reglas para
eliminar la ambigüedad, las cuales “descartan” los árboles sintácticos no deseados,
dejando sólo un árbol para cada enunciado.
22

Eliminación de Ambigüedad
Una GLC es ambigua si existe una cadena w Є L(G) que tiene más de una
derivación por la izquierda o más de una derivación por la derecha o si tiene dos o
más arboles de derivación.
En casi de y que toda cadena w Є L (G) tenga un único árbol de derivación no es
ambigua.
Ejemplo: La gramática S → aS| Sa | a es ambigua porque aa tiene dos derivaciones
por la izquierda S Þ aS Þ aa S Þ Sa Þ aa.
Tipos de Ambigüedad
Dentro del estudio de gramáticas existen dos tipos fundamentales de ambigüedad,
los cuales son:
Ambigüedad
Inherente:
Las gramáticas que presentan este tipo de ambigüedad no pueden utilizarse para
lenguajes de programación, ya que por más transformaciones que se realicen sobre
ellas, nunca se podrá eliminar completamente la ambigüedad que presentan:
Un lenguaje L es inherentemente ambiguo si todas sus gramáticas; si existe cuando
menos una gramática no ambigua para L, L no es ambiguo.
23

El lenguaje de las expresiones no es Ambiguo
Las expresiones regulares no son ambiguas
Ejemplo de un lenguaje inherentemente ambiguo:
La gramática es ambigua: hay cadenas con más de una derivación más izquierda:
24

Generación de matriz predictiva (FIRS y FOLLOW)
FIRST: Sea G:= (V; ∑; Q0; P) una gramática libre de contexto. Para cada forma
sentencial α Є (V U ∑)* y para cada k Є N definiremos la función.
En otras palabras, el operador F IRST k asocia a cada forma sentencial los primeros
k símbolos de cualquier forma terminal alcanzable desde α mediante derivaciones
“masa la izquierda".
FOLLOW: Con las mismas notaciones anteriores, para cada forma sentencial α Є
(V U ∑)* definiremos la función FOLLOWG GK (α) del modo siguiente.
De nuevo nos ocuparemos solamente de FOLLOW: = FOLLOW1. Obsérvese que
FOLLOW k (α) ⊂ ∑* y que para cada x Є FOLLOW (α), Ixl ≤ k. Obsérvese que para
cada variable A Є V, FOLLOW(A) son todos los símbolos terminales que pueden
aparecer a la derecha de A en alguna forma sentencial de la gramática.
25

• Reglas para First Sets
1. Si X es un terminal entonces First(X) es justamente X.
2. Si existe una producción X → ε entonces agregue ε a first(X)
3. Si existe una producción X → Y1Y2..Yk entonces agregue first(Y1Y2..Yk) a
first(X)
4. First(Y1Y2..Yk) es ya sea
5. First(Y1) (si First(Y1) no contiene ε) o (si First(Y1) contiene ε) entonces First
(Y1Y2..Yk) está todo en First(Y1) como también en
First(Y2..Yk)
6. Si First(Y1) First(Y2)..First(Yk) contienen ε entonces agregue ε a
First(Y1Y2..Yk). FIRST(α): devuelve el conjunto de todos los terminales que
se pueden encontrar a la cabeza de cualquier derivación de la frase α.
• Reglas para Follow Sets
1. Primero ingrese $ (el fin de una entrada) en Follow(S) (S es el símbolo de
partida)
2. Si existe una producción A → aBb, (donde a puede ser un string completo)
entonces todo en FIRST(b) excepto para ε está en FOLLOW(B).
3. Si existe una producción A → aB, entonces todo en FOLLOW(A) está en
FOLLOW(B)
4. Si existe una producción A → aBb, donde FIRST(b) contiene ε, entonces todo
en FOLLOW(A) está en FOLLOW(B) FOLLOW(A): devuelve el conjunto de
todos los terminales que se pueden encontrar siguiendo a A en cualquier
derivación posible.
26

Ejemplo.
1) E → TE'
2) E' → +TE'
3) E' → ε
4) T → FT'
5) T' → *FT'
6) T' → ε
7) F → (E)
8) F → id
Construcción de la Tabla
Los analizadores descendentes dirigidos por tabla están constituidos por dos
elementos que se utilizan para llevar a cabo el proceso de análisis sintáctico.
• Una pila, donde se almacenan símbolos gramaticales.
• Una tabla de doble entrada que representa la gramática.
El algoritmo de análisis descendente predictivo para este tipo de analizadores
consiste en ir consultando la tabla para saber que regla aplicar y apoyarse en la pila
27

Asociada:
La gramática NO es LL(1) si y sólo si, existen más de una entrada para cualquier
celda en la tabla.
Gramáticas LL (1)
Se puede aplicar le algoritmo a cualquier gramática G para producir un tabla
de análisis sintáctico M. sin embargo, para alguna gramáticas, M pueden tener
algunas entradas con definiciones múltiples. Por ejemplo, si G es recursiva por la
izquierda o ambigua, entonces M tendrá al menos una entrada con definición
múltiple.
28

Ejemplo.
Left recursion: A veces podemos obtener una gramática LL(k) al remover la “left
recursion”. La idea para “direct left recursion: “ es transformar : A → Aw | Au | Av | a
| b. , en
A → aB | bB
B → wB | uB | vB | Λ.
Ejemplo. Remover la “left recursion. “
S → Sa | b.
Sol: S → bT , T → aT | Λ. Es LL(1).
Left factoring: A veces podemos “left-factor” una gramática LL(k) para obtener una
gramática LL(n) equivalente, donde n < k.
Ejemplo. La gramática S → aaS | ab | b es LL(2) pero no LL(1). Pero si podemos
“factorizar” sobre un prefijo común a desde las producciones S → aaS | ab , para
obtener
S → aT
29

T → aS | b.
Esto da la nueva gramática:
S → aT | b
T → aS | b.
No ambigua, Factorizada por la izquierda y No recursiva a la izquierda.
Decida si es una gramática LL(1), o no.
S → AB | ٨
A → aAb | ٨
B → bB | c.
Solución:
‣ Calculamos los conjuntos FIRST y FOLLOW de las producciones:
30

FIRST(AB) = (FIRST(A) - {٨}) ڂ FIRST(B) = {a} ‏{ڂ b, c} = {a, b, c}.
FIRST(٨) = {٨}, FIRST(aAb) = {a}, FIRST(bB) = {b}, FIRST(c) = {c}.
‣ Calculamos los FOLLOW para los no terminales:
FOLLOW(S) = {$}, FOLLOW(A) = {b, c}, FOLLOW(B) = {$}.
‣ La tabla:
31

Por lo tanto es LL(1), por no tener entradas con definiciones múltiples.
Otra forma, más formal, pero basado en los resultados de FIRST y FOLLOW para
poder aplicar el análisis predictivo LL(1) es necesario que los conjuntos de
predicción de todas las reglas con un mismo antecedente sean disjuntas entre sí.
Esto es,
AÆ abB {a}
AÆ B {b, c}
BÆ b {b}
BÆ c {c}.
Y notamos que {a} ∩ {b,c} = Ǿ es LL(1) , {b} ∩ {c} = Ǿ , es LL(1). Por lo tanto la
gramática en total es LL(1). Pero no perdamos la intuición….. ¿Porque la gramática
es LL(2) pero no LL(1)?
S → aSA | ٨
A → abS | c.
Sol: Consideremos el string aab. Una derivación parte con S ➾ aSA. Ahora el
“lookahead” está en la segunda a de la cadena aab, pero en tal caso, tenemos dos
opciones para escoger, una de ellas es : S → aSA y S → ٨. Entonces, la gramática
no es LL(1). Pero, si consideramos “two lookahead letters” vemos que el substring
ab o ac, se puede lograr con S → aSA para la siguiente etapa.
Analizar si la gramática es LL(1).
32

S → aSC | b
C → cC | d.
Por ejemplo, vemos que el string aabcdd tiene la siguiente “leftmost derivation”,
donde cada etapa está unicamente determinada por el actual símbolo lookahead.
S ➾ aSC ➾ aaSCC ➾ aabCC ➾ aabcCC ➾ aabcdC ➾ aabcdd.
33

Tipos de analizadores
Para comprobar si una cadena pertenece al lenguaje generado por una gramática,
los analizadores sintácticos construyen una representación en forma de árbol de 2
posibles maneras:
– Analizadores sintácticos descendentes (Top-down)
Construyen el árbol sintáctico de la raíz (arriba) a las hojas (abajo).
Parten del símbolo inicial de la gramática (axioma) y van expandiendo
producciones hasta llegar a la cadena de entrada.
– Analizadores sintácticos ascendentes (Bottom-up)
Construyen el árbol sintáctico comenzando por las hojas.
Parten de los terminales de la entrada y mediante reducciones llegan hasta
el símbolo inicial.
En ambos casos se examina la entrada de izquierda a derecha, analizando los
testigos o tokens de entrada de uno en uno.
Análisis Sintáctico Descendente - ASD
Métodos que parten del axioma y, mediante derivaciones por la izquierda, tratan de
encontrar la entrada.
Existen dos formas de implementarlos:
– Análisis descendente recursivo
Es la manera más sencilla, implementándose con una función recursiva
aprovechando la recursividad de la gramática.
– Análisis descendente predictivo
Para aumentar la eficiencia, evitando los retrocesos, se predice en cada
momento cuál de las reglas sintácticas hay que aplicar para continuar el
análisis
34

ASD recursivo
Mediante un método de backtracking se van probando todas las opciones de
expansión para cada no-terminal de la gramática hasta encontrar la correcta.
Cada retroceso en el árbol sintáctico tiene asociado un retroceso en la
entrada: se deben eliminar todos los terminales y no terminales
correspondientes a la producción que se “elimina” del árbol.
Si el terminal obtenido como consecuencia de probar con una opción de las
varias de una producción no coincide con el componente léxico leído en la
entrada, hay que retroceder.
Algoritmo
1. Se colocan las reglas en orden, de forma que si la parte derecha de una
producción es prefijo de otra, esta última se sitúa detrás.
2. Se crea el nodo inicial con el axioma y se considera nodo activo.
3. Para cada nodo activo A:
-Si A es un no-terminal, se aplica la primera producción asociada a A.
• El nodo activo pasa a ser el hijo izquierdo.
• Cuando se terminan de tratar todos los descendientes, el siguiente
nodo activo es el siguiente hijo por la izquierda.
– Si A es un terminal:
• Si coincide el símbolo de la entrada, se avanza el puntero de entrada
y el nodo activo pasa a ser el siguiente “hermano” de A.
• Si no, se retrocede en el árbol hasta el anterior no-terminal (y en la
entrada si se ha reconocido algún componente léxico mediante la
producción que se elimina) y se prueba la siguiente producción.
– Si no hay más producciones para probar, se retrocede hasta el anterior noterminal
y se prueba con la siguiente opción de éste. 4. Si se acaban todas las
opciones del nodo inicial, error sintáctico. Si por el contrario se encuentra un árbol
para la cadena de entrada, éxito.
35

Ejemplo
Comprobar si ccd pertenece al lenguaje de la gramática: S → c X d X → c k | c
ASD recursivo – Problemas
No puede tratar gramáticas con recursividad a izquierdas.
Acaba la ejecución cuando se encuentra el primer error – Difícil proporcionar
mensajes más elaborados que “correcto” o “incorrecto”, como por ejemplo
especificar dónde se ha encontrado el error.
• Aunque la programación es simple, utiliza muchos recursos s
– Como consecuencia del retroceso necesita almacenar los componentes léxicos
ya reconocidos por si es necesario volverlos a tratar.
• Cuando un analizador sintáctico se utiliza para comprobar la semántica y generar
código, cada vez que se expande una regla, se ejecuta una acción semántica. Al
retroceder esa regla o producción se deben deshacer las acciones semánticas, lo
que no es fácil ni siempre posible.
36

ASD predictivo
Intentan predecir la siguiente construcción a aplicar leyendo uno o más
componentes léxicos por adelantado
– “Saben” con exactitud qué regla deben expandir para llegar a la entrada
• Este tipo de analizadores se denomina LL(k)
– Leen la entrada de izquierda a derecha ( Left to rigth)
– Aplican derivaciones por la izquierda para cada entrada ( Left)
– Utilizan k componentes léxicos de la entrada para predecir la dirección del
análisis.
• Están formados por:
– Un buffer para la entrada.
– Una pila de análisis.
– Una tabla de análisis sintáctico.
– Una rutina de control.
37

Componentes de un ASD predictivo
En función de la entrada, de la tabla de análisis y de la pila decide la acción a
realizar.
Posibles acciones: – Aceptar la cadena. – Aplicar producción. – Pasar al siguiente
símbolo de la entrada. – Notificar un error.
Tabla de análisis sintáctico
Se trata de una matriz M [V n, V t ] donde se representan las producciones a
expandir en función del estado actual del análisis y del símbolo de la entrada.
• Las entradas en blanco indican errores
38

Ejemplo
39

40

Manejo de errores
Un compilador es un sistema que en la mayoría de los casos tiene que manejar una
entrada incorrecta. Sobre todo en las primeras etapas de la creación de un
programa, es probable que el compilador se utiliza para efectuar las características
que debería proporcionar un buen sistema de edición dirigido por la sintaxis, es
decir, para determinar si las variables han sido declaradas antes de usarla, o si
faltan corchetes o algo así.
Por lo tanto, el manejo de errores es parte importante de un compilador y el escritor
del compilador siempre debe tener esto presente durante su diseño.
Hay que señalar que los posibles errores ya deben estar considerados al diseñar un
lenguaje de programación. Por ejemplo, considerar si cada proposición del lenguaje
de programación comienza con una palabra clave diferente (excepto la proposición
de asignación, por supuesto). Sin embargo, es indispensable lo siguiente:
El compilador debe ser capaz de detectar errores en la entrada;
El compilador debe recuperarse de los errores sin perder demasiada
información;
Y sobre todo, el compilador debe producir un mensaje de error que permita
al programador encontrar y corregir fácilmente los elementos
(sintácticamente) incorrectos de su programa.
• Los errores léxicos incluyen la escritura incorrecta de los identificadores, las
palabras clave o los operadores; por ejemplo, el uso de un identificador tamaño
Elipce en vez de tamaño Elipse, y la omisión de comillas alrededor del texto que se
debe interpretar como una cadena.
• Los errores sintácticos incluyen la colocación incorrecta de los signos de punto
y coma, además de llaves adicionales o faltantes; es decir, “{” o “}”. Como otro
41

ejemplo, en C o Java, la aparición de una instrucción case sin una instrucción switch
que la encierre es un error sintáctico (sin embargo, por lo general, esta situación la
acepta el analizador sintáctico y se atrapa más adelante en el procesamiento,
cuando el compilador intenta generar código).
• Los errores semánticos incluyen los conflictos de tipos entre los operadores y
los operandos. Un ejemplo es una instrucción return en un método de Java, con el
tipo de resultado void.
• Los errores lógicos pueden ser cualquier cosa, desde un razonamiento
incorrecto del programador en el uso (en un programa en C) del operador de
asignación =, en vez del operador de comparación ==. El programa que contenga =
puede estar bien formado; sin embargo, tal vez no refleje la intención del
programador.
La precisión de los métodos de análisis sintáctico permite detectar los errores
sintácticos con mucha eficiencia. Varios métodos de análisis sintáctico, como los
métodos LL y LR, detectan un error lo más pronto posible; es decir, cuando el flujo
de tokens que proviene del analizador léxico no puede seguirse analizando de
acuerdo con la gramática para el lenguaje. Dicho en forma más precisa, tienen la
propiedad de prefijo viable, lo cual significa que detectan la ocurrencia de un error
tan pronto como ven un prefijo de la entrada que no puede completarse para formar
una cadena válida en el lenguaje.
Otra de las razones para enfatizar la recuperación de los errores durante el análisis
sintáctico es que muchos errores parecen ser sintácticos, sea cual fuere su causa,
y se exponen cuando el análisis sintáctico no puede continuar. Algunos errores
semánticos, como los conflictos entre los tipos, también pueden detectarse con
eficiencia; sin embargo, la detección precisa de los errores semánticos y lógicos en
tiempo de compilación es, por lo general, una tarea difícil.
El mango de errores en un analizador sintáctico tiene objetivos que son simples de
declarar, pero difíciles de llevar a cabo:
Reportar la presencia de errores con claridad y precisión.
• Recuperarse de cada error lo bastante rápido como para poder detectar los errores
42

siguientes.
• Agregar una sobrecarga mínima al procesamiento de los programas correctos.
Por fortuna, los errores comunes son simples, y a menudo basta con un mecanismo
simple para su manejo.
Estrategias para recuperarse de los errores
Una vez que se detecta un error, ¿cómo debe recuperarse el analizador sintáctico?
Aunque no hay una estrategia que haya demostrado ser aceptable en forma
universal, algunos métodos pueden aplicarse en muchas situaciones. El método
más simple es que el analizador sintáctico termine con un mensaje de error
informativo cuando detecte el primer error. A menudo se descubren errores
adicionales si el analizador sintáctico puede restaurarse a sí mismo, a un estado en
el que pueda continuar el procesamiento de la entrada, con esperanzas razonables
de que un mayor procesamiento proporcione información útil para el diagnóstico. Si
los errores se apilan, es mejor para el compilador desistir después de exceder cierto
límite de errores, que producir una molesta avalancha de errores “falsos”.
El resto de esta sección se dedica a las siguientes estrategias de recuperación de
los errores: modo de pánico, nivel de frase, producciones de errores y corrección
global.
Recuperación en modo de pánico Con este método, al describir un error el
analizador sintáctico descarta los símbolos de entrada,
uno a la vez, hasta encontrar un conjunto designado de tokens de sincronización.
Por lo general, los tokens de sincronización son delimitadores como el punto y coma
o }, cuya función en el programa fuente es clara y sin ambigüedades. El diseñador
del compilador debe seleccionar los tokens de sincronización apropiados para el
lenguaje fuente. Aunque la corrección en modo de pánico a menudo omite una
cantidad considerable de entrada sin verificar errores adicionales, tiene la ventaja
43

de ser simple y, a diferencia de ciertos métodos que consideraremos más adelante,
se garantiza que no entrará en un ciclo infinito.
Recuperación a nivel de frase
Al descubrir un error, un analizador sintáctico puede realizar una corrección local
sobre la entrada restante; es decir, puede sustituir un prefijo de la entrada restante
por alguna cadena que le permita continuar. Una corrección local común es sustituir
una coma por un punto y coma, eliminar un punto y coma extraño o insertar un punto
y coma faltante. La elección de la corrección local se deja al diseñador del
compilador. Desde luego que debemos tener cuidado de elegir sustituciones que no
nos lleven hacia ciclos infinitos, como sería, por ejemplo, si siempre insertáramos
algo en la entrada adelante del símbolo de entrada actual.
La sustitución a nivel de frase se ha utilizado en varios compiladores que reparan
los errores, ya que puede corregir cualquier cadena de entrada. Su desventaja
principal es la dificultad que tiene para arreglárselas con situaciones en las que el
error actual ocurre antes del punto de detección.
Producciones de errores
Al anticipar los errores comunes que podríamos encontrar, podemos aumentar la
gramática para el lenguaje, con producciones que generen las construcciones
erróneas. Un analizador sintáctico construido a partir de una gramática aumentada
por estas producciones de errores detecta los errores anticipados cuando se utiliza
una producción de error durante el análisis sintáctico. Así, el analizador sintáctico
puede generar diagnósticos de error apropiados sobre la construcción errónea que
se haya reconocido en la entrada.
Corrección
global
Lo ideal sería que un compilador hiciera la menor cantidad de cambios en el
procesamiento de una cadena de entrada incorrecta. Hay algoritmos para elegir una
secuencia mínima de cambios, para obtener una corrección con el menor costo a
nivel global. Dada una cadena de entrada incorrecta x y una gramática G, estos
44

algoritmos buscarán un árbol de análisis sintáctico para una cadena y relacionada,
de tal forma que el número de inserciones, eliminaciones y modificaciones de los
tokens requeridos para transformar a x en y sea lo más pequeño posible. Por
desgracia, estos métodos son en general demasiado costosos para implementarlos
en términos de tiempo y espacio, por lo cual estas técnicas sólo son de interés
teórico en estos momentos. Hay que observar que un programa casi correcto tal vez
no sea lo que el programador tenía en mente. Sin embargo, la noción de la
corrección con el menor costo proporciona una norma para evaluar las técnicas de
recuperación de los errores, la cual se ha utilizado para buscar cadenas de
sustitución óptimas para la recuperación a nivel de frase.
45

Generadores de analizadores sintácticos
ANTLR:
(ANother Tool for Language Recognition; en español "otra herramienta para
reconocimiento de lenguajes") es una herramienta creada principalmente por
Terence Parr, que opera sobre lenguajes, proporcionando un marco para construir
reconocedores (parsers), intérpretes, compiladores y traductores de lenguajes a
partir de las descripciones gramaticales de los mismos (conteniendo acciones
semánticas a realizarse en varios lenguajes de programación).
GNU bison:
Es un programa generador de analizadores sintácticos de propósito general
perteneciente al proyecto GNU disponible para prácticamente todos los sistemas
operativos, se usa normalmente acompañado de flex aunque los analizadores
léxicos se pueden también obtener de otras formas.
Grammatica:
Es un generador de analizadores sintácticos de C# y Java libre. Es similar a otras
herramientas como Yacc o ANTLR. Grammatica soporta el algoritmo LL(k) para
gramáticas con un número ilimitado de tokens de anticipación. Está bastante bien
probado, y ha sido auto compilado desde la versión 0.1. La documentación contiene
una lista completa de características, así como una comparación con otros
generadores de analizadores.
JavaCC:
(Java Compiler Compiler) es un generador de analizadores sintácticos de código
abierto para el lenguaje de programación Java. JavaCC es similar a Yacc en que
genera un parser para una gramática presentada en notación BNF, con la diferencia
de que la salida es en código Java. A diferencia de Yacc, JavaCC genera
analizadores descendentes (top-down), lo que lo limita a la clase de gramáticas LL
(K) (en particular, la recursión desde izquierda no se puede usar). El constructor de
árboles que lo acompaña, JJTree, construye árboles de abajo hacia arriba (bottomup).
Yacc:
Es un programa para generar analizadores sintácticos. Las siglas del nombre
significan Yet Another Compiler-Compiler, es decir, "Otro generador de
compiladores más". Genera un analizador sintáctico (la parte de un compilador que
comprueba que la estructura del código fuente se ajusta a la especificación
sintáctica del lenguaje) basado en una gramática analíticaescrita en una notación
similar a la BNF. Yacc genera el código para el analizador sintáctico en el Lenguaje
de programación C.
46

Generador sintáctico GNU BISON
GNU bison es un programa generador de analizadores sintácticos de propósito
general perteneciente al proyecto GNU disponible para prácticamente todos los
sistemas operativos, se usa normalmente acompañado de flex
GNU bison tiene compatibilidad con Yacc: todas las gramáticas bien escritas para
Yacc, funcionan en Bison sin necesidad de ser modificadas. Cualquier persona que
esté familiarizada con Yacc podría utilizar Bison sin problemas. Bison fue escrito en
un principio por Robert Corbett; Richard Stallman lo hizo compatible con Yacc y
Wilfred Hansen de la Carnegie Mellon University añadió soporte para literales
multicaracter y otras características.
1. En Bison se declaran los Token, que serían los no terminales de la gramática.
Hay tres formas de declarar Tokens.
2. Un carácter entre comillas simples, este no es necesario declararlo, se puede
utilizar directamente en la gramática y se reconoce como Token, si se desea
darle algún valor semántica, entonces si se tendría que declarar.
%left o %right para definir la asociatividad de los operadores.
47

Conclusión
Se puede decir que con toda la información recabada ya se tiene en claro que es
un analizador sintáctico, como armar un árbol de derivación y saber cuáles son sus
propiedades en fin y a se puede Identificar y conocer el funcionamiento de un
analizador sintáctico, hay que tomar muy en cuenta los errores y los tipos de errores
que se pueden presentar en el compilador, hay que señalar que los posibles errores
ya deben de estar considerados al diseñar un lenguaje de programación. Considerar
su cada proposición del lenguaje de programación comienza con una ´palabra clave
referente. Y pues se vio varios generadores de analizador sintáctico cada una de la
mencionada maneja un lenguaje de programación.
48

Bibliografías
‣ Alfred V. Aho Monica S. Lam Ravi Sethi Jeffrey D. Ullman. (2008).
Compiladores principios, técnicas y herramientas, Segunda edición. México:
Pearson Educación.
‣ Profs. Carlos Pérez y Ricardo Monascal. Traductores e interprestes. 20 de
junio del 2016.
http://ldc.usb.ve/~rmonascal/cursos/ci3725_aj12/archivos/clase8.pdf
‣ Dr. José Antonio Camarena Ibarrola.Enero 2009.LENGUAJES FORMALES
Y AUTOMATAS. 19 de junio del 2016.
http://dep.fie.umich.mx/~camarena/NotasLenguajesFormalesAutomatas_Ca
marena.doc
‣ Sergio Gálvez Rojas. David Tinaquero Fernández. Antonio Guevara Plaza.
Antonio Luis Carrillo León.GENERACIÓN COMPLETA DE COMPILADORES
‣ MEDIANTE DIAGRAMAS DE SINTAXIS EXTENDIDOS. 19 de junio del
2016. http://www.lcc.uma.es/repository/fileDownloader?rfname=LCC829.pdf
‣ Salvador Sánchez Alonso, Daniel Rodríguez García. PROCESADORES DE
LENGUAJES. 19 de junio del 2016.
http://www.cc.uah.es/ie/docencia/ProcesadoresDeLenguaje/ProcesadoresD
eLenguajeTema3ParteI_1xpagina.pdf
‣ Efren Mendez Hernandez. sep 18/2015. Lenguajes automatas 1. 19 de junio
del 2016. http://documents.mx/documents/reporte-unidad-6.html
49