Diseño de Compiladores

Teora de Lenguajes MA 760U
Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 1

UNIVERSIDAD NACIONAL DE INGENIERIA

Facultad de Ingeniera Industril y de Sistemas
rea de Sistemas, Computacin e Informtica
AUTOR:
Lima Per

INTRODUCCIN
El trabajo que presentamos a continuacin tiene por finalidad

desarrollar un estudio detallado de todos los temas vistos en clase relativos
al Ciclo de 2000-III, para ello hacemos hincapi en el diseo delos
compiladores y los elementos bsicos que forman parte de un compilador.
As mismo, hacemos un estudio del compilador de una calculadora en
YACC. Por otra parte se empleara el YaccEditor como herramienta para
disear los Autmatas Finitos a partir del Diagrama de Estados que, entre
otras cosas, dicho editor nos ofrece.
YaccEditor es un editor para TP Yacc que incluye una funcin para

mostrar grficamente la lista de estados adems de la lista de estados en
un formato TXT (texto), que se obtienen al aplicar la tcnica LALR, a
partir del cual se genera el Listado de Estados y el Grafo. Adems se
incorpora algoritmos de optimizacin de gramticas tales como la
eliminacin de reglas borradoras, eliminacin de reglas unitarias y de
recursividad a izquierda, reglas repetidas, entre otros.
Otra caracterstica importante es el uso de la herramienta TP YACC

desde el editor, esto significa que mediante un comando del editor se puede
compilar con TP YACC el documento que se esta editando.
El presente trabajo esta dividido en capitulos en los cuales se

profundizan temas como la Teoria Gramtica, las partes de un
programa en YACC, YACC EDITOR como herramienta, entre otras

CAPITULO I: TEORA DE GRAMTICAS

I.1 DEFINICIN
Una gramtica Formal G, es una cudrupla, es decir se encuentra formada
por 4 elementos
G = { N , T , P , S}
Donde:
N : representa los smbolos no terminales de una gramtica G.

T: representa los smbolos terminales.
P: determina el nmero de reglas de produccin.
S: representa el smbolo inicial.
Smbolo no terminal (SNT): Es aquel que se emplea para sustituir

otros valores, se denota por: <S> o <DATOS>, etc..
Smbolo terminales (ST): Es aquel valor que sirve como finalizacin

para un smbolo no terminal. Notacin: a,1,+,......
I.2 REGLAS DE PRODUCCIN
Es una estructura formada por un lado derecho, un operador () y un

lado izquierdo. Su forma es la siguiente:

Donde:
es un smbolo no terminal
puede ser:
SNT
ST
Combinacin de ST y SNT
Secuencia Nula:
I.3 DERIVACIONES
Se llaman derivaciones a la serie de sustituciones que se llevan a cabo
usando regla de produccin .
Por ejemplo, sea G: 1. <S> a<S>
2. <S> b
3. a
4. c
Primera Derivacin:
1 <S> a<S>
2 2
ab
4
abc

Segunda Derivacin:
1 <S> a<S>
2
aa<S>
21 1
2
aab
4
aabc
4
aabcc
Luego: L{G} = {b,abc,aabcc, ...}
I.4 TIPOS DE DERIVACIONES

a.- Derivacin Ms a la Izquierda
Es aquella que se realiza derivando cada smbolo no terminal
partiendo de izquierda a derecha, en el lado derecho de las reglas de
produccin.
Por ejemplo, sea G:

1. <S> m <A> <C>
2. <A> p
3. q
4. <C> r
Derivacin: <S> m<A><C>

2
mp<C>
3
mpq<C>
4
mpqr
b.- Derivacin Ms a la Derecha
Es aquella que se realiza derivando cada smbolo no terminal
partiendo de derecha a izquierda, en el lado derecho de las reglas de
produccin. Por ejemplo, para la gramtica anterior:
Derivacin:
<S> m<A><C>
4 m<A>r
3 m<A>qr
2
mpqr
LENGUAJE FORMAL.
Dado un conjunto de simbolos denominado Alfabeto, un Lenguaje
Formal sobre tal alfabeto, es un conjunto de secuencia de simbolos
del alfabeto.
Ejemplo. Dado el conjunto A={a,b,c} Alfabeto, entonces:
L1={ac,aa,bb} L3={c}
L2={aaa,bc} L4={a,b,c}

Los lenguajes pueden ser Finitos o Infinitos, para fines de estudio nos
basaremos en lenguajes Infinitos.
FORMAL. Puede ser procesado y manipulado mecnicamente
Ejemplo. L(Pascal)={ Programa1, programa2,......, programan}
Gramticas Formales.- Define la estructura de los elementos del

Lenguaje (respecto a las secuencias de smbolos terminales )
Ejemplo Dado el siguiente Lenguaje expresado en forma Algebraica,

L(G) = { anbnn / n>0}, construir su Gramtica que genere el
conjunto de lenguajes de L.
Solucin
1. <S> a<S>b
2. <S> ab
Observacin . Se debe verificar que .
ac,aa,bb} L3={c}
Obs.

I.5 ARBOL DE DERIVACION

Un rbol de Derivacin, es una representacin grafica de una Derivacin.
Se usa para realizar un Anlisis Sintctico
Por ejemplo, dado G:

1. <S> a<S>
2. <S> b
3. a
4. c
verificar si la cadena: abac pertenece a L(G)
Solucin: 1 <S>
abac
2 3
a <S> 
b ac
b4 a 
c
c
Podemos concluir que la cadena abac L(G)
I.6 GRAMTICA TIPO SIMPLE (tipo-S)

Se dice que una gramtica G es tipo simple si cumple las siguientes
condiciones:
i. Los lados derechos de todas las reglas de produccin deben empezar
con un s.t.
<A> a <C>
 b 
<C> c
ii. Los lados izquierdos de las reglas de produccin que tienen igual
s.n.t.,deben empezar, en sus lados derechos, con s.t. diferentes.
<A> a <C>
ab
<A> b <C>
<C> c
Ejemplo 1: Es G una gramtica simple?

Sea G: 1. <S> c<A>

2. <S> c
3. <A>
Solucin
i) No cumple, pues no todos (, de la regla 3) son smbolos terminales
G no es tipo-S
Ejemplo 2: Es G una gramtica simple?

Sea G: 1. <S> a<A>
2. <A> a
3. a
Solucin
i) Cumple, pues todas las reglas empiezan con smbolos terminales
ii) Cumple, debido a que cada smbolo no terminal (S, A y B) no tiene
smbolos terminales disjuntos.
G es tipo-S
I.7 GRAMTICA COMPLEJA (tipo-q)
Se dice que una gramtica G es tipo compleja si cumple las siguientes

condiciones:
i. Los lados derechos de las reglas de produccin pueden empezar con

smbolos terminales o con secuencia nula ().
ii. Las reglas de produccin con el mismo lado izquierdo tienen
conjunto de seleccin disjunto.
a.- Conjunto de Seguidores: Dado un s.n.t. <X> de una G, el

