analisis lexico

1. Análisis Léxico: Esta fase se encarga de verificar si todas las cadenas pertenecen o no al lenguaje. Es
decir realiza un análisis símbolo por símbolo indicando el token por cada uno de los elementos
reconocidos o el error en caso de no reconocer. Este análisis no logra detectarmuchos errores por su
característica.
Análisis Sintáctico: En esta fase se analiza la estructura de las expresiones en base a gramáticas. Aquí
ya se puede determinar si una estructura por ejemplo una expresión matemática mal formada. El
análisis que se realiza es jerarquico es decir en base a arboles de derivación que se obtienen de las
mismas gramáticas.
Análisis Semántico: Este análisis es más difícil de formalizar, determina el tipo de los resultados
intermedios, comprobar que los argumentos que tienen un operador pertenecen al conjunto de
operadores posible, y si son compatibles entre si.
Configurando Bison en Windows
Como podemos leer en la wikipedia, 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 lexicos se pueden también obtener de
otras formas. En un post anterior mencioné la forma en que uno podía configurar
Flex para realizar analizadores léxicos. Bueno, en esta oportunidad vamos a
desarrollar una sencilla calculadora con Bison y Flex. Los pasos para configurar el
flex, nos dejan configurado al bison, listo para ser usado en nuestra calculadora.
Ahora, voy a pasar a explicar la forma que deben tener los scripts que ingresaremos
tanto a flex como a bison.
Para flex el script debe tener la siguiente estructura:
?
1
%{

2. 2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include "y.tab.h"
%}
%option noyywrap
%option yylineno
DIGITO [0-9]
ID [a-zA-Z][a-zA-Z0-9_]*
%%
{DIGITO}+("."{DIGITO}+)? {yylval.real=atof(yytext); return(TKN_NUM);}
"=" {return(TKN_ASIGN);}
";" {return(TKN_PTOCOMA);}
"*" {return(TKN_MULT);}
"/" {return(TKN_DIV);}
"+" {return(TKN_MAS);}
"-" {return(TKN_MENOS);}
{ID} {return(TKN_ID);}
%%
Como nos podemos dar cuenta, en este fichero declaramos los símbolos y las
expresiones que forman a los token numero (TKN_NUM). Asumo que ya tienen
conocimiento de cada una de las partes de un archivo de flex, así que ahora paso
a mostrar la forma que debe tener el archivo que le ingresaremos a Bison:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
%{
#include <stdio.h>
#include <math.h>
extern int yylex(void);
extern char *yytext;
void yyerror (char *s);
%}
%union
{
float real;
}
%start Calculadora
%token <real> TKN_NUM
%token TKN_ASIGN
%token TKN_PTOCOMA

3. 18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
%token TKN_MULT
%token TKN_DIV
%token TKN_MAS
%token TKN_MENOS
%token <real> TKN_ID
%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.2f", $4);};
Expresion : TKN_NUM{$$=$1;}|
Expresion Expresion TKN_MAS {$$=$1+$2;}|
Expresion Expresion TKN_MENOS {$$=$1-$2;}|
Expresion Expresion TKN_MULT {$$=$1*$2;}|
Expresion Expresion TKN_DIV {$$=$1/$2;};
%%
void yyerror(char *s)
{
printf("Error %s", s);
}
int main()
{
yyparse();
return 0;
}
Tampoco voy a explicar la estructura de este fichero puesto que la documentación
en internet es muy variada. Lo que si voy a detallar es la forma de obtener los
ficheros *.c y *.h, puesto que, a mi parecer, es lo más confuso y poco explicado.
Como mencioné anteriormente, al configurar el flex siguiendo los pasos que
expliqué en el post anterior el Bison quedará configurado también. Así que solo hay
que realizar los siguientes comandos por consola y tendremos todo listo para
integrarlo a nuestro proyecto de Dev-C++.

4. Situamos ambos ficheros en el directorio D:calculadora(Si no existe, tenemos que
crearlo, lógicamente) y luego abrimos una consola de Windows, hacemos lo mismo
que hicimos con el Flex, estableciendo las variables de entorno, como muestro en
la siguiente imagen:
Y con esos comandos se nos generará unos ficheros, los cuales automáticamente
podemos integrarlo a un proyecto de Dev-C++ por ejemplo o agregarle más
funciones.
Ahora ya tenemos lista nuestra sencilla calculadora escrita con ayuda de Bison y
Flex. Solo debemos ejecutar Calculadora.exe e ir introduciendo algunas
expresiones (En notación polaca claro)
?
1
2
3
a=4 5+;
hola=8 12*;
g=12 6/;
Aquí les dejo la carpeta del proyecto con los archivos tanto de flex como de bison.
También les muestro la forma de correr el programa de la calculadora en la siguiente
imagen: