LyAII Evidencia3 TorresEsquivelHenry

Instituto Tecnológico Superior Progreso
Dirección General
Subdirección Académica
INSTITUTO TECNOLÓGICO
SUPERIOR PROGRESO
PROGRAMA ACADÉMICO DE INGENIERÍA EN
SISTEMAS COMPUTACIONALES
ASIGNATURA
Lenguajes y Autómatas II
DOCENTE
Dr. Holzen Atocha Martínez García
TRABAJO
Evidencia 3 – Reporte de práctica (Analizador
Léxico/Sintáctico con símbolos)
PRESENTA
Br. Henry Efrain Torres Esquivel (04190031)
Progreso Yucatán, 17 de 09 de 2022
Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Tel. 969 934 3023 Cel. 999 278 6219
tecnm.mx | progreso.tecnm.mx
Dirección General
Índice.
Contenido
Objetivo de la práctica ...................................................................................................... 4
Introducción. ..................................................................................................................... 4
Marco teórico. ................................................................................................................... 5
¿Qué es analizador léxico? ........................................................................................... 5
Funciones. ..................................................................................................................... 5
PLY............................................................................................................................... 5
Analizador sintáctico. ................................................................................................... 6
¿Cómo funciona el analizador sintáctico? .................................................................... 6
Equipo y tecnologías utilizadas. ....................................................................................... 6
Procedimientos. ................................................................................................................ 7
Procedimientos: Primer programa. ............................................................................... 7
Procedimientos: Segundo programa. .......................................................................... 12
Pruebas y resultados. ...................................................................................................... 24
Resultado del funcionamiento: Primer programa. ...................................................... 24
Resultado del funcionamiento: Segundo programa. ................................................... 26
Conclusiones................................................................................................................... 30
Referencias. .................................................................................................................... 31

Tel. 969 934 3023 Cel. 999 278 6219
Dirección General
Evidencia 3 – Reporte de práctica (Analizador Léxico/Sintáctico con símbolos).
Instrucciones: Elabora el reporte de las actividades ejemplo de Lex/Yacc, que se

describieron en clase. El reporte debe contener:
a) Portada.
b) Objetivo de la práctica: Aplica herramientas computacionales para generar

símbolos y tokens que deriven en salidas congruentes durante las etapas de
análisis léxico y sintáctico del proceso de traducción computacional.
c) INTRODUCCIÓN. Aquí se presenta una descripción breve de lo que fue el

trabajo de forma tal que nos permita conocer a grandes rasgos en qué consistió
este y qué es lo que se presenta en el reporte.
d) Marco Teórico: Explica brevemente (2 a 3 cuartillas) los temas abordados.
e) Material y equipo: Lo que utilizaste para el trabajo (equipo de cómputo con X

memoria ram, Y de almacenamiento, software sublime text versión 3 como IDE,
lenguaje java, python, etc).
f) Procedimiento: Los pasos desglosados y detallados de lo que se realizó. Incluye

Figuras explicadas en el texto. (mínimo 4 cuartillas).
g) Resultados: Es la parte más importante (I) pues aquí se demuestra lo que el

estudiante comprendió y experimentó del trabajo. Una mala explicación indica
una mala comprensión, y, por tanto, una mala nota. Incluye Figuras explicadas
en el texto. (mínimo 3 cuartillas).
h) Conclusiones: Es la parte más importante (II) pues aquí se demuestra lo que el

estudiante comprendió y experimentó del trabajo. Una mala explicación indica
una mala comprensión, y, por tanto, una mala nota. Incluye Figuras explicadas
en el texto. (mínimo 1 cuartilla).
i) Referencias (material utilizado para el marco teórico y la comprensión del tema).
Subirlo en FORMATO PDF

Tel. 969 934 3023 Cel. 999 278 6219 3
Dirección General
Objetivo de la práctica:
Aplica herramientas computacionales para generar símbolos y tokens que deriven en

salidas congruentes durante las etapas de análisis léxico y sintáctico del proceso de
traducción computacional.
Introducción.
Un analizador léxico es un programa, el cual cumple diferentes funciones
específicamente, reconocer un lenguaje, con sus caracteres de entrada, donde se encuentra
la cadena a analizar, reconocer sub – cadenas que correspondan a símbolos del lenguaje
y retornar los tokens correspondientes y sus atributos. Pero escribir analizadores léxicos
eficientes “amano” puede resultar una tarea tediosa y complicada, y para evitarla se han
creado herramientas de software, como lo ha implementado Python con su librería de
PLY.
Los generadores de analizadores léxicos que generan automáticamente un analizador

léxico a partir de una especificación provista por el usuario, pero también se puede
realizar mediante programación desde un determinado lenguaje.
En el presente trabajo se explicará sobre la construcción de un programa de ejemplo

realizado por un desarrollador de Python, con la finalidad de entender de mejor manera
el análisis léxico y sintáctico, para ello se empezará explicando desde las librerías
utilizadas, así como el objetivo que tiene cada función utilizada.
Por otra parte, este trabajo tiene el objetivo de dar a conocer la lógica y funcionamiento
de un analizador léxico y sintáctico, además de permitir a nosotros, como alumnos,
entender mejor este tema, y de este modo adquirir la idea de la implementación de un
programa que ayude en su solución.
Se explicarán dos programas, el primero consiste en realizar un intérprete que recibe

