DIVISIÓN DE INGENIERIA EN SISTEMAS COMPUTACIONALES

Investigación Documental
“Generación de código intermedio”

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
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
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
 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
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.

9
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].

10
 DIRECCIÓN ACADÉMICA

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) Investigación Documental

Criterios de evaluación:

CRITERIOS
SI NO
DE EVALUACIÓN OBSERVACIONES
• 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.

1ª oportunidad 2ª oportunidad
Puntuación
Alcanzada (10)