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.

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

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

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)

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

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