1

Funcionamiento de aplicación realizada

en Lex y Yacc
Bryan Flores, Billy Proaño. Marlon Pachacama
Compiladores y lenguajes.
Escuela Politécnica Nacional
bryan.flores04@epn.edu.ec , flaco_@hotmail.com.ar,
pmarlonisrael@hotmail.com

 YACC significa "Yet Another Compiler Compiler". Esto se

Resumen- Este documento presenta la explicación de como es debe a que este tipo de análisis de archivos de texto
el funcionamiento de la aplicación de “Suma de Matrices 2*2” normalmente se asocia con la escritura de compiladores.
permitiéndole al usuario ingresar datos del ‘1-9’ siguiendo la o
las reglas que se encuentran en el matriz.l en FLEX, después
pasa a matriz.y donde se realizara la declaración de variable, Bison: es un generador de analizador de propósito
token y types, a demás de realizar la función sumamatriz general que convierte una gramática libre de
donde se procesara los datos ingresados y se mostrara en
pantalla las matrices ingresadas y el resultado de la suma, para contexto anotada en un analizador LR determinista
este fin primero aclararemos que son y como funcionan los o LR generalizado (GLR) que emplea tablas de
programas que utilizamos para realizar la aplicación. analizador LALR (1). Como característica
experimental, Bison también puede generar tablas
1. INTRODUCCIÓN de analizador IELR (1) o LR (1) canónicas. Una vez
que domine Bison, puede usarlo para desarrollar
Esta plantilla puede encontrarse a detalle lo que es el una amplia gama de analizadores de lenguaje, desde
funcionamiento de una aplicación de sumas de matrices de los que se usan en calculadoras de escritorio simples
2*2 con términos permitidos a ingresar del ‘1-9’realizado en hasta los lenguajes de programación complejos.
Lex y Yacc que son programas para realización de
analizadores léxicos, con especificaciones mediante
expresiones regulares, y están distribuidos bajo la licencia 2.1 PROCEDIMIENTO PARA LA APLICACION DE
GPL(General Public Licence). SUMAS DE MATRICES 2*2
2. MARCO TEÓRICO
FLEX
1. Se crea las expresiones regulares del
Lex: El programa lex genera analizadores l´exicos a partir de
una especificaci´on de los componentes l´exicos en t´erminos programa.
de expresiones regulares (en el estilo de UNIX); lex toma 2. Se define las reglas para las cadenas de
como entrada un fichero (con la extensi´on .l) y produce un
fichero en C (llamado “lex.yy.c”) que contiene el analizador entrada.
l´exico. El fichero de entrada tiene tres partes (ver los 3. Asignamos lo que deseamos que
ejemplos al final de este documento).
devuelva la aplicación
Yacc: se conoce oficialmente como un "analizador". /*****************
Su trabajo es analizar la estructura del flujo de entrada y Definiciones
operar la "imagen general". Se colocan las cabeceras, variables y expresiones regulares
En el curso de su trabajo normal, el analizador también ********************/
verifica que la entrada sea sintácticamente correcta. %{
Considere nuevamente el ejemplo de un compilador de C En #include "matriz.tab.h"
el lenguaje C, una palabra puede ser un nombre de función o #include<stdlib.h>
una variable, dependiendo de si va seguida de una (o #include <stdio.h>
una = Debe haber exactamente una }para cada uno { en el int yylex ();
programa. int linea=0;
%}
%option noyywrap
 2

DIGITO [0-9] #include <stdlib.h>

NUMERO {DIGITO}+ #include <math.h>
IGNORA [" "|\t]
void yyerror(char*msg);
%% void sumaMatrix(int matriz1[2][2],int matriz2[2][2]);
{NUMERO} {yylval.entero=atoi(yytext); return(NUMERO);}
"ajuntar" {return (SUMAR);} extern char *yytext;
"(" {return (PAA); } extern int linea;
")" {return (PAC); } extern FILE *yyin;
"{" {return (LLAVEABIERTA); } extern int yylex(void);
"}" {return (LLAVECERRADA); } int matriz1[2][2];
"," {return (COMA); } int matriz2[2][2];
":" {return (DOSPUNTOS); }
"fin" {return (FINAL);} %}
"/n" {linea++;} %union
" " {} {
[a-zA-Z]+ {return LETRA;} int entero;
[\t\r\f\n] {} }
.{ %token <entero> NUMERO
printf("Error lexico en linea %d",linea); %token SUMAR
getche(); %token RESTAR
} %token PAA
%% %token PAC
BISON %token LLAVEABIERTA
%token LLAVECERRADA
1. Se crea una función que se llama %token COMA
Suma matriz, que recibe de %token DOSPUNTOS
%token SEMI
parámetros las matrices que se van %token FINAL
a sumar. %token LETRA
2. Se declaran las matrices que se van %type <entero> D
a sumar, y se declara una variable %type <entero> DD
de tipo entero. %type <entero> DDD
%type <entero> DDDD
3. Se especifica de que tipo son los %type <entero> H
tokens. %type <entero> HH
%type <entero> HHH
4. Se especifica la regla para %type <entero> HHHH
introducir en el ejecutable.
%%
5. Captura los valores ingresados por Statement: EXPRESION;
el usuario. EXPRESION: SUMAR PAA MATRIX DOSPUNTOS
MATRIZ PAC FIANILAR;
6. Si lo que ingreso el usuario está
deacuerdo a la regla, se capturan FIANILAR : FINAL{
los datos de las dos matrices y sumaMatrix(matriz1, matriz2)
} | LETRA {
entran a la función sumamatriz, printf("\n La sentencia no es valida ");
caso contrario mostrara un mensaje }
diciendo que existe un error. MATRIX: VECTO VETOC;
VECTO : LLAVEABIERTA H COMA HH
7. Aquí la función sumamatriz, mustra LLAVECERRADA;
las matrices capturadas, mostrando VETOC : LLAVEABIERTA HHH COMA HHHH
una suma termino por termino, y LLAVECERRADA;
H:NUMERO{ matriz1[0][0]= $1;};
mostrando el resultado. HH:NUMERO{ matriz1[0][1]= $1;};
%{ HHH:NUMERO{ matriz1[1][0]= $1;};
#include <stdio.h> HHHH:NUMERO{matriz1[1][1]= $1; };
 3

MATRIZ:VECTOR VECTORE; }
VECTOR : LLAVEABIERTA D COMA DD printf("\n");
LLAVECERRADA; // {digito1,digito2} f++;
VECTORE : LLAVEABIERTA DDD COMA DDDD }
LLAVECERRADA; // // {digito3,digito4} }
D:NUMERO{ matriz2[0][0]= $1;};
DD:NUMERO{ matriz2[0][1]= $1;};
DDD:NUMERO{ matriz2[1][0]= $1;}; 2.2 EXTRACCIÓN DEL EJECUTABLE
DDDD:NUMERO{ matriz2[1][1]= $1;};  Primero compiladores el archive de
Flexx el matriz.l .
%%
void yyerror(char *s){  Esto nos genera un lexx.yy
printf("\n Esta sentencia no es valida: %s",s);
printf("\n Presione cualquiera tecla para salir...");
getche();
 Segundo compilamos matriz.y (bison)
}
int main(int argc,char **argv){  Esto nos general matriz.tab.c
if (argc>1)
yyin=fopen(argv[1],"rt");
else  Despues utilizaremos el comando
yyin=stdin; “matriz.tab.c -o matriz
yyparse();
return 0;
 Esto nos generara el ejecutable
}
void sumaMatrix(int matriz1[2][2],int matriz2[2][2]){ 
int f=0, g=0;
printf("\n\n:: SUMA ::\n");
while(f<2){ Fig 1: Ejecutable
g=0;
while(g<2){ 3. Conclusiones y Recomendaciones
printf("%d\t",matriz1[f][g]);
g++;
}
f++; 3.1. CONCLUSIONES
printf("\n");  El analizador l´exico que genera lex
} reconoce siempre la cadena m´as larga que
printf("---------\n");
coincida con una de las expresiones
f=0; g=0;
regulares, aunque un prefijo de esa cadena
sea reconocido por otras expresiones
while(f<2){ regulares.
g=0;  Las expresiones regulares deben aparecer al
while(g<2){
printf("%d\t",matriz2[f][g]);
principio de la l´ınea para ser reconocidas
g++; por lex; si aparecen m´as a la derecha lex
} pensar´a que son parte de las acciones.
f++;  En general, lex no comprueba que el
printf("\n"); c´odigo sea C, C++ o cualquier otro
}
printf("---------\n"); lenguaje; simplemente lo inserta en el lugar
que le corresponde en el analizador l´exico
f=0; g=0; que va a generar. Este analizador l´exico se
while(f<2){ construye a partir de un esqueleto que suele
g=0; estar escrito en C.
while(g<2){
printf("%d\t",matriz1[f][g]+matriz2[f][g]);  Yacc proporciona una herramienta general
g++; para describir la entrada a un programa de
 4

computadora. El usuario de Yacc especifica

las estructuras de su entrada, junto con el
código que se invocará a medida que se
reconozca cada una de esas
estructuras. Yacc convierte dicha
especificación en una subrutina que maneja
el proceso de entrada; con frecuencia, es
conveniente y apropiado tener la mayor
parte del flujo de control en la aplicación
del usuario manejada por esta subrutina.

RECOMENDACIONES
3.2.
 La sintaxis que ingresa el usuario debe ser
impecable, ya que de otro modo obtendrá un
error.
 Fijarse en la regla o las reglas que acepta la
aplicación.
 Tener en cuenta que el ejecutable se extrae
tras una serie de pasos y está escrito en c.

I. REFERENCIAS
Alicante, U. d. (2017). Hoja Tecnica Lex y Yacc. Alicante.
Johnson, S. C. (2011). Dinosaurio Compiler Tools. Obtenido
de http://dinosaur.compilertools.net/yacc/
LUV. (Junio de 2015). Obtenido de
https://luv.asn.au/overheads/lex_yacc/index.html
Unicen. (2017). Unicen. Obtenido de
http://www.exa.unicen.edu.ar/catedras/compila1/inde
x_archivos/Herramientas/Yacc.pdf