Implementación de REPL para Árbol de Sintaxis Abstracta

Curso de Creación de Lenguajes de Programación: Intérpretes

Contenido del curso

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción del lexer o tokenizador

Construcción del parser o analizador sintáctico

Evaluación o análisis semántico

Mejora del intérprete

Siguientes pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:59

Implementación de REPL para Árbol de Sintaxis Abstracta

Curso de Creación de Lenguajes de Programación: Intérpretes

Clase 38 de 58

Clase 38 / 58

Recursos

¿Cómo mejorar nuestro REPL para mostrar el árbol de evaluación?

Nos encontramos en una etapa crítica del desarrollo de nuestro lenguaje de programación, en donde tenemos nuestro parser funcionando y generando un árbol sintáctico abstracto (AST). Sin embargo, es fundamental poder visualizar este árbol para entender el orden de evaluación dentro de nuestro programa. Para lograrlo, modificaremos nuestro REPL (Read-Evaluate-Print Loop) con algunos pasos claves.

¿Cuáles son los pasos para modificar el REPL?

Importar módulos necesarios:
- Desde typing, importamos la lista, ya que estaremos generando una lista.
- Importamos el program desde nuestro módulo AST.
- Importamos el parser desde el módulo parser.
Implementación del pipeline:
- Primero, pasamos nuestro código al lexer, que genera tokens.
- Luego, esos tokens se envían al parser que, a través de parse program, genera una estructura de tipo programa.
- Debemos asegurarnos de que nuestro REPL muestra también errores de sintaxis que puedan surgir.
Gestión de errores de sintaxis:
- No es necesario detener el análisis del parser cuando se encuentra un error, se almacena para mostrarlo posteriormente.
- Creamos una función privada llamada printParseErrors que recibe una lista de errores y los imprime.
Imprimir la representación del programa:
- Si el parser no encuentra errores, imprimimos el programa representado como un AST.

¿Cómo ejecutar y probar las modificaciones?

Usamos la terminal para correr nuestro intérprete.
Ingresamos una expresión como 2 * 3 / 5 + 4, y observamos el árbol de evaluación que refleja el orden correcto de operaciones:
1. Primero se evalúa 2 * 3.
2. El resultado se divide entre 5.
3. Finalmente, se suma 4.
También podemos asignarle valores a variables, por ejemplo, A = 5 * 4, donde primero se realiza 5 * 4 y luego se asigna el valor a A.

¿Qué reto se propone lograr?

Se propone ajustar el string resultante del árbol de evaluación para representar el árbol de manera más visualmente comprensible. Esto podría hacerse mediante:

Indentaciones: para mostrar la jerarquía de operaciones de manera clara.
ASCII art: para dar un formato visual atractivo y funcional.

¿Cuál es el siguiente paso en el desarrollo?

Avanzamos hacia la creación del evaluador. Esta etapa crucial dará significado a nuestros símbolos matemáticos, permitiéndonos evaluar directamente el lenguaje de programación Platzi. ¡Esto representa un gran paso hacia dotar de vida a nuestro lenguaje!

Recuerda, este camino requiere tanto paciencia como creatividad. Si te sientes emocionado o tienes preguntas, comparte tu experiencia en los comentarios y sigue adelante en este fascinante viaje de construcción de un lenguaje de programación.

from os import system, name 

def clear(): 

    # for windows 
    if name == 'nt': 
        _ = system('cls') 

    # for mac and linux(here, os.name is 'posix') 
    else: 
        _ = system('clear') 

...

while (source := input(">> ")) != "salir()":

        if source == "limpiar()":
        	clear()

        else:

        	lexer: Lexer = Lexer(source)
		...

	    str_program: str = program.__str__()
            statement: str = ''
            count_paremt = 0
            for i, caracter in enumerate(str_program):
                if caracter == '(':
                    _print_statement(caracter,count_paremt)
                    count_paremt +=1
                elif caracter == ')':
                    if statement != '':
                        _print_statement(statement,count_paremt)
                    count_paremt -=1
                    _print_statement(caracter,count_paremt)
                    statement = ''
                elif caracter == ';':
                    statement += caracter
                    if statement != '':
                        _print_statement(statement,count_paremt)
                    statement = ''
                else:
                    if not (statement == '' and caracter == ' '):
                        statement += caracter
                
            _print_statement(statement,count_paremt)

Resumen

¿Cómo mejorar nuestro REPL para mostrar el árbol de evaluación?

¿Cuáles son los pasos para modificar el REPL?

Importar módulos necesarios:
- Desde typing, importamos la lista, ya que estaremos generando una lista.
- Importamos el program desde nuestro módulo AST.
- Importamos el parser desde el módulo parser.
Implementación del pipeline:
- Primero, pasamos nuestro código al lexer, que genera tokens.
- Luego, esos tokens se envían al parser que, a través de parse program, genera una estructura de tipo programa.
- Debemos asegurarnos de que nuestro REPL muestra también errores de sintaxis que puedan surgir.
Gestión de errores de sintaxis:
- No es necesario detener el análisis del parser cuando se encuentra un error, se almacena para mostrarlo posteriormente.
- Creamos una función privada llamada printParseErrors que recibe una lista de errores y los imprime.
Imprimir la representación del programa:
- Si el parser no encuentra errores, imprimimos el programa representado como un AST.

¿Cómo ejecutar y probar las modificaciones?

Usamos la terminal para correr nuestro intérprete.
Ingresamos una expresión como 2 * 3 / 5 + 4, y observamos el árbol de evaluación que refleja el orden correcto de operaciones:
1. Primero se evalúa 2 * 3.
2. El resultado se divide entre 5.
3. Finalmente, se suma 4.
También podemos asignarle valores a variables, por ejemplo, A = 5 * 4, donde primero se realiza 5 * 4 y luego se asigna el valor a A.

