ZX2SB: El Parser o Analizador Sintáctico

Índice de entradas del conversor

---

El Analizador Sintáctico (Parser) en un Transpilador ZX BASIC

Cómo funciona el Parser en ZX2SB y por qué es una pieza clave en la conversión de ZX BASIC

Índice

• ¿Qué es un Analizador Sintáctico?
• El flujo general del transpilador
• Qué hace exactamente un Parser
• ZX BASIC y la necesidad de un Parser tolerante
• Diseño del Parser en ZX2SB
• Diagrama del proceso del Parser
• Gestión de errores y warnings
• Ejemplo de seudocódigo
• Relación con el Analizador Semántico
• Conclusión

---

¿Qué es el Analizador Sintáctico (Parser)?

En un transpilador o compilador, el analizador sintáctico, normalmente llamado Parser, es la fase encargada de comprobar que un programa fuente está correctamente estructurado según la gramática del lenguaje.

En el proyecto ZX2SB, el Parser se sitúa entre el analizador léxico y el analizador semántico, actuando como un filtro estructural antes de interpretar el significado real del programa.

---

El flujo general del transpilador

El proceso de traducción o compilación sigue los pasos que ya hemos visto anteriormente, el parser sería el segundo paso del proceso completo:

Código fuente ZX BASIC
|
v
  Analizador léxico (Lexer)
|
v
 Analizador sintáctico (Parser)
|
v
 Analizador semántico
|
v
 Generador de código

Cada fase tiene una responsabilidad clara y no solapa funciones con las demás.

• Lexer: reconoce palabras, números, cadenas y símbolos.
• Parser: comprueba la estructura de las sentencias.
• Semantic: valida el significado y los tipos.
• Generator: produce el código destino.

---

Qué hace exactamente un Parser

El analizador sintáctico debe responder a preguntas como estas (pero no todas se aplican al BASIC como veremos más adelante):

• ¿La sentencia IF tiene un THEN?
• ¿Un FOR tiene su correspondiente NEXT?
• ¿La forma general de la instrucción es válida?
• ¿Los separadores y palabras clave están bien posicionados?

Es importante destacar lo que el Parser NO hace:

• No comprueba tipos de datos (eso lo hace el analizador semántico).
• No valida el uso de variables ni su significado.
• No decide si una operación es lógica o correcta.
• No genera código final.

Su misión es exclusivamente estructural.

---

ZX BASIC y la necesidad de un Parser tolerante

ZX BASIC es un lenguaje muy permisivo. Muchas construcciones válidas para el intérprete original pueden resultar ambiguas al convertirlas a otros lenguajes.

Por ese motivo, el Parser de ZX2SB está diseñado para:

• Aceptar la sintaxis original del ZX Spectrum.
• Detectar errores estructurales claros.
• Emitir warnings ante estructuras dudosas.
• No ser excesivamente restrictivo.

Ejemplo de programa sintácticamente válido pero lógicamente erróneo:

10 FOR i=1 TO 10
20   FOR j=1 TO 5
30     PRINT i,j
40   NEXT i
50 NEXT j

10 FOR i=1 TO 10
20   FOR j=1 TO 5 : PRINT i,j
30 NEXT i

Estos programas no genera error en BASIC clásico, pero su comportamiento no es el esperado y puede variar según el intérprete.

---

Diseño del Parser en ZX2SB

El Parser trabaja sobre los tokens generados por el Lexer y produce un Árbol de Sintaxis Abstracta (AST).

Dado que el objetivo final es portar el sistema a SuperBASIC, donde no existen estructuras de datos complejas, el AST se almacena como una estructura lineal intermedia (IR).

Entrada

• Secuencia de tokens.
• Números de línea originales.
• Contexto mínimo.

Salida

• Sentencias normalizadas.
• Estructura explícita del programa.
• Errores y avisos.

---

Diagrama del proceso del Parser

+------------------------+
| Tokens del Lexer       |
+-----------+------------+
            |
            v
+------------------------+
| Reconocer sentencias   |
| (IF, LET, FOR, PRINT)  |
+-----------+------------+
            |
            v
+------------------------+
| Verificar estructura   |
+-----------+------------+
            |
            v
+------------------------+
| Emitir IR estructurado |
+------------------------+

---

Gestión de errores y warnings

• Errores: la estructura es inválida.
• Warnings: la estructura es válida pero sospechosa.

La decisión de continuar o abortar depende de las opciones del usuario que se definan, no del Parser.En nuestro sistema, el usuario puede elegir entre parar y preguntar si desea continuar, o bien no parar el proceso y seguir hasta el final, los errores se verán en el fichero de log que se genera.

---

Ejemplo de seudocódigo

function EjecutarParser(tokens):
    for cada línea:
        identificar sentencia
        validar estructura
        emitir error o aviso
    generar IR

---

Relación con el Analizador Semántico

El Parser prepara el terreno para el análisis semántico, permitiendo que este se centre exclusivamente en el significado lógico.

---

Conclusión

El analizador sintáctico es la columna vertebral estructural del transpilador. Sin interpretar significados, garantiza que estos puedan analizarse correctamente más adelante.

En ZX2SB, el Parser respeta la filosofía del ZX BASIC original y prepara el camino para futuras transformaciones a otros lenguajes.