Facultad de Ciencias Físicas y Matemáticas

Escuela de Informática

DISEÑO E IMPLEMENTACIÓN DE UN COMPILADOR

COMPILADOR ONLINE

Autores:
1052700911 – CRUZ OTINIANO, José Martin
1052700511 - FERNÁNDEZ SEGURA, Joel Cesar

Asesor:
José Luis Peralta Lujan

Trujillo, Julio del 2016

 Resumen
El presente informe está enfocado al diseño e implementación de un compilador online
con el propósito de poder realizar cálculos y prueba de escritorio de algoritmos usando
un lenguaje de programación sencillo. Para desarrollarlo es necesario usar las
herramientas Flex y Bison los cuales se encargan de generar código para analizadores
léxicos y sintácticos respectivamente. Para el diseño y la implementación se tiene que
tener la siguiente estructura la cual abarca: el análisis léxico, el análisis sintáctico y la
traducción dirigida
dirigida por la sintaxis usando esquemas de traducción.

En el análisis léxico se especifican los tokens, los cuales se van a encargar de analizar
si un símbolo
símbolo pertenece
pertenece o no al lenguaje, nos ayudaremos
ayudaremos de la herramienta Flex.
Flex.

En el análisis
análisis sintáctico vamos
vamos a especificar
especificar la gramática libre del contexto para
nuestro lenguaje, nos apoyaremos de la herramienta Bison, adicionando código de C
para algunas funciones requeridas y se encargara de ver la estructura de las
sentencias y los tokens .

La traducción dirigida por la sintaxis usando esquemas de traducción va adherida al

análisis sintáctico, específicamente en las declaraciones de gramática y contienen
reglas semánticas, estas reglas suelen tener código de C indicando las operaciones a
realizar.

Para terminar el desarrollo vamos a realizar un entorno web el cual estará en un

servidor web y con el cual podremos ingresar el código a compilar. Este entorno web
se encargara de hacer consultas al compilador y obtendrá los resultados para ser
mostrados.
 Abstract

This report is focused on the design and implementation of an online compiler in order
to be able to perform calculations and test algorithms desktop using a simple
programming language. To develop it is necessary to use Flex and Bison tools which
are responsible for generating code for lexical and syntactic analyzers respectively. For
the design and implementation has to have the following structure which includes:
lexical analysis,
analysis, parsing and translation using syntax-directed translation schemes.

In the lexical analysis tokens, which will be in charge of analyzing whether or not a
symbol belongs to language, we will help the Flex tool specified.

In parsing we will specify the context-free grammar for our language, we will rely on the
Bison tool, adding C code required for some functions and be responsible to see the
structure of sentences and tokens.

The syntax-directed translation using translation schemes will parse adhered to,
specifically statements contain grammar and semantic rules, these rules often have C
code indicating the operations to perform.

To complete the development we will make a web environment which will be on a web
server and which we can enter the code to compile. This web environment would be
responsible
responsible for querying the compiler and get the results to be displayed.

Key words: Flex, Bison, Parsers, Scanners, Schema of translation, compiler online.
 Tabla de Contenidos
RESUMEN ......................................
..........................................................
........................................
.........................................
........................................
.......................................
...........................
.......2

ABSTRACT .....................................
.........................................................
........................................
........................................
........................................
........................................
...........................
.......3

LISTA DE TABLAS ........................................

............................................................
........................................
........................................
........................................
...........................
.......6

LISTA DE ILUSTRACIONES ......................................

.........................................................
........................................
.........................................
.................................
.............7

INTRODUCCIÓN ......................................
.........................................................
.......................................
.........................................
........................................
.................................
..............8

CAPÍTULO 1: DESCRIPCIÓN DEL PROYECTO......................................

..........................................................
........................................
....................9

1.1. PROBLEMA .......................................

..........................................................
........................................
.........................................
........................................
..............................
..........9

1.2. PLANTEAMIENTO DE LA SOLUCIÓN .......................................

..........................................................
........................................
.........................................
....................9

1.3. OBJETIVOS DEL PROYECTO .......................................

...........................................................
........................................
........................................
..............................
..........9

1.3.1. Objetivo General ......................................