conjunto de seguidores de <X>, denotado por Seg(<X>), queda
definido por el conjunto de s.t. que aparecen inmediatamente
despus de <X> en alguna secuencia de s.t. y s.n.t. derivados a
partir del smbolo inicial de G.
Ejemplo: Hallar los seguidores de B y S:
Sea G: 1. <S> a<S>

2. <S> p
3. c
Solucin:

Seg ():
1 <S> a<S>
1
aa<S>
2 <S> a<S>
2
ap
Seg() = {a,p} = A
Seg (<S>):
1 <S> a<S>
1
aa<S>
Seg(<S>) = { } = B
b.- Conjunto de Seleccin de una Regla de Produccin: Sea P una

regla de produccin de G, el conjunto de seleccin denotado por
Sel(P) queda definido por:
{b} si P: <X> b
Sel(P) =
Seg(<X>), si P: <X>
Ejemplo: Es G de tipo q.
Donde G:
1. <S> a<A><S>
2. <S> b
3. <A> c<A><S>
4. <A>
Solucin:
1. Observamos que los lados derechos para las reglas de

produccin, empiezan con smbolos terminales o , entonces se
cumple la 1regla.
2. Luego comprobaremos que si un mismo s.n.t. en la parte
izquierda de una regla de produccin, tienen conjunto de
seleccin disjunto.
Conjunto de Seleccin
P1: Sel (1) = Sel ( P:<S> a<A><S>) = {a}= H

P1: Sel (2) = Sel ( P:<S> b) = {b} = Q

Se observa que los conjuntos H y Q son disjuntos.
P2: Sel (3) = Sel ( P:<A> c<A><S>) = {c}= T

P2: Sel (4) = Sel ( P:<A> ) = Seg (<A>)
Seg (<A>):
1 <S> a<A><S>
1
a<A>a<S>
2 <S> a<S>
2
ab
Seg(<A>) = {a,b}
Sel (4) = {a,b} = R
Entonces, los conjuntos T y R son disjuntos.
Finalmente se cumple la 2 regla.
G es tipo q.
I.8 GRAMTICA AMBIGUA
Se dice que una gramtica G es ambigua si una cadena (lenguaje) puede

obtenerse por dos mtodos diferentes.
Por ejemplo, sea G:
1. <S> a <A>
2. <A> <A> a
3. <A> a
4. <A>
Verificar si la cadena aa L(G).
1 Mtodo 2 Mtodo.
<S> <S>
1 1
a <A> a <A>
2 3
<A> a a
4

G es Ambigua
I.9 TABLAS DE CONTROL

Es aquella tabla que sirve para hacer un anlisis sintctico y generar una
gramtica a partir de los s.t. y s.n.t. que se relacionan en la tabla. Esta
tabla est formada por:
i. Una columna de entrada para s.n.t. definidos en G.

ii. Una fila de entrada para s.t. definidos en G.
Ejemplo:
Sea la gramtica G:
1. <S> 1<A>1
2. <A> 0<A>
3. <A> 0
Tabla de Control.
1 0
<S> Re (<A>) Rech Rech
Av
<A> Rech Av/pop() Rech
Av
1 Pop() Rech Rech
Av
Rech Rech Aceptar
I.10 AUTMATAS FINITOS NO DETERMINSTICOS

Un Autmata Finito es un GRAFO que permite aceptar un lenguaje L; si y
solamente si existe un camino desde el estado inicial al estado inicial que
desea aceptar. Esta representacin est formada por estados (repre-
sentados por crculos) y caminos (representados por flechas).
Ejemplo:
Dado L(G)= {ab, ba}. Su Autmata Finito ser:
1 b
a
0 3
b a
2

I.11 MATRIZ DE TRANSICIN
Es aquella tabla que sirve para hacer un anlisis sintctico y comprobar

si una cadena o lenguaje pertenece a una gramtica. Esta matriz se
construye a partir de un A.F. y est formada por:
i. Una columna de entrada para los estados propios del A.F.

ii. Una fila de entrada para s.t. definidos en G.
iii. Una celda llamada total en donde se obtiene el total de estados que
existen en el GRAFO.
Ejemplo:
Para el lenguaje anterior, la matriz de transicin ser:
estados s.t a b Total.

0 1 2 2
1 - 3 1
2 3 - 1
Total 2 2 4
4 es el nmero de estados para el A.F.
I.12 DIAGRAMAS SINTCTICO QUE PERMITEN REPRESENTAR REGLAS

DE PRODUCCIN
Para llevar a cabo estos diagramas sintcticos se deben considerar las
siguientes reglas:
1) Un s.n.t. se representa de la siguiente manera:
2) Un s.t. se representa de la siguiente manera:
3) Reglas de la forma :
<S> <A> | | | <N>
Se representa de la siguiente manera:
A

4) Reglas de la forma :
<S> <A> <N>
Se representa de la siguiente manera:
A B N
5) Reglas de la forma: <S> 
Se representa por:
6) Cuando existe recursividad:
Ejemplo: Sea G:
<S> <A>b<A>
<A> <A>a
<A> a
El diagrama ser:
S
S: A b A
A b
A
A:
b

I.13 GRAMTICA LL(1)

Cuando el lado izquierdo de una gramtica con igual smbolo no terminal
deben tener conjuntos de seleccin disjuntos.
Ej.:
<S> <A>
<A> a
<A> m
 p
 h
Ejemplo: Verificar que G es de tipo LL(1)
G:
1. <E> <T><Lista_E>
2. <Lista_E> +<T> (1)
3. <Lista_E>
4. <T> <Lista_T>
5. <Lista_T> *<Lista_T>
(2)
6. <Lista_T>
7. (<E>)
8. const (3)
Solucin
Si (1), (2) y (3) son conjuntos disjuntos entonces G es de tipo LL(1)
(1) Sel(2) = {+}

Sel(3) = Seg(Lista_E)
<E>
1
<T> <Lista_E>
4
 <Lista_T>
7
( <E> )
1
<T> <Lista_E>
Seg(<Lista_E>) = { ) }
Sel (3) = { ) }
Luego Sel (2) y Sel (3) son disjuntos

Captulo II: DISEO DE COMPILADORES
En el corazn de la implementacin de un lenguaje est, naturalmente, el

diseo de compiladores efectivos para el lenguaje. Por supuesto, el diseo de
compiladores es un tema complejo, sin embargo, a continuacin se esboza el
diseo de compiladores, de forma que pueda comprenderse el enlace entre
sintaxis, semntica e implementacin de un lenguaje.
II.1 COMPILADORES.
Un compilador es un traductor que convierte un texto escrito en un

lenguaje fuente de alto nivel en un programa objeto en cdigo mquina.
Un compilador es un programa en el que pueden distinguirse dos

subprogramas o fases principales: una fase de anlisis, en la cual se lee el
programa fuente y se estudia la estructura y el significado del mismo; y
otra fase de sntesis, en la que es genera el programa objeto.
En un compilador pueden distinguirse, adems, algunas estructuras de

