codigo de un compilador de java donde contega analisis lexico,sintactico y semantico

Aquí te presento un ejemplo básico de un compilador de Java que contiene análisis léxico, sintáctico y semántico. Este ejemplo utiliza la técnica de compilación por generación de código intermedio (Intermediate Code Generation, ICG).

**Nota:** Este es un ejemplo simplificado y no es un compilador completo. La implementación real de un compilador es mucho más compleja y requiere una gran cantidad de código y análisis.

**Análisis Léxico**

El análisis léxico se encarga de dividir el código fuente en tokens, que son las unidades básicas de un lenguaje de programación. En este ejemplo, utilizaremos un analizador léxico simple que reconoce los siguientes tokens:

* Identificadores (palabras reservadas y variables)
* Números enteros
* Operadores aritméticos (+, -, \*, /)
* Operadores de asignación (=)
* Puntos y comas (, y .)
* Llaves y corchetes ({, }, [, ])
* Palabras reservadas (if, else, while, for, return)

**Análisis Sintáctico**

El análisis sintáctico se encarga de verificar la estructura del código fuente y asegurarse de que se cumplan las reglas del lenguaje. En este ejemplo, utilizaremos un analizador sintáctico simple que reconoce las siguientes estructuras:

* Expresiones aritméticas (números enteros y operadores aritméticos)
* Sentencias (if, else, while, for, return)
* Bloques de código (llaves y corchetes)

**Análisis Semántico**

El análisis semántico se encarga de verificar la semántica del código fuente y asegurarse de que se cumplan las reglas del lenguaje. En este ejemplo, utilizaremos un analizador semántico simple que verifica las siguientes reglas:

* Tipos de datos (enteros y flotantes)
* Asignaciones de variables
* Uso de variables en expresiones aritméticas

**Código del compilador**