como entrada varias expresiones aritméticas y presentando como salida el resultado de
dichas expresiones.
El segundo programa, se desarrollará un intérprete que recibe como entrada un archivo

de texto que contiene varias sentencias de un lenguaje de programación que fue diseñado
especialmente para esta aplicación. Primero se hace análisis léxico y sintáctico de dicha
entrada, durante el análisis sintáctico se carga en memoria un Árbol de Sintaxis Abstracta
(AST) que se utiliza posteriormente para ejecutar las sentencias. El analizador se genera
con PLY utilizando Python 3.
A continuación, se presenta el reporte de manera específica, detallando cada apartado

solicitado.

Tel. 969 934 3023 Cel. 999 278 6219 4
Dirección General
Marco teórico.
¿Qué es analizador léxico?
El analizador léxico. Se encarga de buscar los componentes léxicos o palabras que

componen el programa fuente, según unas reglas o patrones. La entrada del analizador
léxico podemos definirla como una secuencia de caracteres.
Imagen 1. Representación gráfica de un analizador léxico.
Funciones.
El analizador léxico es la primera fase de un compilador. 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. Esta interacción, suele
aplicarse convirtiendo al analizador léxico en una subrutina o corrutina del analizador
sintáctico. Recibida la orden “Dame el siguiente componente léxico” del analizador
sintáctico, el analizador léxico lee los caracteres de entrada hasta que pueda identificar el
siguiente componente léxico.
PLY.
PLY es una implementación en Python de lex y yacc, herramientas populares para la

construcción de compiladores.
La principal tarea de un analizador léxico es leer los caracteres de entrada del programa
fuente, agruparlos en lexemas y producir como salida una secuencia de tokens.
• Un token es un par que consiste en un nombre de token y un valor de atributo

opcional.
• Un lexema es una secuencia de caracteres en el programa fuente, que coinciden
con el patrón para un token y que el analizador léxico identifica como una
instancia de este token.
• Un patrón es una descripción de la forma que pueden tomar los lexemas de un
token.

Tel. 969 934 3023 Cel. 999 278 6219 5
Dirección General
El analizador sintáctico obtiene una cadena de tokens del analizador léxico y verifica que
dicha cadena pueda generarse con la gramática para el lenguaje fuente. Una gramática
proporciona una especificación precisa y fácil de entender de un lenguaje de
programación.
En PLY se definen los patrones de los diferentes tokens que se desean reconocer, esto se
hace a través de expresiones regulares. Mientras que las producciones y acciones para
formar la gramática se definen a través de funciones.
Analizador sintáctico.
Es un programa que normalmente es parte de un compilador. El compilador se asegura

de que el código se traduce correctamente a un lenguaje ejecutable. La tarea del analizador
es, en este caso, la descomposición y transformación de las entradas en un formato
utilizable para su posterior procesamiento. Se analiza una cadena de instrucciones en un
lenguaje de programación y luego se descompone en sus componentes individuales.
¿Cómo funciona el analizador sintáctico?
Analiza una cadena de símbolos de acuerdo a las reglas de una gramática formal. El
análisis sintáctico convierte el texto de entrada en otras estructuras (comúnmente árboles),
que son más útiles para el posterior análisis y capturan la jerarquía implícita de la entrada.
Un analizador léxico crea tokens de una secuencia de caracteres de entrada y son estos
tokens los que son procesados por el analizador sintáctico para construir la estructura de
datos, por ejemplo, un árbol de análisis o árboles de sintaxis abstracta.
Imagen 2. Representación gráfica de un analizador léxico y sintáctico.
Equipo y tecnologías utilizadas.
• Nombre del dispositivo: Henry.

• Procesador: Intel (R) Core (TM) i7-7500U CPU @ 2.70GHz 2.90 GHz.
• RAM instalada: 16,0 GB.
• Tipo de sistema: Sistema operativo de 64 bits, procesador x64.
• Entorno de programación: Visual Studio Code.
• Lenguaje de programación: Python 3, extensión: PLY.

Tel. 969 934 3023 Cel. 999 278 6219 6
Dirección General
Procedimientos.
Procedimientos: Primer programa.
En el primer programa, se desarrollará un intérprete que recibe como entrada varias

expresiones aritméticas y presentando como salida el resultado de dichas expresiones.
Para el correcto funcionamiento del programa, se requieren de algunas tecnologías

obligatorias que se deberán tener en el ordenador. Las tecnologías a utilizar son:
• PLY: Generador de analizadores léxicos y sintácticos.