datos comunes, la ms importante de las cuales es la Tabla de Smbolos,
junto con las funciones de gestin de sta y de los dems elementos del
compilador, y de una serie de rutinas auxiliares para deteccin de errores.
II.2 ELEMENTOS BSICOS DE UN COMPILADOR TPICO
Programa Anlisis
Lexicogrfico
Anlisis
Sintctico
Anlisis
Semntico
Generacin de
Cdigo
Optimizacin Programa Objeto

II.3 ANLISIS LEXICOGRFICO

El anlisis lexicogrfico es aquel que recibe el programa fuente leyndolo
carcter a carcter y cuya tarea es reconocer los tokens bsicos que
existen en el programa y clasificarlos como constantes, identificadores,
palabras reservadas, etc. Por tanto, esta fase convierte al texto del
programa de ser una cadena a una lista de tokens del lenguaje. La
construccin inicial de la tabla de smbolos ocurre tambin en esta fase.
El analizador lexicogrfico, adems, realiza ciertas tareas adicionales

como:
Eliminar los blancos, saltos de pgina, tabuladores, retornos de carro,

y dems caracteres propios del dispositivo de entrada.
Eliminar los comentarios del programa fuente.
Reconocer las variables y asignarles una posicin en la tabla de
smbolos.
Crear unos smbolos intermedios llamados tokens.
Avisa de los errores lxico grficos que detecta.
Relacionar los mensajes de error que produce el compilador en sus
diversas fases con la parte correspondiente del programa fuente
(nmero de lnea en que aparecen). En ciertos casos el analizador
lexicogrfico se encarga tambin de producir el listado del programa
con los errores de comparacin.
Ej:
Sea la siguiente sentencia en Pascal: previo := siguiente cont * 3
genera un cdigo simplificado para el anlisis sintctico posterior, por

ejemplo:
<id1> <: => <id2> < + > <id3> < * > <ent>
Cada elemento encerrado entre <> representa un nico token. Las

abreviaturas id y ent significan identificador y entero respectivamente.
II.4 ANLISIS SINTCTICO
Es aquel que convierte esta lista de tokens en un rbol de reconocimiento,

usando una representacin interna de la gramtica del lenguaje como
gua. Existen distintas estrategias para realizar el anlisis sintctico,
puesto que es un proceso relativamente complejo y debe hacerse de la
forma ms eficiente posible.
El anlisis sintctico comprueba que las sentencias que componen el texto

fuente son correctas en el lenguaje, creando una representacin interna

que corresponde a la sentencia analizada. De esta manera se garantiza

que solo sern procesadas las sentencias que pertenezcan al lenguaje
fuente. Durante el anlisis sintctico, as como en las dems etapas se van
mostrando los errores que se encuentran.
Ejemplo: Las sentencias anteriores son de la forma:
< id > <: => <expresin >
y la parte que se denomina <expresin> es de la forma:
<id> <-> <expresin> o bien

<id> <*> <expresin> o bien
<real>
La estructura de la sentencia queda, por tanto, de manifiesto mediante el

siguiente esquema:
<id1><: =><expresin> | <id2><-><expresin>

|<id1><*><expresin> | <real>
II.5 ANLISIS SMANTICO

Es aquel que se ocupa de analizar si la sentencia tiene algn significado.
Se pueden encontrar sentencias que son sintcticamente correctas pero
que no se pueden ejecutar porque carecen de sentido. En general, el
anlisis semntico se hace a la par que el anlisis sintctico introduciendo
en este unas rutinas semnticas.
Es necesario dotar al compilador de una serie de rutinas auxiliares que

permita captar todo aquello que no se ha expresado mediante la sintaxis
del lenguaje y todo aquello que hace descender a nuestro lenguaje de
programacin. A todas estas rutinas auxiliares se las denomina
genricamente anlisis semntico.
El anlisis semntico, a diferencia de otras fases, no se realiza claramente

diferenciando del resto de las tareas que lleva a cabo el compilador, mas
bien podra decirse que el anlisis semntico completa las dos fases
anteriores de anlisis lexicogrfico y sintctico incorporando ciertas
comprobaciones que no pueden asimilarse al mero reconocimiento de una
cadena dentro de un lenguaje.
Ejemplo: En la sentencia que se ha analizado existe una variable entera.

Sin embargo, las operaciones se realizan entre identificadores reales, por
lo que hay dos alternativas: o emitir un mensaje de error discordancia de
tipos, o realizar una conversin automtica al tipo superior, mediante una
funcin auxiliar inttoreal.

<id1><: =><expresin> | <id2><-><expresin> |

<id3><*><expresin> | <real> | <inttoreal> | <int>
II.5 GENERACION DE CODIGO

Es bsicamente el enlace entre la sintaxis de un lenguaje y su semntica o
representacin mquina. Esto es, convierte el rbol de reconocimiento en
una lista equivalente de instrucciones en ensamblador (mquina) del
lenguaje.
II.7 OPTIMIZACION DE CODIGOTICO

Es aquella que intenta refinar el cdigo generado para que es mejore el
rendimiento en tiempo de ejecucin. Este es un proceso complejo en el
que se intenta localizar las construcciones semnticamente redundantes,
el uso ineficiente de registros y dems. Es decir, que aqu se crea un
nuevo cdigo ms compacto y eficiente, eliminando por ejemplo
sentencias que no se ejecutan nunca, simplificando expresiones
aritmticas, etc. Frecuentemente, esta fase ocurre antes y despus de la
generacin de cdigo, en el primer caso operando directamente sobre el
propio rbol de reconocimiento.
El programa objeto que se obtiene despus de la compilacin puede estar

en lenguaje mquina o en algn lenguaje intermedio, siendo preferible
esto ltimo en los casos en los que se desea una gran transportabilidad.
Debe quedar claro que a largo de estas fases la tabla de smbolos juega
un papel central. Adems, tambin debe incorporarse dentro de este
diseo una buena estrategia para dar informacin sobre los errores
sintcticos o diagnsticos.
II.8 RUTINAS DE ERRORES
Estn incluidas en cada uno de los procesos de compilacin (anlisis

lexicogrfico, sintctico y semntico), y se encargan de informar de los
errores que se encuentran en el texto fuente. Los programas pueden
contener diversos tipos de errores que pueden ser:
1. Errores Lexicogrficos: se producen cuando el analizador no

puede generar un token tras leer una secuencia de caracteres
determinada. Podra caber la siguiente analoga: los errores
lexicogrficos son a los lenguajes de programacin como las faltas de
ortografa son a los lenguajes naturales. La aparicin de errores
lexicogrficos pueden darse por situaciones como las siguientes:
Omisin de un carcter: escribir por ejemplo, BEIN en lugar de

BEGIN.

Introduccin de un nuevo carcter: escribir por ejemplo,

BEGGIN en lugar de BEGIN.
Permutacin de caracteres en el token analizado: escribir por
ejemplo, BEIGN en lugar de BEGIN.
Cambio de algn carcter: escribir por ejemplo, BEGIM en lugar
de BEGIN.
Las tcnicas de recuperacin de errores lexicogrficos se basan, en

general, en la obtencin de los distintos sinnimos de una
determinada cadena que hemos detectado como errnea.
2. Errores Sintcticos: como por ejemplo, una expresin aritmtica