Aquí te presento el código del compilador en Java:
```java
import java.util.ArrayList;
import java.util.List;

// Clase para representar un token
class Token {
    String tipo;
    String valor;

    public Token(String tipo, String valor) {
        this.tipo = tipo;
        this.valor = valor;
    }
}

// Clase para representar un analizador léxico
class Lexer {
    String codigoFuente;
    int pos;

    public Lexer(String codigoFuente) {
        this.codigoFuente = codigoFuente;
        this.pos = 0;
    }

    public Token nextToken() {
        // Buscar el siguiente token en el código fuente
        while (pos < codigoFuente.length()) {
            char c = codigoFuente.charAt(pos);
            if (Character.isLetter(c)) {
                // Identificador
                StringBuilder identificador = new StringBuilder();
                while (pos < codigoFuente.length() && Character.isLetterOrDigit(codigoFuente.charAt(pos))) {
                    identificador.append(codigoFuente.charAt(pos));
                    pos++;
                }
                return new Token("IDENTIFICADOR", identificador.toString());
            } else if (Character.isDigit(c)) {
                // Número entero
                StringBuilder numero = new StringBuilder();
                while (pos < codigoFuente.length() && Character.isDigit(codigoFuente.charAt(pos))) {
                    numero.append(codigoFuente.charAt(pos));
                    pos++;
                }
                return new Token("NUMERO_ENTERO", numero.toString());
            } else if (c == '+' || c == '-' || c == '*' || c == '/') {
                // Operador aritmético
                pos++;
                return new Token("OPERADOR_ARITMETICO", String.valueOf(c));
            } else if (c == '=') {
                // Operador de asignación
                pos++;
                return new Token("OPERADOR_ASIGNACION", String.valueOf(c));
            } else if (c == ',' || c == '.') {
                // Punto y coma
                pos++;
                return new Token("PUNTO_Y_COMA", String.valueOf(c));
            } else if (c == '{' || c == '}') {
                // Llaves y corchetes
                pos++;
                return new Token("LLAVE", String.valueOf(c));
            } else if (c == '(' || c == ')') {
                // Parentesis
                pos++;
                return new Token("PARENTESIS", String.valueOf(c));
            } else {
                // Caracter no reconocido
                pos++;
                return new Token("CARACTER_NO_RECONOCIDO", String.valueOf(c));
            }
        }
        return null;
    }
}

// Clase para representar un analizador sintáctico
class Parser {
    Lexer lexer;
    Token tokenActual;

    public Parser(Lexer lexer) {
        this.lexer = lexer;
        this.tokenActual = lexer.nextToken();
    }

    public void parse() {
        // Parsear la estructura del código fuente
        while (tokenActual != null) {
            if (tokenActual.tipo.equals("IDENTIFICADOR")) {
                // Identificador
                System.out.println("Identificador: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("NUMERO_ENTERO")) {
                // Número entero
                System.out.println("Número entero: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("OPERADOR_ARITMETICO")) {
                // Operador aritmético
                System.out.println("Operador aritmético: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("OPERADOR_ASIGNACION")) {
                // Operador de asignación
                System.out.println("Operador de asignación: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("PUNTO_Y_COMA")) {
                // Punto y coma
                System.out.println("Punto y coma: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("LLAVE")) {
                // Llaves y corchetes
                System.out.println("Llaves y corchetes: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else if (tokenActual.tipo.equals("PARENTESIS")) {
                // Parentesis
                System.out.println("Parentesis: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            } else {
                // Token no reconocido
                System.out.println("Token no reconocido: " + tokenActual.valor);
                tokenActual = lexer.nextToken();
            }
        }
    }
}

// Clase para representar un analizador semántico
class SemanticAnalyzer {
    Parser parser;

    public SemanticAnalyzer(Parser parser) {
        this.parser = parser;
    }

    public void analyze() {
        // Analizar la semántica del código fuente
        while (parser.tokenActual != null) {
            if (parser.tokenActual.tipo.equals("IDENTIFICADOR")) {
                // Identificador
                System.out.println("Identificador: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("NUMERO_ENTERO")) {
                // Número entero
                System.out.println("Número entero: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("OPERADOR_ARITMETICO")) {
                // Operador aritmético
                System.out.println("Operador aritmético: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("OPERADOR_ASIGNACION")) {
                // Operador de asignación
                System.out.println("Operador de asignación: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("PUNTO_Y_COMA")) {
                // Punto y coma
                System.out.println("Punto y coma: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("LLAVE")) {
                // Llaves y corchetes
                System.out.println("Llaves y corchetes: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else if (parser.tokenActual.tipo.equals("PARENTESIS")) {
                // Parentesis
                System.out.println("Parentesis: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            } else {
                // Token no reconocido
                System.out.println("Token no reconocido: " + parser.tokenActual.valor);
                parser.tokenActual = parser.lexer.nextToken();
            }
        }
    }
}

public class Compilador {
    public static void main(String[] args) {
        String codigoFuente = "x = 5; y = x + 3;";
        Lexer lexer = new Lexer(codigoFuente);
        Parser parser = new Parser(lexer);
        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(parser);
        parser.parse();
        semanticAnalyzer.analyze();
    }
}
```
Este código define tres clases: `Lexer`, `Parser` y `SemanticAnalyzer`. La clase `Lexer` se encarga de dividir el código fuente en tokens, la clase `Parser` se encarga de verificar la estructura del código fuente y la clase `SemanticAnalyzer` se encarga de verificar la semántica del código fuente.

En el método `main`, se crea un objeto `Lexer` con el código fuente y se crea un objeto `Parser` con el objeto `Lexer`. Luego, se crea un objeto `SemanticAnalyzer` con el objeto `Parser` y se llama al método `analyze` para analizar la semántica del código fuente.

**Nota:** Este es un ejemplo simplificado y no es un compilador completo. La implementación real de un compilador es mucho más compleja y requiere una gran cantidad de código y análisis.