• Python 3: Es un lenguaje de programación interpretado de alto nivel.
• Visual Studio Code: Es un editor de código ligero pero poderoso. Existen
complementos para trabajar con este lenguaje.
Explicación del código fuente para el analizador léxico.
Lo primero que debemos hacer es definir el listado de tokens que vamos a reconocer ya
asignarlo a la variable tokens.
El primer paso para el desarrollo del programa, es definir el listado de tokens que servirán
para reconocer las operaciones que se utilizarán. Se asignará a la variable: “tokens”.
Imagen 3. Asignación de los tokens para utilizar en el programa.
Seguidamente, se asignaron los patrones que tendrán los tokens que se definieron. Existen
dos formas de definir las reglas para los tokens.
La primera, es con expresiones regulares, se agrega el prefijo: “t_” al token que queremos
definir y luego le especificamos la expresión regular, para esto se hace uso del módulo:
“re” de Python.
Imagen 4. Asignación de patrones de los tokens definidos.

Tel. 969 934 3023 Cel. 999 278 6219 7
Dirección General
La otra forma es a través de funciones, esto nos sirve para manipular el valor del token
que procesamos. Por ejemplo, para los valores numéricos los retornamos con el tipo
apropiado, hacer sus validaciones, etc.
Imagen 5. Asignación de patrones de los tokens definidos a través de funciones.
De igual manera, es importante definir también los caracteres que se van a ignorar.
Imagen 6. Definición de caracteres a ignorar.
Las funciones también llevan el prefijo: “t_” antes del nombre del token que queremos
procesar. La función recibe un parámetro, “t” en nuestro ejemplo, este contiene el valor
del token. Retornamos el valor ya procesado que deseamos, o no retornar nada si lo que
deseamos es ignorar el token (por ejemplo: comentarios, contadores, etc.).
Imagen 7. Funciones con retorno de acuerdo al valor procesado.
Finalmente, es turno de construir el analizador léxico haciendo uso de las librerías de

PLY.
Imagen 8. Construcción del analizador léxico a través de las librerías de PLY.

Tel. 969 934 3023 Cel. 999 278 6219 8
Dirección General
Explicación del código fuente para el analizador sintáctico.
Otra de las ventajas de Python es que en el mismo archivo podemos definir nuestro
análisis sintáctico haciendo uso de los tokens previamente definidos en la sección del
analizador léxico.
Primeramente, definimos la asociatividad y precedencia de los operadores, ya que la

gramática escrita es ambigua, es necesario definir una precedencia para que el analizador
no entre en conflicto al analizar, en este caso, la precedencia es la misma que la de los
operadores aritméticos, la precedencia más baja la tienen la suma y la resta, luego están
la multiplicación y la división que tienen una precedencia más alta, y, por último, está el
signo menos de las expresiones negativas que tendría la precedencia más alta.
Imagen 9. Asociación de operadores y precedencia.
Ahora, procedemos a escribir nuestras producciones, aquí vemos otra de las ventajas de
Python, las acciones semánticas de nuestras producciones se hacen en forma de funciones.
Las características de estas funciones son:
• El nombre inicia con el prefijo: “_p”. El complemento del nombre queda a nuestra
discreción.
• Tiene un único parámetro: “t”, el cual es una tupla, en cada posición tiene el valor
de los terminales y no terminales de la producción.
• Haciendo uso del docstring de las funciones de Python, especificamos las
producciones que serán procesadas por la función.
• En el cuerpo de la función definimos la funcionalidad que deseamos.
Ejemplo:
Imagen 10. Ejemplificación de expresiones a evaluar asignadas a una función.
En la imagen anterior, se sintetiza en p[0] (expresión) el valor del resultado de sumar los
valores de p[1] (expresión) y p[3] (expresión).

Tel. 969 934 3023 Cel. 999 278 6219 9
Dirección General
Para el programa en desarrollo, se utilizaron siete gramáticas. A continuación, el código

completo de las producciones trabajadas:
Imagen 11. Definición de las gramáticas utilizadas.
Por último, podemos manejar también las producciones de error para el manejo de errores
sintácticos. Como se logró visualizar en el último bloque de la imagen anterior.
Ahora, se construyó el analizador sintáctico, la funcionalidad para leer el archivo y

enviarle su contenido a nuestro compilador.
Imagen 12. Construcción y lectura del analizador sintáctico para envío de contenido al
compilador.

Tel. 969 934 3023 Cel. 999 278 6219 10
Dirección General
Creando un archivo de entrada para nuestro analizador.
Se creó un nuevo archivo de texto, utilizando nuestro editor, el archivo se nombró como:
“entrada.txt”. El contenido de este archivo es el siguiente:
Imagen 13. Estructura de contenido para compilar con el programa de operaciones

con el analizador léxico y sintáctico.
De esta manera, se finaliza la explicación del procedimiento para el primer programa,

únicamente restaría ejecutar y compilar el programa, específicamente el archivo:
“gramatica.py”.

Tel. 969 934 3023 Cel. 999 278 6219 11
Dirección General
Procedimientos: Segundo programa.
En el segundo programa, se desarrollará un intérprete que recibe como entrada un archivo

de texto que contiene varias sentencias de un lenguaje de programación diseñado
especialmente para esta aplicación. Primero se hace análisis léxico y sintáctico de dicha
entrada, durante el análisis sintáctico se carga en memoria un Árbol de Sintaxis Abstracta
(AST), que se utiliza posteriormente para ejecutar las sentencias. El analizador se genera
con PLY utilizando Python 3.
Para el correcto funcionamiento del programa, se requieren de algunas tecnologías

