Herramientas Flex Bison

PONTIFICIA UNIVERSIDAD CATÓLICA DEL ECUADOR SEDE IBARRA
ESCUELA DE INGENIERÍA EN SISTEMAS
TALLER DE COMPILADORES
Nombre: Marcos Ruales
Fecha: 21/06/2017
UTILIZANDO LA HERRAMIENTA DE BÚSQUEDA DE LA WEB, INVESTIGAR LOS
SIGUIENTES TEMAS:
Herramientas para la construcción de procesadores de lenguaje.
Seguidamente mostraremos las herramientas disponibles que pueden
utilizarse para la realización de la Práctica de Procesadores de Lenguajes.
Estas herramientas funcionan bajo Windows, aunque se puede utilizar, si se
desea, cualquier otra herramienta.

Aplicación de los lenguajes:
Hoy en día los lenguajes de programación 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.
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:
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).
Que 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.
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.
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:
2 Ejemplos 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. */
{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 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)}
;
/* 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
(a
r
g
c
>
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

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/bas
h 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.

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:

EJEMPLO 2
Archivo para FLEX
?
1 %{
2 #include <stdio.h>
3 #include <conio.h> 4 #include
"parser.h"
%}
5 %option noyywrap
6 %option yylineno
7 letra [a-zA-Z]
8 digito [0binario [0-9]-1]
9 ignora " "|t|n
10operarit *|+|-|/
11operlog &|$
12 comparador <|>|<=|>=|==|!=
13%% {ignora }+ {;}
14"Entero" {printf("Palabra reservada para tipo de dato
15enteron");return PRENTERO;}
16"Real" {printf("Palabra reservada para tipo de dato 17
realn");return PRREAL;}
18"Booleano" {printf("Palabra reservada para tipo de dato
19booleanon");return PRBOOLEANO;}
20"Caracter" {printf("Palabra reservada para tipo de dato
21caractern");return PRCARACTER;}
22"Si" {printf("Palabra reservada para 23condicional
n");return PRSI;}
24"Sino" condicional n");return {printf("Palabra
reservada para otro PRSINO;}
25"SinoSi" {printf("Palabra reservada para definir
26condicionales secundariasn");return PRSINOSI;}

27"Entonces" {printf("Palabra reservada para definir
accion a
28realizarn");return PRENTONCES;}
29"FinSi" {printf("Palabra reservada finalizar
30condicionaln");return PRFINSI;}
31"Para" {printf("Palabra reservada para bucle de tipo
32Paran");return PRPARA;}
33"FinPara" {printf("Palabra reservada para fin de bucle
de
34tipo Paran");return PRFINPARA;}
35"Mientras" {printf("Palabra reservada para bucle de tipo
36Mientras n");return PRMIENTRAS;}
37"Hacer" empieza algo n");return {printf("Palabra
reservada para indicar que se PRHACER;}
38"FinMientras" {printf("Palabra reservada fin de bucle de
tipo
39Mientrasn");return PRFINMIENTRAS;}
40"FinHacerMientras" {printf("Palabra reservada para indicar
fin
41de bucle Hacer-Mientrasn");return PRFINHACERMIENTRAS;}
42"Funcion" {printf("Palabra reservada para declaracion
de
43funcionesn");return PRFUNCION;}
44"Estructura" {printf("Palabra reservada para declaracion
de
45estructurasn");return PRESTRUCTURA;}
46"FinFuncion" {printf("Palabra reservada para finalizar
47funcionn");return PRFINFUNCION;}
48"Retorna" {printf("Palabra reservada para retorno de
49funcionn");return PRRETORNA;}
50"SinValor" {printf("Palabra reservada para funcion sin
valor
51de retorno n");return PRSINVALOR;}
52"Definir" funciones n");return {printf("Palabra
reservada para definir PRDEFINIR;}

53"Constante" {printf("Palabra reservada para definir
54constantesn");return PRCONSTANTE;}
55"Entrada" {printf("Palabra reservada para definir
56entradasn");return PRENTRADA;}
57"Salida" {printf("Palabra reservada para definir
58salidasn");return PRSALIDA;}
59{letra}({letra}|{digito})* {printf("Identificadorn");return
60IDENT;} {letra}+ {printf("Caractern");return
CARACTER;}
61{binario}+ {printf("Binarion");return
BOOLEANO;}
62{digito}+ {printf("Enteron");return ENTERO;}
63{digito}+"."{digito}+ {printf("Realn");return REAL;}
64{comparador} {printf("Comparadorn");return
65COMPARADOR;}
66":=" {printf("Asignadorn");return ASIG;}
67";" {printf("Fin sentencian");return PCOMA;}
68"!=" {printf("Diferenten");return DIF;}
69"," {printf("Coman");return COMA;}
70"==" {printf("Igualn");return IGUAL;}
71"." {printf("Punton");return PTO;}
72">=" {printf("Signo mayor-igualn");return MAIGU;}
73"<=" {printf("Signo menor-igualn");return MEIGU;}
74"(" {printf("(n");return PARIZ;}
75")" {printf(")n");return PARDE;}
76">" {printf(">n");return MAYOR;}
77"<" {printf("<n");return MENOR;}
78"{" {printf("{n");return LLIZ;}
79"}" {printf("}n");return LLDE;}
80"+" {printf("+n");return MAS;} 81 "-"
{printf("-n");return MENOS;}
82 "*" {printf("*n");return POR;}
"/" {printf("/n");return ENTRE;}

"&" {printf("&n");return YLOG;}
"$" {printf("Operador Logicon");return OLOG;}
. {printf("ERROR LEXICO EN LINEA %d
n",yylineno);}
%%
int main(int argc,char *argv[])
{
if ((yyin = fopen(argv[1], "rt")) == NULL)
{ printf("nNo se puede abrir el archivo:
%sn", argv[1]);
}
e
l
s
e
{
//yylex();
yypar
se();
}
fclos
e(yyi
n);
return 0;
}
Arhcivo
parser.h
?
1 #ifndef YYSTYPE
2 #define YYSTYPE int
3 #endif#define PRENTERO 257
4 #define PRREAL 258 5
#define PRBOOLEANO 259
6 #define PRCARACTER 260
7 #define PRSI 261
8 #define PRSINO#define PRSINOSI 263 262
9 #define PRENTONCES 264
10#define PRFINSI 265
11#define PRPARA 266

12#define PRFINPARA 267
13#define PRMIENTRAS 268 #define PRHACER 269
14#define PRFINMIENTRAS 270
15#define PRFINHACERMIENTRAS 271 16 #define
PRFUNCION 272
17#define PRFINFUNCION #define PRRETORNA 274 273
18#define PRSINVALOR 275
19#define PRESTRUCTURA 276
20#define MAS 277
21 #define MENOS 278
22#define POR 279 #define ENTRE 280
23#define OLOG 281
24#define YLOG 282
25#define PRDEFINIR 283
26#define PRCONSTANTE 284 #define IDENT 285
27 #define ENTERO 286
28 #define REAL 287
29#define BOOLEANO 288
30#define CARACTER 289
31#define COMPARADOR 290 #define ASIG 291
32#define PCOMA 292
33#define DIF 293
34#define COMA 294
35#define IGUAL 295 #define PTO 296
36#define MAIGU 297
37#define MEIGU 298
38#define PARIZ 299
39 #define PARDE 300
40#define MAYOR 301 #define MENOR 302
41 #define LLIZ 303
42 #define LLDE 304
43 #define PRSALIDA 305

44#define PRENTRADA 306
45
46extern YYSTYPE yylval;
Archivo para Bison:
1 %{
2 int yystopparser=0;
3 %}
4
5
6 %token PRENTERO PRREAL PRBOOLEANO PRCARACTER PRSI PRSINO
PRSINOSI
7 PRENTONCES PRFINSI PRPARAPRFINPARA PRMIENTRAS PRHACER
PRFINMIENTRAS PRFINHACERMIENTRAS
8 PRFUNCION PRFINFUNCION PRRETORNA PRSINVALOR PRESTRUCTURA MAS
MENOS
9 POR ENTRE OLOG YLOG
10 PRDEFINIR PRCONSTANTE IDENT ENTERO REAL BOOLEANO CARACTER
11 COMPARADOR ASIG PCOMA DIF COMA IGUAL PTOMAIGU MEIGU PARIZ PARDE
MAYOR MENOR LLIZ LLDE PRSALIDA PRENTRADA
12 %start inicio
13 14 %%
15 inicio :
funcion 16 |
constante
17 | estructura;
18
19 estructura : PRESTRUCTURA IDENT LLIZ n

52 comparacion : IDENT COMPARADOR b
53 b | REAL: IDENT
54 | ENTERO
55 | BOOLEANO
56 ;
57
58 declaracion : PRENTERO c
59 | PRREAL c| PRBOOLEANO c
60 | PRCARACTER c
61 c : IDENT PCOMA
62 ;
63
64 asignaciona : IDENT PCOMA : IDENT ASIG a
65 | ENTERO PCOMA
66 | REAL PCOMA
67 | BOOLEANO PCOMA
68 | oparitmetica PCOMA
69 ;
70 mientras : PRMIENTRAS PARIZ x
71 x : comparacion y
72 | oplogica y
73 y : PARDE sentencia PRFINMIENTRAS
74 ;
75
76 hacermientras : PRHACER sentencia PRFINHACERMIENTRAS
PRMIENTRAS PARIZ cc
77 cc : comparacion PARDE
78 | oplogica PARDE
79 ;
80
81 parasentencia PRFINPARA : PRPARA PARIZ asignacion
comparacion PCOMA asignacion PARIZ
82 ;

Herramientas Flex Bison

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Herramientas Flex Bison

Similar a Herramientas Flex Bison (20)

Último

Último (20)

Herramientas Flex Bison