..........................................................
........................................
........................................
..............................
..........9

1.3.2. Objetivos Específicos .......................................

..........................................................
........................................
.........................................
.......................
... 9

CAPÍTULO 2: MARCO TEÓRICO........................................

...........................................................
........................................
.........................................
...................... 10

2.1. INTRODUCCIÓN A LOS COMPILADORES .......................................

...........................................................
........................................
................................
............10

2.1.1. Definición de un compilador .....................................

.........................................................
........................................
................................
............10

2.1.2. Estructura de un Compilador ........................................

...........................................................
.......................................
.............................
.........11

2.2. ANÁLISIS LÉXICO ......................................

..........................................................
........................................
........................................
........................................
......................
.. 12

2.3. ANÁLISIS SINTÁCTICO ......................................

..........................................................
........................................
.........................................
...................................
..............14

2.3.1. Análisis sintáctico

sintáctico descendente ........................................
...........................................................
.......................................
.........................
..... 15

2.4. ANÁLISIS SEMÁNTICO ......................................

..........................................................
........................................
.........................................
...................................
..............16

2.4.1. Traducción dirigida por la sintaxis .......................................

..........................................................
........................................
....................... 17

2.4.2. Atributos.....................................
.........................................................
........................................
.........................................
.........................................
...................... 18

2.4.3. Notaciones para asociar reglas semánticas ........................................

............................................................
.........................
.....18

2.4.3.1. Definición dirigida por la sintaxis ..................................

....................................................
....................................
....................................
...........................
......... 18

2.4.3.2. Esquemas de traducción ..................................

....................................................
....................................
....................................
....................................
........................
...... 19

2.5. GENERACIÓN DE CÓDIGO INTERMEDIO .....................................

.........................................................
........................................
...................................
...............20

2.6. GENERACIÓN DE CÓDIGO FINAL ........................................

...........................................................
........................................
.........................................
...................... 20

2.7. TABLAS DE SÍMBOLOS Y TIPOS......................................

..........................................................
........................................
........................................
.........................
..... 21

2.8. MANEJO DE ERRORES ......................................

..........................................................
........................................
.........................................
...................................
..............21

2.9. HERRAMIENTAS DE CONSTRUCCIÓN DE COMPILADORES .......................................

..........................................................
...............................
............22

2.10. HERRAMIENTA PARA GENERAR ANALIZADORES LÉXICOS FLEX ......................................

..........................................................
.........................
..... 23

2.10.1. ESTRUCTURA DE UN FICHERO FLEX ......................................

..........................................................
........................................
...................................
...............24

2.10.1.1. LA SECCIÓN DE DEFINICIONES ........................................

............................................................
........................................
...................................
...............24

2.10.1.2. LA SECCIÓN DE REGLAS ......................................

..........................................................
........................................
........................................
.........................
..... 24
 2.10.1.3. LA SECCIÓN DE CÓDIGO DE USUARIO ......................................................................................25
2.11. HERRAMIENTA PARA GENERAR ANALIZADORES SINTÁCTICOS BISON ......................................................25
2.11.1. ESTRUCTURA DE BISON ...........................................................................................................25
2.11.1.1. DECLARACIONES EN C Y EN BISON .........................................................................................25
2.11.1.2. REGLAS GRAMATICALES Y ACCIONES ......................................................................................26

2.11.1.3. CÓDIGO C ADICIONAL .........................................................................................................26

2.12. UN SERVIDOR WEB ....................................................................................................................26

CAPÍTULO 3: DESARROLLO ...........................................................................................................27

3.1. ANÁLISIS LÉXICO ........................................................................................................................ 27

3.1.1. Definición de tokens ..................................................................................................... 27

3.1.2. Implementación en FLEX ..............................................................................................27

3.2. ANÁLISIS SINTÁCTICO .................................................................................................................29

3.2.1. Definición de Gramáticas libres del Contexto ...............................................................29

3.2.2. Implementación en BISON ............................................................................................29

3.3. COMPILACIÓN DEL PROGRAMA ..................................................................................................... 32

3.4. CREACIÓN DE PROYECTO WEB Y FUNCIONAMIENTO ONLINE .................................................................33

