BAMM PortafolioEvidencias C4

DIVISIÓN DE INGENIERIA EN SISTEMAS COMPUTACIONALES
Portafolio de evidencias
Asignatura: Lenguajes y Autómatas II
Elaborado por:
Bautista Monter Marya Fernanda
183107254
Docente: Brian Antonio Mejía Díaz
Grupo: 363M
Período: 2021-1
CONTENIDO
Instrumentación didáctica para la formación y desarrollo de competencias 1
profesionales
Evaluación diagnóstica 2
Competencia específica 1. Diseña mediante el uso de reglas semánticas 3
dirigidas por sintaxis, un analizador semántico para un compilador.
1. Investigación Documental 4
2. Cuadro Sinóptico 5
3. Fase 1 Compilador (Pila semántica) 6
Competencia específica 2. Diseña las reglas para traducir el código fuente a 7

un código intermedio
2. Cuadro Comparativo 9
3. Fase 2 del Compilador 10
Competencia específica 3. Conoce e identifica los diferentes tipos de 11

optimización que permita eficientar el código intermedio
2. Mapa Conceptual 13
3. Fase 3 Compilador Final 14
4. Fase 1 ChatBot (Interfaz Gráfica) 15
Competencia específica 4. Utiliza un lenguaje de bajo nivel para traducir el 16

código construido a lenguaje máquina para su ejecu-ción.
2. Mapa Conceptual 18
3. Reporte de Semana Cultural 19
4. ChatBot (Terminado) 20
•
•
•
•
•
• •
• •
•
•
•
•
• •
• •
•
•
•
•
• •
• •
•
•
•
•
•
• •
• •
•
•
• •
• •
EXAMEN DIAGNÓSTICO
COMPETENCIA 1
Competencia específica: 1. Diseña mediante el uso de reglas semánticas dirigidas por
sintaxis, un analizador semántico para un compilador.
Indicadores de alcance:
A. Desarrollar el uso de las reglas semánticas para la construcción de un compilador

B. Describir el uso de las reglas semánticas para la construcción de un compilador
Temas y subtemas:
1.1 Árboles de expresiones.

1.2 Acciones semánticas de un analizador sintáctico.
1.3 Comprobaciones de tipos en expresiones.
1.4 Pila semántica en un analizador sintáctico.
1.5 Esquema de traducción.
1.6 Generación de la tabla de símbolo y tabla de direcciones.
1.7 Manejo de errores semánticos.
Investigación Documental
“Análisis Semántico”
Asignatura:
Lenguajes y Autómatas II
Elaborado por:
Marya Fernanda Bautista Monter 183107254
Docente:
Ing. Brayan Antonio Mejía Díaz
Grupo:
363-M
Período: 2021-1
Contenido
Tabla de Ilustraciones....................................................................................................................... 2
Introducción ..................................................................................................................................... 3
1 Análisis Semántico ................................................................................................................... 4
1.1 Árboles de Expresiones ..................................................................................................... 4
1.1.1 Reglas para la construcción de árboles de expresión ................................................. 5
1.2 Acciones Semánticas de un Analizador Sintáctico ............................................................ 5
1.3 Comprobaciones de Tipos en Expresiones ........................................................................ 6
1.3.1 Comprobaciones estáticas .......................................................................................... 6
1.3.2 Comprobaciones dinámicas........................................................................................ 6
1.3.3 Verificación de Tipos ................................................................................................. 7
1.3.4 Interferencia de Tipos................................................................................................. 7
1.4 Pila Semántica en un Analizador Sintáctico ...................................................................... 7
1.5 Eliminación de Ambigüedad ............................................................................................. 8
1.6 Generación de la Tabla de Símbolo y Tabla de Direcciones ............................................. 9
1.7 Manejo de Errores Semánticos .......................................................................................... 9
Conclusion ...................................................................................................................................... 11
Referencias ..................................................................................................................................... 12
Tabla de Ilustraciones
Ilustración 1. Árbol de Expresiones ................................................................................................. 4
Introducción
Definitivamente la mejor forma de programar es teniendo en cuenta que probablemente el
ochenta por ciento de nuestras líneas de código (o más), tengan por lo menos un error, o en algún
momento nos marcaran el bello y diminuto zigzag rojo debajo de nuestra sentencia.
A pesar de que el ochenta o noventa por ciento de nuestro trabajo esté basado en lo que
podríamos llamar “prueba y error”, sabemos que no puede existir la prueba y error sin el error, y
no puede existir el error sin que alguien o algo nos diga que estamos en un error.
Llegando precisamente a este punto en el que necesitamos de una guía o un
acompañamiento a través de la creación y estructuración de un buen proyecto, podemos encontrar
como algunas muy buenas herramientas, el uso de algunas aplicaciones para desarrollar
programas, en vez de utilizar el no muy confiable o agradable archivo de texto.
Aun teniendo cada una de estas grandes herramientas que nos ayudan a detectar, nos dan
opciones para corregir nuestras equivocaciones, aportan rutas más fáciles para la creación de
código e incluso al momento de ejecutar y compilar el programa completo nos dicen el lugar
exacto en el que estamos cometiendo un error. Hay momentos en los que nos es completamente
imposible identificar el error que tenemos presente.
La realidad es que ninguno de nosotros somos completamente capaces de generar un
código cien por ciento libre de errores, ya que no tenemos la capacidad de reconocimiento y
memoria de cada una de estas ya mencionadas herramientas, sino que conocemos las sentencias
principales y las órdenes básicas que un programa debe llevar por lo menos para declarar
variables, reconocer algunas operaciones básicas o manipular cadenas de caracteres con las
operaciones más simples o comunes que conocemos.
Para realizar otro tipo de operaciones, generar una variedad de extensiones o incluso
importar o crear ciertas paqueterías, tenemos las maravillas de alguien más que decidió hacernos
la vida mucho más fácil, y con estos increíbles trabajos también podemos encontrar las palabras,
caracteres y funciones que nuestro programa o más bien lenguaje pueden reconocer (que no
siempre nos salvan la vida, pero sí son de gran ayuda).
3
1 Análisis Semántico
1.1 Árboles de Expresiones
Se refiere a las estructuras de datos que definen código. Se basan en las mismas
estructuras que usa un compilador para analizar el código y generar el resultado compilado.
Los árboles de expresiones representan el código de nivel del lenguaje en forma de datos.
Los datos se almacenan en una estructura con forma de árbol. Cada nodo del árbol de expresión
representa una expresión, por ejemplo, una llamada al método o una operación binaria, como x <
y.
Un árbol de expresión sirve para evaluar expresiones del tipo: (a + b)*c/d
Para que un árbol represente una expresión se deben tomar en cuenta 2 características
muy importantes:
➢ Cualquier hoja está etiquetada sólo con un operando.
➢ Cualquier nodo interior n está etiquetado por un operador.
Ilustración 1. Árbol de Expresiones
4
1.1.1 Reglas para la construcción de árboles de expresión
Para construir el árbol de expresiones que represente nuestra expresión matemática es
necesario construir primero la misma expresión, pero en la notación polaca correspondiente y a
partir de esta es que se construye el árbol.
• Regla I
Existe un orden de prioridad para los operadores, que de menor a mayor es
el siguiente: suma (+) y resta (-), multiplicación (*) y división (/), exponenciación
(^), operadores unarios.
El paréntesis izquierdo lo trataremos como un operador (aunque no lo es)
cuyo orden de prioridad es el mayor de todos cuando se quiera apilar y el menor
de todos cuando esté en la cima de la pila.
• Regla II
Si el nodo corresponde a un operando, entonces se apila.
Si el nodo corresponde a un operador unario entonces se des apila un nodo
de la pila de nodos y es enlazado a la rama izquierda del nodo correspondiente al
operador unario y este último es apilado. Si el nodo corresponde a un operador
binario entonces dos nodos son des apilados de la pila de nodos, el primero es
enlazado a la rama derecha del nodo binario y el segundo a la rama izquierda,
nuevamente este nodo es apilado.
1.2 Acciones Semánticas de un Analizador Sintáctico
Un analizador sintáctico es la fase del analizador que se encarga de chequear el texto de

entrada en base a una gramática dada. Y en caso de que el programa de entrada sea válido,
suministra el árbol sintáctico que lo reconoce.
En teoría, se supone que la salida del analizador sintáctico es alguna representación del
árbol sintáctico que reconoce la secuencia de Token suministrada por el analizador léxico.
5
En la práctica, el analizador sintáctico también hace:
• Acceder a la tabla de símbolos (para hacer parte del trabajo del analizador semántico).
• Chequeo de tipos (del analizador semántico).
• Generar código intermedio.
• Generar errores cuando se producen.
• En definitiva, realiza casi todas las operaciones de la compilación. Este método de trabajo
da lugar a los métodos de compilación dirigidos por sintaxis.
El manejo de errores de sintaxis es el más complicado desde el punto de vista de la

creación de compiladores. Nos interesa que cuando el compilador encuentre un error, se recupere
y siga buscando errores. Por lo tanto, el manejador de errores de un analizador sintáctico tiene
como objetivos:
• Indicar los errores de forma clara y precisa. Aclarar el tipo de error y su localización.
• Recuperarse del error, para poder seguir examinando la entrada.
• No ralentizar significativamente la compilación
1.3 Comprobaciones de Tipos en Expresiones

La comprobación de tipos consiste en conferir las instrucciones sintácticas del lenguaje a
la semántica de tipificación y en realizar todo tipo de comprobaciones de dicha índole. Sin
embargo, por su naturaleza se encuentra repartida entre la fase de análisis semántico y la
generación de código intermedio.
1.3.1 Comprobaciones estáticas
Recogen el compendio de todas aquellas tareas de carácter semántico que, por su
naturaleza, pueden ser realizadas directamente durante la fase de compilación mediante el uso de
los artefactos y mecanismos propios de dicha fase. Este tipo de comprobaciones son beneficiosas
puesto que confieren seguridad a la ejecución del programa.
1.3.2 Comprobaciones dinámicas
No se realizan durante la fase de compilación y se delegan al momento de la ejecución del
programa. Ello requiere generar código ejecutable específicamente diseñado para realizar tales
comprobaciones. Los lenguajes con una carga excesiva de comprobaciones dinámicas generan
programas más largos, lentos e inseguros en ejecución.
6
1.3.3 Verificación de Tipos
Comprueba la compatibilidad de tipos de todas las expresiones del código fuente
recuperando la información durante la gestión de declaraciones. Además, se asegura de que no
existe en el programa ninguna referencia a ningún símbolo no declarado.
1.3.4 Interferencia de Tipos
En lenguajes sin tipificación de variables o con sobrecarga se aplican tareas de inferencia
de tipos en el nivel gramatical de las expresiones para resolver el tipo de datos de la expresión
resultante en función del contexto de evaluación.
1.4 Pila Semántica en un Analizador Sintáctico
Las pilas y colas son estructuras de datos que se utilizan generalmente para simplificar
ciertas operaciones de programación. Estas estructuras pueden implementarse mediante arrays o
listas enlazadas.
Una pila es una colección de datos a los cuales se les puede acceder mediante un extremo,
que se conoce generalmente como tope. Las pilas tienen dos operaciones básicas:
• Push (para introducir un elemento)
• Pop (para extraer un elemento)
Sus características fundamentales es que al extraer se obtiene siempre el último elemento que
acabe de insertarse. Por esta razón también se conoce como estructuras de datos LIFO, una
posible implementación mediante listas enlazadas seria insertando y extrayendo siempre por el
principio de la lista. Las pilas se utilizan en muchas aplicaciones que utilizamos con frecuencia.
Las pilas y colas son estructuras de datos que se utilizan generalmente para simplificar
ciertas operaciones de programación. Estas estructuras pueden implementarse mediante arrays o
listas enlazadas.
Un analizador sintáctico es un autómata de pila que reconoce la estructura de una cadena
de componentes léxicos.
En general, el analizador sintáctico inicializa el compilador y para cada símbolo de
entrada llama al analizador morfológico y proporciona el siguiente símbolo de entrada.
7
Al decir pila semántica no se refiere a que hay varios tipos de pila, hace referencia a que
se debe programar única y exclusivamente en un solo lenguaje, es decir, no podemos mezclar
código de C++ con Visual Basic.
1.5 Eliminación de Ambigüedad
Como la mayoría de los operadores aritméticos son asociativos por la izquierda, es natural
utilizar gramáticas recursivas por la izquierda para las expresiones. La transformación se aplica a
esquemas de traducción con atributos sintetizados.
Para el análisis sintáctico descendente, se supone que una acción se ejecuta en el mismo
momento en que se expandiría un símbolo en la misma posición. Un atributo heredado de un
símbolo debe ser calculado por una acción que aparezca antes que el símbolo, y un atributo
sintetizado del no terminal de la izquierda se debe calcular después de que hayan sido calculados
todos los atributos de los que depende.
Un atributo heredado de un símbolo debe ser calculado por una acción que aparezca antes
que el símbolo, y un atributo sintetizado del no terminal de la izquierda se debe calcular después
de que hayan sido calculados todos los atributos de los que depende.
Los fragmentos de código así insertados se denominan acciones semánticas. Dichos
fragmentos actúan, calculan y modifican los atributos asociados con los nodos del árbol
sintáctico. El orden en que se evalúan los fragmentos es el de un recorrido primero-profundo del
árbol de análisis sintáctico.
En general, para poder aplicar un esquema de traducción hay que construir el árbol
sintáctico y después aplicar las acciones empotradas en las reglas en el orden de recorrido
primero-profundo. Por supuesto, si la gramática es ambigua una frase podría tener dos árboles y
la ejecución de las acciones para ellos podría dar lugar a diferentes resultados. Si se quiere evitar
la multiplicidad de resultados (interpretaciones semánticas) es necesario precisar de qué árbol
sintáctico concreto se está hablando.
8
1.6 Generación de la Tabla de Símbolo y Tabla de Direcciones
Las tablas de símbolos realizan dos importantes funciones en el proceso de traducción:

