Tecnológico de Estudios Superiores de Ecatepec

División de Ingeniería en Sistemas Computacionales

LENGUAJES Y AUTÓMATAS I
Profesor: Stein Carrillo Juan Manuel

TAREA 2: MANUAL DE FLEX

Bello Pérez Ximena
Grupo: 5503
26 de junio de 2021.
CONTENIDO
INTRODUCCIÓN.............................................................................................................................3
DESARROLLO.................................................................................................................................4
VISUAL STUDIO CODE..............................................................................................................4
MINGW.........................................................................................................................................7
FLEX...........................................................................................................................................11
COMPROBACIÓN DE INSTALACIÓN COMPLETA CON VISUAL STUDIO CODE..........16
Programa 1..............................................................................................................................16
Programa 2..............................................................................................................................19
CONCLUSIONES...........................................................................................................................22
BIBLIOGRAFÍA..............................................................................................................................22
INTRODUCCIÓN
El Análisis Léxico es la primera fase de un compilador y consiste en un programa
que recibe como entrada el código fuente de otro programa (secuencia de
caracteres) y produce una salida compuesta de tokens (componentes léxicos) o
símbolos. Su principal función consiste en leer los caracteres de entrada y
elaborar como salida una secuencia de componentes léxicos que utiliza el
analizador sintáctico para hacer el análisis
DESARROLLO
VISUAL STUDIO CODE
Para iniciar este manual, es de suma importancia que iniciemos haciendo la
instalación de Visual Studio Code que utilizaremos más adelante, posteriormente
haremos la instalación de los demás elementos que necesitamos para poder
iniciar a programar.
1. Primero, entramos al siguiente link para poder descargar el ejecutable de
Visual Studio y posteriormente dar inicio a la instalación:
https://code.visualstudio.com/docs/?dv=win64

2. Ya que tenemos descargado el software damos clic en ejecutar, al iniciar la

instalación aceptaremos los términos, luego debemos de indicar la ruta de
destino del software, en este caso dejamos la ruta que nos da por default.
3. Continuando con la instalación seleccionaremos la carpeta de inicio, las
tareas adicionales que tendrá nuestro programa, y observaremos el listado
todo aquello que se instalará en nuestro equipo de cómputo, damos clic en
instalar, para que así inicie la instalación del programa.

4. Finalmente, ya que queda la instalación aparecerá la siguiente ventana y

por último damos clic en “Finalizar”.
5. La siguiente imagen nos muestra que el programa fue instalando
correctamente, y ahora sí ya tenemos la ventana principal de Visual Studio
Code, al iniciar debemos elegir con que tipo de diseño vamos a trabajar.
MINGW
Lo siguiente que haremos es, descargar e instalar MinGW, este compilador nos
permitirá implementar compiladores GCC, en entornos Windows, además permite
crear aplicaciones nativas, ejecutables y bibliotecas.
1. Primero, entramos al siguiente link para poder descargar el compilador y
posteriormente dar inicio a la instalación:
https://osdn.net/projects/mingw/downloads/68260/mingw-get-setup.exe/

2. Una vez descargado, damos clic en ejecutar, en la primera ventana

aparecerá la licencia y daremos clic en Instalar, elegimos la ruta donde
estará el programa, damos clic a Continuar.
3. La siguiente ventana, iniciará la instalación del programa, una vez que
termine damos clic en Continuar, y posteriormente aparecerá una ventana,
donde podremos ver todos los paquete que podemos instalar.

4. Elegiremos los paquetes que queremos descargar, en este caso será los
que tiene la descripción de “Basic MinGW” y “GNU C++ Compiler”,
elegiremos dando en clic en “Mark for Installation”, en la pestaña de
Instalación daremos clic en “Apply Changes”
5. En la ventana que nos aparece, damos clic en “Apply”, y así ya podrá iniciar
la instalación de los paquetes que hemos seleccionado, y una vez que
termine la instalación podremos dar clic en “Close”, y por último ya
podemos cerrar la ventana de instalación.
6. Una vez terminada la instalación, corroboraremos que la instalación fue la
correcta, nos dirigiremos al explorador de Windows y nos ubicaremos hasta
la carpeta de “bin” y copiaremos la ruta, después abriremos la consola.
7. En la consola, pegaremos la ruta que copiamos C:\MinGW\bin, una vez
dentro de la ruta, usaremos los comandos gcc --version y g++ --version,
si la consola nos responde dando las versiones que solicitamos, quiere
decir que todo fue instalado correctamente.
FLEX
Por último, lo que haremos será instalar a Flex, que es un programa de que nos
ayudará a generar analizadores léxicos.
1. Primero, entramos al siguiente link para poder descargar el compilador y
posteriormente dar inicio a la instalación:
http://gnuwin32.sourceforge.net/packages/flex.htm

2. Ya descargado, procedemos a ejecutar el programa, nos saldrá la ventana

de bienvenida y le damos en siguiente y luego aceptamos los términos y
condiciones.
3. A continuación, elegimos la ruta de destino del programa, y los
componentes que utilizaremos, tareas adicionales y ahora si podemos dar
en iniciar la instalación dando clic en “Install”, finalizada la instalación
damos clic en “Finish”.
4. Después, nos ubicaremos en la consola dentro de la carpeta donde se
encuentran los archivos usando el siguiente comando cd C:\Program Files
(x86)\GnuWin32, ahora comprobaremos que se instalo adecuadamente
usando el comando flex --version, posteriormente agrageramos dos
librerías.

5. Para agregar las librerías, entraremos al Sistema y en configuraciones

avanzadas del sistema, entraremos a Variables de entorno y modificaremos
la variable “Path”.