3.4.1. Pasos para crear el proyecto ........................................................................................33

3.4.2. Explicación del funcionamiento del proyecto ...............................................................34

3.4.3. Controlador de servidor ................................................................................................35

3.4.4. Despliegue de la aplicación hacia servidor (Heroku) ....................................................36

CONCLUSIONES ................................................................................................................................37

RECOMENDACIONES .......................................................................................................................38

GLOSARIO ..........................................................................................................................................39

BIBLIOGRAFÍA ...................................................................................................................................40

ANEXO 1: HERRAMIENTAS NECESARIAS ..................................................................................41

 Lista De Tablas
Tabla 1: Definición de tokens para el analizador sintáctico .......................................... 27

Tabla 2: Definición de la gramática libre del contexto y reglas semánticas.................. 29

 Lista De Ilustraciones
Ilustración 1: Esquema de un Traductor. (Galvez Rojas & Mora Mata, 2005).............. 10

Ilustración 2: Esquema de un Compilador (Ruiz Catalan, 2010) .................................. 10

Ilustración 3: Fases de un compilador: (Ruiz Catalan, 2010)........................................ 12

Ilustración 4: Ejemplo de Árbol sintáctico. (Galvez Rojas & Mora Mata, 2005) ............ 14

Ilustración 5: Árbol sintáctico 1 (Ruiz Catalan, 2010) .................................................... 15

Ilustración 6:Árbol sintáctico 2 (Ruiz Catalan, 2010) ..................................................... 15

Ilustración 7:Análisis sintáctico descendente para id+id*id (Aho, Lam, Sethi, & Ullman,
1998) ............................................................................................................................... 16

Ilustración 8: Traducción dirigida por la sintaxis. (Galvez Rojas & Mora Mata, 2005) . 18

Ilustración 9: Definición orientada por la sintaxis de una calculadora de escritorio

simple. (Aho, Lam, Sethi, & Ullman, 1998) .................................................................... 19

Ilustración 10: Implementación de un esquema de traducción orientado. (Aho, Lam,

Sethi, & Ullman, 1998).................................................................................................... 19

Ilustración 11: Codigo HTML de la vista ........................................................................ 34

Ilustración 12: Interfaz de Compilador Online................................................................ 35

Ilustración 13: Codigo php para el control del servidor ................................................ 35

 Capítulo 1: Descripción Del Proyecto

1.1. Problema

El avance de la tecnología, el uso extendido de las aplicaciones web y la

necesidad de tener un medio virtual online para poder realizar cálculos, pruebas
de escritorio de algoritmos.

1.2. Planteamiento de la Solución

Por la problemática mostrada anteriormente se propone el diseño e

implementación de un compilador online para facilitar el acceso, solo será
necesario el uso de aparatos móviles ya que estará disponible en un servidor
web.

1.3. Objetivos del Proyecto

1.3.1. Objetivo General

Diseño e implementación de un compilador online.

1.3.2. Objetivos Específicos

1. Diseñar un lenguaje de programación sencillo que resuelva operaciones
e instrucciones básicas.
2. Estudiar la herramienta Flex para desarrollo del Análisis Léxico
3. Estudiar la herramienta Bison para el desarrollo del Análisis Sintáctico.
4. Estudiar la Traducción dirigida por la sintaxis para el Análisis Semántico.
 Capítulo 2: Marco Teórico
2.1. Introducción a los Compiladores
2.1.1. Definición de un compilador

Los procesadores del lenguaje son aplicaciones las cuales reciben como
entrada un lenguaje. Este concepto es abarcado por los traductores, ”Un
traductor se define como un programa que traduce o convierte desde un texto o
programa escrito en un lenguaje fuente hasta un texto o programa equivalente
escrito en un lenguaje destino produciendo, si cabe, mensajes de error ”
(Galvez Rojas & Mora Mata, 2005). Ver figura 1

Ilustración 1: Esquema de un Traductor. (Galvez Rojas & Mora Mata, 2005)

Dentro de los traductores están los compiladores, un compilador es un sistema