verificar que la semántica sea correcta y ayudar en la generación apropiada de código. Ambas
funciones se realizan insertando o recuperando desde la tabla de símbolos los atributos de las
variables usadas en el programa fuente.
Estos atributos, tales como: el nombre, tipo, dirección de almacenamiento y dimensión de
una variable, usualmente se encuentran explícitamente en las declaraciones o más implícitamente
a través del contexto en que aparecen los nombres de variables en el programa.
Una de las estructuras de datos que se encuentran relacionadas con las fases del proceso
de compilación es la tabla de símbolos, la cual tiene como propósito registrar información que se
comparte entre varias etapas y que permite administrar los recursos asociados a las entidades que
manipulará el programa.
Una tabla de símbolos puede conceptualizarse como una serie de renglones, cada uno de
los cuales contiene una lista de valores de atributos que son asociados con una variable en
particular.
Las clases de los atributos que aparecen en una tabla de símbolos dependen en algún
grado de la naturaleza del lenguaje de programación para el cual se escribe el compilador.
Por ejemplo, un lenguaje puede ser sin tipos, y por lo tanto el atributo tipo no necesita
aparecer en la tabla. Similarmente, la organización de la tabla de símbolos variará dependiendo
de las limitaciones de memoria y tiempo de acceso.
1.7 Manejo de Errores Semánticos
Es una de las misiones más importantes de un compilador, aunque, al mismo tiempo, es lo

que más dificulta su realización. A veces unos errores ocultan otros.
A veces un error provoca una avalancha de muchos errores que se solucionan con el
primero.
Es conveniente un buen manejo de errores, y que el compilador detecte todos los errores
que tiene el programa y no se pare en el primero que encuentre.
9
Existen dos criterios a seguir a la hora de manejar errores:
• Pararse al detectar el primer error.
• Detectar todos los errores de una pasada.
El análisis semántico es posterior al sintáctico y mucho más difícil de formalizar que éste.
Se trata de determinar el tipo de los resultados intermedios, comprobar que los argumentos que
tiene un operador pertenecen al conjunto de los operadores posibles, y si son compatibles entre sí,
etc. En definitiva, comprobará que el significado de lo que se va leyendo es válido.
La salida "teórica" de la fase de análisis semántico sería un árbol semántico. Consiste en
un árbol sintáctico en el que cada una de sus ramas ha adquirido el significado que debe tener. En
el caso de los operadores polimórficos (un único símbolo con varios significados), el análisis
semántico determina cuál es el aplicable.
10
Conclusion
What would we do if we couldn't see our mistakes? That is the biggest issue that we could
imagine. We are available to make mistakes once, twice, third, or a million more times. The
problem when we make mistakes is when we can't see it.
Maybe in a current way in our life, we forget to do something or take a thing from the
table in the kitchen, or something like that usual mistakes. But at any time in the day, we will
notice about it even if we don't, it doesn't represent the end of the world.
Another case is an app. If we start to program and we aren't available to see that we have a
mistake, all the programs will fail. In that situation, we are sure in big troubles.
Of course, nothing of that could be possible if we hadn't found the best way to help
ourselves, but anyway, all that thigs as regular expressions are the things that make our life so
easy to make other life easy.
Now all that we have to do is try our best to make the fewer mistakes possible even if we
have a powerful tool as regular expressions.
11
Referencias
• Ullman, J. D. et al. (2007) Introducción a la teoría de autómatas, lenguajes y computación (3ª.
Ed.). Madrid: Pearson Educación. Disponible en: ELibro (Accediso: 10.03.2021)
• Badenas Carpio, J., Llopis Borrás, J. and Coltell Simón, O., 2001. Curso Práctico De
Programación En C Y C++. 2nd ed. Castelló de la Plana: Publicaciones de la Universitat
Jaume I, p.103.
• Hopcroft, J., Motwani, R. and Ullman, J., 2007. Introducción A La Teoría De Autómatas,
Lenguajes Y Computación (3A. Ed.). 1st ed. Madrid: Pearson Educación, pp.28-32.
12
DIRECCIÓN ACADÉMICA
Formato de entrega de evidencias
FO-205P11000-14
División: (1) Ingeniería en Sistemas Computacionales Grupo: (2) 363-M

Asignatura: (3) Lenguajes y Autómatas II Docente: (4) Brian Antonio Mejía Díaz
Nombre y número de control: (5) Bautista Monter Marya Fernanda 183107254
Fecha de entrega: (6) 12/ Marzo/ 2021
Competencia No.: (7) 1 Descripción: (8) Diseña mediante el uso de reglas semánticas dirigidas por sintaxis, un
analizador semántico para un compilador.
Indicador de alcance: (9) A. Desarrollar el uso de las reglas semánticas para la construcción de un compilador
Evidencia de aprendizaje: (10) Cuadro Sinóptico
Referencias
• Ullman, J. D. et al. (2007) Introducción a la teoría de autómatas, lenguajes y
computación (3ª.
• Ed.). Madrid: Pearson Educación. Disponible en: ELibro (Accediso: 10.03.2021)
Badenas Carpio, J., Llopis Borrá s, J. and Coltell Simó n, O., 2001. Curso Prá ctico
De Programació n En C Y C++. 2nd ed. Castelló de la Plana: Publicaciones de la
Universitat Jaume I, p.103.
• Hopcroft, J., Motwani, R. and Ullman, J., 2007. Introducció n A La Teoría De
Autó matas, Lenguajes Y Computació n (3A. Ed.). 1st ed. Madrid: Pearson
Educació n, pp.28-32
Visualización del diagrama

https://lucid.app/lucidchart/invitations/accept/c643c1c0-1353-4620-8f4b-
75c4e65141d1
Guía estructurada de evaluación

FO-205P11000-13
División: (1) Ingeniería en Sistemas Computacionales
Docente: (2) Ing. Brian Antonio Mejía Díaz
Asignatura: (3) Lenguajes y Autómatas II
Nombre y número de
control:(5)
Bautista Monter Marya Fernanda 183107254 Grupo: (6) 363M
Evidencia de aprendizaje: (7) Compilador fase 1 (Interfaz gráfica)
Criterios de evaluación:
CRITERIOS
SI NO
DE EVALUACIÓN OBSERVACIONES
• El alumno muestra la interfaz del

compilador siendo única y no repetida en
su estilo.
Presentación
• El trabajo fue realizado las estrategias
vistas en clase y asignadas por el
docente dentro de las sesiones de la
asignatura.
• La interfaz gráfica es adecuada
Diseño
empleando colores y matices
grafico
adecuados dentro del desarrollo.
• La fase 1 del compilador contiene una
Estructura y estructura adecuada y con la
orden terminología donde el lenguaje del
analizador es único en su realización.
• El analizador es realizado en Visual

Software
Basic 2012 o superior.
1ª oportunidad 2ª oportunidad
Puntuación
Alcanzada (10)
FO-205P11000-14

Fecha de entrega: (6) 24/ Marzo/ 2021
Competencia No.: (7) 1 Descripción: (8) Diseña mediante el uso de reglas semánticas dirigidas por sintaxis, un
analizador semántico para un compilador
Indicador de alcance: (9) B. Describir el uso de las reglas semánticas para la construcción de un compilador
Evidencia de aprendizaje: (10) Fase 1 Compilador (Pila Semántica)
FORMULARIO DE INICIO
Se muestra la pantalla de inicio del compilador, misma que contiene los datos
principales y dos botones de interacción: los botones “INICIO” y “SALIR”.
Ilustración 1. Formulario de Inicio

BOTÓN INICIO
Al dar click en el botón inicio, se despliega un cuadro de diálogo con la leyenda
“¿Quieres iniciar el compilador?”.
Ilustración 2. Botón Inicio
Si el usuario da click en “Si”, se mostrará otro cuadro de diálogo con la leyenda

“Abriendo el Compilador Espere por favor” y abrirá el formulario del compilador al
pulsar “Aceptar”.
Ilustración 3. Cuadro de Texto "Sí"

En caso contrario, se mostrará un cuadro de diálogo con la leyenda “El formulario
inicial continúa en ejecución”, mismo que se cerrará al pulsar “Aceptar”.
Ilustración 4. Cuadro de Texto "No"
BOTÓN SALIR
“¿Desea Cerrar el Compilador?”.
Ilustración 5. Botón Salir

“Cerrando el Compilador Espere por favor” y cerrará el compilador al pulsar “Aceptar”.


VENTANA DEL COMPILADOR
La ventana de compilador contiene cinco botones: “ANALIZAR”, “COMPILA”,
“REGRESAR”, “←” (borrar último carácter) y “LIMPIAR”, el cuadro de texto en el que se
escribirá la expresión y los respectivos cuadros en los que se mostrarán caracteres, operandos,
operadores y las operaciones que hará el compilador.
El momento en el que se abre la ventana del compilador, están deshabilitados los
botones “ANALIZAR” y “COMPILA”.
Ilustración 8. Ventana del Compilador
Una vez que el usuario haga click en el cuadro de texto, se habilitará el botón
“ANALIZAR”.
Ilustración 9. Habilitar botón Analizar

Una vez que el usuario haga click en “ANALIZAR, se habilitará el botón
“COMPILA”.
Ilustración 10. Habilitar botón Compila
BONTÓN “←”
En caso de que el usuario escriba mal un carácter en el cuadro de texto de expresión,
el usuario puede corregirlo con el botón “←”.
Ilustración 11. Texto con error

Ilustración 12. Texto corregido
BOTÓN “LIMPIAR”
Una vez que todo el compilador esté programado, en el momento en el que se necesite
limpiar todos los campos del formulario, el usuario puede utilizar el botón “LIMPIAR” para
borrar la información y ocultar el resto de los componentes del formulario. De igual manera,
se volverá a deshabilitar el botón “COMPILAR”.
Ilustración 13. Botón limpiar

BOTÓN REGRESAR
Al dar click en el botón “REGRESAR”, se despliega un cuadro de diálogo con la
leyenda “¿Desea volver a la ventana inicial del compilador?”.
Ilustración 14. Botón Regresar

“Volviendo a la ventana de inicio Espere por favor”, abrirá el formulario de inicio y
cerrará el formulario del compilador al pulsar “Aceptar”.
Ilustración 15. Cuadro de Texto "Si"

En caso contrario, se mostrará un cuadro de diálogo con la leyenda “El compilador
continúa en ejecución”, mismo que se cerrará al pulsar “Aceptar”.


FO-205P11000-13
Nombre y número de
control: (5)
Evidencia de aprendizaje: (7) Compilador fase 1 (Interfaz gráfica)
CRITERIOS
SI NO

su estilo.
• Entrega las capturas de pantalla realizadas
Presentación
en esta fase en el formato de evidencias
previamente requisitado.
vistas en clase y asignadas por el docente
dentro de las sesiones de la asignatura.
• La interfaz gráfica es adecuada empleando
Diseño
colores y matices adecuados dentro del
grafico
desarrollo.
• La fase 1 del compilador contiene una
Estructura y estructura adecuada y con la terminología
orden donde el lenguaje del analizador es único
en su realización.
• El analizador es realizado en Visual Basic

Software
2012 o superior.
Puntuación
Alcanzada (10)
COMPETENCIA 2
Competencia específica: 2. Diseña las reglas para traducir el código fuente a un código
intermedio
A. Evalúa las reglas las para traducir la codificación fuente en un código intermedio.
B. Desarrolla las reglas las para traducir la codificación fuente en un código intermedio.
Temas y subtemas:
2.1 Notaciones.
2.1.1 Prefija.
2.1.2 Infija.
2.2.3 Postfija.
2.2 Representaciones de código intermedio.

2.2.1 Notación Polaca.
2.2.2 Código P.
2.2.3 Triplos.
2.2.4 Cuádruplos.
2.3 Esquema de generación.

