Migración completa a Python

app.py

@@ -0,0 +1,29 @@
+import gradio as gr
+import json
+from lexer import lexer
+from parser import Parser
+from semantico import AnalizadorSemantico
+
+def analizar_codigo(archivo):
+    try:
+        contenido = archivo.read().decode("utf-8")
+        tokens = lexer(contenido)
+        parser = Parser(tokens)
+        ast = parser.parse()
+        analizador = AnalizadorSemantico(ast)
+        resultado = analizador.analizar()
+        errores = "\n".join(resultado["errores_semanticos"])
+        json_resultado = json.dumps(resultado, indent=2)
+        return errores, json_resultado
+    except Exception as e:
+        return f"Error: {e}", "{}"
+
+gr.Interface(
+    fn=analizar_codigo,
+    inputs=gr.File(label="Sube un archivo de código"),
+    outputs=[
+        gr.Textbox(label="Errores detectados"),
+        gr.Code(label="Contenido de analisis.json", language="json")
+    ],
+    title="Analizador Semántico en Python - Lenguaje de Robots"
+).launch()

entrada.txt

@@ -0,0 +1,5 @@
+x = 5;
+y = z + 3.5;
+IF y THEN {
+    a = y - 1;
+}

lexer.py

@@ -0,0 +1,62 @@
+import re
+from typing import List, Tuple
+
+Token = Tuple[str, str]
+
+# Lista de palabras clave y símbolos
+RESERVED = {
+    "ACTIVATE_ALARM", "ACTIVATE_SENSOR", "BREAK", "CALIBRATE", "CHARGE_BATTERY", "CHECK_BATTERY",
+    "CLOSE_DOOR", "CONTINUE", "COPY_FILE", "DEACTIVATE_ALARM", "DEACTIVATE_SENSOR",
+    "DECREASE_SPEED", "DELETE_FILE", "DOWNLOAD", "ELSE", "FALSE", "FOR", "IF", "INCREASE_SPEED",
+    "INIT", "LOCK", "LOG", "LOW_BATTERY", "MOVE_BACKWARD", "MOVE_FORWARD", "MOVE_TO", "NULL",
+    "OPEN_DOOR", "PAUSE", "PRINT", "READ_SENSOR", "REBOOT", "RENAME_FILE", "RESET", "RESUME",
+    "REVERSE", "ROTATE", "SAVE_FILE", "SCAN", "SET_SPEED", "SHUTDOWN", "SHUT_OFF", "START", "STOP",
+    "STOP_IMMEDIATELY", "THEN", "TOGGLE_LIGHT", "TRUE", "TURN_DOWN", "TURN_LEFT", "TURN_RIGHT",
+    "TURN_UP", "UNLOCK", "UPLOAD", "UPLOAD_FILE", "WAIT", "WHILE"
+}
+
+TOKEN_SPEC = [
+    ("FLOAT",        r'\d+\.\d+'),
+    ("INT",          r'\d+'),
+    ("ASSIGN",       r'='),
+    ("PLUS",         r'\+'),
+    ("MINUS",        r'-'),
+    ("MULTIPLY",     r'\*'),
+    ("DIVIDE",       r'/'),
+    ("EQUAL",        r'=='),
+    ("NOT_EQUAL",    r'!='),
+    ("GREATER",      r'>'),
+    ("LESS",         r'<'),
+    ("OPEN_PAREN",   r'\('),
+    ("CLOSE_PAREN",  r'\)'),
+    ("OPEN_BRACE",   r'\{'),
+    ("CLOSE_BRACE",  r'\}'),
+    ("SEMICOLON",    r';'),
+    ("COLON",        r':'),
+    ("COMMA",        r','),
+    ("NEWLINE",      r'\n'),
+    ("SKIP",         r'[ \t\r]+'),
+    ("IDENTIFIER",   r'[a-zA-Z_][a-zA-Z0-9_]*'),
+    ("MISMATCH",     r'.'),
+]
+
+TOK_REGEX = '|'.join(f'(?P<{name}>{pattern})' for name, pattern in TOKEN_SPEC)
+token_re = re.compile(TOK_REGEX)
+
+def lexer(code: str) -> List[Token]:
+    tokens = []
+    for match in token_re.finditer(code):
+        kind = match.lastgroup
+        value = match.group()
+        if kind == "NEWLINE" or kind == "SKIP":
+            continue
+        elif kind == "IDENTIFIER":
+            if value in RESERVED:
+                tokens.append((value, value))
+            else:
+                tokens.append(("IDENTIFIER", value))
+        elif kind == "MISMATCH":
+            raise RuntimeError(f"Token no reconocido: {value}")
+        else:
+            tokens.append((kind, value))
+    return tokens

main.py

