Este documento describe herramientas para la construcción de procesadores de lenguaje como Flex y Bison. Flex define reglas de reconocimiento de símbolos utilizando expresiones regulares, mientras que Bison convierte una descripción formal de un lenguaje en un programa que realiza análisis sintáctico. El documento también explica cómo instalar estas herramientas y algunos conceptos básicos como patrones, emparejamiento de entrada y condiciones de arranque.

1. ESCUELA DE INGENIERÍA
SEMESTRE MAYO – AGOSTO 2020
COMPILADORES
ACTIVIDAD EN CLASES N° 21
Nombre: Josseline Andrade Fecha: 15-07-2020
HERRAMIENTAS PARA LA CONSTRUCCIÓN DE PROCESADORES
DE LENGUAJE
Estas herramientas funcionan bajo Windows, aunque se puede utilizar, si se desea,
cualquier otra herramienta.
APLICACIÓN DE LOS LENGUAJES
Los lenguajes de programación hoy en día tienen una infinidad de aplicaciones,
básicamente cualquier objeto electrónico tiene cierto grado de programación. Algunos
de los más comunes son C++ y JAVA, también existe HTML, HTTP, XML, XAML y C#,
este último actualmente es el más utilizado en todos los dispositivos y redes basados
en MICROSOFT (Xbox 350, Windows Mobile, Windows Phone, Windows Cloud, Zune,
etc.).
Ya que los lenguajes de programación son informáticamente un puente entre el
Hardware y el Software estos permiten que las computadoras puedan establecer
conexión con un celular, una cámara o una consola portátil de videojuego.
Otra de las aplicaciones de los lenguajes de programación son las matemáticas como
las calculadoras, cajas registradoras, cajeros automáticos, por solo mencionar algunos
ejemplos sencillos.

2. RESEÑA HISTÓRICA
Los primeros lenguajes de programación surgieron de la idea de Charles Babagge, la
cual se le ocurrió a este hombre a mediados del siglo XIX. Era un profesor matemático
de la universidad de Cambridge e inventor inglés, que al principio del siglo XIX predijo
muchas de las teorías en que se basan los actuales ordenadores. Consistía en lo que
él denominaba la maquina analítica, pero que por motivos técnicos no pudo construirse
hasta mediados del siglo XX. Con él colaboro Ada Lovedby, la cual es considerada como
la primera programadora de la historia, pues realizo programas para aquélla supuesta
máquina de Babagge, en tarjetas perforadas. Como la maquina no llego nunca a
construirse, los programas de Ada, lógicamente, tampoco llegaron a ejecutarse, pero si
suponen un punto de partida de la programación, sobre todo si observamos que en
cuanto se empezó a programar, los programadores utilizaron las técnicas diseñadas por
Charles Babagge, y Ada, que consistían entre otras, en la programación mediante
tarjetas perforadas. A pesar de ello, Ada ha permanecido como la primera programadora
de la historia. Se dice por tanto que estos dos genios de antaño, se adelantaron un siglo
a su época, lo cual describe la inteligencia de la que se hallaban dotados.
En 1823 el gobierno Británico lo apoyo para crear el proyecto de una máquina de
diferencias, un dispositivo mecánico para efectuar sumas repetidas. Pero Babagge se
dedicó al proyecto de la máquina analítica, abandonando la máquina de diferencias, que
se pudiera programar con tarjetas perforadas, gracias a la creación de Charles Jacquard
(francés). Este hombre era un fabricante de tejidos y había creado un telar que podía
reproducir automáticamente patrones de tejidos, leyendo la información codificada en
patrones de agujeros perforados en tarjetas de papel rígido. Entonces Babagge intento
crear la máquina que se pudiera programar con tarjetas perforadas para efectuar
cualquier cálculo con una precisión de 20 dígitos. Pero la tecnología de la época no
bastaba para hacer realidad sus ideas. Si bien las ideas de Babagge no llegaron a
materializarse de forma definitiva, su contribución es decisiva, ya que los ordenadores
actuales responden a un esquema análogo al de la máquina analítica. En su diseño, la
máquina constaba de cinco unidades básicas:
1) Unidad de entrada, para introducir datos e instrucciones.
2) Memoria, donde se almacenaban datos y resultados intermedios; 3) Unidad de control,
para regular la secuencia de ejecución de las operaciones; 4) Unidad Aritmético-Lógica,
que efectúa las operaciones; 5) Unidad de salida, encargada de comunicar al exterior
los resultados. Charles Babbage, conocido como el "padre de la informática" no pudo
completar en aquella época la construcción del computador que había soñado, dado
que faltaba algo fundamental: la electrónica. El camino señalado de Babbage, no fue
nunca abandonado y siguiéndolo, se construyeron los primeros computadores.
Cuando surgió el primer ordenador, el famoso ENIAC (Electronic Numerical Integrator
And Calculator), su programación se basaba en componentes físicos, o sea, que se
programaba, cambiando directamente el Hardware de la máquina, exactamente lo que
sé hacia era cambiar cables de sitio para conseguir así la programación de la máquina.
La entrada y salida de datos se realizaba mediante tarjetas perforadas.