2.3.1 Variables y constantes.
2.3.2 Expresiones.
2.3.3 Instrucción de asignación.
2.3.4 Instrucciones de control.
2.3.5 Funciones.
2.3.6 Estructuras.
“Generación de código intermedio”
Asignatura:
Elaborado por:
Docente:
Grupo:
363-M
Período: 2021-1
Contenido
Introducción ..................................................................................................................................... 3
2 Generación de Código Intermedio ........................................................................................... 4
2.1 Notaciones ......................................................................................................................... 4
2.1.1 Prefija ......................................................................................................................... 4
2.1.2 Infija ........................................................................................................................... 4
2.1.3 Postfija........................................................................................................................ 5
2.2 Representaciones de Código Intermedio ........................................................................... 5
2.2.1 Notación Polaca.......................................................................................................... 5
2.2.2 Código P ..................................................................................................................... 6
2.2.3 Triplos ........................................................................................................................ 6
2.2.4 Cuádruplos ................................................................................................................. 7
2.3 Esquema de Generación .................................................................................................... 7
2.3.1 Variables y Constantes ............................................................................................... 7
2.3.2 Expresiones ................................................................................................................ 7
2.3.3 Instrucción de Asignación .......................................................................................... 7
2.3.4 Instrucciones de Control............................................................................................. 8
2.3.5 Funciones ................................................................................................................... 8
2.3.6 Estructuras .................................................................................................................. 8
Conclusion ........................................................................................................................................ 9
Referencias ..................................................................................................................................... 10
Introducción
3
2 Generación de Código Intermedio
2.1 Notaciones
Los símbolos son la base para expresar oraciones bien definidas. El símbolo más utilizado
es para expresar operaciones aritméticas. Las expresiones aritméticas se pueden expresar de tres
formas diferentes: infijo, prefijo y sufijo.
La diversidad de símbolos se corresponde con el hecho de que, en algunos casos, un tipo
de símbolo es más simple. La notación también depende de la forma en que se atraviesa el árbol
de sintaxis, que se puede ordenar, pre o post. Existe una relación de uno a uno con el símbolo del
operador.
2.1.1 Prefija
La Expresión o Notación PreFija nos indica que el operador va antes de los operandos sus
características principales son:
• Los operandos conservan el mismo orden que la notación infija equivalente.
• No requiere de paréntesis para indicar el orden de precedencia de operadores.
• Se evalúa de izquierda a derecha hasta que encontrar el primer operador seguido
inmediatamente de un par de operandos.
• Se evalúa la expresión binaria y el resultado se cambia como un nuevo operando. Se
repite este hasta que nos quede un solo resultado.
2.1.2 Infija
La Expresión o Notación Infija es la forma más común que utilizamos para escribir
expresiones matemáticas, refiere que el operador esta entre los operandos. La notación infija
puede estar completamente entre paréntesis o puede basarse en un esquema de precedencia de
operadores así como el uso de paréntesis para invalidar los arreglos al expresar el orden de
evaluación de una expresión:
3*4=12
3*4+2=14
3*(4+2)=18
4
2.1.3 Postfija
Como su nombre lo indica se refiere a que el operador ocupa la posición después de los
operandos sus características principales son:
• El orden de los operandos se conserva igual que la expresión infija equivalente.
• No utiliza paréntesis ya que no es una operación ambigua.
• La operación posfija no es exactamente lo inverso a la operación prefija equivalente:
(A+B)*C AB+C*
Si deseamos representar las expresiones (2+(3*4)) = x y ((2+3)*4)= x en las tres

notaciones mencionadas, el resultado sería:
(2+(3*4)) = x
((2+3)*4) = x
Notación prefija Notación infija
=+2*34x 2+3*4 = x
=*+234x (2+3)*4 = x
Notación postfija
234*+x=
23+4*x=
2.2 Representaciones de Código Intermedio
Existen maneras “formales” de representar el código intermedio. Ese tipo de notaciones
simplifican la traducción de nuestro código fuente a nuestro código objeto ya que ahorran y
acotan símbolos de la tabla de símbolos.
2.2.1 Notación Polaca
Es una representación de lógica, aritmética, álgebra y cálculo. Es único porque coloca al
operador a la izquierda de su operando. Si la fijeza del operador es fija, el resultado es la falta de
paréntesis u otros símbolos de agrupación en la gramática, y el análisis gramatical aún se puede
hacer explícitamente.
5
2.2.2 Código P
Hace referencia a máquinas que utilizan o se auxilian de pilas para generar código objeto.
En muchos casos, la “P” es asociada a un código portable, el que garantiza que el código
compilado en una máquina se pueda ejecutar en otras.
Para garantizar la portabilidad del código se necesita que el lenguaje esté estandarizado
por algún instituto y que dicho código no tenga extensiones particulares.
También es recomendada la no utilización de características especiales exclusivas de
alguna arquitectura de computadoras en particular.
2.2.3 Triplos
Las proposiciones de tres direcciones se parecen mucho al ensamblador, el que es un
lenguaje intermedio más entendible para la máquina.
Las estructuras de control (if, switch, while, do-while, for) sin realmente etiquetas go to
disfrazadas.
El problema de usar cuádruplos radica en que se tienen que colocar los valores temporales
en la tabla de símbolos.
Con una estructura de tres campos, se pueden omitir los valores temporales, dicha
estructura recibe el nombre de triplos y tiene los campos:
• Op
• Arg1
• Arg2
Generalmente el código que generan los triples recibe el nombre de código de dos
direcciones, aunque en ocasiones puede variar. Cuando se utilizan triples se ocupan punteros a la
misma estructura de los triples.
• b t1 t2 //cuádruplos
• b (0) //triple
Se debe tener en cuenta el proceso de asignación, de declaración, expresiones booleanas.

Las expresiones lógicas también pueden pasarse a código de tres direcciones, utilizando para ello
expresiones en corto circuito.
La evaluación de expresiones en corto circuito implica que se evalúan condiciones
revisando valores anteriores; por ejemplo, para el operador AND con una condición que se
6
detecte como falsa toda la expresión es falsa, en el caso del operador OR si se encuentra una
condición verdadera todo será verdadero.
La notación de tres direcciones es una forma abstracta de código intermedio. Esta
notación se puede implementar como registros con campos para el operador y operadores.
2.2.4 Cuádruplos
Es una estructura tipo registro con cuatros campos que se llaman:
• Op (Con un código intermedio)
• arg1
• arg2
• resultado
Los operadores unarios como x: = -y no utilizan arg2. Generalmente arg1, arg2 y

resultado son valores de tipo puntero y apuntan a una entrada en la tabla de símbolos.
2.3 Esquema de Generación
Los esquemas de generación son las estrategias o acciones que se deberán realizarse y
tomarse en cuenta en el momento de generar código intermedio. Los esquemas de generación
dependen de cada lenguaje.
2.3.1 Variables y Constantes
Las declaraciones de variables y constantes deben separarse de tal manera que queden las
expresiones una por una de manera simple. Por ejemplo, int a, b, c; se descompone a int a; int b;
intc; respectivamente.
2.3.2 Expresiones
Para generar expresiones estas deben representarse de manera más simple y literal para
que su conversión sea más rápida. Por ejemplo, la traducción de operaciones aritméticas debe
especificarse una por una, de tal forma que una expresión sea lo más mínimo posible.
2.3.3 Instrucción de Asignación
Las operaciones de asignación deben quedar expresadas por una expresión sencilla, si está
es compleja se debe reducir hasta quedar un operador sencillo. Por ejemplo: x = a +b /5; debe
quedar de la forma y = b/5; z = a + y; x=z
7
2.3.4 Instrucciones de Control
Esta forma de programación solo le permite resolver problemas simples. Para resolver
problemas más complejos, es posible que nos interese ejecutar determinadas instrucciones u otras
instrucciones, según el valor de los datos.
Una descripción condicional nos permitirá representar este tipo de comportamiento.
Sentencias IF y SWITCH. En otros casos, encontramos que necesitamos repetir una o más
instrucciones un número específico de veces.
En estos casos, usaremos instrucciones de control iterativas o repetidas (bucles).
Declaraciones WHILE, DO-WHILE y FOR.
2.3.5 Funciones
Las funciones pueden reducir a en línea, lo que se hace es expander el código original de
la función. Las funciones se descomponen simplificando los parámetros de manera individual al
igual que el valor de retorno.
2.3.6 Estructuras
Implica agrupar componentes léxicos en frases gramaticales, y el compilador usa estas
frases gramaticales para sintetizar la salida. Las frases gramaticales generalmente se representan
mediante árboles de análisis sintáctico.
Muchos lenguajes usan reglas para definir proposiciones de forma recursiva. Por ejemplo:
si identificador1 es un identificador y expresión2 es un identificador, entonces:
Identificador1 = expresión2 Si expresión1 es una expresión y proposición2 es una
proposición, entonces:
while (expresión1) realiza una posición2 Si (expresión1), entonces la función de análisis
lineal (léxico) de la proposición 2 no es suficiente para analizar proposiciones o expresiones
recursivas. Cuando las construcciones del lenguaje fuente son recursivas, es factible formalizar la
recursividad usando una gramática libre de contexto.
8
Conclusion
9
Referencias
• Prog-de-sistemas.blogspot.com. 2021. Notaciones Infija,prefija y posfija. [online] Available at:
<http://prog-de-sistemas.blogspot.com/2008/11/notaciones-infijaprefija-y-posfija.html>
[Accessed 7 April 2021].
• Olivares Rojas, J., 2021. Generación de Código Intermedio. [online] Dsc.itmorelia.edu.mx.
Available at: <http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u6> [Accessed 8
April 2021].
10

FO-205P11000-13
Nombre y número de
control:(5)
Evidencia de aprendizaje: (7) Investigación Documental
CRITERIOS
SI NO
• Contiene portada con las especificaciones (Nombre
del Docente, Nombre del Estudiante, # de control,
grupo y tema a investigar).
• Contiene introducción a 1 cuartilla.

• Contiene las tablas correspondientes a:
• Índice de Contenido
• Índice de Imágenes
Estructura del • Índice de Tablas
Documento Respectivamente y en caso de existir.
• Contiene desarrollo parafraseado y en ½ cuartilla, por
tema.
• Contiene conclusión de acuerdo con las
características propias de hacerlo en inglés y con sus
propias palabras, de acuerdo con el nivel que presente
sin utilizar ninguna clase de traductor a ½ cuartilla.
• Referencias Bibliográficas (al menos 2 libros)
• Faltas de Ortografía.
• Márgenes Definidos 2.5 por lado.
• Interlineado a 1.5 y justificado.

Características
del Documento • Los títulos y subtítulos se ven propiamente resaltados
y diferenciados el cuerpo del documento.
• Las referencias se encuentran en formato OXFORD.
• Entrega en tiempo y forma de acuerdo con las
indicaciones del docente.
Puntuación
Alcanzada (10)
FO-205P11000-14

Fecha de entrega: (6) 09/ Abril/ 2021
Competencia No.: (7) 2 Descripción: (8) Diseña las reglas para traducir de un código fuente a un código intermedio
Indicador de alcance: (9) A. Evalúa las reglas las para traducir la codificación fuente en un código intermedio.
Evidencia de aprendizaje: (10) Cuadro comparativo
CONCEPTO EJEMPLO VENTAJAS DESVENTAJAS
Las expresiones aritméticas
(2+(3*4)) = x
se pueden expresar de tres • Permite reducir el
((2+3)*4) = x
formas diferentes: número de cifras
• Si desea agregar o
Prefijo Notación prefija significativas sin
restar 2 números,
El operador va antes de los =+2*34x sacrificar la
debe escribir uno de
operandos. =*+234x exactitud de la
los números para la
NOTACIONES Infijo magnitud.
Notación infija misma potencia de
El operador ocupa la • Permite simplificar
2+3*4 = x diez como otro.
posición después de los las expresiones
(2+3)*4 = x antes de realizar una
operandos. que son muy
suma o una resta.
Postfijo Notación postfija grandes o
El operador esta entre los 234*+x= pequeñas.
operandos. 23+4*x=
• No se puede utilizar
a = b + c * d; • Permite abstraer la
el modelo de una
El generador de código máquina, separar
pasada.
Existen maneras “formales” intermedio, tratar de operaciones de
• Dificulta llevar a
de representar el código dividir esta expresión alto nivel de su
cabo optimizaciones
intermedio. Ese tipo de en sub-expresiones y, a implementación a
específicas de la
REPRESENTACIONES notaciones simplifican la continuación, generar bajo nivel.
arquitectura destino.
DE CÓDIGO traducción de nuestro código el código • Permite la
• Suele ser ortogonal
INTERMEDIO fuente a nuestro código correspondiente. reutilización de los
a la máquina
objeto ya que ahorran y front-ends y back-
destino.
acotan símbolos de la tabla r1 = c * d; ends;
• La traducción a una
de símbolos. r2 = b + r1; • Permite
arquitectura
r3 = r2 + r1; optimizaciones
específica será más
a = r3 generales.
larga e ineficiente.
La generación de • facilita la escritura
código para las de compiladores
sentencias if-then e if- para distintas
then-else pasa por máquinas.
entender a través de • La traducción del • Problema de
Estrategias o acciones que se un esquema la forma lenguaje a código complejidad
ESQUEMAS DE deberán realizarse y tomarse en la que este se intermedio sería • Variables pueden
GENERACIÓN en cuenta en el momento de genera. idéntica en todas y ser modificadas en
generar código intermedio. Empecemos por el de lo único que cualquier parte del
la sentencia S1 → if E cambiaría sería el programa
then S2: traductor de
código intermedio
a código de
máquina.
Referencias
• Ullman, J. D. et al. (2007) Introducción a la teoría de autómatas, lenguajes y
computación (3ª. Ed.). Madrid: Pearson Educación. Disponible en: ELibro
(Accediso: 07.04.2021)
• Prog-de-sistemas.blogspot.com. 2021. Notaciones Infija,prefija y posfija. [online]
Available at: <http://prog-de-sistemas.blogspot.com/2008/11/notaciones-
infijaprefija-y-posfija.html> [Accessed 7 April 2021].
• Olivares Rojas, J., 2021. Generación de Código Intermedio. [online]
Dsc.itmorelia.edu.mx. Available at:
<http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u6> Accessed 8 April
2021].