con menor nmero de parntesis de apertura que de cierre.
3. Errores Semnticos: como por ejemplo, la aplicacin de un

operador a un tipo de datos incompatible con el mismo.
4. Errores Lgicos: como por ejemplo, un bucle sin final.
II.9 TABLA DE SIMBOLOS

Es el medio de almacenamiento de toda la informacin referente a las
variables y objetos en general del programa que se est compilando. Por
ejemplo, hemos visto que en ciertos momentos del proceso de
compilacin debemos hacer uso de cierta informacin referente a los
identificadores o los nmeros que aparecen en nuestra sentencia, como
son su tipo, su posicin de almacenamiento en memoria, etc. Esta
informacin es la que se almacena en la tabla de smbolos.

Captulo III: Laboratorio (Uso del Programa Yacc)

YACC es un programa que permite disear analizadores gramaticales en C
usando una gramtica de contexto libre. Para su uso se disear el compilador
de una calculadora.
Para crear un programa en YACC se debe seguir los siguientes pasos:
1. Ejecutar el D.O.S.
2. Escribir C:\YACC>edit
3. En la pantalla azul que aparece se digitar el cdigo en lenguaje YACC.
4. El archivo deber ser guardado con extensin *. Y
5. Volver a D.O.S. se compila el archivo creado en YACC as: C:\
YACC>yacc *. Y
6. Luego de ello se generar un programa en lenguaje C con el nombre
YTAB.C el cual debe ser compilado en dicho lenguaje presionando CTRL
+ F9.
7. Finalmente, se formar el archivo YTAB.EXE el cual podr ejecutarse y
luego ingresar los datos.
III.1 ESQUEMA DE UN TRADUCTOR DE ENTRADA/SALIDA CON YACC
Compilador
Entrada: calc.y Ytab.c
YACC
Compilador
Ytab.c Ytab.exe
C
Datos
Ytab.exe Salida
Token
III.2 SECCIONES DE UN PROGRAMA FUENTE EN YACC
Existen tres secciones en un programa fuente:
1. La parte de declaraciones
Existen dos secciones opcionales en esta parte: en la primera seccin

se ponen declaraciones ordinarias en C, delimitadas por % {y %}.
Aqu se sitan las declaraciones de todas las variables temporales

usadas por las reglas de traduccin o los procedimientos de las

segunda y tercera seccin. Por ejemplo, para nuestro programa
calc.y se muestra:
%{
#include <ctype.h>
int tabla[3];
void setear_valor(char, int);
int buscar_valor(char);
%}
En la segunda seccin, se ponen declaraciones de los componentes

lxicos de la gramtica. Por ejemplo: % token DIGITO, declara que
DIGITO es un componente lxico o token.
2. La Parte de las reglas de traduccin:
Despus del primer par %% se escriben las reglas de traduccin.

Cada regla consta de una produccin de la gramtica y la accin
semntica asociada. Por ejemplo:
<lado izquierdo> -- <var1> | <var2> | ..... <var n>
En YACC se escribira
<lado izquierdo> : <var1> {accin semntica 1}

| <var2> {accin semntica 2}
...
| <var n> {accin semntica n}
;
En una produccin en YACC, un carcter simple entre comillas a, se

considera como el smbolo terminal a, y las cadenas sin comillas de
letras y dgitos no declarados como componentes lxicos se
consideran smbolos no terminales. Los lados derechos alternativos
de las reglas se pueden separar con una barra vertical, y un smbolo
de punto y coma sigue a cada lado izquierdo con sus alternativas y
sus acciones semnticas. El primer lado izquierdo se considera, por
defecto, el smbolo inicial.
Una accin semntica en YACC es una secuencia de sentencias en C.

En una accin semntica, el smbolo $$ se refiere al valor del
atributo asociado con el no terminal del lado izquierdo, mientras que
$i se refiere al valor asociado con el i-simo smbolo gramatical
(terminal o no terminal) del lado derecho.

3. La parte de las rutinas de apoyo en C:
La tercera parte de una especificacin en YACC consta de rutinas de

apoyo escritas en C. Se debe proporcionar un anlisis lxico de
nombre yylex(). En caso necesario se pueden agregar otros
procedimientos, como rutinas de recuperacin de errores.
El analizador lxico yylex() produce pares formados por un

componente lxico y su valor de atributo asociado. Si se devuelve un
componente lxico DIGITO, el componente lxico se debe declarar
en la primera seccin de la especificacin en YACC.
Lee caracteres de entrada de uno en uno, utilizando la funcin

getchar() de C. Si el carcter es un dgito, el valor del dgito, se
almacena en la variable yylval, y se devuelve el componente lxico
DIGITO. De lo contrario, se devuelve el propio carcter como
componente lxico.

Captulo IV
COMPILADOR DE CALCULADORA
IV.1 GRAMATICA
EDICION DE PROGRAMA DE
GRAMATICA
GRAMATICA EN YACC
%%
lineas : linea lineas 1. <lineas> <linea><lineas>
|
;
linea : expr '\n' { printf("%d\n", $1); } 2. <linea> <expr>\n
| variable '=' expr '\n' { setear_valor($1, $3); } 3. <linea> <VARIABLE>=<EXPR>\n
;
expr : expr '+' termino { $$ = $1 + $3; } 4. <expr> <expr>+<TERMINO>
| expr '-' termino { $$ = $1 - $3; } 5. <EXPR> <expr>-<TERMINO>
| termino 6. <EXPR> <TERMINO>
;
termino: termino '*' factor { $$ = $1 * $3; } 7. <TERMINO> <TERMINO>*<FACTOR>
| termino '/' factor { $$ = $1 / $3; } 8. <TERMINO> <TERMINO>/<FACTOR>
| factor 9. <TERMINO> <FACTOR>
;
factor: '(' expr ')' { $$ = $2; } 10. <factor> (<EXPR>)
| digito 11. <factor> <digito>
| variable { $$ = buscar_valor($1); } 12. <factor> <VARIABLE>
;
digito : '0' { $$ = 0; } 13. <digito> 0
| '1' { $$ = 1; } 14. <digito> 1
| '2' { $$ = 2; } 15. <digito> 2
| '3' { $$ = 3; } 16. <digito> 3
| '4' { $$ = 4; } 17. <digito> 4
| '5' { $$ = 5; } 18. <digito> 5
| '6' { $$ = 6; } 19. <digito> 6
| '7' { $$ = 7; } 20. <digito> 7
| '8' { $$ = 8; } 21. <digito> 8
| '9' { $$ = 9; } 22. <digito> 9
;
variable: 'a' { $$ = 'a'; } 23. <VARIABLE> a

| 'b' { $$ = 'b'; } 24. <VARIABLE> b
| 'c' { $$ = 'c'; } 25. <VARIABLE> c
;
%%

IV.2 Diagrama de Arbol
Expresion: 2+5*(1+3)+2-3*(2-1)
<LINEA>
<EXPR>
2+5*(1+3)+2-3*(2-1)
<TERMINO> <FACTOR>
2+5*(1+3)+2-3 (2-1)
<EXPR>
<EXPR> <TERMINO> 2-1
2+5*(1+3)+2 3
<EXPR> <TERMINO>
<EXPR> <TERMINO> <FACTOR> 2 1
2+5*(1+3) 2 3
<EXPR> <TERMINO> <TERMINO> <FACTOR>