@@ -0,0 +1,19 @@
+from lexer import lexer
+from parser import Parser
+from semantico import AnalizadorSemantico
+import json
+
+with open("entrada.txt", "r", encoding="utf-8") as f:
+    codigo = f.read()
+
+tokens = lexer(codigo)
+parser = Parser(tokens)
+ast = parser.parse()
+
+analizador = AnalizadorSemantico(ast)
+resultado = analizador.analizar()
+
+with open("analisis.json", "w", encoding="utf-8") as out:
+    json.dump(resultado, out, indent=2)
+
+print("✔ Análisis completo. Resultados guardados en 'analisis.json'")

parser.py

@@ -0,0 +1,68 @@
+from typing import List, Tuple, Any
+
+Token = Tuple[str, str]
+
+class Parser:
+    def __init__(self, tokens: List[Token]):
+        self.tokens = tokens
+        self.pos = 0
+        self.ast = []
+
+    def current(self) -> Token:
+        return self.tokens[self.pos] if self.pos < len(self.tokens) else ("EOF", "")
+
+    def match(self, expected_type: str) -> Token:
+        if self.current()[0] == expected_type:
+            tok = self.current()
+            self.pos += 1
+            return tok
+        raise SyntaxError(f"Se esperaba {expected_type} pero se encontró {self.current()}")
+
+    def parse(self):
+        while self.current()[0] != "EOF":
+            self.ast.append(self.instruction())
+        return self.ast
+
+    def instruction(self) -> Any:
+        token = self.current()
+        if token[0] == "IDENTIFIER":
+            return self.assignment()
+        elif token[0] == "IF":
+            return self.if_statement()
+        else:
+            raise SyntaxError(f"Instrucción no válida: {token}")
+
+    def assignment(self):
+        ident = self.match("IDENTIFIER")[1]
+        self.match("ASSIGN")
+        expr = self.expression()
+        self.match("SEMICOLON")
+        return {"type": "assign", "var": ident, "value": expr}
+
+    def if_statement(self):
+        self.match("IF")
+        condition = self.expression()
+        self.match("THEN")
+        self.match("OPEN_BRACE")
+        body = []
+        while self.current()[0] != "CLOSE_BRACE":
+            body.append(self.instruction())
+        self.match("CLOSE_BRACE")
+        return {"type": "if", "condition": condition, "body": body}
+
+    def expression(self):
+        left = self.term()
+        while self.current()[0] in ("PLUS", "MINUS"):
+            op = self.match(self.current()[0])[0]
+            right = self.term()
+            left = {"type": "binop", "op": op, "left": left, "right": right}
+        return left
+
+    def term(self):
+        token_type, token_value = self.current()
+        if token_type == "IDENTIFIER":
+            return {"type": "var", "value": self.match("IDENTIFIER")[1]}
+        elif token_type == "NUMERO":
+            return {"type": "num", "value": self.match("NUMERO")[1]}
+        else:
+            raise SyntaxError(f"Expresión inválida: {self.current()}")

requirements.txt

@@ -0,0 +1 @@
+gradio

semantico.py

@@ -0,0 +1,46 @@
+class AnalizadorSemantico:
+    def __init__(self, ast):
+        self.ast = ast
+        self.tabla_simbolos = {}
+        self.errores = []
+
+    def analizar(self):
+        for nodo in self.ast:
+            self.analizar_instruccion(nodo)
+        return {
+            "variables_declaradas": self.tabla_simbolos,
+            "errores_semanticos": self.errores
+        }
+
+    def analizar_instruccion(self, nodo):
+        if nodo["type"] == "assign":
+            tipo_valor = self.analizar_expresion(nodo["value"])
+            self.tabla_simbolos[nodo["var"]] = tipo_valor
+        elif nodo["type"] == "if":
+            tipo_condicion = self.analizar_expresion(nodo["condition"])
+            if tipo_condicion != "int":
+                self.errores.append(
+                    f"Condición del IF debe ser de tipo int, pero se encontró '{tipo_condicion}'"
+                )
+            for instr in nodo["body"]:
+                self.analizar_instruccion(instr)
+
+    def analizar_expresion(self, expr):
+        if expr["type"] == "num":
+            return "float" if "." in expr["value"] else "int"
+        elif expr["type"] == "var":
+            nombre = expr["value"]
+            if nombre not in self.tabla_simbolos:
+                self.errores.append(f"Variable '{nombre}' usada sin ser declarada.")
+                return "error"
+            return self.tabla_simbolos[nombre]
+        elif expr["type"] == "binop":
+            tipo_izq = self.analizar_expresion(expr["left"])
+            tipo_der = self.analizar_expresion(expr["right"])
+            if tipo_izq != tipo_der:
+                self.errores.append(f"Tipos incompatibles: {tipo_izq} y {tipo_der}")
+                return "error"
+            return tipo_izq
+        else:
+            self.errores.append(f"Expresión no reconocida: {expr}")
+            return "error"