3. DISEÑO Y CONSTRUCCIÓN DE UN COMPILADOR
En el proceso de construcción de compiladores se integran muchos conceptos
diferentes de las Ciencias de la Computación:
• Algoritmos de búsqueda.
• Árboles, Hashing.
• Programación modular.
• Lenguaje Assembly.
• Análisis: Se trata de la comprobación de la corrección del programa fuente,
e incluye las fases correspondientes al Análisis léxico (que consiste en la
descomposición del programa fuente en componentes léxicos), Análisis
sintáctico (agrupación de los componentes léxicos en frases gramaticales) y
Análisis
• semántico (comprobación de la validez semántica de las sentencias
aceptadas en la fase de Análisis Sintáctico).
• Síntesis: Su objetivo es la generación de la salida expresada en el lenguaje
objeto y suele estar formado por una o varias combinaciones de fases de
Generación de Código (normalmente se trata de código intermedio o de
código objeto) y de Optimización de Código (en las que se busca obtener un
código lo más eficiente posible).
QUÉ ES FLEX Y BISON ?
Son dos herramientas útiles para crear programas que reaccionen a una entrada de
datos con una estructura y un lenguaje predeterminado, como por ejemplo, podemos
crear compiladores, intérpretes y analizadores de línea de comando.
Flex: El Flex define las reglas de reconocimiento de símbolos (Tokens) a partir de
expresiones regulares. Cuando un Token es reconocido por uno de estos patrones de
agrupamiento se le define una acción, por lo general esta acción es devolver el Tipo y
el valor (lexema).
El Flex cuando se utiliza combinado con el Bison, utiliza las definiciones de los Tokens
realizadas en el Bison para la comunicación entre ellos, 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 aunque los analizadores léxicos se pueden también
obtener de otras formas.
Bison convierte la descripción formal de un lenguaje, escrita como una gramática libre
de contexto LALR, en un programa en C, C++, o Java que realiza análisis sintáctico. Es
utilizado para crear analizadores para muchos lenguajes, desde simples calculadoras
hasta lenguajes complejos. Para utilizar Bison, es necesaria experiencia con la sintaxis
usada para describir gramáticas.

4. COMO SE INSTALA FLEX Y BISON?
1. Descarga el software disponible en el sitio de la cátedra.
2. Instalar el software en la unidad C: (para explicar a partir del punto 4 se tendrá como
hipótesis de que flex y bison han sido instalados en la ruta: C:GnuWin32 donde contiene
una subcarpeta llamada bin donde se encuentran los programas respectivos)
3. Flex y bison son aplicaciones de consola, por lo que se deberá entrar al Símbolo del
sistema y tipear líneas de comando para ejecutar Flex. Una alternativa es crear un archivo
de proceso por lotes (*.bat) que contenga las líneas de comando para la ejecución de Flex
y Bison y/o la compilación del archivo generado.
4. Si deseas que flex y bison se integren al conjunto de variables del entorno (esto te va a
permitir llamar a flex/bison desde cualquier ubicación en la línea de comandos) debes
hacer lo siguiente:
• Clic derecho en “Mi PC”.
• Selecciona “Propiedades”
• Clic en la pestaña “Opciones Avanzadas”
• Presiona el botón “Variables de entorno”
• En la ventana de variables de entorno, ubicarse en la sección “Variables del
sistema” luego haz clic en PATH y luego en el botón “Modificar” (si no está hacer
clic en “Nueva” y agregar PATH) • En la nueva ventana, escribir la ruta completa al
directorio “bin” de la aplicación flex/bison. Si existe otro valor, separarlos con
comas.
• Aceptar los cambios y luego reiniciar el sistema operativo.
5. Si deseas instalar un compilador de C como MinGwin, deberás integrar la ruta de
acceso al compilador a las variables de entorno para facilitar la llamada al programa. Por
ejemplo si se instaló MingWin en “C:Mingw” y dentro de la carpeta “bin” se encuentra
“gcc.exe” que es el ejecutable, entonces de deberá agregar (análogo a los pasos
anteriores) lo siguiente:
6. Cuando tengas listo podrás llamar a flex/bison desde el símbolo del sistema sin
necesidad de ubicarte en la carpeta donde ha sido instalado flex/bison.