obligatorias que se deberán tener en el ordenador. Las tecnologías a utilizar son:
• PLY: Generador de analizadores léxicos y sintácticos.

• Python 3: Es un lenguaje de programación interpretado de alto nivel.
• Visual Studio Code: Es un editor de código ligero pero poderoso. Existen
complementos para trabajar con este lenguaje.
El lenguaje de entrada.
Dentro de la carpeta del proyecto, hay un archivo de entrada llamado: “entrada.txt”, en

el cual se muestran ejemplos de todas las funciones del lenguaje diseñado para esta
aplicación, al leerlo se puede tener una idea clara de las funciones con las que el lenguaje
cuenta, este archivo contiene lo siguiente:
Imagen 14. Ejemplo de explicación de lo que realiza cada función del programa.

Tel. 969 934 3023 Cel. 999 278 6219 12
Dirección General
Como se logró observar en la imagen anterior, el lenguaje acepta:
• Comentarios simples, es decir de una sola línea (//).
• Comentarios múltiples, es decir de más de una línea (/ /).
• Concatenación de cadenas mediante el operador &.
• Función Imprimir. Recibe como parámetro una cadena e imprime su valor en

consola.
• Declaración de variables. Únicamente se acepta definición de variables de

tipo número, incluyendo enteros y decimales.
• Asignación de variables. A cualquier variable se le puede asignar cualquier

expresión que tenga como resultado un número.
• Instrucción Mientras. Tiene el comportamiento clásico del ciclo while, ejecuta

el ciclo mientras la expresión booleana que recibe sea verdadera. Esta instrucción
soporta anidamiento.
• Instrucción If e If-Else. Tiene el comportamiento clásico de las sentencias de

selección If e If-Else, evalúa la expresión booleana y ejecuta el bloque de
instrucciones en If si es verdadera. En caso contrario y si existe un bloque Else,
se ejecuta este bloque de instrucciones. Estas instrucciones también soportan
anidamiento.
• Expresiones aritméticas. Se soportan las expresiones aritméticas binarias: suma,

resta, multiplicación y división. También la expresión unaria: negación.
Adicionalmente se soporta expresiones agrupadas en paréntesis. Se maneja la
precedencia habitual de las expresiones aritméticas.
• Expresiones booleanas. Comparan dos expresiones que tengan como resultado

un número y soportan únicamente los operados Mayor Que y Menor que (<, >).
El analizador léxico y sintáctico.
En el archivo: “gramatica.py”, se detalla la estructura del lenguaje utilizando PLY. A

continuación, se detallarán los aspectos más relevantes.

Tel. 969 934 3023 Cel. 999 278 6219 13
Dirección General
Sobre el analizador léxico.
El analizador léxico define los patrones para los tokens que deseamos reconocer.
Hacemos uso de expresiones regulares para identificar números, cadenas y comentarios.
Para esto hacemos uso del módulo: “re”, de Python (tiene relación con el primer programa
explicado en el apartado anterior).
Imagen 15. definición de los patrones para los tokens que se deseen reconocer.
Nótese que los comentarios, saltos de líneas y espacios en blanco son ignorados (no
retornan ningún valor).
Otro aspecto importante a destacar, es que las palabras reservadas son tratadas como:
“Identificadores”, esto se debe a que PLY da precedencia a las expresiones regulares
más generales. Por ejemplo, la palabra reservada: “Imprimir”, siempre hará match con
la expresión regular de Identificador, por lo que si se define de la forma: “t_IMPRIMIR
= r'imprimir'”, nunca será alcanzado. Esto lo hace con la finalidad de hacer el proceso
de parsing más eficiente al tener menos expresiones regulares que evaluar.

Tel. 969 934 3023 Cel. 999 278 6219 14
Dirección General
Sobre el analizador sintáctico.
El objetivo principal de nuestro analizador sintáctico es validar que la entrada sea válida
y, si lo es, construir el AST. Para lograr esto hacemos uso de la programación orientada
a objetos. Específicamente haremos uso del polimorfismo para la construcción de nuestro
árbol. Las clases utilizadas para construir las diferentes instrucciones que componen
nuestro AST, están definidas en el archivo: “instrucciones.py”.
Clases para Instrucciones.
Primero definimos una clase abstracta: “Instruccion”, esto nos permitirá abstraer las
Instrucciones que soporta nuestro lenguaje.
Imagen 16. Clase abstracta para instrucciones.
Seguidamente, definimos una clase concreta para cada una de las formas posibles que
puede tomar: “Instrucción”.
Imagen 17. Clases que puede tomar una instrucción.
Por ejemplo, para la clase: “Imprimir”, vemos que extiende de: “Instruccion”, y que su
única propiedad es la cadena que se va imprimir. Esta propiedad, cadena, es de tipo
“ExpresionCadena”, que se explicará más adelante.
De la misma forma, la instrucción: “Mientras”, extiende de: “Instruccion”, y sus

propiedades son la expresión lógica a evaluar y el set de instrucciones a ejecutar mientras
la condición sea verdadera. expLogica es de tipo ExpresionLogica e instrucciones es
una lista, y sus elementos son de tipo Instruccion.

Tel. 969 934 3023 Cel. 999 278 6219 15
Dirección General
El proceso es similar para las instrucciones de Definición y Asignación.
Imagen 18. Clases abstractas de instrucciones de definición y asignación.
Finalmente, completamos nuestras instrucciones con If e If-Else.
Imagen 19. Clases abstractas de instrucciones para condicionales.
Clases para expresiones.
De la misma manera que manejamos las instrucciones manejaremos las expresiones.

Definimos 3 clases abstractas que representan los 3 tipos de expresiones soportadas por
nuestro lenguaje: Expresiones Aritméticas, Expresiones con Cadenas y Expresiones
Lógicas, todas ellas definidas dentro del archivo: “expresiones.py”.

Tel. 969 934 3023 Cel. 999 278 6219 16
Dirección General
También, haremos uso de enumeraciones para definir constantes de nuestras operaciones,

esto es altamente recomendado para evitar bugs durante el desarrollo.
Imagen 20. Clases abstractas para operaciones aritméticas y lógicas.
Iniciamos definiendo nuestra clase: “ExpresionNumerica”, de tipo abstracta y será

nuestra clase base para las expresiones numéricas.
Imagen 21. Clase abstracta para expresiones numéricas.
Las formas que puede tomar nuestra clase: “ExpresionNumerica”, son las siguientes:
• ExpresionBinaria. Representa una operación aritmética binaria, la clase recibe los

2 operados: exp1 y exp2, ambos de tipos ExpresionNumérica. Y recibe
el operador el cual es un calor de nuestro enum definidos anteriormente.
• ExpresionNegativo. Representa la operación aritmética unaria de negación.

Únicamente recibe como parámetro la expresión que se negara, esta es también
de tipo ExpresionNumerica.
• ExpresionNumero. Representa un valor terminal numérico. El

parámetro val contiene el valor extraído por el analizador léxico.

Tel. 969 934 3023 Cel. 999 278 6219 17
Dirección General
• ExpresionIdentificador. Representa un identificador. El parámetro id representa

el nombre de la variable que se desea operar.
Imagen 22. Clases abstractas de tipos de expresiones que puede tomar una expresión
numérica.
Ahora, siguiendo el proceso anterior, definimos nuestras expresiones con cadenas.
de cadena.
Y, finalmente, definimos nuestras expresiones lógicas.
lógica.

Tel. 969 934 3023 Cel. 999 278 6219 18
Dirección General
Construcción del AST.
Para construir el AST durante el análisis sintáctico, se importaron las clases de

instrucciones y expresiones. Esto también incluye los enum para las constantes, esto se
hará en el archivo: “gramatica.py”.
Imagen 25. Importan las clases de expresiones e instrucciones abstractas creadas.
Una vez importados, podemos hacer uso de ellas en la gramática. Por ejemplo, para la
construcción de operaciones aritméticas hacemos uso de nuestras clases de tipo:
“ExpresionNumerica”, pasamos como parámetros los operandos y el tipo operación
(utilizando nuestras constantes).
Imagen 26. Pasando parámetros a las funciones abstractas para operaciones

aritméticas.
El proceso es el mismo para las Instrucciones, cada producción de tipo Instrucción

construye una instancia concreta de la instrucción apropiada.
Imagen 27. Pasando parámetros a las funciones abstractas para instrucciones.

Tel. 969 934 3023 Cel. 999 278 6219 19
Dirección General
Finalmente, una vez que hayamos reconocido toda la entrada, construimos un arreglo con
cada uno de los nodos. Este será nuestro AST.
Imagen 28. Construcción del arreglo de cada nodo.
La tabla de símbolos.
La tabla de símbolos es la que permite el almacenamiento y recuperación de los valores

de las variables. Para su implementación hacemos uso de una clase, ya que necesitaremos
más de una instancia de tabla de símbolos. Cada ámbito tiene acceso únicamente a su
propia tabla de símbolos y a la de los niveles superiores, la definición de esta clase puede
encontrarse en el: “archivo ts.py”.
Se definieron las constantes para los tipos de datos, en este ejemplo hace uso únicamente
del tipo de dato numérico.
Imagen 29. Definiendo las constantes para los tipos de datos.
A continuación, se define una clase para los Símbolos.
Imagen 30. Creación de una clase para los símbolos.

Tel. 969 934 3023 Cel. 999 278 6219 20
Dirección General
La clase: “TablaDeSimbolos”, define la estructura de una tabla de símbolos y sus

funciones para agregar, modificar y obtener símbolos.
Imagen 31. Creación de la clase para la tabla de símbolos.
Construcción del Intérprete.
La definición del Intérprete se encuentra en el archivo: “principal.py”. Para iniciar con

la implementación, primero se importa la gramática, las constantes y clases de nuestro
AST y la Tabla de Símbolos.
Imagen 32. Importando las clases pertinente para el correcto funcionamiento del
programa.
Seguidamente, obtenemos el AST a partir del archivo de entrada.
Imagen 33. Obtención del AST para compilar los resultados.
En la imagen anterior, podemos notar que el AST está contenido en la variable

instrucciones. La función principal del intérprete es de reconocer cada instrucción y
ejecutarla, para esto es necesario recorrer el AST; es por ello que se ha definido la función
procesar_instrucciones, la cual itera las instrucciones en un ámbito y las ejecuta.

Tel. 969 934 3023 Cel. 999 278 6219 21
Dirección General
Para iniciar con la ejecución, se crea la tabla de símbolos para el ámbito global y se invoca
la función procesar_instrucciones, con la raíz del AST y la tabla de símbolos del ámbito
global.
Imagen 34. Proceso de salida y entrada de instrucciones a través de un método.
Existe una función para procesar cada instrucción.
Las sentencias Mientras, If e If-Else crean nuevas tablas de símbolos antes de procesar
las instrucciones dentro de sus bloques de instrucciones. Estas nuevas tablas de símbolos
se inicializan con los valores de la tabla de símbolo actual y al terminar la ejecución de la
sentencia los valores son eliminados, ya que, la instancia se crea localmente en el cuerpo
de la función.
Imagen 35. Funciones correspondientes para cada instrucción.
Las sentencias de Declaración y Asignación agregan y modifican valores de la tabla de

símbolos. La sentencia Imprimir muestra el valor de una cadena en la consola.
Imagen 36. Funciones para declaración, asignación e impresión de valores.

Tel. 969 934 3023 Cel. 999 278 6219 22
Dirección General
Finalmente, todas las sentencias descritas anteriormente hacen uso de las operaciones
numéricas, con cadenas y lógicas las cuales hacen uso de la tabla de símbolos para obtener
valores de las variables.
Para las expresiones numéricas evaluamos el tipo de operación y con base en ellos
resolvemos el valor apropiado.
Imagen 37. Función para evaluar la expresión aritmética.
Para las expresiones con cadenas, también validamos el tipo de operación para verificar
si es necesario una operación de concatenación. En cualquier caso, se resuelve la cadena.
También es posible concatenar valores numéricos, para esto resolvemos la expresión
apoyándonos de la función para procesar expresiones numéricas.
Imagen 38. Función para evaluar la expresión de cadena.
Al igual que las expresiones con cadena, las expresiones lógicas también se apoyan en la
función que procesa expresiones numéricas para poder evaluar las condiciones booleanas.
Imagen 39. Función para evaluar la expresión lógica.
De esta manera, se finaliza la explicación del procedimiento para el segundo programa,

únicamente restaría ejecutar y compilar el programa, específicamente el archivo:
“principal.py”.

Tel. 969 934 3023 Cel. 999 278 6219 23
Dirección General
Pruebas y resultados.
Resultado del funcionamiento: Primer programa.
Ejecución.
Para ejecutar el programa, desde el editor de texto que esté utilizando, ejecutar
específicamente el archivo llamado: “gramatica.py”.
Una vez compilado el programa, procedemos a observar los resultados obtenidos, para el
primer ejemplo, podemos ver que primero se hace la lectura del archivo: “entrada.txt”,
posteriormente, se muestran los resultados obtenidos, una vez pasada la prueba del
analizador léxico y sintáctico que se ha realizado en el programa.
Imagen 40. Resultados obtenidos en tiempo de ejecución.
Para experimentar con otros valores y verificar que nuestro programa funciona
correctamente, es necesario probar con todas las operaciones posibles, como se mostrará
a continuación.
Como primer paso, se introdujeron en las cuatro primeras líneas, las operaciones básicas,
tales como, sumar, restar, multiplicar y dividir, de igual forma, en la penúltima línea, se
puede visualizar como se describe una operación que aplica jerarquía de operaciones, este
paso será importante en los pasos de la definición de las gramáticas en las funciones, ya
que, determinará su resultado correcto. Finalmente, en la última línea, se introdujo una
prueba de error, para ver si en las funciones sintácticas de nuestro analizador se cumple
con la función que determinamos.
Imagen 41. Expresiones escritas para evaluar en tiempo de compilación del programa.

Tel. 969 934 3023 Cel. 999 278 6219 24
Dirección General
Como podemos observar en la siguiente imagen, el programa pasa la prueba de manera

satisfactoria, arrojando los resultados deseados. El analizador léxico / sintáctico de
nuestro programa funciona correctamente.
Imagen 42. Resultados obtenidos en tiempo de ejecución del programa.
De forma resumida, los resultados pasan por dos etapas, el analizador léxico y el
analizador sintáctico, en el analizador léxico, se crea la tokenización de los caracteres del
programa (si se va a evaluar, si será un carácter, un tipo de dato, un mensaje de error, un
salto de línea, etc.).
En el analizador sintáctico, trabaja conjuntamente con los tokens que se han creado,
generando la asociatividad y precedencia de los operadores, debido a que la gramática
propuesta en el analizador léxico es ambigua. En esta etapa, se verifica que las
operaciones sean correctas, si tal carácter va a ser aceptado o no, si se realizará alguna
operación, si se enviará por pantalla un mensaje, si se leerá algún archivo, etc.
Ambos análisis van de la mano, para el correcto funcionamiento del programa. De esta
manera, se concluye con la parte de resultados para el primer programa, demostrando en
la prueba de resultados anteriores que su compilamiento fue el correcto.

Tel. 969 934 3023 Cel. 999 278 6219 25
Dirección General
Resultado del funcionamiento: Segundo programa.
Ejecución.
Para ejecutar el programa, desde el editor de texto que esté utilizando, ejecutar
específicamente el archivo llamado: “principal.py”.
Una vez compilado el programa, procedemos a observar los resultados obtenidos, para el
primer ejemplo, podemos ver que primero se hace la lectura del archivo: “entrada.txt”,
posteriormente, se muestran los resultados obtenidos, una vez pasada la prueba del
analizador léxico y sintáctico que se ha realizado en el programa.
Imagen 43. Resultados obtenidos en tiempo de ejecución.

Tel. 969 934 3023 Cel. 999 278 6219 26
Dirección General
Explicando el funcionamiento del programa.
Para entender la obtención de resultados al momento de compilar el programa, requerimos

específicamente el archivo: “entrada.txt”, que hace la simulación como un bloc de notas
para escribir el programa deseado, en este caso, una tabla de multiplicar o determinar si
un número es mayor que otro.
En primera instancia, se declara un comentario de línea (recordemos que, en un principio,

así lo declaramos en los tokens), la función imprimir (será la que se muestre por mensaje
en pantalla), los caracteres entre comillas (hacen referencia a que contendrá una cadena),
el carácter ‘&’ (hace referencia a que se hará una concatenación) y, por último, el carácter
punto y coma, es el que determina hasta donde termina la sentencia o instrucción de línea.
De igual forma, podemos ver como se declaran las variables y cómo se le asigna un
determinado valor.
Imagen 44. Bloque de código de asignación de variables e impresión de datos.
En la siguiente imagen, podemos ver como se representa un comentario de bloque, al

igual que un ciclo (mientras), hasta que ya no se cumpla determinada condición, se siga
ejecutando dicho bloque, podemos observar un ciclo anidado (representará la tabla de
multiplicar) y se podrá visualizar con la función de imprimir.
Imagen 45. Ciclo mientras, bloque de código y condiciones de ejecución de un ciclo.

Tel. 969 934 3023 Cel. 999 278 6219 27
Dirección General
Por último, observamos de nueva cuenta la asignación de variables y condicionales, en

donde vemos la estructura básica como en cualquier lenguaje de programación.
Imagen 46. Asignación de variables, comentarios en bloque, comentarios en línea,

ciclos y sentencias anidadas.

Tel. 969 934 3023 Cel. 999 278 6219 28
Dirección General
El resultado final es el siguiente, mostrando la funcionalidad de que los comentarios en

línea y bloque no se muestren, las condiciones se recurran y ejecuten correctamente y las
impresiones finales sean las esperadas al compilar el programa.
Imagen 47. Resultados finales correctos al tiempo de compilación y ejecución del

programa.
De esta manera, se concluye con la parte de resultados para el segundo programa,

demostrando en la prueba de resultados anteriores que su compilamiento fue el correcto.

Tel. 969 934 3023 Cel. 999 278 6219 29
Dirección General
Conclusiones.
El análisis léxico es una técnica que se encuentra basada en un conjunto de reglas que
relacionan un conjunto de partes para formar un CPU. Un analizador léxico es la primera
fase de un compilador consiste en un programa que recibe el código fuente de otro
programa y produce una salida compuesta en tokens o símbolos. Estos tokens sirven para
una posterior etapa del proceso de traducción, siendo la entrada del analizador sintáctico.
Imagen 48. Analizador léxico (funciones principales).
Un lenguaje de programación incluye un conjunto de reglas que definen léxico, las cuales
consisten en expresiones regulares que indican el conjunto de posibles secuencias de
carácter que definen un token o lexema.
Algunas aplicaciones de los analizadores léxicos son:
• El analizador léxico divide la entrada en componentes léxicos.

• Los componentes se agrupan en categorías léxicas.
• Asociamos atributos a las categorías léxicas.
• Especificamos las categorías mediante expresiones regulares.
• Para reconocer los lenguajes asociados a las expresiones regulares empleamos
autómatas de estados finitos (AFD).
• se pueden crear los AFD directamente a partir de la expresión regular.
• El analizador léxico utiliza la maquina discriminadora determinista.
• El tratamiento de errores en nivel léxico es muy simple.
• Se pueden emplear las ideas de los analizadores léxicos para facilitar el
tratamiento de ficheros de texto.
Como comentarios finales, los analizadores léxicos y sintácticos son una aplicación de
los compiladores que se encargan de verificar que el texto esté escrito en un formato
aceptado para todo el programa que está escrito en un lenguaje de programación, al igual
que se encarga de verificar que tenga congruencia, los analizadores léxicos y sintácticos
sirven en gran parte para resolver problemas que pueden surgir a causa de que el programa
no tenga congruencia o no este bien estructurado.

Tel. 969 934 3023 Cel. 999 278 6219 30
Dirección General
Referencias.
1. Navarro, E. (2020). Intérprete sencillo utilizando PLY con Python 3. ICARUS.

Intérprete sencillo utilizando PLY con Python 3 - Erick Navarro
2. Navarro, E. (2020). Mi primer proyecto utilizando PLY con Python 3. ICARUS.

Mi primer proyecto utilizando PLY con Python 3 - Erick Navarro
3. Navarro, E. (2020). Mi primer proyecto utilizando Yacc y Lex. ICARUS.

https://www.ericknavarro.io/tags/Python/
4. S / A. (2017). Analizador léxico. BLOGSPOT.

https://materiacompliladores3110.blogspot.com/2017/02/analizador-lexico.html
5. S / A. (2022). 2. Análisis léxico. PYTHON.

https://docs.python.org/es/3/reference/lexical_analysis.html
6. S / A. (2022). PLY (Python Lex-Yacc). DABEAZ. https://www.dabeaz.com/ply/
7. S / A. (s.f.). Analizador léxico. ECURED.

https://www.ecured.cu/Analizador_l%C3%A9xico
8. S / A. (s.f.). Calc.py - A simple calculator with variables - all in one file.

DABEAZ. https://www.dabeaz.com/ply/example.html
9. Vargas, J. (2020). 4.1 – Funciones del analizador léxico. BLOGSPOT. Lenguajes

Y Automatas 1: 4.1 - Funciones del analizador léxico
(lenguajesyautomatasvargasrodrigueztec.blogspot.com)

Tel. 969 934 3023 Cel. 999 278 6219 31

LyAII Evidencia3 TorresEsquivelHenry

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

LyAII Evidencia3 TorresEsquivelHenry

Cargado por

Copyright:

Formatos disponibles

Instituto Tecnológico Superior Progreso

Progreso Yucatán, 17 de 09 de 2022

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Evidencia 3 – Reporte de práctica (Analizador Léxico/Sintáctico con símbolos).

Instrucciones: Elabora el reporte de las actividades ejemplo de Lex/Yacc, que se

b) Objetivo de la práctica: Aplica herramientas computacionales para generar