de software que se encarga de la traducción de un lenguaje de alto nivel a un
lenguaje de bajo nivel, ver figura 2 , “un compilador es un programa que puede
leer un programa en un lenguaje (el lenguaje fuente) y traducirlo en un
programa equivalente en otro lenguaje (el lengua je destino)”. (Aho, Lam, Sethi,
& Ullman, 1998).

Ilustración 2: Esquema de un Compilador (Ruiz Catalan, 2010)

Otro tipo de traductor son los intérpretes, un intérprete es como un compilador,

 ejecuta a la vez. No se produce un resultado físico (código máquina) sino lógico
(una ejecución). Hay lenguajes que sólo pueden ser interpretados, como por
ejemplo Lisp.

La diferencia entre compilador e intérprete es que el compilador analiza todo el

programa fuente, crea el programa objeto y luego permite su ejecución (sólo
del programa objeto obtenido) y el intérprete lee sentencia por sentencia el
programa fuente, la convierte en código objeto y la ejecuta. Por lo tanto, es fácil
comprender que tras compilar un programa, su ejecución es mucho más rápida
que la ejecución de un programa interpretado.

2.1.2. Estructura de un Compilador

En la estructura de un compilador hay dos procesos en esta asignación:

análisis y síntesis.

La parte del análisis divide el programa fuente en componentes e impone

una estructura gramatical sobre ellas. Después utiliza esta estructura para
crear una representación intermedia del programa fuente. Si la parte del
análisis detecta que el programa fuente está mal formado en cuanto a la
sintaxis, o que no tiene una semántica consistente, entonces debe
proporcionar mensajes informativos para que el usuario pueda corregirlo. La
parte del análisis también recolecta información sobre el programa fuente y
la almacena en una estructura de datos llamada tabla de símbolos, la cual
se pasa junto con la representación intermedia a la parte de la síntesis.

La parte de la síntesis construye el programa destino deseado a partir de la

representación intermedia y de la información en la tabla de símbolos. A la
parte del análisis se le llama comúnmente el front-end del compilador; la
parte de la síntesis (propiamente la traducción) es el back-end.

En la figura 3 podemos ver el esquema de un compilador.

 Ilustración 3: Fases de un compilador: (Ruiz Catalan, 2010)

2.2. Análisis Léxico

En esta fase, la cadena de caracteres que constituye el programa fuente se lee
de izquierda a derecha y se agrupa en componentes léxicos, que son
secuencias de caracteres que tienen un significado atómico; además el
analizador léxico trabaja con la tabla de símbolos introduciendo en ésta los
nombres de las variables.
Los componentes léxicos se llaman tokens (caracteres relacionados entre sí).
Estos tokens constituyen la entrada para el siguiente proceso de análisis
(análisis sintáctico). El agrupamiento de caracteres en tokens depende del
lenguaje que vayamos a compilar; es decir, un lenguaje generalmente agrupará
caracteres en tokens diferentes de otro lenguaje.
Los tokens pueden ser de dos tipos; cadenas específicas como palabras
reservadas, puntos y comas, etc., y no específicas, como identificadores,
constantes y etiquetas. La diferencia entre ambos tipos de tokens radica en si
ya son conocidos previamente o no.
Por ejemplo, la palabra reservada while es conocida previamente en un
lenguaje que la utilice, pero el nombre de una variable no es conocido
anteriormente ya que es el programador el que le da nombre en cada
programa.
Por lo tanto, y resumiendo, el analizador léxico lee los caracteres que
componen el texto del programa fuente y suministra tokens al analizador
sintáctico.
El analizador léxico irá ignorando las partes no esenciales para la siguiente
fase, como pueden ser los espacios en blanco, los comentarios, etc., es decir,
realiza la función de preprocesador en cierta medida.
Los tokens se consideran entidades con dos partes: su tipo y su valor o
lexema. En algunos casos, no hay tipo (como en las palabras reservadas). Esto
quiere decir que por ejemplo, si tenemos una variable con nombre “x”, su tipo
es identificador y su lexema es x.
Por ejemplo, supongamos que tenemos que analizar un trozo de programa
fuente escrito en lenguaje Java: x = x + y – 3;
Los tokens suministrados al analizador sintáctico serían estos (el nombre que
le demos a los tipos de tokens depende de nosotros):
 “x” : Tipo identificador, lexema x
 “=” : Lexema =
 “x” : Tipo identificador, lexema x
 “+” : Lexema +
 “y” : Tipo identificador, lexema y
 “-“ : Lexema –
 “3” : Tipo entero, lexema 3
 “;” : Lexema ;
