# data[].attributes.body
Diseño del Programa

El programa debe:

1. Leer una expresión matemática.

2. Convertir la expresión en una estructura de triplos.

3. Mostrar la representación intermedia.

Código en Java

import java.util.*;

class Triplo {
    String operador, operando1, operando2;

    public Triplo(String operador, String operando1, String operando2) {
        this.operador = operador;
        this.operando1 = operando1;
        this.operando2 = operando2;
    }

    @Override
    public String toString() {
        return "(" + operador + ", " + operando1 + ", " + operando2 + ")";
    }
}

public class GeneradorTriplos {
    private static List<Triplo> triplos = new ArrayList<>();
    private static int tempIndex = 1;

    public static String generarTriplo(String operador, String operando1, String operando2) {
        String temp = "T" + tempIndex++;
        triplos.add(new Triplo(operador, operando1, operando2));
        return temp;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Ingrese la expresión en notación postfija (ejemplo: a b + c *):");
        String[] tokens = scanner.nextLine().split(" ");
        Stack<String> pila = new Stack<>();

        for (String token : tokens) {
            if (token.matches("[a-zA-Z]") || token.matches("\\d+")) {
                pila.push(token);
            } else {
                String op2 = pila.pop();
                String op1 = pila.pop();
                String temp = generarTriplo(token, op1, op2);
                pila.push(temp);
            }
        }

        System.out.println("Triplos generados:");
        for (int i = 0; i < triplos.size(); i++) {
            System.out.println(i + ": " + triplos.get(i));
        }
    }
}

Explicación del Código

Se define la clase Triplo para almacenar las tuplas.

generarTriplo crea nuevas tuplas y las guarda en una lista.

Se solicita una expresión en notación postfija.

Se usa una pila para evaluar la expresión y generar los triplos.

Ejecución y Resultados

Ejemplo de entrada:

a b + c *

Salida esperada:

0: (+, a, b)
1: (*, T1, c)

# data[].attributes.body
Código Intermedio

El código intermedio es una representación abstracta entre el código fuente y el código de máquina. Su propósito principal es independizar la fase de análisis de la fase de generación de código, permitiendo optimizaciones antes de la traducción final.

Triplos en Compiladores

Los triplos son una forma de representar expresiones aritméticas y lógicas de manera estructurada. Cada operación se guarda en una tupla de tres elementos:

(operador, operando1, operando2)

Por ejemplo, la expresión:

x = a + b * c

Se representa en triplos como:

( *, b, c ) → T1
( +, a, T1 ) → x

Aquí, T1 es una variable temporal que almacena el resultado intermedio.

Estructura de un Triplo

Cada triplo contiene:

Operador: Tipo de operación (+, -, *, /, etc.).

Operando 1: Primer operando.

Operando 2: Segundo operando (puede ser otro triplo).

# data[].attributes.body
Índice

1. Introducción

2. Conceptos clave

Código intermedio

Triplos en compiladores

Estructura de un triplo

3. Desarrollo del proyecto

Descripción del problema

Transformación de expresiones en código intermedio

Representación con triplos

4. Implementación en Java

Diseño del programa

Explicación del código

Ejecución y resultados

5. Conclusiones

6. Referencias

# data[].attributes.attachment_link.title
Esquemas de Generación de código intermedio

# data[].attributes.body
Lenguajes y Autamatas ll

GENERADOR DE CODIGO INTERMEDIO. TRANSFORMACION DE EXPRESIONES

Docente:

Oscar A. Garizurieta Castillo

Integrantes del Equipo:

Barrios Lara Jesús Emmanuel

Carrillo Morales Ilse del Carmen

Carrera

Ingeniería en Sistemas Computacionales

# data[].attributes.body
En el proceso de compilación, la generación de código intermedio es una fase crucial que facilita la optimización y posterior traducción del programa a código de máquina. Uno de los métodos más utilizados para representar este código intermedio es a través de triplos, los cuales estructuran cada operación en una tupla de tres elementos: (operador, operando1, operando2).

Este proyecto tiene como objetivo diseñar e implementar un Generador de Código Intermedio con Triplos en el lenguaje de programación Java, utilizando el entorno de desarrollo Apache NetBeans. Se busca transformar expresiones matemáticas en código intermedio y representarlas mediante triplos, facilitando la comprensión del proceso de compilación.

# data[].attributes.body
Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2006). Compiladores: Principios, Técnicas y Herramientas(2da ed.). Pearson Educación.

Appel, A. W. (2002). Implementación moderna de compiladores en Java. Cambridge University Press.

Muchnick, S. S. (1997). Diseño avanzado de compiladores e implementación. Morgan Kaufmann.

Dragon Book. (1986). Principios de compiladores. Pearson.

Hopcroft, J. E., Motwani, R., & Ullman, J. D. (2007). Introducción a la teoría de autómatas, lenguajes y computación. Pearson Educación.

Louden, K. (2004). Construcción de compiladores: Principios y práctica. Thomson Learning.

Tanenbaum, A. S. (2014). Sistemas operativos modernos (3ra ed.). Pearson Educación.

# data[].attributes.body
Descripción del Problema

El problema consiste en transformar expresiones matemáticas en código intermedio usando triplos. Se debe diseñar un sistema que reciba expresiones, las analice y genere la representación con triplos.

Transformación de Expresiones en Código Intermedio

Para convertir una expresión matemática en triplos, se debe analizar la precedencia de operadores y asignar temporales para resultados intermedios.

Ejemplo: Expresión: (a + b) * c

1. Sumar a + b → T1 = ( +, a, b )

2. Multiplicar T1 * c → *T2 = ( , T1, c )

Representación con Triplos

Cada operación se almacena en una estructura de datos que contiene:

Índice del triplo

Operador

Operando 1

Operando 2

# data[].attributes.body
El uso de triplos en compiladores permite una representación estructurada y optimizada del código intermedio. Con esta implementación en Java, se logra una conversión eficiente de expresiones matemáticas a su forma intermedia, facilitando futuras optimizaciones y traducción a código de máquina.