TAller sobre flex y bison

1. 1
Nombre: Danilo Puente
Fecha:21/06/2018
TALLER DE COMPILADORES
Utilizando la herramienta de búsqueda de la Web, Investigar los siguientes temas:
Herramientas para la construcción de procesadores de lenguaje.
Herramienta
Lenguaje
Descripción
Bison C Generador de Analizadores Sintácticos Ascendentes tipo YACC
COCO/R
C/C++ Generador de Analizadores Léxicos y Sintácticos Descendentes Recursivos
Flex C Generador de Analizadores Léxicos tipo Lex
Lex C Generador de Analizadores Léxicos
SDGLL1 exe Sistema Detector de Gramáticas LL(1) y generador de la tabla
TS 2006 C/C++ Tipo abstracto de datos Tabla de Símbolos de uso sencillo
TS C Tipo abstracto de datos Tabla de Símbolos
TS-OO C++ Tipo abstracto de datos orientado a objetos Tabla de Símbolos
VASt exe
Visualizador de árboles sintácticos partiendo de los ficheros con la
gramática y el parse pedidos en laPráctica [versión 2.0, Windows]
VASt C++
Visualizador de árboles sintácticos partiendo de los ficheros con la
gramática y el parse pedidos en laPráctica [versión 1.0, Linux]
YACC C Generador de Analizadores Sintácticos Ascendentes LR(1)
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. Existen

2. 2
también niveles de programación mucho más complejos como los videojuegos o los pilotos
automáticos de los aviones comerciales o las máquinas de juego de los casinos que siguen un patrón
de probabilidad a partir de un arreglo de números al azar establecido por una programación
numérica. La robótica es la combinación de mecánica, electrónica y programación, la cual en base a
sensores y mecanismos sigue una serie de instrucciones algorítmicas las cuales le permiten por
ejemplo a un brazo robótico montar una rueda, ajustar un tornillo o cortar un rectángulo de 3 cm
cuadrados en una placa de acero. Con el avance de la tecnología los límites de la programación se
vuelven cada vez más distantes.
Reseña Histórica:
Las primeras aplicaciones del procesamiento del lenguaje natural surgieron entre 1940 y 1960,
teniendo como interés fundamental la traducción automática de textos entre diferentes idiomas.
Los experimentos en este ámbito se basaban fundamentalmente en la sustitución automática
palabra por palabra, por lo que se obtenían traducciones muy rudimentarias, que no
proporcionaban unos resultados claros.
Surgió por tanto la necesidad de resolver ambigüedades sintácticas y semánticas, así como la
importancia de considerar la información contextual. Los problemas más relevantes en este
tiempo fueron la carencia de un orden de la estructura oracional en algunas lenguas, y la dificultad
para obtener una representación tanto sintáctica como semántica, pero una vez que se empezaron
a tener en cuenta se dio paso a una concepción más realista del lenguaje en la que era necesario
contemplar las transformaciones que se producen en la estructura de la frase durante el proceso
de traducción.
Los últimos años se caracterizan por la incorporación de técnicas estadísticas y el desarrollo de
formalismos adecuados para el tratamiento de la información léxica. Se ha introducido nuevas
técnicas de representación del conocimiento muy cercanas a la inteligencia artificial, y las técnicas
de procesamiento utilizadas por investigadores procedentes del área de la lingüística e
informática son cada vez más próximas.
Diseño y construcción de un compilador.

3. 3
Diseño:
Construcción:
La construcción de un compilador involucra la división del proceso en una serie de fases que variará
con su complejidad. Generalmente estas fases se agrupan en dos tareas: el análisis del programa
fuente y la síntesis del programa objeto.
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).
Las herramientas Flex y Bison:
Esta herramienta se usa en consonancia con la herramienta flex y sirve para especificar analizadores
sintácticos. De la misma forma que flex tiene como base las expresiones regulares, la herramienta
bison también se basa en otro formalismo para describir lenguajes, en este caso serán las gramáticas
independientes del contexto las que constituirán el núcleo de las especificaciones que procesará
bison.

4. 4
Que es flex
Es una herramienta útil 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.
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.
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”

5. 5
•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.
Patrones en flex
Los patrones en la entrada se escriben utilizando un conjunto extendido de expresiones regulares.
Estas son:
`x': empareja el caracter `x'
`.': cualquier caracter (byte) excepto una línea nueva
`[xyz]': una "clase de caracteres"; en este caso, el patrón empareja una `x', una `y', o una `z'
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

6. 6
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.
Condiciones de arranque
Variables disponibles para el usuario

7. 7
Compilación y ejecución en flex de un programa.
Introducción a Bison