6. A la variable que ya mencionamos, la seleccionamos y damos clic en

“Editar”, agregaremos una variable de entorno, ponemos la siguiente ruta
C:\MinGW\bin, una vez agregada damos clic en aceptar y ya podemos
cerrar las demás ventanas
7. A continuación, cerramos y abrimos la consola, y usamos los siguientes
comandos c++ --version y g++ --version, si nos responde y regresa lo
que solicitamos todo quedo instalado adecuadamente.

8. Finalmente, copiaremos la librería “libfl.a” de GnuWin32, a la caperta de

librerías de MinGW, y ahora sí una vez finalizado todo cerraremos ventanas
y reiniciaremos nuestro equipo.
COMPROBACIÓN DE INSTALACIÓN COMPLETA CON VISUAL STUDIO CODE
Para terminar, realizaremos unos programas, si corren adecuadamente, significará
que todas las instalaciones hechas, las modificaciones, las librerías agregadas y
demás fueron hechas con éxito.
Programa 1
1. Entramos a Visual Studio, y crearemos un nuevo archivo, tendrá por
nombre “prog1.l”
2. Al terminar, nos damos cuenta que nos aparece una ventana y la daremos
clic en “Search Marketplace”, nos mandará a una pestaña en donde
descargaremos la extensión “LEX FLEX YACC BISON”.
3. Lo siguiente será escribir el siguiente código, dentro del archivo que
previamente habíamos creado:

Explicación de código
%{  colocaremos nuestra llave principal
 int a=0;  declararemos un entero “a” en el cual tendrá un valor de
0
%}  cerraremos la llave principal

%%  pondremos un bloque (elemento de flex)

 [ ] a++;  pondremos los corchetes para que nos digan si habrá un
espacio, le pondremos un contador para que nos cuente si hay un
espacio
%%  cerraremos el bloque

int main(){  pondremos nuestro método principal

   yylex(); hará el conteo
   printf("\n cuantos espacios tenemos: %d ", a);  aquí nos
imprimirá el conteo de nuestros espacios
   return 0;  retornaremos nuestro programa
}  cerraremos la llave de nuestro método principal
4. Para poder entrar a la terminal del lado donde nos aparece el Explorador,
demos clic derecho sobre el archivo y elegimos la opción de “Open in
Integrated Terminal”, y nos abrirá la terminal en la parte de abajo.

5. Primero es necesario usar el comando flex prog1.l para crear el

programa y después usaremos el comando dir para checar que fue creado
el programa y el lex.yy.c.
 6. Por último, usaremos el comando gcc lex.yy.c -lfl, después dir para
corroborar que el ejecutable “ a.exe” fue creado, finalmente escribimos el
nombre del ejecutable y vemos que funcionó correctamente.

Programa 2
1. Primero iniciaremos este segundo programa, creando un archivo con
extensión “.txt”, que contendrá las siguientes palabras, este archivo será
utilizado para hacer el conteo de número de líneas y número de caracteres.

2. Para el siguiente programa debemos escribir el siguiente código, dentro del

archivo que previamente habíamos creado con el nombre de “prog2.l”.
%{
  int numLineas = 1, numCaracteres = 0;  Declaramos dos variables de
tipo entero iniciando numLineas en 1 para que el conteo de las líneas de
texto que coloquemos sea desde 1, la otra variable inicia en 0
%}
%%
\n ++numLineas;  colocamos contador del número de líneas
. ++numCaracteres;  colocamos Contador para el número de caracteres
%%
int main(){  iniciamos con el método main
    yyin= fopen("texto.txt", "r");  mandamos a llamar el archivo .txt
de donde se hará el conteo
    yylex();  se hace el análisis léxico
    printf("No de lineas = %d, No de caracteres = %d \n", numLineas, numC
aracteres);  imprime el total de no, de líneas y no. de caracteres
encontrados
    return 0;  retorna el programa
}

3. Usamos el comando flex prog2.l para crear el programa y después

usaremos el comando dir para checar que fue creado el programa y el
lex.yy.c.
4. Por último, usaremos el comando gcc lex.yy.c -lfl, después dir para
corroborar que el ejecutable “a.exe” fue creado, finalmente escribimos el
nombre del ejecutable y vemos que funcionó correctamente y nos regresa
el conteo del no. de líneas y el no. de caracteres que contiene el archivo.
CONCLUSIONES
Conforme hemos ido aprendiendo acerca de los analizadores léxicos sabemos
que estos nos dan la oportunidad de realizar la lectura de entrada de caracteres,
dándonos como resultado o devolviéndonos los valores léxicos que utiliza el
analizador sintáctico para hacer el análisis completo de aquellos caracteres o
cadena que hayamos ingresado previamente, claro esto dependerá del programa
que hayamos elaborado o de la acción que nosotros le hayamos determinado al
analizador léxico.
Personalmente, puedo decir que en un principio comprender en su totalidad la
definición me costaba trabajo pero ahora que hemos comenzado a hacer uso de
los analizadores léxicos me resulta más fácil comprender cuál es la función
principal de estos, además creo que gracias a que el profesor fue guiándonos
paso a paso sobre cómo instalar cada uno de los componentes de los cuales
haríamos uso para aprender a programar analizadores léxicos fue que logramos
comprender de qué manera utilizar el programa claramente conforme vayamos
avanzando iremos aprendiendo más sobre la estructura de Flex y de los
analizadores léxicos.

BIBLIOGRAFÍA
AHO, A. V. (2008). COMPILADORES. PRINCIPIOS, TÉCNICAS Y
HERRAMIENTAS. Segunda edición. México: PEARS ON EDUCACIÓN.