c) INTRODUCCIÓN. Aquí se presenta una descripción breve de lo que fue el

d) Marco Teórico: Explica brevemente (2 a 3 cuartillas) los temas abordados.

e) Material y equipo: Lo que utilizaste para el trabajo (equipo de cómputo con X

f) Procedimiento: Los pasos desglosados y detallados de lo que se realizó. Incluye

g) Resultados: Es la parte más importante (I) pues aquí se demuestra lo que el

h) Conclusiones: Es la parte más importante (II) pues aquí se demuestra lo que el

i) Referencias (material utilizado para el marco teórico y la comprensión del tema).

Subirlo en FORMATO PDF

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Aplica herramientas computacionales para generar símbolos y tokens que deriven en

Los generadores de analizadores léxicos que generan automáticamente un analizador

En el presente trabajo se explicará sobre la construcción de un programa de ejemplo

Se explicarán dos programas, el primero consiste en realizar un intérprete que recibe

El segundo programa, se desarrollará un intérprete que recibe como entrada un archivo

A continuación, se presenta el reporte de manera específica, detallando cada apartado

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

¿Qué es analizador léxico?

El analizador léxico. Se encarga de buscar los componentes léxicos o palabras que

Imagen 1. Representación gráfica de un analizador léxico.

El analizador léxico es la primera fase de un compilador. Su principal función consiste en