¿Qué reto se propone lograr?

Se propone ajustar el string resultante del árbol de evaluación para representar el árbol de manera más visualmente comprensible. Esto podría hacerse mediante:

Indentaciones: para mostrar la jerarquía de operaciones de manera clara.
ASCII art: para dar un formato visual atractivo y funcional.

¿Cuál es el siguiente paso en el desarrollo?

Carlos Eduardo Gomez García

Hace 6 años

Para modificar el formato de salida del REPL hay que modificar los dunder __str__ methods para cambiar su formato, pero hacer esto puede llevar a muchos fallos en los tests xD Además ya quiero empezar con el evaluador que es lo que más me da curiosidad OwO!!! . Por cierto, algo cursiodi es que en nuestro REPL no podemos usar las flechas de izquierda y derecha porque se imprimen caracteres raros, tampoco podemos navegar a través de la historia de los comandos que hemos escrito, muchos REPL's si lo permiten usar. . Si quieren agregar este feature al REPL (que lo hace muuuuucho más elegante), solo tienen que agregar esto al inicio de repl.py:

import readline

Con eso ya pueden usar las flechitas del teclado y navegar entre todas las líneas de código que han escrito en su REPL usando las flechitas de "arriba" y "abajo".

Otra cosa importante dentro de cualquier REPL es poder limpiar la pantalla, para hacer eso, yo agregué esta función al repl.py:

from os import system, name 

def clear(): 

    # for windows 
    if name == 'nt': 
        _ = system('cls') 

    # for mac and linux(here, os.name is 'posix') 
    else: 
        _ = system('clear') 

...

while (source := input(">> ")) != "salir()":

        if source == "limpiar()":
        	clear()

        else:

        	lexer: Lexer = Lexer(source)
		...

Y simplemente en el REPL en ejecución escribes limpiar() y se limpia la pantalla :D . Aquí dejo mi REPL completo hasta ahorita por si lo quieren copiar: . Adicion de clear y uso de flechas dentro del REPL

Fabián Vega Alcota

Hace 6 años

Wow, muchas gracias! Gran aporte

Comentarios (2)2 comentarios

Jorge Vidoni

Como menciona RetaxMaster, posiblemente realizar una buena implementación puede llevar realizar demasiadas modificaciones al código.

Pero invirtiendo unos minutos en el repl y trabajando el programa (de una manera no muy eficiente) se puede tabular los paréntesis para que facilite la lectura

el resultado es algo como esto

((5 + (6 * 9)) + 8)
(

( ( 5 + 6 * 9 ) )

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción de Intérpretes de Software en Python 3.8

Creación de Compiladores e Intérpretes con Lenguaje Platzi

Construcción del lexer o tokenizador

Análisis Léxico: Construcción de un Léxer para Intérpretes

Definición de Tokens en Lenguaje de Programación Platzi

Desarrollo de un Lexer con Test-Driven Development

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

Lexer: Identificación de Keywords y Tokens Complejos

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

Implementación de Operadores y Condicionales en Lexer de Platzi

Implementación de Operadores de Dos Caracteres en Lexer

Creación de un REPL en Python para Lenguaje de Programación

Construcción del parser o analizador sintáctico

Construcción de un Parser para el Lenguaje Platzi

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python

Desarrollo de un AST en Python: Creación de la Clase Programa

Parseo de Let Statements en Lenguaje Platzi

Implementación de funciones advanced y expected tokens

Manejo de Errores en Parsers con Test Driven Development

Parseo de Return Statements en Lenguaje Platzi

Técnicas de Parsing: Top-Down y Bottom-Up

Pruebas de AST para Let y Return Statements en Parsers

Pratt Parsing: Implementación y Registro de Funciones en Python

Parseo de Identificadores en Lenguajes de Programación

Parseo de Expression Statements en Platzi Parser

Parseo de Enteros en Lenguaje Platzi

Implementación de Operadores Prefijo en Parsers

Operadores InFix en Expresiones: Implementación y Pruebas

Implementación de Operadores InFix en un Parser

Expresiones Booleanas en el Lenguaje de Programación Platzi

Evaluación de Precedencia y Testeo de Booleanos en Parsers

Evaluación de Expresiones Agrupadas en un Parser

Parseo de Condicionales en Lenguaje Platzi

Implementación de Condicionales en Parser de Lenguaje

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST

Construcción de nodos de función en un parser AST

Llamadas a Funciones en Lenguajes de Programación

Implementación de llamadas a funciones en un parser con AST

Parseo de Expresiones en LET y RETURN Statements

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

Evaluación Semántica en Lenguajes de Programación

Estrategias de Evaluación en Lenguajes de Programación

Representación de Nodos AST y Objetos en Python

Evaluación de Expresiones en JavaScript y Python

Implementación del Patrón Singleton para Booleanos y Nulos

Evaluación de Prefijos en Lenguaje de Programación Platzi

Evaluación de Expresiones Infix en Lenguaje Platzi

Evaluación de Condicionales en Lenguaje de Programación Platzi

Evaluación y Uso del Return Statement en Programación

Manejo de Errores Semánticos en Lenguaje Platzi

Declaración y Gestión de Variables en Lenguajes de Programación

Manejo de Ambientes y Variables en Lenguajes de Programación

Declaración de Funciones en Lenguaje de Programación Platzi

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

Implementación de Strings en un Intérprete de Lenguaje de Programación

Operaciones de Concatenación y Comparación de Strings en Intérprete

Implementación de Funciones Built-in en Python

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

Desarrollo de Lenguaje de Programación y Estructuras de Datos en Python

Construcción de un Intérprete en Python desde Cero

Implementación de REPL para Árbol de Sintaxis Abstracta