8. 8
Bison es un generador de analizadores sintácticos de propósito general que convierte una
descripción para una gramática independiente del contexto (en realidad de una subclase de éstas,
las LALR) en un programa en C que analiza esa gramática. Es compatible al 100% con Yacc, una
herramienta clásica de Unix para la generación de analizadores léxicos, pero es un desarrollo
diferente realizado por GNU bajo licencia GPL. Todas las gramáticas escritas apropiadamente para
Yacc deberían funcionar con Bison sin ningún cambio. Usándolo junto a Flex esta herramienta
permite construir compiladores de lenguajes.
Símbolos terminales y no terminales
Los símbolos terminales de la gramática se denominan en Bison tokens y deben declararse en la
sección de definiciones. Por convención se suelen escribir los tokens en mayúsculas y los símbolos
no terminales en minúsculas.
Hay tres maneras de escribir símbolos terminales en la gramática. Aquí se describen las dos más
usuales:
• Un token declarado se escribe con un identificador, de la misma manera que un identificador en
C. Por convención, debería estar todo en mayúsculas. Cada uno de estos nombres debe definirse
con una declaración de %token.
• Un token de carácter se escribe en la gramática utilizando la misma sintaxis usada en C para las
constantes de un carácter; por ejemplo, ‘+’ es un tipo de token de carácter. Un tipo de token de
carácter no necesita ser declarado a menos que necesite especificar el tipo de datos de su valor
semántico, asociatividad, o precedencia. Por convención, un token de carácter se utiliza únicamente
para representar un token consistente en ese carácter en particular.
Sintaxis de las reglas gramaticales (producciones)

9. 9
Declaraciones en Bison
La sección de declaraciones de Bison de una gramática de Bison define los símbolos utilizados en la
formulación de la gramática y los tipos de datos de los valores semánticos. Todos los nombres de
tokens (pero no los tokens de carácter literal simple tal como ‘+’ y ‘*’) se deben declarar. Los
símbolos no terminales deben ser declarados si necesita especificar el tipo de dato a utilizar para
los valores semánticos.
La primera regla en el fichero también especifica el símbolo inicial, por defecto. Si desea que otro
símbolo sea el símbolo de arranque, lo debe declarar explícitamente.
Precedencia de operadores

10. 10
Funcionamiento del analizador
El fuente de Bison se convierte en una función en C llamada yyparse. Aquí describimos las
convenciones de interfaz de yyparse y las otras funciones que éste necesita usar. Tenga en cuenta
que el analizador utiliza muchos identificadores en C comenzando con ‘yy’ e ‘YY’ para propósito
interno.
Si utiliza tales identificadores (a parte de aquellos descritos en el manual) en una acción o en código
C adicional en el archivo de la gramática, es probable que se encuentre con problemas.
2 ejemplos de la creación de un compilador utilizando Flex y Bison.

11. 11
Ejemplo 1:

12. 12

13. 13

14. 14

15. 15

16. 16

17. 17
Ejemplo 2:
Ante la siguiente entrada
a =12+2*cos(3.14) ;
La salida debe ser:
El valor del identificador a es 10.LABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11
Fichero léxico_solo.l
%{
/* Ejemplo para una pequeña calculadora que permite trabajar con numeros enteros y reales con
las operaciones básicas de suma, resta, producto, division y trigonometricas como el seno y el
coseno */
#include <stdio.h>
#include <stdlib.h>
int nlines=0;
%}

18. 18
DIGITO [0-9]
ID [a-zA-Z][a-zA-Z0-9_]*
%%
{DIGITO}+ {printf("Encontrado TKN_NUM_ENTERO: %d",atoi(yytext));}
{DIGITO}+"."{DIGITO}+ {printf("Encontrado TKN_NUM_REAL: %f",atof(yytext));}
"=" {printf("Encontrado TKN_ASIGN: %s",yytext);}
";" {printf("Encontrado TKN_PTOCOMA: %s",yytext);}
"*" {printf("Encontrado TKN_MULT: %s",yytext);}
"/" {printf("Encontrado TKN_DIV: %s",yytext);}
"+" {printf("Encontrado TKN_MAS: %s",yytext);}
"-" {printf("Encontrado TKN_MENOS: %s",yytext);}
"(" {printf("Encontrado TKN_PAA: %s",yytext);}
")" {printf("Encontrado TKN_PAC: %s",yytext);}
"cos" {printf("Encontrado TKN_COS: %s",yytext);}
"sen" {printf("Encontrado TKN_SEN: %s",yytext);}
{ID} {printf("Encontrado TKN_ID: %s",yytext);}
"n" {nlines++;}
.LABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11
%% void main(int argc,char **argv)
{
if (argc>1)
yyin=fopen(argv[1],"rt");

19. 19
else
yyin=stdin;
yylex();
printf("nNumero lineas analizadas: %dn", nlines);
}
/* para compilar
flex lexico.l
cc lex.yy.c -o milex -lfl -lm
*/LABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11
Fichero léxico.l (versión a enlazar con Bison)
%{
/* Ejemplo para una pequeña calculadora que permite trabajar
con las operaciones básicas de suma, resta, producto, division y
trigonometricas como el seno y el coseno */
#include <stdio.h>
#include <stdlib.h>
#include "sintactico.tab.h"
int nlines=0;
%}
DIGITO [0-9]

20. 20
ID [a-zA-Z][a-zA-Z0-9_]*
%%
{DIGITO}+("."{DIGITO}+)? {//printf("Encontrado TKN_NUM: %fn",atof(yytext));
yylval.real=atof(yytext);
return(TKN_NUM);}
"=" {//printf("Encontrado TKN_ASIGN: %sn",yytext);
return(TKN_ASIGN);}
";" {//printf("Encontrado TKN_PTOCOMA: %sn",yytext);
Steven Tabango PUCESI
return(TKN_PTOCOMA);}
"*" {//printf("Encontrado TKN_MULT: %sn",yytext);
return(TKN_MULT);}
"/" {//printf("Encontrado TKN_DIV: %sn",yytext);
return(TKN_DIV);}
"+" {//printf("Encontrado TKN_MAS: %sn",yytext);
return(TKN_MAS);}
"-" {//printf("Encontrado TKN_MENOS: %sn",yytext);LABORATORIO DE PROCESADORES DE
LENGUAJE CURSO 2010-11
return(TKN_MENOS);}
"(" {//printf("Encontrado TKN_PAA: %sn",yytext);
return(TKN_PAA);}
")" {//printf("Encontrado TKN_PAC: %sn",yytext);

21. 21
return(TKN_PAC);}
"cos" {//printf("Encontrado TKN_COS: %sn",yytext);
return(TKN_COS);}
"sen" {//printf("Encontrado TKN_SEN: %sn",yytext);
return(TKN_SEN);}
{ID} {//printf("Encontrado TKN_ID: %sn",yytext);
return(TKN_ID);}
"n" {nlines++;}
.
%%
/********
Para el lexico solo
void main(int argc,char **argv)
{
if (argc>1)
yyin=fopen(argv[1],"rt");
else
yyin=stdin;
yylex();
printf("nNumero lineas analizadas: %dn", nlines);
}

22. 22
*******/
/* para compilar
flex lexico.l
cc lex.yy.c -o milex -lfl -lm
*/LABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11
Fichero sintactico.y (Bison)
%{
/* Ejemplo para una pequeña calculadora que permite trabajar
con numeros enteros y reales con las operaciones básicas de
suma, resta, producto, division y trigonometricas como el seno y el coseno */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
extern int yylex(void);
extern char *yytext;
extern int nlines;
extern FILE *yyin;
void yyerror(char *s);
%}

23. 23
%union
{
float real;
}
%start Calculadora
%token <real> TKN_NUM
%token TKN_ASIGN
%token TKN_PTOCOMA
%token TKN_MULT
%token TKN_DIV
%token TKN_MAS
%token TKN_MENOS
%token TKN_PAA
%token TKN_PACLABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11

24. 24
%token TKN_COS
%token TKN_SEN
%token <real> TKN_ID
%type Calculadora
%type <real> Expresion
%left TKN_MAS TKN_MENOS
%left TKN_MULT TKN_DIV
%%
Calculadora : TKN_ID { printf("El valor de %s es: ", yytext);}
TKN_ASIGN Expresion TKN_PTOCOMA { printf("%5.2fn", $4); } ;
Expresion : TKN_NUM {$$=$1;}|
Expresion TKN_MAS Expresion {$$=$1+$3;}|
Expresion TKN_MENOS Expresion {$$=$1-$3;}|
Expresion TKN_MULT Expresion {$$=$1*$3;}|
Expresion TKN_DIV Expresion {$$=$1/$3;} |
TKN_PAA Expresion TKN_PAC {$$=$2;}|
TKN_COS TKN_PAA Expresion TKN_PAC {$$=cos($3);}|
TKN_SEN TKN_PAA Expresion TKN_PAC {$$=sin($3);};
%%

25. 25
void yyerror(char *s)
{
printf("Error %s",s);
}
int main(int argc,char **argv)
{
if (argc>1)
yyin=fopen(argv[1],"rt");LABORATORIO DE PROCESADORES DE LENGUAJE CURSO 2010-11
else
yyin=stdin;
Steven Tabango PUCESI
yyparse();
printf("FIN del Analisis. Entrada CORRECTAn");
printf("Numero lineas analizadas: %dn", nlines);
return 0;
}
/* para compilar
bison -d sintactico.y

26. 26
flex lexico.l
cc lex.yy.c sintactico.tab.c -o analizador -lfl -lm
*/