<FACTOR> <DIGITO> 2 1
2 5*(1+3)
2 3
<TERMINO> <FACTOR> <DIGITO>

<TERMINO> <FACTOR>
2 5 <DIGITO> 2 1
(1+3) 2
<FACTOR> <FACTOR> <EXPR> <DIGITO>

2 1+3
5 2
<EXPR> <TERMINO>
<DIGITO> <DIGITO> 1 3
2 5
<TERMINO> <FACTOR>
1 3
<FACTOR> <DIGITO>
1 3
<DIGITO>
2
14

IV.3 PROGRAMAS FUENTE
Yacc: calc.y
%{
#include <ctype.h>
int tabla[3];
%}
%%
lineas : linea lineas
|
;
linea : expr '\n' { printf("%d\n", $1); }
| variable '=' expr '\n' { setear_valor($1, $3); }
;
expr : expr '+' termino { $$ = $1 + $3; }
| expr '-' termino { $$ = $1 - $3; }
| termino
;
termino: termino '*' factor { $$ = $1 * $3; }
| termino '/' factor { $$ = $1 / $3; }
| factor
;
factor: '(' expr ')' { $$ = $2; }
| digito
| variable { $$ = buscar_valor($1); }
;
digito : '0' { $$ = 0; }
| '1' { $$ = 1; }
| '2' { $$ = 2; }
| '3' { $$ = 3; }
| '4' { $$ = 4; }
| '5' { $$ = 5; }
| '6' { $$ = 6; }
| '7' { $$ = 7; }
| '8' { $$ = 8; }
| '9' { $$ = 9; }
;
variable: 'a' { $$ = 'a'; }

| 'b' { $$ = 'b'; }
| 'c' { $$ = 'c'; }
;
%%
yylex() {
return(getchar());
}

yyerror() {
printf("Error\n");
}
main() {
yyparse();
void setear_valor(char c, int valor) {

tabla[c - 'a'] = valor;
}
int buscar_valor(char c) {
return(tabla[c - 'a']);
}
3.2 En C: Ytab.c conjunto de instrucciones en C, desde donde se puede

definir un Archivo Ejecutable o ejecutar desde el mismo compilador
# line 2 "calc.y"
#include <ctype.h>
int tabla[3];
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256
# line 45 "calc.y"
yylex() {
return(getchar());
}
yyerror() {
printf("Error\n");
}
main() {
yyparse();
}
void setear_valor(char c, int valor) {

tabla[c - 'a'] = valor;
}
int buscar_valor(char c) {
return(tabla[c - 'a']);
}
short yyexca[] ={

-1, 1,
0, -1,
-2, 0,
};
# define YYNPROD 27
# define YYLAST 60
hort yyact[]={
10, 26, 37, 36, 9, 24, 23, 25, 12, 13,

14, 15, 16, 17, 18, 19, 20, 21, 27, 3,
11, 2, 5, 28, 30, 4, 1, 4, 0, 22,
29, 0, 34, 35, 0, 24, 0, 25, 0, 24,
0, 25, 0, 0, 0, 0, 33, 31, 32, 0,
0, 0, 0, 0, 0, 0, 0, 6, 7, 8 };
short yypact[]={
-40,-1000, -40, -4, -60, -24,-1000,-1000,-1000,-1000,

-40,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000, -40, -40, -40, -40, -40, -38,
-1000, -24, -24, -8,-1000,-1000,-1000,-1000 };
short yypgo[]={
0, 26, 21, 19, 24, 22, 4, 20 };

short yyr1[]={
0, 1, 1, 2, 2, 3, 3, 3, 5, 5,
5, 6, 6, 6, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 4, 4, 4 };
short yyr2[]={
0, 2, 0, 2, 4, 3, 3, 1, 3, 3,
1, 3, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1 };
short yychk[]={
-1000, -1, -2, -3, -4, -5, 97, 98, 99, -6,
40, -7, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, -1, 10, 43, 45, 61, 42, 47, -3,
-4, -5, -5, -3, -6, -6, 41, 10 };
short yydef[]={
2, -2, 2, 0, 13, 7, 24, 25, 26, 10,

0, 12, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 1, 3, 0, 0, 0, 0, 0, 0,
13, 5, 6, 0, 8, 9, 11, 4 };
#ifndef lint
static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley)
2/11/83";
#endif not lint
# define YYFLAG -1000

# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)
/* parser for yacc output */
#ifdef YYDEBUG
int yydebug = 0; /* 1 for debugging */
#endif

YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */

int yychar = -1; /* current input token number */
int yynerrs = 0; /* number of errors */
short yyerrflag = 0; /* error recovery flag */
yyparse() {
short yys[YYMAXDEPTH];
short yyj, yym;
register YYSTYPE *yypvt;
register short yystate, *yyps, yyn;
register YYSTYPE *yypv;
register short *yyxi;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyps= &yys[-1];
yypv= &yyv[-1];
yystack: /* put a state and value onto the stack */
#ifdef YYDEBUG
if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
#endif
if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" );
return(1); }
*yyps = yystate;
++yypv;
*yypv = yyval;
yynewstate:
yyn = yypact[yystate];
if( yyn<= YYFLAG ) goto yydefault; /* simple state */
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;

if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */

