Parseo de Let Statements en Lenguaje Platzi

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:0020:21

Parseo de Let Statements en Lenguaje Platzi

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

Clase 15 de 58

Clase 15 / 58

Recursos

¿Cómo parsear 'let statements' en el lenguaje de programación Platzi?

En el proceso de crear nuestro propio lenguaje de programación, encontramos que hay dos tipos fundamentales de statements: los 'let statements' y los 'return statements'. Aquí, nos enfocaremos en entender cómo parsear los 'let statements', esenciales para asignar valores a variables. Imagina que el proceso completo se asemeja a la construcción de un árbol, donde el nodo principal es el programa que contiene varios 'statements'.

¿Qué estructura tiene un 'let statement'?

Un 'let statement' se compone de:

Identificador: Corresponde al nombre de la variable, por ejemplo, 'x' en let x = 5;.
Expresión: Es el valor asignado a la variable, que puede ser un número, un booleano, una función, entre otros.

Ahora bien, para crear un parser que interprete 'let statements', necesitamos definir ciertos nodos y realizar test específicos.

¿Cómo implementamos los nodos para 'let statements'?

Definición de nodos: Debemos crear nodos de tipo 'let statement' e 'identifier'. Esto se logra extendiendo una clase base llamada 'statement'.
Constructor: En el constructor del 'let statement', se recibe un token, un nombre opcional (identifier) y un valor opcional (expression).

Por ejemplo, un nodo 'let statement' se inicializa de la siguiente manera:

class LetStatement(Statement):
    def __init__(self, token, name=None, value=None):
        super().__init__(token)
        self.name = name
        self.value = value

¿Cómo llevar a cabo tests para 'let statements'?

Primero, creamos una función de test para verificar la correcta interpretación de los 'let statements'. La prueba inicializa un lexer y un parser con un programa de prueba:

def test_let_statements():
    input_program = "let x = 5; let y = 10; let foobar = 838383;"
    lexer = Lexer(input_program)
    parser = Parser(lexer)
    program = parser.parse_program()
    assert len(program.statements) == 3

Con estos test, nos aseguramos de que nuestro parser reconoce correctamente los 'let statements' del programa de ejemplo y que estos son almacenados como nodos dentro del árbol de nuestro programa.

¿Cómo funciona el proceso de parsear 'let statements'?

Para parsear los 'let statements', es vital definir las funciones necesarias que verificarán la sintaxis correcta y reconocerán los tokens involucrados:

Advance Tokens: Funciona como un iterador que avanza al siguiente token.
Expected Token: Evalúa si el siguiente token es el esperado de acuerdo a la gramática. Por ejemplo, después de un identificador en un 'let statement', da por hecho que el siguiente debe ser un operador de asignación.

¿Cuáles son los pasos finales para asegurar la correcta interpretación?

Parse Statement: Método que identifica si el token actual representa un 'let statement'.
Parse Let Statement: Método específico para los 'let statements'. Evalúa si la estructura de tokens sigue la sintaxis prevista (ej., let x = 5;).

Por último, la implementación de estas funciones asegura que el parser maneje adecuadamente los errores y solo integre statements con la sintaxis correcta en el programa.

Recomendaciones y siguientes pasos

Al trabajar en el parseo de 'let statements', es crucial implementar técnicas de test driven development (TDD) para asegurar que tu código maneje todo tipo de escenarios. Anímate a explorar más allá y crea tus propios tests. Una vez dominado el parseo de 'let statements', el siguiente reto será integrar el manejo de expresiones complejas y profundizar en 'return statements'. ¡Adelante, tu lenguaje de programación te está esperando!

Carlos Eduardo Gomez García

Hace 6 años