2.3. Análisis Sintáctico
El análisis sintáctico trabaja con una gramática libre del contexto y genera el
árbol sintáctico que reconoce su sentencia de entrada. En nuestro caso las
categorías gramaticales del análisis léxico son los terminales de la gramática.
Ejemplo de Gramática libre del contexto.
S -> <ID> <ASIG> expr <TERM>
expr -> <ID>
| <ID> <+> expr
| <ID> <*> expr
| <NUM>
El análisis sintáctico intenta generar un árbol sintáctico que encaje con la
sentencia de entrada. Para nuestro ejemplo, dicho árbol sintáctico existe y es el
de la figura 4

Ilustración 4: Ejemplo de Árbol sintáctico. (Galvez Rojas & Mora Mata, 2005)

El analizador sintáctico tiene como entrada los lexemas que le suministra el

analizador léxico y su función es comprobar que están ordenados de forma
correcta (dependiendo del lenguaje que queramos procesar). Los dos
analizadores suelen trabajar unidos e incluso el léxico suele ser una subrutina
del sintáctico. Al analizador sintáctico se le suele llamar párser. El párser
genera de manera teórica un árbol sintáctico. Este árbol se puede ver como
una estructura jerárquica que para su construcción utiliza reglas recursivas. La
estructuración de este árbol hace posible diferenciar entre aplicar unos
operadores antes de otros en la evaluación de expresiones. Es decir, si
tenemos esta expresión: x = x * y – 2;
El valor de x dependerá de si aplicamos antes el operador producto que el
operador suma. Una manera adecuada de saber qué operador aplicamos antes
es elegir qué árbol sintáctico generar de los dos posibles.
 Glosario
Lenguaje de Programación: según DRAE. Conjunto de signos y reglas que permite
la comunicación con un ordenador.

Alfabeto: Conjunto no vacío de símbolos

Cadena: secuencias de caracteres formados a partir de símbolos.

Gramática: mecanismo que nos permite generar un lenguaje.

Derivación: proceso que consiste en sustituir el lado izquierdo por su lado derecho

Sentencia: cadena generada a partir de una gramática.

Sintaxis: la forma o estructura de las expresiones, declaraciones y unidades de

programa.

Semántica: el significado de las expresiones, declaraciones, y unidades de

programas.

Notación BNF. Método más ampliamente conocido para describir la sintaxis de un

lenguaje de programación.
 Bibliografía

Aho, A., Lam, M., Sethi, R., & Ullman, J. (1998). Compiladores: Principios, Tecnicas y
Herramientas 2 Edicion. New Jersey: Pearson.

Bejar Hernandez, R. (20 de 07 de 2016). Universidad de Zaragoza- Introduccion a Flex

y Bison. Obtenido de
http://webdiis.unizar.es/asignaturas/LGA/material_2004_2005/Intro_Flex_Bison.
pdf

Galvez Rojas, S., & Mora Mata, M. A. (2005). TRADUCTORES Y COMPILADORES

CON LEX/YACC, JFLEX/CUP Y JAVACC. Malaga: Universidad de Malaga.

Ruiz Catalan, J. (2010). Compiladores: Teoria e Implementacion. Madrid: Graficas

DEVA S.L.
 Anexo 1: Herramientas necesarias
Puedes descargar las herramientas Flex y Bison en la siguiente dirección:

Flex:
- Ingresar al siguiente link:

http://gnuwin32.sourceforge.net/packages/flex.htm

- Descargar la última versión

Bison:
- Ingresar al siguiente link:
http://gnuwin32.sourceforge.net/packages/bison.htm
- Descargar la ultima version

MinGW:
- MinGw es un compilador del lenguaje C/C++, trae librerías necesarias para la
ejecución de programas en C/C++
- Ingresar en el siguiente link
- http://www.mingw.org/category/wiki/download
- Descargar la versión para tu tipo de arquitectura x86 o x64