FO-205P11000-13
Docente: (2) Brian Antonio Mejía Díaz
Nombre y número de Bautista Monter Marya Fernanda 183107254
Grupo: (6) 363M
control:(5)
Evidencia de aprendizaje: (7) Cuadro Comparativo
CRITERIOS
SI NO
Identifica todos los elementos de
Establece los elementos
comparación. Las características
y las características a
elegidas son suficientes y
comparar
pertinentes.
Identifica las Identifica de manera clara y precisa

semejanzas y las semejanzas y diferencias entre
diferencias los elementos comparados.
Se entrega:
• En formato de evidencia
debidamente llenado
Presentación
• De forma limpia y ordenado
• En tiempo y forma indicado por el
docente
Se encuentra sin errores ortográficos

Ortografía
y de gramática.
Contiene referencias bibliográficas

Referencias que no sean de Wikipedia, Rincón
del Vago, Buenas Tareas.
Puntuación
Alcanzada (10)
FO-205P11000-14

Fecha de entrega: (6) 23/ Abril/ 2021
Competencia No.: (7) 2 Descripción: (8) Diseña las reglas para traducir el código fuente a un código intermedio
Indicador de alcance: (9) B. Desarrolla las reglas para traducir la codificación fuente en un código intermedio
Evidencia de aprendizaje: (10) Fase 2 Compilador (Validación de operadores y operandos)

BOTÓN INICIO


BOTÓN SALIR



“ANALIZAR”.

“COMPILA”.
BONTÓN “←”


BOTÓN REGRESAR



FASE 2
Continuando con la segunda fase del proyecto, agregamos un módulo llamado
“Module1” en el que declaramos variables mirilla, mismas que utilizaremos de forma general
a lo largo de los procedimientos.
Module Module1
Public valor(30) As String
Public valo(30) As String
Public simbolo(31) As String
Public imp As String
Public resultado As Object
Public ss As String
Public orden As Integer
Public orde As Integer
Public op As Integer
Public token As String
Public contador As Integer
Public tama As Integer, m As Integer
Public pru As String, res As String, operacion As String, s As String
Public i As Integer, o As Integer, lim As Integer, a As Integer, se As Integer,
ats As Integer, repetision As Integer, veces As Integer
Public vez As Boolean
Public basura As String, basura2 As String, cd As String
Public des As Integer, z As Integer
Public ordn As Boolean
Public dis As Integer, dr As Integer
Public daf As Integer, x As Integer
End Module
Posteriormente, generamos una clase de nombre “ModuleCodeDom” que contiene

las sentencias de una librería que nos permitirá tener mayor control y eficiencia sobre los
procedimiento y resultados del compilador K.
Option Strict On
Imports System.CodeDom.Compiler
Imports System.Reflection
Public Class ModuleCodeDom
Shared Function Eval(ByVal expresion As String) As Object
Dim CrLf As String = Environment.NewLine
Dim cpar As New CompilerParameters()
cpar.GenerateInMemory = True
cpar.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll")
Dim vbcp As New VBCodeProvider()

Dim source As String =
"Imports Microsoft.VisualBasic" & CrLf &
"Namespace MiNamespace" & CrLf &
" Public Class MiClase" & CrLf &
" Public Shared Function Eval() As Object " & CrLf &
" Return " & expresion & CrLf &
" End Function" & CrLf &
" End Class" & CrLf &
"End Namespace"
Dim res As CompilerResults = vbcp.CompileAssemblyFromSource(cpar, source)

res.TempFiles.KeepFiles = True
If (res.Errors.Count > 0) Then _

Return res.Errors(0).ErrorText
Dim ty As System.Type =
res.CompiledAssembly.GetType("MiNamespace.MiClase")
Dim funceval As MethodInfo = ty.GetMethod("Eval")
Return funceval.Invoke(Nothing, Nothing)
End Function
End Class
Dentro del formulario número 2, declaramos variables adicionales para su uso en los
siguientes procedimientos.
Dim expresion As String

Dim tam As Integer
Dim caracter As String
Dim operandos As String
Dim operadores As String
Dim numeros As String
Dim simbolos As String
Dim parte1, parte2 As String
Dim valor1, valor2, resultado As Integer
Dim la As Integer
Dim y As Integer
Dim almacena As String, cara
Dim s As String
Dim c As Char
Dim w As Integer
Dim parentesis As String
Dim cadena As String
Dim largo As Integer
Dim simbolo(40) As String
Dim cas As Integer
Dim confirmar As Boolean
Agregamos elementos extra al procedimiento “Limpiar”, de tal forma que ciertas
variables se “reinicien” cada que se limpien los campos.
Private Sub Limpiar()

txtCaracteres.Clear()
txtOperandos.Clear()
txtOperadores.Clear()
txtOperacion.Clear()
expresion = Nothing
tam = Nothing
caracter = Nothing
operandos = Nothing
operadores = Nothing
numeros = Nothing
simbolos = Nothing
End Sub
Posteriormente a estos cambios, realizamos la programación de los métodos que nos

permitirán la identificación de paréntesis y operaciones, así como los procedimientos para la
realización de las operaciones aritméticas que generarán los resultados de nuestro
compilador.
Método “Tipo de Operación”

Public Sub TipoOperacion()
contador = 0
imp = imp
largo = Len(imp)
For i = 0 To largo
token = Mid(imp, i, 1)
If token = "+" Or token = "-" Or token = "*" Or token = "/" Then
contador = contador + 1
End If
Next
End Sub
Método “Análisis”
Public Sub Analisis()
daf = 0
cd = 0
op = 0
a = 0
o = 0
lim = 0
dr = 0
se = 0
veces = 0
x = 0
ats = 0
token = Mid(imp, 1, 1)
If token = "(" Then

o = 1
MsgBox("")
Else
o = 2
End If
If o = 1 Then
For x = 0 To tama
token = Mid(imp, x, 1)
If token <> ")" Then
op = op + 1
ElseIf token = ")" Then
lim = x
Exit For
End If
Next
Label1.Text = op
daf = tama - op + 1
operacion = Mid(imp, 2, op - 1)
basura = Mid(imp, lim + 1, daf)
resultado = ModuleCodeDom.Eval(operacion)
res = Convert.ToString(resultado)
imp = res + basura
txtOperacion.AppendText(imp & vbCrLf)
imp = imp
tama = Len(imp)
Else
For x = 1 To tama
If token <> "(" Then
op = op + 1
Else
Exit For
End If
Next
For a = op + 1 To tama
token = Mid(imp, a, 1)
lim = lim + 1
m = lim
Else
Exit For
End If
Next
se = lim + op + 1
basura = Mid(imp, 1, op)
operacion = Mid(imp, op + 2, lim - 1)
If se = tama Then
res = Convert.ToString(operacion)
imp = basura + res
imp = imp
tama = Len(imp)
Else
ats = tama - res
basura2 = Mid(imp, se + 1, ats)
imp = basura + res + basura2
imp = imp
tama = Len(imp)
End If
End If
End Sub
Método “Suma”
Public Sub Suma()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "+" Then
x = i
m = i
While x > 1
token = Mid(imp, x + 1, 1)
If token = "+" Or token = "-" Then
Exit While
Else
lim = lim + 1
End If
x = x + 1
End While
Exit For
End If
Next
dis = lim + m
operacion = Mid(imp, 1, dis)
z = tama - m
basura = Mid(imp, dis + 1, z)
imp = res + basura
End Sub
Método “Resta”
Public Sub Resta()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "-" Then
x = i
m = i
While x > 1
Exit While
Else
lim = lim + 1
End If
x = x + 1
End While
Exit For
End If
Next
dis = lim + m
z = tama - m
imp = res + basura
End Sub
Método “Multiplicación”
Public Sub Multiplicar()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "+" Or token = "-" Or token = "/" Then
o = 1
Exit For
ElseIf token = "*" Then

o = 2
Exit For
End If
Next
For i = 1 To tama
If token = "*" Then
x = i
m = i
While x > 1
z = x
Exit While
Else
lim = lim + 1
End If
x = x - 1
End While
While m <= tama
token = Mid(imp, m, 1)
Exit While
Else
des = des + 1
End If
m = m + 1
End While
Exit For
End If
Next
s = lim + des
If o = 1 Then
operacion = Mid(imp, z + 1, s - 1)
basura = Mid(imp, 1, z)
ss = basura + operacion
dis = tama - Len(ss)
If dis = 0 Then
imp = basura + res
tama = Len(imp)
Else
basura2 = Mid(imp, Len(ss) + 1, dis)
tama = Len(imp)
End If
Else
dr = s
While dr > tama
op = op + 1
dr = dr + 1
End While
operacion = Mid(imp, 1, s)
basura = Mid(imp, s + 1, op)
imp = res + basura
tama = Len(imp)
End If
End Sub
Método “División”
Public Sub Dividir()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "+" Or token = "-" Or token = "*" Then
o = 1
Exit For
ElseIf token = "/" Then

o = 2
Exit For
End If
Next
For i = 1 To tama
If token = "/" Then
x = i
m = i
While x > 1
z = x
Exit While
Else
lim = lim + 1
End If
x = x - 1
End While
While m <= tama
Exit While
Else
des = des + 1
End If
m = m + 1
End While
Exit For
End If
Next
s = lim + des
If o = 1 Then
If dis = 0 Then
imp = basura + res
tama = Len(imp)
Else
tama = Len(imp)
End If
Else
dr = s
While dr > tama
op = op + 1
dr = dr + 1
End While
imp = res + basura
tama = Len(imp)
End If
End Sub
Finalmente, realizamos algunas modificaciones en la interfaz, de tal forma que los

labels correspondientes a “Caracteres”, “Operando”, “Operadores” y “Operación”, así cómo
sus respectivos TextBox sean invisibles desde que se abre la ventana de la corrida del
compilador.
Ilustración 17. Modificaciones de la interfaz de Compilador K


FO-205P11000-13
Nombre y número de
control:(5)
Evidencia de aprendizaje: (7) Compilador fase 2 (Validación de operadores y operandos)
CRITERIOS
SI NO
• El alumno muestra la interfaz del compilador
siendo única y no repetida en su estilo.
• Entrega las capturas de pantalla realizadas en
Presentación esta fase en el formato de evidencias
• El trabajo fue realizado las estrategias vistas
en clase y asignadas por el docente dentro de
las sesiones de la asignatura.
Diseño grafico colores y matices adecuados dentro del
desarrollo.
• La fase 2 del compilador cumple con realizar la
validación correcta de los operadores, de
Estructura y acuerdo con los datos ingresados.
orden • La fase 2 del compilador cumple con realizar la
validación de los operandos de acuerdo con los
datos ingresados
• El analizador es realizado en Visual Basic 2012
Software
o superior.
Puntuación
Alcanzada (10)
COMPETENCIA 3
Competencia específica: 3. Conoce e identifica los diferentes tipos de optimización que
permita eficientar el código intermedio
A. Aplica los diferentes tipos de optimización para eficientar el código intermedio

B. Desarrolla los diferentes tipos de optimización para eficientar el código intermedio
Temas y subtemas:
3.1 Tipos de optimización.