yychar = -1;
yyval = yylval;
yystate = yyn;
if( yyerrflag > 0 ) --yyerrflag;
goto yystack;
}
yydefault:
/* default state action */
if( (yyn=yydef[yystate]) == -2 ) {
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
/* look through exception table */
for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi

+= 2 ) ; /* VOID */
while( *(yyxi+=2) >= 0 ){

if( *yyxi == yychar ) break;

}
if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
}
if( yyn == 0 ){ /* error */

/* error ... attempt to resume parsing */
switch( yyerrflag ){
case 0: /* brand new error */
yyerror( "syntax error" );

yyerrlab:
++yynerrs;
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while ( yyps >= yys ) {

yyn = yypact[*yyps] + YYERRCODE;
if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] ==
YYERRCODE ){
yystate = yyact[yyn]; /* simulate a shift of
"error" */
goto yystack;
}
yyn = yypact[*yyps];
/* the current yyps has no shift onn "error", pop

stack */
#ifdef YYDEBUG
if( yydebug ) printf( "error recovery pops state %d,
uncovers %d\n", *yyps, yyps[-1] );
#endif
--yyps;
--yypv;
}
/* there is no state on the stack with an error shift

... abort */
yyabort:
return(1);
case 3: /* no shift yet; clobber input char */
#ifdef YYDEBUG
if( yydebug ) printf( "error recovery discards char
%d\n", yychar );
#endif
if( yychar == 0 ) goto yyabort; /* don't discard EOF,

quit */
yychar = -1;
goto yynewstate; /* try again in the same state */

/* reduction by production yyn */
#ifdef YYDEBUG
if( yydebug ) printf("reduce %d\n",yyn);
#endif
yyps -= yyr2[yyn];
yypvt = yypv;
yypv -= yyr2[yyn];
yyval = yypv[1];
yym=yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyj = yypgo[yyn] + *yyps + 1;
if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn )
yystate = yyact[yypgo[yyn]];
switch(yym){
case 3:
# line 12 "calc.y"
{ printf("%d\n", yypvt[-1]); } break;
case 4:
# line 13 "calc.y"
{ setear_valor(yypvt[-3], yypvt[-1]); } break;
case 5:
# line 15 "calc.y"
{ yyval = yypvt[-2] + yypvt[-0]; } break;
case 6:
# line 16 "calc.y"
{ yyval = yypvt[-2] - yypvt[-0]; } break;
case 8:
# line 19 "calc.y"
{ yyval = yypvt[-2] * yypvt[-0]; } break;
case 9:
# line 20 "calc.y"
{ yyval = yypvt[-2] / yypvt[-0]; } break;
case 11:
# line 23 "calc.y"
{ yyval = yypvt[-1]; } break;
case 13:
# line 25 "calc.y"
{ yyval = buscar_valor(yypvt[-0]); } break;
case 14:
# line 28 "calc.y"
{ yyval = 0; } break;
case 15:
# line 29 "calc.y"
case 16:
# line 30 "calc.y"
case 17:
# line 31 "calc.y"
case 18:
# line 32 "calc.y"

case 19:
# line 33 "calc.y"
case 20:
# line 34 "calc.y"
case 21:
# line 35 "calc.y"
case 22:
# line 36 "calc.y"
case 23:
# line 37 "calc.y"
case 24:
# line 40 "calc.y"
{ yyval = 'a'; } break;
case 25:
# line 41 "calc.y"
{ yyval = 'b'; } break;
case 26:
# line 42 "calc.y"
{ yyval = 'c'; } break;
}
goto yystack; /* stack new state and value */
IV.4 ESTADOS (Tomados del Editor Yacc)
YaccEditor es un editor para TP. Yacc incluye una funcin para mostrar
grficamente la lista de estados adems de la lista de estados en un formato
TXT (texto), que se obtienen al aplicar la tcnica LALR
Mediante el YaccEditor podemos editar nuestro programa fuente y

compilarlo en YACC. Adems, podemos visualizar el Diagrama de Estados a
travs del Men LALR, el cual nos ofrece dos comandos: Generar listado de
estados (F8) y Generar grfico (F9). El Listado de Estados genera un listado de
texto con la descripcin de los estados y las transiciones que se producen al
aplicar la tcnica LALR.
A continuacin se muestra la Figura 1, en donde se ha generado el grafo

del compilador de la Calculadora (CALC.Y).
REFERENCIAS DEL GRAFICO

* Los estado donde existe un Reduce se
simbolizan con crculos en color verde.
* Los estados donde existe al menos un
conflicto (ya sea Reduce-Reduce o Shift-Reduce)
se simbolizan con crculos en color rojo.
Al hacer un click con el botn izquierdo del mouse en algn estado, se
muestra la informacin correspondiente a ese estado (ver Figura 2), es

decir, las reglas del kernel o ncleo, las respectivas reglas de la clausura,
todos los goto o saltos con sus respectivos smbolos y, adems,
informacin de los conflicto en caso de que el estado tenga alguno.
Figura 1. Diagrama de Estados.
Este grfico muestra todos los estados (en forma de crculos), los
smbolos con los que se realizan las transiciones y hacia que estados se
efectan los mismos.
estado 0
Ncleo:
regla 0: dist0 --> _lineas '$' ;
clausura:
regla 1: lineas --> _linea lineas ; '$'
regla 2: lineas --> _ ; '$' reducir por regla borradora(2)
regla 3: linea --> _expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 4: linea --> _variable '=' expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 5: expr --> _expr '+' termino ; '\n' '+' '-'
regla 6: expr --> _expr '-' termino ; '\n' '+' '-'
regla 7: expr --> _termino ; '\n' '+' '-'
regla 24: variable --> _'a' ; '='
regla 25: variable --> _'b' ; '='
regla 26: variable --> _'c' ; '='
regla 8: termino --> _termino '*' factor ; '\n' '+' '-' '*' '/'
regla 9: termino --> _termino '/' factor ; '\n' '+' '-' '*' '/'
regla 10: termino --> _factor ; '\n' '+' '-' '*' '/'
regla 11: factor --> _'(' expr ')' ; '\n' '+' '-' '*' '/'
regla 12: factor --> _digito ; '\n' '+' '-' '*' '/'
regla 13: factor --> _variable ; '\n' '+' '-' '*' '/'
regla 14: digito --> _'0' ; '\n' '+' '-' '*' '/'

regla 15: digito --> _'1' ; '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; '\n' '+' '-' '*' '/'
regla 18: digito --> _'4' ; '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; '\n' '+' '-' '*' '/'
ir con el smbolo: lineas al estado 1

ir con el smbolo: linea al estado 3
ir con el smbolo: expr al estado 5
ir con el smbolo: variable al estado 35
ir con el smbolo: termino al estado 34
ir con el smbolo: 'a' al estado 30
ir con el smbolo: 'b' al estado 31
ir con el smbolo: 'c' al estado 32
ir con el smbolo: factor al estado 33
ir con el smbolo: '(' al estado 11
ir con el smbolo: digito al estado 18
ir con el smbolo: '0' al estado 20
conflicto shift - reduce entre reglas:2 y 0 con simbolo '$'
estado 1
Ncleo:
regla 0: dist0 --> lineas _'$' ;
ir con el smbolo: '$' al estado 2
estado 2
Ncleo:
regla 0: dist0 --> lineas '$' _ ; "aceptar" (reducir por regla) (0)
estado 3
Ncleo:
regla 1: lineas --> linea _lineas ; '$'
clausura:
regla 1: lineas --> _linea lineas ; '$'
regla 2: lineas --> _ ; '$' reducir por regla borradora(2)
regla 3: linea --> _expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 4: linea --> _variable '=' expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 5: expr --> _expr '+' termino ; '\n' '+' '-' ')' '+' '-'
regla 24: variable --> _'a' ; '='
regla 25: variable --> _'b' ; '='
regla 26: variable --> _'c' ; '='
regla 14: digito --> _'0' ; '\n' '+' '-' '*' '/'

regla 15: digito --> _'1' ; '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; '\n' '+' '-' '*' '/'
regla 18: digito --> _'4' ; '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; '\n' '+' '-' '*' '/'
ir con el smbolo: lineas al estado 4

ir con el smbolo: linea al estado 3
estado 4
Ncleo:
regla 1: lineas --> linea lineas _ ; '$' reducir por regla (1)
estado 5
Ncleo:
regla 3: linea --> expr _'\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 5: expr --> expr _'+' termino ; '\n' '+' '-' ')' '+' '-'
regla 6: expr --> expr _'-' termino ; '\n' '+' '-'
ir con el smbolo: '\n' al estado 6