5. PATRONES
Los patrones en la entrada se escriben utilizando un conjunto extendido de expresiones regulares y
usando como alfabeto cualquier carácter ASCII. Cualquier símbolo excepto el espacio en blanco,
tabulador, cambio de línea y los caracteres especiales se escriben tal cual en las expresiones regulares
(patrones) de Flex. Los caracteres especiales son:
“ [ ^ - ? . * + | ( ) $ / { } % < >
Algunos de los patrones de Flex son:
x
empareja el carácter ‘x’
.
cualquier carácter excepto una línea nueva
[xyz]
un conjunto de caracteres; en este caso, el patrón empareja una ‘x’, una ‘y’, o una ‘z’
[abj-oZ]
un conjunto de caracteres con un rango; empareja una ‘a’, una ‘b’, cualquier letra desde la
‘j’ hasta la ‘o’, o una ‘Z’
[^A-Z]
4
Introducción a Flex y Bison
cualquier carácter menos los que aparecen en el conjunto. En este caso, cualquier carácter
EXCEPTO una letra mayúscula.
[^A-Zn]
cualquier carácter EXCEPTO una letra mayúscula o una línea nueva
r*
cero o más r’s, donde r es cualquier expresión regular
r+
una o más r’s
r?
cero o una r (es decir, "una r opcional")
r{2,5}
entre dos y cinco concatenaciones de r
r{4}
exactamente 4 r’s
{nombre}
la expansión de la definición de "nombre" (ver más abajo)
"[xyz]"foo"
la cadena literal: [xyz]"foo
x
si x es una ‘a’, ‘b’, ‘f’, ‘n’, ‘r’, ‘t’, o ‘v’, entonces la interpretación ANSI-C de x
(por ejemplo t sería un tabulador). En otro caso, un literal ‘x’ (usado para la concordancia
exacta de caracteres especiales ( . ?)
(r)
empareja una R; los paréntesis se utilizan para anular la precedencia (ver más abajo)
rs
la expresión regular r seguida por la expresión regular s; se denomina "concatenación"
r|s
bien una r o una s
r/s
una r pero sólo si va seguida por una s.

6. ^r
una r, pero sólo al comienzo de una línea
r$
una r, pero sólo al final de una línea (es decir, justo antes de una línea nueva). Equivalente a
"r/n".
<s>r
una r, pero sólo en la condición de arranque s (ver más adelante).
<s1,s2,s3>r
lo mismo, pero en cualquiera de las condiciones de arranque s1, s2, o s3
EMPAREJAMIENTO DE LA ENTRADA
Cuando el escáner generado está funcionando, este analiza su entrada buscando
cadenas que concuerden con cualquiera de sus patrones. Si encuentra más de un
emparejamiento, toma el que empareje el texto más largo. Si encuentra dos o más
emparejamientos de la misma longitud, se escoge la regla listada en primer lugar en el
fichero de entrada de Flex.
Una vez que se determina el emparejamiento, el texto correspondiente al
emparejamiento (denominado el token) está disponible en el puntero de carácter global
yytext, y su longitud en la variable global entera yyleng. Entonces la acción
correspondiente al patrón emparejado se ejecuta y luego la entrada restante se analiza
para otro emparejamiento.
Si no se encuentra un emparejamiento, entonces se ejecuta la regla por defecto: el
siguiente carácter en la entrada se considera reconocido y se copia a la salida estándar.
Un ejemplo clarificador:
%%
aa {printf(“1”);}
aab {printf(“2”);}
uv {printf(“3”);}
xu {printf(“4”);}
Con el texto de entrada Laabdgf xuv, daría como salida L2dgf 4v. El ejecutable copiará L,
reconocerá aab (porque es más largo que aa) y realizará el printf(“2”), copiará dgf ,
reconocerá xu(porque aunque tienen la misma longitud que uv, y uvestá antes en el
fuente, en el momento de reconocer la x flex no reconoce el posible conflicto, puesto que
sólo xupuede emparejarse con algo que empieza por x(el manual de flex no es muy claro
al respecto, pero parece que usa un analizador de izquierda a derecha) y ejecutará el
printf(“4”) y luego copiará la vque falta).

7. CONDICIONES DE ARRANQUE
Flex dispone de un mecanismo para activar reglas condicionalmente. Cualquier regla cuyo
patrón se prefije con "<sc>" únicamente estará activa cuando el analizador se encuentre
en la condición de arranque llamada "sc". Por ejemplo,
<STRING>[^"]* { /* se come el cuerpo de la cadena ... */
...
}
estará activa solamente cuando el analizador esté en la condición de arranque "STRING",
y
<INITIAL,STRING,QUOTE>. { /* trata una secuencia de escape ... */
...
}
estará activa solamente cuando la condición de arranque actual sea o bien "INITIAL",
"STRING", o "QUOTE".
Las condiciones de arranque se declaran en la (primera) sección de definiciones de la
entrada usando líneas sin sangrar comenzando con %sseguida por una lista de nombres.
Una condición de arranque se activa utilizando la acción BEGIN. Hasta que se ejecute la
próxima acción BEGIN, las reglas con la condición de arranque dada estarán activas y las
reglas con otras condiciones de arranque estarán inactivas. Las reglas sin condiciones de
arranque también estarán activas.
BEGIN(0)retorna al estado original donde solo las reglas sin condiciones de arranque
están activas. Este estado también puede referirse a la condición de arranque INITIAL, así
que BEGIN(INITIAL) es equivalente a BEGIN(0). (No se requieren los paréntesis
alrededor del nombre de la condición de arranque pero se considera de buen estilo.)
VARIABLES DISPONIBLES PARA EL USUARIO
Esta sección resume algunos de los diferentes valores disponibles al usuario en
las acciones de las reglas.
• char *yytext apunta al texto del token actual (última palabra reconocida en
algún patrón). Por ejemplo printf(“%s”, yytext) lo escribiría por pantalla.
• int yyleng contiene la longitud del token actual.

8. COMO SE COMPILA CON FLEX Y BISON
Luego de escribir las especificaciones de flex y bison realizar lo siguiente. Si se desea
invocar a flex:
Si se desea invocar a bison (recordar que bison trabaja en conjunto con flex):
Para invocar a Bison en conjunción con flex realizar lo siguiente:
Para compilar los archivos generados. Flex: MinGW
Una alternativa es utilizar un compilador para windows como DevC++ o Borland C++
4.5
Abriendo el archivo lex.yy.c y luego compilándolo se generará el ejecutable “lex.yy.exe”
BISON y FLEX en conjunción:

9. EJEMPLO DE LA CREACIÓN DE UN COMPILADOR UTILIZANDO FLEX Y BISON
Vamos a realizar un ejemplo de una calculadora sencilla que reconocerá las
principales operaciones aritmética (+,-,* y /).
Abrimos un editor de texto y pegamos el siguiente código que será nuestro scanner
/*****************
Definiciones
Se colocan las cabeceras, variables y expresiones regulares
********************/
%{
#include <stdio.h>
#include <stdlib.h>
#include
"sintactico.tab.h" int
linea=0;
%}
/*
Creamos todas las expresiones regulares
Creamos la definición llamada DIGITO, podemos acceder esta
definición usando {DIGITO}*/ DIGITO [0-9]
NUMERO {DIGITO}+("."{DIGITO}+)?
%%
/***************
Reglas
*****************/
/* Creamos las reglas que reconocerán las cadenas que
acepte Nuestro scanner y retornaremos el token a bison
con la funcion return. */

10. {NUMERO} {yylval.real=atof(yytext); return(NUMERO);}
"=" {return(IGUAL);}
"+" {return(MAS);}
"-" {return(MENOS);}
";" {return(PTOCOMA);}
"*" {return(POR);}
"/" {return(DIV);}
"(" {return(PAA);}
")" {return(PAC);}
"n" {linea++;}
[trf] {}
" " {}
/* Si en nuestra entrada tiene algún caracter que no
pertenece a las reglas anteriores, se genera un error léxico
*/
. {printf("Error lexico en linea %d",linea);}
%%
/*
Código de Usuario
Aquí podemos realizar otras funciones, como por ejemplo
ingresar símbolos a nuestra tabal de símbolos o cualquier
otra accione del usuario.
Todo lo que el usuario coloque en esta sección se copiara al
archvi lex.yy.c tal y como esta.
*/
Guardamos el archivo como lexico.l. Luego creamos un nuevo archivo y colocamos
el siguiente código.
%{
/********************
Declaraciones en C
**********************/
#include <stdio.h>
#include
<stdlib.h>
#include
<math.h> extern
int yylex(void);
extern char
*yytext; extern

11. int linea; extern
FILE *yyin;
void yyerror(char *s);
%}
/************************
Declaraciones de Bison
*************************/
/* Especifica la coleccion completa de tipos de datos para poder usar
varios tipos de datos en los terminales y no terminales*/
%union
{
float real;
}
/* Indica la produccion con la que inicia nuestra gramatica*/
%start Exp_l
/* Especificacion de termines, podemos especificar tambien su tipo */
%token <real> NUMERO
%token MAS
%token MENOS
%token IGUAL
%token PTOCOMA
%token POR
%token DIV
%token PAA
%token PAC
/* No Terminales, que tambien podemos especificar su tipo */
%type <real> Exp
%type <real> Calc
%type <real> Exp_l
/* Definimos las precedencias de menor a mayor */
%left MAS MENOS
%left POR DIV
%%
/**********************
Reglas Gramaticales
***********************/
Exp_l: Exp_l Calc
|Calc
;
Calc : Exp PTOCOMA {printf ("%4.1fn",$1)}

12. ;
/* Con el símbolo de $$ asignamos el valor semántico de toda la acción de la derecha
y se la asignamos al no terminal de la izquierda, en la siguiente regla, se la asigna a
Exp. Para poder acceder al valor de los terminales y no terminales del lado derecho
usamos el símbolo $ y le concatenamos un número que representa la posición en la
que se encuentra es decir si tenemos
A --> B NUMERO C
Si queremos usar le valor que tiene el no terminal B usamos $1, si queremos
Usar el valor que tiene NUMERO usamos $2 y así sucesivamente.
*/
Exp : NUMERO {$$=$1;}
|Exp MAS Exp {$$=$1+$3;}
|Exp MENOS Exp {$$=$1-$3;}
|Exp POR Exp {$$=$1*$3;}
|Exp DIV Exp {$$=$1/$3;}
|PAA Exp PAC {$$=$2;}
;
%%
/********************
Codigo C Adicional
**********************/
void yyerror(char *s)
{
printf("Error sintactico %s",s);
}
int main(int argc,char **argv)
{ if
(argc>
1)
yyin=fopen(argv[1],"rt"); else
yyin=stdin;
yyparse();
return 0;
}
Guardamos este archivo con el nombre sintáctico.y y con eso ya tenemos nuestro
scanner y nuestro parser terminado. Para compilar estos archivos usamos los
comandos
Compilando sintactico.y
~> bison -d sintactico.y

13. El parámetro –d, crea el fichero t.tab.h, que contiene los identificadores de los tokens
de bison usados por flex
Compilando lexico.l
~> flex lexico.l
Compilando arhivos generados y crear ejecutable
~> cc lex.yy.c sintactico.tab.c -o analizador -lfl -lm
Esto nos genera un ejecutable llamado analizador.
Muchas veces necesitamos modificar nuestro archivo sintáctico.y o lexico.l y
tenemos que compilar todo cada vez que hacemos un cambio, para no estar
escribiendo los comandos cada vez que realizamos un cambio, crearemos un script,
que al ejecutarlo realizara todos los comandos de compilación. Para eso creamos un
nuevo archivo en blanco y escribimos
#!/bin/bash
bison -d
sintactico.y
flex lexico.l
cc lex.yy.c sintactico.tab.c -o analizador -lfl –lm
Guardamos este archivo con cualquier nombre, por ejemplo compilar.sh. Ahora
cambiaremos las propiedades de este archivo para poder ejecutar. Le damos clic derecho
sobre este archivo y en la pestaña permisos elegimos la opción de “Permitir ejecutar el
archivo como un programa”, cerramos esa ventana.

14. Para poder compilar, desde consola nos ubicamos donde se encuentra este archivo
.sh y escribimos
./compilar.sh
Esto nos genera nuestro ejecutable que podemos correr para poder probar nuestra
calculadora. Para ejecutar este ejemplo usamos el comando
./analizador
Ingresamos algunas expresiones y el resultado que obtenemos es:
Realice un collage con las palabras más importantes sobre el tema Flex y
Bison.

15. Realizar un comentario personal sobre el funcionamiento que tiene las
herramientas Flex y Bison para la creación de compiladores pequeños.
La investigación en la construcción de compiladores ha conducido a herramientas que
hacen mucho más fácil crear compiladores, de modo que los estudiantes de informática de
hoy en día pueden crear sus propios lenguajes pequeños y desarrollar un compilador
simple en pocas semanas esto se logra con Flex y Bison que son herramientas que
permiten generar analizadores léxicos.