3.1.1 Locales.
3.1.2 Ciclos.
3.1.3 Globales.
3.1.4 De mirilla.
3.2 Costos.
3.2.1 Costo de ejecución. (memo-ria, registros, pilas).
3.2.2 Criterios para mejorar el códi-go.
3.2.3 Herramientas para el análisis del flujo de datos.
“Conoce e identifica los diferentes tipos de optimización que permita eficientar el
código intermedio”
Asignatura:
Elaborado por:
Docente:
Grupo:
363-M
Período: 2021-1
Contenido
Introducción ..................................................................................................................................... 3
3 Conoce e identifica los diferentes tipos de optimización que permita eficientar el código
intermedio......................................................................................................................................... 4
3.1 Tipos de Optimización ........................................................................................................... 4
3.1.1 Locales ....................................................................................................................... 4
3.1.2 Ciclos .......................................................................................................................... 4
3.1.3 Globales ...................................................................................................................... 5
3.1.4 De mirilla.................................................................................................................... 5
3.2 Costos ................................................................................................................................ 5
3.2.1 Costos de ejecución (memoria, registros, pilas .......................................................... 5
3.2.2 Criterios para mejorar el código ................................................................................. 6
3.2.3 Herramientas para el análisis del flujo de datos ......................................................... 6
Conclusion ........................................................................................................................................ 7
Referencias ....................................................................................................................................... 8
Introducción
3
3 Conoce e identifica los diferentes tipos de optimización que
permita eficientar el código intermedio
3.1 Tipos de Optimización
Es el conjunto de fases de un compilador que transforman un fragmento de código en otro
fragmento con un comportamiento equivalente y que se ejecuta de forma más eficiente, es decir,
usando menos recursos de cálculo como memoria o tiempo de ejecución.
Las optimizaciones pueden realizarse de diferentes formas con base al alcance ofrecido
por el compilador. Depende del lenguaje de programación y es directamente proporcional al
tiempo de compilación.
Este es un proceso que tiende a minimizar o maximizar alguna variable de rendimiento,
generalmente tiempo, espacio, procesador, etc. La optimización se realiza reestructurando el
código de forma que el nuevo código tenga mayores beneficios.
3.1.1 Locales
Se realiza sobre módulos del programa. En la mayoría de las ocasiones a través de
funciones, métodos, procedimientos, clases, etc. Solo se ven reflejadas en las secciones locales.
Sirve cuando un bloque de programa o sección es crítico. Como el espacio de soluciones
es más pequeño, la optimización local es más rápida.
3.1.2 Ciclos
Se trata de una de las partes más esenciales en el rendimiento de un programa, dado que
realizan acciones repetitivas, y si dichas acciones están mal realizadas, el problema puede crecer
mucho más.
La mayoría de las optimizaciones sobre ciclos tratan de encontrar elementos que no deben
repetirse en un ciclo.
El problema de la optimización en ciclos y en general radica es que muy difícil saber el
uso exacto de algunas instrucciones. Así que no todo código de proceso puede ser optimizado.
Otros usos de la optimización pueden ser el mejoramiento de consultas en SQL o en
aplicaciones remotas
4
3.1.3 Globales
Dada con respecto al código completo.
Este tipo de optimización es más lenta, pero tiene la capacidad de mejorar el desempeño
general de todo el programa y puede depender de la arquitectura de la máquina.
En algunos casos es mejor mantener variables globales para agilizar los procesos, pero
consume memoria. Algunas optimizaciones incluyen utilizar como variables registros del CPU o
utilizar instrucciones en ensamblador.
3.1.4 De mirilla
La optimización de mirilla trata de estructurar de manera eficiente el flujo del programa,
sobre todo en instrucciones de bifurcación como son las decisiones, ciclos y saltos de rutinas. La
idea es tener los saltos lo más cerca de las llamadas, siendo el salto lo más pequeño posible.
3.2 Costos
Los costos son el factor más importante para tomar en cuenta a la hora de optimizar ya
que en ocasiones la mejora obtenida puede verse no reflejada en el programa final, pero si ser
perjudicial para el equipo de desarrollo.
La optimización de una pequeña mejora tal vez tenga una pequeña ganancia en tiempo o
espacio, pero sale muy costosa en tiempo en generarla. Pero en cambio si esa optimización se
hace por ejemplo en un ciclo, la mejora obtenida puede ser N veces mayor por lo cual el costo se
minimiza y es benéfico la mejora.
3.2.1 Costos de ejecución (memoria, registros, pilas
Son aquellos que vienen implícitos al ejecutar el programa. En algunos programas se tiene
un mínimo para ejecutar el programa, por lo que el espacio y la velocidad de microprocesadores
son elementos que se deben optimizar para tener un mercado potencial más amplio.
Las aplicaciones multimedia como los videojuegos tienen un costo de ejecución alto por
lo cual la optimización de su desempeño es crítica, la gran mayoría de las veces requieren de
procesadores rápidos o de mucha memoria.
Los dispositivos móviles tienen recursos más limitados que un dispositivo de cómputo
convencional razón por la cual, el mejor uso de memoria y otros recursos de hardware tiene
mayor rendimiento.
5
3.2.2 Criterios para mejorar el código
Los criterios de optimización siempre están definidos por el compilador.
La mejor manera de optimizar el código es hacer ver a los programadores que optimicen
su código desde el inicio, el problema radica en que el costo podría ser muy grande ya que tendría
que codificar más y/o hacer su código más legible.
Muchos de estos criterios pueden modificarse con directivas del compilador desde el
código o de manera externa. Este proceso lo realizan algunas herramientas del sistema como los
ofuscadores para código móvil y código para dispositivos móviles.
3.2.3 Herramientas para el análisis del flujo de datos

Existen algunas herramientas que permiten el análisis de los flujos de datos, entre ellas
tenemos los depuradores y desambladores.
Depurador
Es una aplicación que permite correr otros programas, permitiendo al usuario ejercer
cierto control sobre los mismos a medida que los estos se ejecutan, y examinar el estado del
sistema (variables, registros, banderas, etc.) en el momento en que se presente algún problema.
Éste permite detener el programa en:
• Un punto determinado mediante un punto de ruptura.
• Un punto determinado bajo ciertas condiciones mediante un punto de ruptura condicional.
• Un momento determinado cuando se cumplan ciertas condiciones.
• Un momento determinado a petición del usuario.
Durante la interrupción puede:

• Examinar y modificar la memoria y las variables del programa.
• Examinar el contenido de los registros del procesador.
• Cambiar el punto de ejecución, de manera que el programa continúe su ejecución en un
punto diferente al punto en el que fue detenido.
• Ejecutar instrucción a instrucción.
• Ejecutar partes determinadas del código, como el interior de una función, o el resto de
código antes de salir de una función.
6
Desamblador
Es un programa de computadora que traduce el lenguaje de máquina a lenguaje
ensamblador, la operación inversa de la que hace el ensamblador.
Un desensamblador se diferencia de un decompilador, en que está dirigido a un lenguaje
de alto nivel en vez de al lenguaje ensamblador.
Son ampliamente utilizados para crackear programas y para realizar ingeniería inversa.
También son utilizados por desarrolladores de software, investigadores o estudiantes.
Conclusion
7
Referencias
• Clarisó, R., 2021. Optimización de código: un código más eficiente - Tecnología++. [online]
Tecnología++. Available at: <https://informatica.blogs.uoc.edu/optimizacion-de-codigo-un-
codigo-mas-eficiente/> [Accessed 28 April 2021].
• Olivares Rojas, J., 2021. Unidad VII Otimización. [online] Dsc.itmorelia.edu.mx. Available at:
<http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u7.pdf> [Accessed 29 April
2021].
• Lenguajes y Autómatas 2, 2020. 3.2.3 Herramientas para Análisis del Flujo de Datos. [online]
Blogspot. Available at: <https://equiponegro8.blogspot.com/2020/03/3_53.html> [Accessed
28 April 2021].
8

FO-205P11000-13
Nombre y número de
control:(5)
CRITERIOS
SI NO

tema.

Características
Puntuación
Alcanzada (10)
FO-205P11000-14

Fecha de entrega: (6) 03/ Mayo/ 2021
Competencia No.: (7) 3 Descripción: (8) Conoce e identifica los diferentes tipos de optimización que permita
eficientar el código intermedio
Indicador de alcance: (9) A. Aplica los diferentes tipos de optimización para eficientar el código intermedio
Evidencia de aprendizaje: (10) Mapa Conceptual

FO-205P11000-13
Nombre y número de Bautista Monter Marya Fernanda
control: (5) 183107254 Grupo: (6) 363-M
Evidencia de aprendizaje: (7) Mapa Conceptual
.
CRITERIOS DE
SI NO OBSERVACIONES
EVALUACIÓN
El concepto principal es adecuado y
Concepto pertinente con el tema y la pregunta de
principal enfoque.
El mapa conceptual incluye todos los
conceptos importantes que representa la
Conceptos información principal del tema o pregunta de
subordinados enfoque. No repite conceptos
Clasificación de conceptos
presentados de manera
lógica, estos se encuentran
Conexión de relacionados unos con otros a través de
conceptos palabras claves
y /o conectores, de tal manera que resulta
fácil su comprensión
Bibliografía Contiene referencias bibliográficas
El mapa conceptual se encuentra

impecablemente presentado en el formato
Presentación de evidencias y el cual se encuentra
debidamente lleno.
Gramática y No contiene errores gramaticales y faltas de
ortografía ortografía.
Se entrega en el tiempo establecido por el
Entrega docente
Puntuación
Alcanzada (10)
FO-205P11000-14

Indicador de alcance: (9) B. Desarrolla los diferentes tipos de optimización para eficientar el código intermedio
Evidencia de aprendizaje: (10) Fase 3 Compilador (Optimización de la Pila Semántica)

BOTÓN INICIO


BOTÓN SALIR




“ANALIZAR”.

“COMPILA”.
BONTÓN “←”
BOTÓN REGRESAR



FASE 2
Continuando con la segunda fase del proyecto, agregamos un módulo llamado
“Module1” en el que declaramos variables mirilla, mismas que utilizaremos de forma general
a lo largo de los procedimientos.
Module Module1
Public valor(30) As String
Public valo(30) As String
Public simbolo(31) As String
Public imp As String
Public resultado As Object
Public ss As String
Public orden As Integer
Public orde As Integer
Public op As Integer
Public token As String
Public contador As Integer
Public tama As Integer, m As Integer
Public pru As String, res As String, operacion As String, s As String
Public i As Integer, o As Integer, lim As Integer, a As Integer, se As Integer,
ats As Integer, repetision As Integer, veces As Integer
Public vez As Boolean
Public basura As String, basura2 As String, cd As String
Public des As Integer, z As Integer
Public ordn As Boolean
Public dis As Integer, dr As Integer
Public daf As Integer, x As Integer
End Module
Posteriormente, generamos una clase de nombre “ModuleCodeDom” que contiene

las sentencias de una librería que nos permitirá tener mayor control y eficiencia sobre los
procedimiento y resultados del compilador K.
Option Strict On
Imports System.CodeDom.Compiler
Imports System.Reflection
Public Class ModuleCodeDom
Shared Function Eval(ByVal expresion As String) As Object
Dim CrLf As String = Environment.NewLine
Dim cpar As New CompilerParameters()
cpar.GenerateInMemory = True
cpar.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll")
Dim vbcp As New VBCodeProvider()

Dim source As String =
"Imports Microsoft.VisualBasic" & CrLf &
"Namespace MiNamespace" & CrLf &
" Public Class MiClase" & CrLf &
" Public Shared Function Eval() As Object " & CrLf &
" Return " & expresion & CrLf &
" End Function" & CrLf &
" End Class" & CrLf &
"End Namespace"
Dim res As CompilerResults = vbcp.CompileAssemblyFromSource(cpar, source)

res.TempFiles.KeepFiles = True
If (res.Errors.Count > 0) Then _

Return res.Errors(0).ErrorText
Dim ty As System.Type =
res.CompiledAssembly.GetType("MiNamespace.MiClase")
Dim funceval As MethodInfo = ty.GetMethod("Eval")
Return funceval.Invoke(Nothing, Nothing)
End Function
End Class
Dentro del formulario número 2, declaramos variables adicionales para su uso en los
siguientes procedimientos.
Dim expresion As String

Dim tam As Integer
Dim caracter As String
Dim operandos As String
Dim operadores As String
Dim numeros As String
Dim simbolos As String
Dim parte1, parte2 As String
Dim valor1, valor2, resultado As Integer
Dim la As Integer
Dim y As Integer
Dim almacena As String, cara
Dim s As String
Dim c As Char
Dim w As Integer
Dim parentesis As String
Dim cadena As String
Dim largo As Integer
Dim simbolo(40) As String
Dim cas As Integer
Dim confirmar As Boolean
Agregamos elementos extra al procedimiento “Limpiar”, de tal forma que ciertas
variables se “reinicien” cada que se limpien los campos.
Private Sub Limpiar()

txtCaracteres.Clear()
txtOperandos.Clear()
txtOperadores.Clear()
expresion = Nothing
tam = Nothing
caracter = Nothing
operandos = Nothing
operadores = Nothing
numeros = Nothing
simbolos = Nothing
End Sub
Posteriormente a estos cambios, realizamos la programación de los métodos que nos

permitirán la identificación de paréntesis y operaciones, así como los procedimientos para la
realización de las operaciones aritméticas que generarán los resultados de nuestro
compilador.
Método “Tipo de Operación”

Public Sub TipoOperacion()
contador = 0
imp = imp
largo = Len(imp)
For i = 0 To largo
If token = "+" Or token = "-" Or token = "*" Or token = "/" Then
contador = contador + 1
End If
Next
End Sub
Método “Análisis”
Public Sub Analisis()
daf = 0
cd = 0
op = 0
a = 0
o = 0
lim = 0
dr = 0
se = 0
veces = 0
x = 0
ats = 0
token = Mid(imp, 1, 1)
If token = "(" Then

o = 1
MsgBox("")
Else
o = 2
End If
If o = 1 Then
For x = 0 To tama
op = op + 1
ElseIf token = ")" Then
lim = x
Exit For
End If
Next
Label1.Text = op
daf = tama - op + 1
operacion = Mid(imp, 2, op - 1)
basura = Mid(imp, lim + 1, daf)
imp = res + basura
imp = imp
tama = Len(imp)
Else
For x = 1 To tama
If token <> "(" Then
op = op + 1
Else
Exit For
End If
Next
For a = op + 1 To tama
token = Mid(imp, a, 1)
lim = lim + 1
m = lim
Else
Exit For
End If
Next
se = lim + op + 1
basura = Mid(imp, 1, op)
operacion = Mid(imp, op + 2, lim - 1)
If se = tama Then
imp = basura + res
imp = imp
tama = Len(imp)
Else
ats = tama - res
basura2 = Mid(imp, se + 1, ats)
imp = imp
tama = Len(imp)
End If
End If
End Sub
Método “Suma”
Public Sub Suma()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "+" Then
x = i
m = i
While x > 1
Exit While
Else
lim = lim + 1
End If
x = x + 1
End While
Exit For
End If
Next
dis = lim + m
z = tama - m
imp = res + basura
End Sub
Método “Resta”
Public Sub Resta()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
If token = "-" Then
x = i
m = i
While x > 1
Exit While
Else
lim = lim + 1
End If
x = x + 1
End While
Exit For
End If
Next
dis = lim + m
z = tama - m
imp = res + basura
End Sub
Método “Multiplicación”
Public Sub Multiplicar()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
o = 1
Exit For

o = 2
Exit For
End If
Next
For i = 1 To tama
If token = "*" Then
x = i
m = i
While x > 1
z = x
Exit While
Else
lim = lim + 1
End If
x = x - 1
End While
While m <= tama
Exit While
Else
des = des + 1
End If
m = m + 1
End While
Exit For
End If
Next
s = lim + des
If o = 1 Then
If dis = 0 Then
imp = basura + res
tama = Len(imp)
Else
tama = Len(imp)
End If
Else
dr = s
While dr > tama
op = op + 1
dr = dr + 1
End While
imp = res + basura
tama = Len(imp)
End If
End Sub
Método “División”
Public Sub Dividir()
o = 0
m = 0
x = 0
z = 0
lim = 0
dis = 0
s = 0
dr = 0
op = 0
des = 0
For i = 1 To tama
o = 1
Exit For
ElseIf token = "/" Then

o = 2
Exit For
End If
Next
For i = 1 To tama
If token = "/" Then
x = i
m = i
While x > 1
z = x
Exit While
Else
lim = lim + 1
End If
x = x - 1
End While
While m <= tama
Exit While
Else
des = des + 1
End If
m = m + 1
End While
Exit For
End If
Next
s = lim + des
If o = 1 Then
If dis = 0 Then
imp = basura + res
tama = Len(imp)
Else
tama = Len(imp)
End If
Else
dr = s
While dr > tama
op = op + 1
dr = dr + 1
End While
imp = res + basura
tama = Len(imp)
End If
End Sub
Finalmente, realizamos algunas modificaciones en la interfaz, de tal forma que los

labels correspondientes a “Caracteres”, “Operando”, “Operadores” y “Operación”, así cómo
sus respectivos TextBox sean invisibles desde que se abre la ventana de la corrida del
compilador.
Ilustración 17. Modificaciones de la interfaz de Compilador K

FASE 3
Para finalizar nuestro programa, lo que hicimos fue generar el código dentro de los
botones “Analizar” y “Compila”, de esta manera, cada uno de ellos ya puede realizar la
función requerida.
Lo primero que vamos a hacer es programar el botón “Analizar”, en el que haremos
que el programe valide los caracteres que estamos utilizando y los separe entre operadores y
operandos. Igualmente, nos habilitará el botón “Compila”.
btnCompilar.Enabled = True
Limpiar()
If TxtExpresion.Text = " " Or TxtExpresion.Text = "" Or TxtExpresion.Text =
Nothing Then
MessageBox.Show("No has ingresado ninguna expresión", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
Exit Sub
End If
expresion = TxtExpresion.Text
tam = Len(expresion)
lblCaracteres.Visible = True
txtCaracteres.Visible = True
For i As Integer = 1 To tam

caracter = Mid(expresion, i, 1)
Select Case caracter
Case "0"
operandos = operandos & caracter
txtCaracteres.AppendText(caracter & " Autenticado" & vbCrLf)
Case "1"
Case "2"
Case "3"
Case "4"
Case "5"
Case "6"
Case "7"
Case "8"
Case "9"
Case "+"
operadores = operadores & caracter
Case "-"
Case "*"
Case "/"
Case "{"
Case "}"
Case Else
txtCaracteres.AppendText(caracter & " No autenticado" & vbCrLf)
MessageBox.Show("Los valores ingresados no han sido
autenticados", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
txtOperacion.Visible = False
txtOperadores.Visible = False
txtOperandos.Visible = False
lblOperacion.Visible = False
lblOperadores.Visible = False
lblOperandos.Visible = False
Exit Sub
End Select
Next
tam = Len(operandos)
lblOperandos.Visible = True
txtOperandos.Visible = True
numeros = Mid(operandos, i, 1)
txtOperandos.AppendText(numeros & vbCrLf)
Next
tam = Len(operadores)
lblOperadores.Visible = True
txtOperadores.Visible = True
simbolos = Mid(operadores, i, 1)
txtOperadores.AppendText(simbolos & vbCrLf)
Next
Ilustración 18. Pantalla al dar click en "Analizar"
Por último, programamos el botón “Compila”, que es el que nos mostrará la resolución de la
operación que hemos ingresado; esto a través de los procedimientos que ya creamos de “Suma”,
“Resta”, “Multiplicación” y “División”.
lblOperacion.Visible = True
txtOperacion.Visible = True
ordn = True
imp = TxtExpresion.Text
tama = Len(imp)
While ordn = True

TipoOperacion()
If contador = 1 Then
operacion = imp
txtOperacion.AppendText(res & vbCrLf)
ordn = False
GoTo fin
Else
For x = 1 To tama
If token = "{" Then
Analisis()
GoTo fin
Exit For
End If
Next
For x = 1 To tama
If token = "/" Then
Dividir()
GoTo fin
Exit For
Multiplicar()
GoTo fin
End If
Next
For x = 1 To tama
If token = "+" Then
Suma()
GoTo fin
Exit For
ElseIf token = "-" Then
Resta()
GoTo fin
End If
Next
fin: End If
End While
Ilustración 19. Pantalla al dar click en “Compila”

FO-205P11000-13
Nombre y número Bautista Monter Marya Fernanda
Grupo: (6) 363-M
de control: (5) 183107254
Evidencia de aprendizaje: (7) Compilador fase 3 (Optimización de la pila semántica)
CRITERIOS
SI NO

su estilo.
• Entrega las capturas de pantalla realizadas

Presentación
en esta fase en el formato de evidencias

Diseño grafico colores y matices adecuados dentro del
desarrollo.
• La fase 3 del compilador cumple con la
tener coherencia y congruencia en la parte
del desarrollo.
• La fase 3 del compilador cumple con
realizar la validación de los de los datos,
Estructura y sobre los datos insertados y aceptados
orden previamente.
• La fase 3 realiza el desglosé de la pila
semántica y aplica de manera correcta las
operaciones posfijas, infijas o prefijas.
• La fase 3 logra tener el resultado correcto
de la operación a realizar.
• El analizador es realizado en Visual Basic
Software
2012 o superior.
Puntuación
Alcanzada (10)
FO-205P11000-14

Indicador de alcance: (9) B. Desarrolla los diferentes tipos de optimización para eficientar el código intermedio
Evidencia de aprendizaje: (10) Fase 1 ChatBot (Interfaz Gráfica)
FORMULARIO DE CARGA
Se muestra la pantalla de inicio del chat bot, misma que contiene la leyenda
“Cargando la matriz operativa de Baymax” “Espere…”, así como una barra de carga que
indicará la apertura del formulario 2.
Ilustración 1. Formulario de Carga

FORMULARIO 2
Una vez que la barra de carga termine de llenarse, el programa abrirá el segundo
formulario, el que contendrá dos RichTextBox; el primero será el área en el que aparecerá
nuestra conversación con el ChatBot, y el segundo en el que podremos visualizar las
sentencias que éste haya aprendido.
De igual manera, encontraremos un label con el texto “Clave” junto con un TextBox
de nombre “TxtClave” en el que podremos introducir frases nuevas para que el ChatBot
reconozca. Debajo de éstas, encontramos el label con texto “Respuesta” y su TextBox de
nombre “TxtRespuesta” en el que especificaremos la respuesta a las claves que añadimos.
Junto a éstos tenemos el botón “Guardar” para grabar ambas sentencias.
Como parte de la información que el ChatBot tendrá almacenada para funcionar,
tenemos dos botones; “Editar” y “Ordenar”, con los que podremos editar directamente el
documento en el que se almacenan las claves y respuestas de Baymax.
Por último encontramos el botón salir para cerrar el programa.
Ilustración 2. Formulario 2
BOTÓN SALIR
“¿Desea Cerrar el ChatBot?”.

“Cerrando el ChatBot Espere por favor” y cerrará el programa al pulsar “Aceptar”.
Ilustración 4. Cuadro de Texto "Sí”



FO-205P11000-13
Grupo: (6) 363-M
de control: (5) 183107254
Evidencia de aprendizaje: (7) ChatBot fase 1(Interfaz grafica)
CRITERIOS
SI NO
• El alumno muestra la interfaz del ChatBot

siendo única y no repetida en su estilo.
• Entrega las capturas de pantalla

Presentación
realizadas en esta fase en el formato de
evidencias previamente requisitado.

Diseño
colores y matices adecuados dentro del
grafico
desarrollo.
• La fase 1 del ChatBot contiene una
Estructura y estructura adecuada y con la terminología
orden donde el lenguaje del Chatedor inteligente
es único en su realización.
• El ChatBot es realizado en Visual Basic

Software
2012 o superior.
Puntuación
Alcanzada (10)
COMPETENCIA 4
Competencia específica: 4. Utiliza un lenguaje de bajo nivel para traducir el código
construido a lenguaje máquina para su ejecu-ción.
A. Conoce las bases del lenguaje de bajo nivel para la traducción de un código intermedio
B. Desarrolla las bases del lenguaje de bajo nivel para la traducción de un código
intermedio (ChatBot)
Temas y subtemas:
4.1 Registros.
4.2 Lenguaje ensamblador.
4.3 Lenguaje máquina.
4.4 Administración de memoria.
“Utiliza un lenguaje de bajo nivel para traducir el código construido a lenguaje
máquina para su ejecución”.
Asignatura:
Elaborado por:
Docente:
Grupo:
363-M
Período: 2021-1
Contenido
Introducción ..................................................................................................................................... 3
4 GENERACIÓN DE CÓDIGO INTERMEDIO ....................................................................... 4
4.1 Registros ............................................................................................................................ 4
4.2 Lenguaje Ensamblador ...................................................................................................... 4
4.2.1 Ensambladores Básicos .............................................................................................. 5
4.2.2 Ensambladores Modulares ......................................................................................... 5
4.3 Lenguaje Máquina ............................................................................................................. 5
4.4 Administración de Memoria .............................................................................................. 6
Conclusion ........................................................................................................................................ 7
Referencias ....................................................................................................................................... 7
Introducción
3
4 GENERACIÓN DE CÓDIGO INTERMEDIO
4.1 Registros
Son la memoria principal de la computadora. Existen diversos registros de propósito
general y otros de uso exclusivo. Existen registros acumuladores para puntero de instrucción,
pila, etc.
En éstos mismo existe la distribución, ésta es el proceso en el que el programa generado
puede ejecutarse en otras máquinas. Respecto al ensamblador, la mayoría del direccionamiento se
hace relativo para que el programa sea relocalizable por un programa llamado cargador.
Respecto a los programas compilados se necesitan librerías, si son estáticas se incluyen en
el ejecutable, por lo que el programa se hace gráfico, si son dinámicas, el programa se hará más
pequeño.
La asignación de valores a variables se hace a través de un proceso de mover el contenido
de memoria a registro, o de registro a memoria, pero nunca de memoria a memoria. Cuando se
trata de memoria dinámica se debe seguir el rastro de los datos.
4.2 Lenguaje Ensamblador
El lenguaje ensamblador se trata de un traductor de código de bajo nivel que pasa la
información a un código que es posible ejecutar directamente por la máquina en la que fue
generado. El lenguaje ensamblador fue la primera abstracción de un lenguaje de programación,
posteriormente aparecieron los compiladores para sustituirlo.
Lo que hace el programa es leer un archivo escrito en lenguaje ensamblador y luego
sustituye cada uno de los códigos con un equivalente en código máquina. Los programas
generados se hacen portables de máquina a máquina y el cálculo de bifurcaciones se hace de
manera sencilla.
Una de las ventajas del uso del ensamblador, es que se encarga de administrar de manera
transparente para el usuario la creación de memoria, las bifurcaciones y el paso de los
parámetros. Además, permite el acceso directo a los recursos de la máquina para un mejor
desempeño.
4
4.2.1 Ensambladores Básicos
De muy bajo nivel. Ofrecen nombres simbólicos a las distintas instrucciones, parámetros
y cosas tales como los modos de direccionamiento.
4.2.2 Ensambladores Modulares
Son descendientes de los ensambladores básicos, fueron muy populares en las décadas de
los 50´s y 60´s, antes de la generalización de los lenguajes de alto nivel. Una macroinstrucción es
el equivalente a una función en un lenguaje de alto nivel.
4.3 Lenguaje Máquina

El lenguaje máquina sólo es entendible por las computadoras. Se basa en una lógica
binaria de 0 y 1, generalmente implementada por mecanismos eléctricos. En general el lenguaje
máquina es difícil de entender para los humanos por este motivo hacemos uso de lenguajes más
parecidos a los lenguajes naturales.
El lenguaje máquina realiza un conjunto de operaciones predeterminadas llamadas
microoperaciones. Las microoperaciones sólo realizan operaciones del tipo aritmética (+,-,*, /),
lógicas (AND, OR, NOT) y de control (secuencial, decisión, repetitiva).
Es dependiente del tipo de arquitectura. Así un programa máquina para una arquitectura
intel x86 no se ejecutará en una arquitectura Power PC de IBM de manera nativa. Algunos
microprocesadores implementan más funcionalidades llamado CISC, pero son más lentos que los
RISC ya que estos tienen registros más grandes.
Dentro del lenguaje máquina, una parte fundamental es el direccionamiento, un programa
no tiene la posibilidad de ejecutarse a menos que se encuentre almacenado en la memoria
principal, de esta forma, el direccionamiento es la manera en la que se accede a la memoria para
poder realizar las instrucciones del programa. La forma de acceder a la memoria depende del
microprocesador, pero en general existen dos tipos de direccionamiento: directo e indirecto.
• Direccionamiento Directo
También recibe el nombre de direccionamiento absoluto y el acceso a las
direcciones se hace de manera directa.
• Direccionamiento Indirecto
También recibe el nombre de direccionamiento relativo y se basa a partir de una
dirección genérica, generalmente el inicio del programa.
5
4.4 Administración de Memoria
La administración de la memoria de un proceso hoy en día muy importante, de tal modo
que su mal o buen uso tiene una acción directa sobre el desempeño de memoria. En general un
ensamblador tiene un administrador de memoria más limitado que un compilador.
En la mayoría de los lenguajes de programación el uso de punteros no estaba vigilado por
lo que se tienen muchos problemas con el uso de memoria. Los lenguajes más recientes controlan
el uso de punteros y tienen un programa denominado recolector de basura que se encarga de
limpiar la memoria no utilizada mejorando el desempeño.
Las técnicas que existen para la carga de programas en la memoria son: partición fija, que
es la división de la memoria libre en varias partes (de igual o distinto tamaño) y la partición
dinámica, que son las particiones de la memoria en tamaños que pueden ser variables, según la
cantidad de memoria que necesita cada proceso.
Entre las principales operaciones que desarrolla la administración de memoria se
encuentran la reubicación, que consiste en trasladar procesos activos dentro y fuera de la
memoria principal para maximizar la utilización del procesador; la protección, mecanismos que
protegen los procesos que se ejecutan de interferencias de otros procesos; uso compartido de
códigos y datos, con lo que el mecanismo de protección permite que ciertos procesos de un
mismo programa que comparten una tarea tengan memoria en común.
6
Conclusion
Referencias
• Clarisó, R., 2021. Administración de memoria - Tecnología++. [online] Tecnología++.
Available at: <https://informatica.blogs.uoc.edu/optimizacion-de-codigo-un-codigo-mas-
eficiente/> [Accessed 03 June 2021].
• Olivares Rojas, J., 2021. Unidad VII Otimización. [online] Dsc.itmorelia.edu.mx. Available at:
<http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u7.pdf> [Accessed 03 June
2021].
• Lenguajes y Autómatas 2, 2020. 3.2.3 Herramientas para Análisis del Flujo de Datos. [online]
Blogspot. Available at: <https://equiponegro8.blogspot.com/2020/03/3_53.html> [Accessed
03 June 2021].
7

FO-205P11000-13
Nombre y número de
control:(5)
CRITERIOS
SI NO

tema.

Características
Puntuación
Alcanzada (10)
FO-205P11000-14

Fecha de entrega: (6) 09/ Junio/ 2021
Competencia No.: (7) 4 Descripción: (8) Utiliza un lenguaje de bajo nivel para traducir el código construido a
lenguaje máquina para su ejecución.
Indicador de alcance: (9) A. Conoce las bases del lenguaje de bajo nivel para la traducción de un código intermedio
Evidencia de aprendizaje: (10) Mapa Mental
https://view.genial.ly/60be995ef5f8410d54931b6b/interactive-image-generacion-
de-codigo-intermedio

FO-205P11000-13
Nombre y número de Bautista Monter Marya Fernanda
Grupo: (6) 363-M
control: (5) 183107254
Evidencia de aprendizaje: (7) Mapa Mental
CRITERIOS OBSERVACIONES
SI NO
DE EVALUACIÓN
Profundización Descripción clara y sustancial del tema y

del tema buena cantidad de detalles.
Aclaración sobre Tema bien organizado y claramente

el tema presentado, así como de fácil seguimiento.
Mapa mental sobresaliente y atractivo que

Alta calidad del
cumple con los criterios de diseño
diseño
planteados, sin errores de ortografía.
La imagen central se asocia correctamente

con el tema, las ideas principales y
Elementos
secundarias se distinguen unas de otras y
propios del mapa
las palabras clave representan conceptos
mental
importantes. Las imágenes utilizadas son
adecuadas.
La selección de los colores y la tipografía
Presentación del usada fueron atractivas, además el mapa
mapa mental se entregó de forma limpia en el formato
que determino el docente (papel o digital).
Contiene referencias bibliográficas de

Referencias
donde se obtuvo la información
Puntuación
Alcanzada (10)
FO-205P11000-14

Indicador de alcance: (9) B. Desarrolla las bases del lenguaje de bajo nivel para la traducción de un código intermedio
(ChatBot)
Evidencia de aprendizaje: (10) Reporte de Semana Cultural
La Magia del Servicio Detrás de Disney
La conferencia llevada por el ponente René Carrasco Bernal, quien entre muchas
cosas nos compartió los principios y las estrategias que se presentan para el funcionamiento
de Disney World.
Desde el principio de ésta, se nos mencionaron dos instituciones fundamentales para
la capacitación de personal de los parques y de los externos. Éstas con los nombres de
“Disney Institute” el que se encarga de mostrar los modelos Disney a todo externo que lo
desee y/o necesite, y “Disney University” el que cuenta como requisito para todos y cada uno
de los trabajadores de los parques Dinsey.
Entre muchas cualidades y principios, Disney mete a todo su personal bajo la misma
línea, es decir, “El pensamiento Disney”. El que básicamente (aunque no es basta la
expresión), se trata de mantener a todo trabajador bajo un solo propósito; GENERAR
MOMENTOS MÁSGICOS.
El hecho de marcar una diferencia entre un “momento feliz” y un MOMENTO
MÁGICO (es decir, generar momentos inolvidables y trascendente), es parte de lo que hace
a Disney lo que hoy es, y para lograrlo tienen conceptos muy específicos, entre ellos el hecho
de que sus trabajadores no son trabajadores, sino actores, y que los clientes no son clientes
sino huéspedes, por lo que éstos deben ser tratados como amigos o incluso familia.
Para demostrar que cada una de las personas involucradas está completamente
comprometida con este objetivo, Disney no se preocupa en mantener un uniforme, sino que
no escatima en el vestuario de cada uno de sus actores, lo que a su vez implica que las
entrevistas de trabajo no sean eso mismo, más bien son denominadas Audiciones, de tal
forma que tomando en cuenta de que hablamos de una industria hasta cierto punto teatral, el
“trabajo” de cada actor, es interpretar su correspondiente rol.
Otra de las grandes estrategias de Disney, que acompañan los roles de sus actores, se
refiere a las atracciones (cabe puntualizar que NO son juegos mecánicos), ya que cada una
de ellas tiene la misión de contar una historia y de tomar todo lo que está a su alrededor para
llevar de la mano a sus huéspedes en ella.
Las personas encargadas de hacer estas historias realidad son denominadas
Imagineers, es decir ingenieros encargados de no dejar de soñar, de tal forma que son
profesionales los que piensan en hacer y/o deshacer lo que sea necesario para que el huésped
esté lleno de las sensaciones que Disney quiere transmitir.
De la mano de éstos Imagineers, vienen también las reuniones después de cada día en
la que el objetivo es identificad cada una de las cosas que se hicieron bien, es decir, cada uno
de los actores se encarga de trasmitir al resto del elenco las historias que vieron: las familias
que llegaron y qué los hizo felices, qué es lo que un niño hace cuando ve a uno de los
personajes, por qué los huéspedes sonríen en cada atracción, etc.
Estas reuniones, lo que generan normalmente es la creación de nuevos productos y
servicios. Así fue como nació también la rama Disney's Fairy Tale Weddings &
Honeymoons, de forma que Disney se ha posicionado en el record mundial de nuevos
productos, generando en promedio productos nuevos cada 5 minutos.
Así como cada uno de los detalles que Disney se propone generar, tenemos que
incluso su estacionamiento se trata de un “momento mágico”, ya que es tremendamente
importante que los huéspedes sientan la magia desde que llegan, hasta que se van.
Y tanta magia les ha sido tan útil que tan sólo de estacionamiento Disney facturó 10
millones de dólares en 2019, bajo una política muy puntual en la que dicen que “lo que no se
cuenta, no se puede mejorar”.
Así como ser una empresa obsesionada con los detalles y totalmente entregada con
sus huéspedes, Disney es uno de los lugares que más emplea, esto con la finalidad de tener
el suficiente personal, o los suficientes actores, para mantener cada detalle en total control.
Los muchos empleados de Disney son utilizados todo el tiempo de forma eficiente,
de tal forma que tan solo un actor de Disney se encuentra 20 minutos trabajando y 20 minutos
descansando cíclicamente durante toda su jornada. Logrando esto gracias a los múltiples
túneles que se encuentran debajo del parque.
Así después de haber trabajado y “exprimido” totalmente la capacidad de un actor de
estar en una botarga por 20 minutos, la persona que lo acompaña hace una pausa muy breve
con los huéspedes para que este actor sea relevado por otro con el mismo personaje y continúe
generando momentos mágicos.
Las instalaciones de los parques Disney cuentan con redes de internet abiertas en todo
el parque, estacionamientos y restaurantes, así nuestra empresa consigue que los huéspedes
se sientan en la libertad de subir fotografías cuando están en las atracciones, transmitir en
vivo durante el recorrido y de paso ganar publicidad gratis.
Pero las redes de Disney no son manejadas por los Imagineers, sino que las empresas
de telecomunicaciones de encargan de ese aspecto, lo que nos lleva a la siguiente gran
estrategia de Disney: Trabaja en Equipo. A lo largo del mundo y de sus años de experiencia,
Disney ha conseguido generar negocios con las grandes empresas que satisfacen sus
necesidades, entre ellas, las redes, las sodas, alimentos, recuerdos, etc. Logrando así la venta
de 14 millones de dólares en comida por hora, 40 mil orejas de Mickey por hora, 245 mil
litros de helado al año y 45 millones de refrescos al año (por mencionar algunos).
Una de las grandes metas de Walt Disney cuando creó su compañía, era que quería
que sus parques estuviesen abiertos las 24 horas los 365 días del año. Y lo ha logrado gracias
a sus múltiples parques en todo el mundo, así mientras los parques de la mitad del mundo
cierran, los de la otra mitad apenas están abriendo.
Algunos de nosotros podemos recordar al primer personaje de Disney “Oswald” (o
no), realmente la mayoría no conoce al no tan famoso Oswald, ya que su creación fue
compartida con uno de los colaboradores de Walt Disney, quien logró quitarle los derechos
impidiendo que se volviera parte de las atracciones de Walt.
Con ésta valiosa experiencia, Walt Disney aprendió entre muchas cosas, dos muy
importantes: que nunca trabajaría para nadie y que nadie se hace rico trabajando para alguien
más (aunque la segunda llegara un poco después de este episodio). Y dejándonos a todos los
demás sus estrategias gerenciales más importantes:
• Predicar con el ejemplo
• ¿Qué se hizo bien? (productos)
• Divertirse, no trabajar
• Actitud más que aptitud (El estudio e idioma son importantes, pero valen más los
valores)
• Productos, servicios y habilidades únicos
• Obsesión por los detalles
Por último, como aprendizaje personal, me gustaría dejar algo que tal vez pueda
englobar cada una de las estrategias que el Sr. Walt Disney nos ha hecho llegar, que es
básicamente: Haz lo imposible.
Conclusión
Las cosas que hacemos para garantizar el éxito deben estar completamente ligadas a
la forma en la que estamos dispuestos a trabajar y aún más a vivir. Si bien, la mayoría de las
políticas empresariales (sobre todo de servicio) es que el cliente siempre tiene la razón y que
se hace todo por el cliente, debemos entender que nosotros formamos parte de esta directriz,
pero más allá, debemos estar comprometidos con lo que hacemos.
Cada uno de nosotros supuestamente estamos estudiando lo que estudiamos para vivir
de ello, es decir, que lo que hacemos ahora es lo que haremos el resto de nuestras vidas, y
debemos estar completamente comprometidos con éste papel, ya que lo que le entregamos al
público, cliente o huésped, es todo en lo que nosotros también creemos, y por tanto, hacemos
lo imposible para siempre hacerlo mejor.
FO-205P11000-14

Indicador de alcance: (9) B. Desarrolla las bases del lenguaje de bajo nivel para la traducción de un código intermedio
(ChatBot)
Evidencia de aprendizaje: (10) Fase 2 ChatBot (Interfaz Gráfica)
FORMULARIO DE CARGA
Se muestra la pantalla de inicio del chat bot, misma que contiene la leyenda
“Cargando la matriz operativa de Baymax” “Espere…”, así como una barra de carga que
indicará la apertura del formulario 2.
Ilustración 1. Formulario de Carga

FORMULARIO 2
Una vez que la barra de carga termine de llenarse, el programa abrirá el segundo
formulario, el que contendrá dos RichTextBox; el primero será el área en el que aparecerá
nuestra conversación con el ChatBot, y el segundo en el que podremos visualizar las
sentencias que éste haya aprendido.
De igual manera, encontraremos un label con el texto “Clave” junto con un TextBox
de nombre “TxtClave” en el que podremos introducir frases nuevas para que el ChatBot
reconozca. Debajo de éstas, encontramos el label con texto “Respuesta” y su TextBox de
nombre “TxtRespuesta” en el que especificaremos la respuesta a las claves que añadimos.
Junto a éstos tenemos el botón “Guardar” para grabar ambas sentencias.
Como parte de la información que el ChatBot tendrá almacenada para funcionar,
tenemos dos botones; “Editar” y “Ordenar”, con los que podremos editar directamente el
documento en el que se almacenan las claves y respuestas de Baymax.
Por último encontramos el botón salir para cerrar el programa.
Ilustración 2. Formulario 2
BOTÓN SALIR
“¿Desea Cerrar el ChatBot?”.

“Cerrando el ChatBot Espere por favor” y cerrará el programa al pulsar “Aceptar”.
Ilustración 4. Cuadro de Texto "Sí”


FASE 2
Continuando con la segunda fase del proyecto, comenzamos a desarrollar el
resto de la programación a nuestro ChatBot. Inicialmente, agregamos algunos
parámetros a la propiedad Load de nuestra segunda ventana que nos permitirá estar
seguros de que existe un lugar en el que se almacene lo que le enseñamos a nuestro
chatbot, así como agregamos un par de librerías para estas funciones.
Librerías
Imports System.IO
Imports System.Text
Load del Form 2

Private Sub Form2_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Form1.Visible = False
If My.Computer.FileSystem.FileExists(Application.StartupPath & "\Base.txt")
= False Then
My.Computer.FileSystem.WriteAllText(Application.StartupPath &
"\Base.txt", "", False)
End If
End Sub
El siguiente método implementado fue el método “Entrena”, que como su nombre lo

dice, nos va a permitir entrenar a nuestro Chatbot con las frases que ingresemos y lo que
deseamos que éste nos responda.
Método Entrena( )
Public Sub Entrena(ByVal Clave As String)
Try
If Clave.ToLower.Contains("hola") Then
RichTextBox1.SelectionColor = Color.DarkGreen
RichTextBox1.AppendText("Baymax: " & "Hola, yo soy Baymax, tu
asistente digital presonal" & vbCrLf)
RichTextBox1.ScrollToCaret()
ElseIf Clave.ToLower.Contains("me duele") Then
RichTextBox1.AppendText("Baymax: " & "Deberías acudir a lo que los
humanos llaman doctor" & vbCrLf)
Else
Dim Encuentra As Boolean = False
Dim Datos As String = Application.StartupPath & "\Base.txt"
For Each Linea In File.ReadLines(Datos, Encoding.UTF8)
Dim Encontrado As String() = Linea.Split(":")
If Clave.ToLower.Contains(Encontrado(0)) Then
RichTextBox1.AppendText("Baymax: " & Encontrado(1) & vbCrLf)
Encuentra = True
Exit For
End If
Next
If Encuentra = False Then
RichTextBox1.AppendText("Baymax: " & "No encuentro en la base de
datos alguna respuesta para continuar la conversación" & vbCrLf)
End If
End If
Catch ex As Exception
MsgBox(ex.Message)
End Try
End Sub
Seguido de éste encontramos el procedimiento “Editar”, con el que podremos mostrar

en el segundo panel de texto las frases que ya le hemos enseñado al Chatbot, así podremos
visualizar las respuestas que podríamos recibir dependiendo de cómo se dé la conversación.
Método Editar ( )
Public Sub Editar()
Try
TxtEditar.Clear()
TxtEditar.Text += Linea & vbCrLf & vbCrLf
Next
MsgBox(ex.Message)
End Try
End Sub
Así como tenemos la facilidad para observar cuáles han sido las respuestas del
Chatbot, podemos ordenar estas mismas para mayor facilidad de lectura.
Método Ordenar ( )
Public Sub Ordenar()
Dim Array As New ArrayList
Array.Add(Linea)
Next
Array.Sort()
Try
My.Computer.FileSystem.DeleteFile(Application.StartupPath & "\Base.txt")
MsgBox(ex.Message)
End Try
For I = 0 To Array.Count - 1
"\Base.txt", Array(I) & vbCrLf, True)
Next
End Sub
Implementamos una llave para que el usuario pueda enviar el mensaje que desea que
la computadora responda cuando éste presione la tecla “Enter”
KeyDown Enter
Private Sub TxtTexto_KeyDown(sender As Object, e As KeyEventArgs) Handles
TxtTexto.KeyDown
If TxtTexto.Text <> "" Then
If e.KeyCode = Keys.Enter Then
e.SuppressKeyPress = True
RichTextBox1.SelectionColor = Color.Black
RichTextBox1.AppendText("Karela: " & TxtTexto.Text & vbCrLf)
Entrena(TxtTexto.Text)
TxtTexto.Clear()
End If
End If
End Sub
Programamos el botón “Guardar” para cuando deseemos enseñar al programa una

nueva clave y respuesta, de forma que envié los nuevos valores en el mismo documento que
se ha creado en el programa.
Botón Guardar
Private Sub BtnGuardar_Click(sender As Object, e As EventArgs) Handles
BtnGuardar.Click
If TxtClave.Text <> "" And TxtRespuesta.Text <> "" Then
"\Base.txt", TxtClave.Text.ToLower.Trim & ": " & TxtRespuesta.Text.Trim & vbCrLf,
True)
MsgBox("Guardado Correctamente", MsgBoxStyle.Information, "Guardado")
TxtClave.Clear()
TxtRespuesta.Clear()
Else
MsgBox("Falta de información al realizar la consulta",
MsgBoxStyle.Information, "Error")
End If
End Sub
Por último, mandaremos llamar los métodos de Editar y Ordenar que ya creamos, en
sus correspondientes botones.
Botones Editar y Ordenar

Private Sub BtnEditar_Click(sender As Object, e As EventArgs) Handles
BtnEditar.Click
Editar()
End Sub
Private Sub BtnOrdenar_Click(sender As Object, e As EventArgs) Handles

BtnOrdenar.Click
Ordenar()
Editar()
End Sub

FO-205P11000-13
Grupo: (6) 363M
de control: (5) 183107254
Evidencia de aprendizaje: (7) ChatBot fase 2 (Interfaz gráfica)
CRITERIOS
SI NO
• El alumno muestra la interfaz del ChatBot siendo única y

no repetida en su estilo.
Presentación
• El trabajo fue realizado las estrategias vistas en clase y
asignadas por el docente dentro de las sesiones de la
asignatura.
• La interfaz gráfica es adecuada empleando colores y
Diseño grafico
matices adecuados dentro del desarrollo.
• La fase 2 del ChatBot cumple con la tener coherencia y

congruencia en la parte del desarrollo.
• La fase 2 del ChatBot cumple con realizar optimizaciones
dentro del desarrollo y la codificación.
• La fase 2 del ChatBot cumple con llevar a cabo la

Estructura y
generación de código intermedio que permita tener la
orden
interacción de habla con el usuario.
• La fase 2 del ChatBot permite aprender palabras o
expresiones nuevas para interactuar durante el habla.
• La fase 2 del ChatBot tiene algún, archivo o conexión a BD

para guardar las expresiones que se le vayan agregando.
(aprendizaje
Software • El analizador es realizado en Visual Basic 2012 o superior.
Puntuación
Alcanzada (10)

BAMM PortafolioEvidencias C4

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

BAMM PortafolioEvidencias C4

Uploaded by

Copyright:

Available Formats

DIVISIÓN DE INGENIERIA EN SISTEMAS COMPUTACIONALES

Asignatura: Lenguajes y Autómatas II

Docente: Brian Antonio Mejía Díaz

3. Fase 1 Compilador (Pila semántica) 6

Competencia específica 2. Diseña las reglas para traducir el código fuente a 7

3. Fase 2 del Compilador 10

Competencia específica 3. Conoce e identifica los diferentes tipos de 11

3. Fase 3 Compilador Final 14

4. Fase 1 ChatBot (Interfaz Gráfica) 15

Competencia específica 4. Utiliza un lenguaje de bajo nivel para traducir el 16

3. Reporte de Semana Cultural 19

A. Desarrollar el uso de las reglas semánticas para la construcción de un compilador

1.1 Árboles de expresiones.

Ilustración 1. Árbol de Expresiones

1.2 Acciones Semánticas de un Analizador Sintáctico

Un analizador sintáctico es la fase del analizador que se encarga de chequear el texto de

El manejo de errores de sintaxis es el más complicado desde el punto de vista de la

1.3 Comprobaciones de Tipos en Expresiones

1.4 Pila Semántica en un Analizador Sintáctico

Las tablas de símbolos realizan dos importantes funciones en el proceso de traducción:

1.7 Manejo de Errores Semánticos

Es una de las misiones más importantes de un compilador, aunque, al mismo tiempo, es lo

División: (1) Ingeniería en Sistemas Computacionales Grupo: (2) 363-M

Visualización del diagrama

Guía estructurada de evaluación

Evidencia de aprendizaje: (7) Compilador fase 1 (Interfaz gráfica)

• El alumno muestra la interfaz del

• El analizador es realizado en Visual

División: (1) Ingeniería en Sistemas Computacionales Grupo: (2) 363-M

Ilustración 1. Formulario de Inicio

Ilustración 2. Botón Inicio

Si el usuario da click en “Si”, se mostrará otro cuadro de diálogo con la leyenda

Ilustración 3. Cuadro de Texto "Sí"

Ilustración 4. Cuadro de Texto "No"

Ilustración 5. Botón Salir

Ilustración 6. Cuadro de Texto "Sí"

En caso contrario, se mostrará un cuadro de diálogo con la leyenda “El formulario

Ilustración 7. Cuadro de Texto "No"

Ilustración 8. Ventana del Compilador

Ilustración 9. Habilitar botón Analizar

Ilustración 10. Habilitar botón Compila

Ilustración 11. Texto con error

Ilustración 13. Botón limpiar

Ilustración 14. Botón Regresar

Si el usuario da click en “Si”, se mostrará otro cuadro de diálogo con la leyenda

Ilustración 15. Cuadro de Texto "Si"

Ilustración 16. Cuadro de Texto "No"

Guía estructurada de evaluación

Evidencia de aprendizaje: (7) Compilador fase 1 (Interfaz gráfica)

• El alumno muestra la interfaz del

• El analizador es realizado en Visual Basic

2.2 Representaciones de código intermedio.

2.3 Esquema de generación.

Si deseamos representar las expresiones (2+(3*4)) = x y ((2+3)*4)= x en las tres

Se debe tener en cuenta el proceso de asignación, de declaración, expresiones booleanas.

Los operadores unarios como x: = -y no utilizan arg2. Generalmente arg1, arg2 y

Guía estructurada de evaluación

Evidencia de aprendizaje: (7) Investigación Documental

• Contiene introducción a 1 cuartilla.

• Márgenes Definidos 2.5 por lado.

• Interlineado a 1.5 y justificado.

División: (1) Ingeniería en Sistemas Computacionales Grupo: (2) 363-M

Guía estructurada de evaluación

Evidencia de aprendizaje: (7) Cuadro Comparativo

Si deseamos representar las expresiones (2+(34)) = x y ((2+3)4)= x en las tres