PLY es una implementación en Python de lex y yacc, herramientas populares para la

• Un token es un par que consiste en un nombre de token y un valor de atributo

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Es un programa que normalmente es parte de un compilador. El compilador se asegura

¿Cómo funciona el analizador sintáctico?

Imagen 2. Representación gráfica de un analizador léxico y sintáctico.

Equipo y tecnologías utilizadas.

• Nombre del dispositivo: Henry.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Procedimientos: Primer programa.

En el primer programa, se desarrollará un intérprete que recibe como entrada varias

Para el correcto funcionamiento del programa, se requieren de algunas tecnologías

• PLY: Generador de analizadores léxicos y sintácticos.

Explicación del código fuente para el analizador léxico.

Imagen 3. Asignación de los tokens para utilizar en el programa.

Imagen 4. Asignación de patrones de los tokens definidos.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Imagen 5. Asignación de patrones de los tokens definidos a través de funciones.

Imagen 6. Definición de caracteres a ignorar.

Imagen 7. Funciones con retorno de acuerdo al valor procesado.

Finalmente, es turno de construir el analizador léxico haciendo uso de las librerías de

Imagen 8. Construcción del analizador léxico a través de las librerías de PLY.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Explicación del código fuente para el analizador sintáctico.

Primeramente, definimos la asociatividad y precedencia de los operadores, ya que la

Imagen 9. Asociación de operadores y precedencia.

Las características de estas funciones son:

Imagen 10. Ejemplificación de expresiones a evaluar asignadas a una función.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Para el programa en desarrollo, se utilizaron siete gramáticas. A continuación, el código

Imagen 11. Definición de las gramáticas utilizadas.

Ahora, se construyó el analizador sintáctico, la funcionalidad para leer el archivo y

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Creando un archivo de entrada para nuestro analizador.

Imagen 13. Estructura de contenido para compilar con el programa de operaciones

De esta manera, se finaliza la explicación del procedimiento para el primer programa,