ir con el smbolo: '+' al estado 7
ir con el smbolo: '-' al estado 14
estado 6
Ncleo:
regla 3: linea --> expr '\n' _ ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' reducir por regla (3)
estado 7
Ncleo:
regla 5: expr --> expr '+' _termino ; '\n' '+' '-' ')' '+' '-'
clausura:
regla 8: termino --> _termino '*' factor ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'
regla 14: digito --> _'0' ; '\n' '+' '-' '*' '/'
regla 15: digito --> _'1' ; '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; '\n' '+' '-' '*' '/'

regla 18: digito --> _'4' ; '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; '\n' '+' '-' '*' '/'
regla 24: variable --> _'a' ; '\n' '+' '-' '*' '/'
regla 25: variable --> _'b' ; '\n' '+' '-' '*' '/'
regla 26: variable --> _'c' ; '\n' '+' '-' '*' '/'

estado 8
Ncleo:
regla 5: expr --> expr '+' termino _ ; '\n' '+' '-' ')' '+' '-' reducir por regla (5)
regla 8: termino --> termino _'*' factor ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'
regla 9: termino --> termino _'/' factor ; '\n' '+' '-' '*' '/'
ir con el smbolo: '*' al estado 9

ir con el smbolo: '/' al estado 16
estado 9
Ncleo:
regla 8: termino --> termino '*' _factor ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'
clausura:
regla 11: factor --> _'(' expr ')' ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'
regla 14: digito --> _'0' ; '\n' '+' '-' '*' '/'
regla 15: digito --> _'1' ; '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; '\n' '+' '-' '*' '/'
regla 18: digito --> _'4' ; '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; '\n' '+' '-' '*' '/'
regla 24: variable --> _'a' ; '\n' '+' '-' '*' '/' '='
regla 25: variable --> _'b' ; '\n' '+' '-' '*' '/' '='
regla 26: variable --> _'c' ; '\n' '+' '-' '*' '/' '='



estado 10
Ncleo:
regla 8: termino --> termino '*' factor _ ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/' reducir por regla (8)
estado 11
Ncleo:
regla 11: factor --> '(' _expr ')' ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'
clausura:
regla 5: expr --> _expr '+' termino ; ')' '+' '-'
regla 6: expr --> _expr '-' termino ; ')' '+' '-' '\n' '+' '-'
regla 7: expr --> _termino ; ')' '+' '-' '\n' '+' '-'
regla 8: termino --> _termino '*' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 9: termino --> _termino '/' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 10: termino --> _factor ; ')' '+' '-' '*' '/'
regla 11: factor --> _'(' expr ')' ; ')' '+' '-' '*' '/'
regla 12: factor --> _digito ; ')' '+' '-' '*' '/'
regla 13: factor --> _variable ; ')' '+' '-' '*' '/'
regla 14: digito --> _'0' ; ')' '+' '-' '*' '/'
regla 15: digito --> _'1' ; ')' '+' '-' '*' '/'
regla 16: digito --> _'2' ; ')' '+' '-' '*' '/'
regla 17: digito --> _'3' ; ')' '+' '-' '*' '/'
regla 18: digito --> _'4' ; ')' '+' '-' '*' '/'
regla 19: digito --> _'5' ; ')' '+' '-' '*' '/'
regla 20: digito --> _'6' ; ')' '+' '-' '*' '/'
regla 21: digito --> _'7' ; ')' '+' '-' '*' '/'
regla 22: digito --> _'8' ; ')' '+' '-' '*' '/'
regla 23: digito --> _'9' ; ')' '+' '-' '*' '/'
regla 24: variable --> _'a' ; ')' '+' '-' '*' '/'
regla 25: variable --> _'b' ; ')' '+' '-' '*' '/'
regla 26: variable --> _'c' ; ')' '+' '-' '*' '/'

estado 12
Ncleo:
regla 11: factor --> '(' expr _')' ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/'

regla 5: expr --> expr _'+' termino ; ')' '+' '-'

regla 6: expr --> expr _'-' termino ; ')' '+' '-' '\n' '+' '-'
ir con el smbolo: ')' al estado 13

estado 13
Ncleo:
regla 11: factor --> '(' expr ')' _ ; '\n' '+' '-' '*' '/' ')' '+' '-' '*' '/' reducir por regla (11)
estado 14
Ncleo:
regla 6: expr --> expr '-' _termino ; ')' '+' '-' '\n' '+' '-'
clausura:
regla 8: termino --> _termino '*' factor ; ')' '+' '-' '*' '/'
regla 9: termino --> _termino '/' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 10: termino --> _factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 12: factor --> _digito ; ')' '+' '-' '*' '/'
regla 13: factor --> _variable ; ')' '+' '-' '*' '/'
regla 14: digito --> _'0' ; ')' '+' '-' '*' '/'
regla 15: digito --> _'1' ; ')' '+' '-' '*' '/'
regla 16: digito --> _'2' ; ')' '+' '-' '*' '/'
regla 17: digito --> _'3' ; ')' '+' '-' '*' '/'
regla 18: digito --> _'4' ; ')' '+' '-' '*' '/'
regla 19: digito --> _'5' ; ')' '+' '-' '*' '/'
regla 20: digito --> _'6' ; ')' '+' '-' '*' '/'
regla 21: digito --> _'7' ; ')' '+' '-' '*' '/'
regla 22: digito --> _'8' ; ')' '+' '-' '*' '/'
regla 23: digito --> _'9' ; ')' '+' '-' '*' '/'
regla 24: variable --> _'a' ; ')' '+' '-' '*' '/'
regla 25: variable --> _'b' ; ')' '+' '-' '*' '/'
regla 26: variable --> _'c' ; ')' '+' '-' '*' '/'

estado 15
Ncleo:
regla 6: expr --> expr '-' termino _ ; ')' '+' '-' '\n' '+' '-' reducir por regla (6)
regla 8: termino --> termino _'*' factor ; ')' '+' '-' '*' '/'
regla 9: termino --> termino _'/' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'

estado 16

Ncleo:
regla 9: termino --> termino '/' _factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
clausura:
regla 12: factor --> _digito ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 13: factor --> _variable ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 14: digito --> _'0' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 15: digito --> _'1' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 18: digito --> _'4' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 24: variable --> _'a' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '='
regla 25: variable --> _'b' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '='
regla 26: variable --> _'c' ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '='

estado 17
Ncleo:
regla 9: termino --> termino '/' factor _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' reducir por regla (9)
estado 18
Ncleo:
regla 12: factor --> digito _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' reducir por regla (12)
estado 19
Ncleo:
regla 13: factor --> variable _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' reducir por regla (13)
estado 20
Ncleo:
regla 14: digito --> '0' _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' reducir por regla (14)
estado 21
Ncleo:
estado 22
Ncleo:

estado 23
Ncleo:
estado 24
Ncleo:
estado 25
Ncleo:
estado 26
Ncleo:
estado 27
Ncleo:
estado 28
Ncleo:
estado 29
Ncleo:
estado 30
Ncleo:
regla 24: variable --> 'a' _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '=' reducir por regla (24)
estado 31
Ncleo:
regla 25: variable --> 'b' _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '=' reducir por regla (25)
estado 32
Ncleo:
regla 26: variable --> 'c' _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' '=' reducir por regla (26)
estado 33
Ncleo:
regla 10: termino --> factor _ ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/' reducir por regla (10)
estado 34
Ncleo:
regla 7: expr --> termino _ ; ')' '+' '-' '\n' '+' '-' reducir por regla (7)
regla 8: termino --> termino _'*' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'
regla 9: termino --> termino _'/' factor ; ')' '+' '-' '*' '/' '\n' '+' '-' '*' '/'

estado 35

Ncleo:
regla 4: linea --> variable _'=' expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 13: factor --> variable _ ; '\n' '+' '-' '*' '/' reducir por regla (13)
ir con el smbolo: '=' al estado 36
estado 36
Ncleo:
regla 4: linea --> variable '=' _expr '\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
clausura:
regla 5: expr --> _expr '+' termino ; '\n' '+' '-'
regla 14: digito --> _'0' ; '\n' '+' '-' '*' '/'
regla 15: digito --> _'1' ; '\n' '+' '-' '*' '/'
regla 16: digito --> _'2' ; '\n' '+' '-' '*' '/'
regla 17: digito --> _'3' ; '\n' '+' '-' '*' '/'
regla 18: digito --> _'4' ; '\n' '+' '-' '*' '/'
regla 19: digito --> _'5' ; '\n' '+' '-' '*' '/'
regla 20: digito --> _'6' ; '\n' '+' '-' '*' '/'
regla 21: digito --> _'7' ; '\n' '+' '-' '*' '/'
regla 22: digito --> _'8' ; '\n' '+' '-' '*' '/'
regla 23: digito --> _'9' ; '\n' '+' '-' '*' '/'
regla 24: variable --> _'a' ; '\n' '+' '-' '*' '/'
regla 25: variable --> _'b' ; '\n' '+' '-' '*' '/'
regla 26: variable --> _'c' ; '\n' '+' '-' '*' '/'

estado 37
Ncleo:
regla 4: linea --> variable '=' expr _'\n' ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
regla 5: expr --> expr _'+' termino ; '\n' '+' '-'
regla 6: expr --> expr _'-' termino ; '\n' '+' '-'
ir con el smbolo: '\n' al estado 38

estado 38
Ncleo:

regla 4: linea --> variable '=' expr '\n' _ ; 'a' 'b' 'c' '(' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' reducir por
regla (4)

IV.5 MATRIZ DE TRANSICIN
( + - * / ) a b c = 0 1 2 3 4 5 6 7 8 9 Total
Estado
s.t.
0 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
3 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
5 - 7 14 - - - - - - - - - - - - - - - - - 2
7 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
8 - - - 9 16 - - - - - - - - - - - - - - - 2
9 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
11 11 - - - - - - - - - 20 21 22 23 24 25 26 27 28 29 11
12 - 7 14 - - 13 - - - - - - - - - - - - - - 3
14 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
15 - - - 9 16 - - - - - - - - - - - - - - - 2
16 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
34 - - - 9 16 - - - - - - - - - - - - - - - 2
35 - - - - - - - - - 36 - - - - - - - - - - 1
36 11 - - - - - 30 31 32 - 20 21 22 23 24 25 26 27 28 29 14
37 - 7 14 - - - - - - - - - - - - - - - - - 2
Total 8 3 3 3 3 1 7 7 7 1 8 8 8 8 8 8 8 8 8 8 123
IV.6 DIAGRAMA SINTCTICO PARA REPRESENTAR LAS REGLAS DE

PRODUCCIN
expr
linea
variable = expr
expr + termino
expr expr - termino
termino
termino * factor
termino termino / factor
factor
( expr )
factor digito
variable

1
digito
variable b

Diseño de Compiladores

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Diseño de Compiladores

Uploaded by

Copyright:

Available Formats

Teora de Lenguajes MA 760U

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 1

UNIVERSIDAD NACIONAL DE INGENIERIA

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 2

El trabajo que presentamos a continuacin tiene por finalidad

YaccEditor es un editor para TP Yacc que incluye una funcin para

Otra caracterstica importante es el uso de la herramienta TP YACC

El presente trabajo esta dividido en capitulos en los cuales se

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 3

CAPITULO I: TEORA DE GRAMTICAS

N : representa los smbolos no terminales de una gramtica G.

Smbolo no terminal (SNT): Es aquel que se emplea para sustituir

Smbolo terminales (ST): Es aquel valor que sirve como finalizacin

I.2 REGLAS DE PRODUCCIN

Es una estructura formada por un lado derecho, un operador () y un

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 4

I.4 TIPOS DE DERIVACIONES

Por ejemplo, sea G:

Derivacin: <S> m<A><B><C>

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 5

FORMAL. Puede ser procesado y manipulado mecnicamente

Ejemplo. L(Pascal)={ Programa1, programa2,......, programan}

Gramticas Formales.- Define la estructura de los elementos del

Ejemplo Dado el siguiente Lenguaje expresado en forma Algebraica,

Observacin . Se debe verificar que .

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 6

I.5 ARBOL DE DERIVACION

Por ejemplo, dado G:

verificar si la cadena: abac pertenece a L(G)

I.6 GRAMTICA TIPO SIMPLE (tipo-S)

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 7

Sea G: 1. <S> c<A>

Ejemplo 2: Es G una gramtica simple?

I.7 GRAMTICA COMPLEJA (tipo-q)

Se dice que una gramtica G es tipo compleja si cumple las siguientes

i. Los lados derechos de las reglas de produccin pueden empezar con

a.- Conjunto de Seguidores: Dado un s.n.t. <X> de una G, el

Sea G: 1. <S> a<B><S>

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 8

b.- Conjunto de Seleccin de una Regla de Produccin: Sea P una

1. Observamos que los lados derechos para las reglas de

P1: Sel (1) = Sel ( P:<S> a<A><S>) = {a}= H

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 9

Se observa que los conjuntos H y Q son disjuntos.

P2: Sel (3) = Sel ( P:<A> c<A><S>) = {c}= T

Sel (4) = {a,b} = R

Entonces, los conjuntos T y R son disjuntos.

Finalmente se cumple la 2 regla.

I.8 GRAMTICA AMBIGUA

Se dice que una gramtica G es ambigua si una cadena (lenguaje) puede

Por ejemplo, sea G:

Verificar si la cadena aa L(G).

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 10

i. Una columna de entrada para s.n.t. definidos en G.

I.10 AUTMATAS FINITOS NO DETERMINSTICOS

Universidad Nacional de Ingeniera . Prof. Crdova Neri, Teodoro 11

I.11 MATRIZ DE TRANSICIN

Es aquella tabla que sirve para hacer un anlisis sintctico y comprobar

i. Una columna de entrada para los estados propios del A.F.

Para el lenguaje anterior, la matriz de transicin ser:

estados s.t a b Total.

4 es el nmero de estados para el A.F.

I.12 DIAGRAMAS SINTCTICO QUE PERMITEN REPRESENTAR REGLAS