Vale, trataré de explicar con mis propias palabras este código para ver si entendí bien 🤔 . Como dije en un aporte anterior, parse_program es el que se encargará de empezar a crear nuestro AST, primero creará el nodo principal (el programa) que básicamente es un wrapper de todos nuestros staments, básicamente un statement es cada acción de nuestro programa, por ejemplo, el conjunto de palabras que declaran una variable: variable platzi = 10; eso sería un statement. . Después de inicializar el programa, parse_program empezará a buscar los diferentes tokens (recordemos que aquí ya hablamos de tokens porque el Lexer que hicimos ya nos está dando los tokens de nuestro programa) . La condición de: while self._current_token.token_type != TokenType.EOF lo único que está diciendo es que mientras aún hayan tokens, se va a mandar a generar un statement. Básicamente sabemos que el token que finaliza nuestro programa es el EOF (End Of File). . Ahora, hablando de la generación de statements dentro de la función parse_statement... en primera, dentro de nuestro programa podemos tener varios tipos de statements (aunque según el profesor, dentro de LPP solo habrán dos), un ejemplo de ellos son los let statements (o statements de declaración de variables para que se entienda), es por eso que verificamos que si el token actual es LET significa que el usuario quiere declarar una variable, así que tenemos que empezar a verificar que la sintaxis de declaración sea correcta, pero esa tarea se la delegamos a _parse_let_satatement. . Entonces, básicamente _parse_let_satatement obtiene una instancia de la clase LetStatement (ubicada en ast.py) y empieza a validar, en teoría, la función _expected_token debería determinar cuál es el siguiente token que arrojó el Lexer y comparar si el token arrojado es un IDENT (recordemos que el token IDENT define el nombre de la variable, en el statement variable platzi = 10;, platzi sería el token IDENT). . En dado caso que el token no sea un IDENT significa que hay un error de sintaxis, por ahora devolvemos "None", esto provocará que _parse_statement retorne None y a su vez, dentro de parse_program la variable statement que está dentro del while acabará siendo None, por lo que por la condición que está debajo no dejará que este statement mal programado entre a la lista de statements de nuestro programa :D . En dado caso que el expected token sí haya sido un IDENT, procederemos a crear una instancia de Identifier con este identificador, después seguimos revisando la sintaxis, después del identificador debe haber un "=", así que comparamos que el siguiente token sea uno de asignación, si no lo es, misma historia, hay un error de sintaxis así que retornamos None, si sí lo es, entonces continuamos revisando los tokens hasta que encontremos el ";" . Ya que todo se terminó de revisar correctamente, se retorna el statement, lo que provocará que _parse_statement retorne un statement provocando que dentro parse_program acabe retornándose un statement también, y debido a que este sí es un statement de verdad, el if que está ahí sí dejará guardar ese statement dentro de nuestro Program :D . Así es como entiendo que funciona este código, traté de describirlo lo mejor posible xD

Gerard Chávez

Hace 6 años

Excelente la explicación. Estos aportes son los valiosos.

Isaac Reyes

Hace 6 años

Uuf, se dan muchas vueltas pasando lo que regresa cada función a otras pero se entendió muy bien, gracias

Comentarios (9)9 comentarios

Piero Rolando

Hace 5 años

tio, no sé como sobrevives sin autocompletado🗿

Raúl Humberto Peñate Ramírez

Hace 2 años

Y pensar que así era la programación antes del 2004-2010. Ahora nos diran a nosotros: "no sé como haces sin AI para programar" xd

Carlos Nexans

Hice que el repositorio corra los tests en cada commit con github actions

Mi proyecto es un lenguaje basado en Python, con sintaxis similar a python pero con estructuras de datos dentro del lenguaje y sintaxis reducida como la de go (menos opciones)

Me imagino poder integrarlo con Manim para generar animaciones matemáticas dentro del propio lenguaje

Algunos test que debes agregar en tu lexer

for_identifier No es un token for, es un identificador

true__ No es un literal true, es un identificador

Jherom Chacon

Implementación _parse_statement

Implementación _parse_let_statement

implementación de la clase Identifier

Implementación de la clase LetStatement

Implementación del test_let_statements

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

Parseo de Let Statements en Lenguaje Platzi