Implementación de funciones advanced y expected tokens

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:26

Implementación de funciones advanced y expected tokens

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

Clase 16 de 58

Clase 16 / 58

Recursos

¿Cómo implementar las funciones avanzadas en nuestro parser?

Cuando desarrollamos un parser para un lenguaje de programación, implementar funciones como advanced tokens y expected token es crucial. Estas funciones nos permiten navegar entre los tokens y validar si los tokens esperados coinciden con los definidos por el lenguaje que estamos creando. La función expected token nos ayuda a asegurar que el próximo token es el correcto en contexto, mientras que advanced tokens nos ayuda a avanzar al siguiente token.

¿Qué es y cómo se crea expected token?

La función expected token recibe como parámetro un token type. Su propósito es verificar si el siguiente token es del tipo esperado.

Uso de Assert: Mediante un assert, se compara el tipo del token actual (pick token) con el tipo que esperamos.
Resultado: Si coincide, la función avanza al siguiente token y devuelve true. Si no coincide, devuelve false.

def expected_token(token_type):
    assert peek_token.token_type == token_type, "Token inesperado!"
    advance_token()
    return True

¿Cómo funciona advanced tokens?

advanced tokens está diseñado para avanzar entre tokens, similar a cómo avanzamos entre caracteres. Se realiza al guardar el pick token actual como el current token y solicitar un nuevo pick token del Lexer.

Proceso de Avance: Primero, se asigna el pick token al current token. Después, se solicita un nuevo pick token al Lexer.
Objetivo: Mantener el flujo entre tokens, permitiendo análisis secuenciales y confiables.

def advance_tokens():
    current_token = peek_token
    peek_token = lexer.get_next_token()

¿Cómo solucionar problemas comunes al inicializar y correr tests?

Es frecuente enfrentarse a errores al configurar las estructuras de un parser. A continuación, se presentan algunos problemas comunes y cómo solucionarlos.

Inicialización de tokens

Al comenzar a analizar tokens, es esencial inicializarlos adecuadamente para evitar errores de tipo None.

Doble Llamada: Para iniciar tanto el pick como el current token, se hace una llamada repetida a advance_tokens durante la inicialización del parser.

def initialize_parser():
    advance_tokens()
    advance_tokens()

Ajustes durante el ciclo de vida del parser

Al terminar de parsear declaraciones, es crucial avanzar al token siguiente.

Integration con bucles: Es importante asegurarse de que dentro de un bucle while, se esté avanzando correctamente al próximo token.

while current_token is NOT None:
    parse_statement()
    advance_tokens()

¿Cómo verificar la precisión de los identificadores en let statements?

Es vital no sólo parsear correctamente los resultados, sino también verificar que los nombres de los identificadores sean precisos.

Primer y único reto: Validación de nombres

El instructor propone un reto para el estudiante que consiste en asegurar que no sólo los let statements estén correctamente parseados, sino que también los nombres de los identificadores coincidan con los esperados:

Ejemplo de Verificación: Comprueba que el nombre del primer identificador sea x, el segundo y, y el tercero fu.

def test_identifier_names():
    assert program[0].identifier == 'x'
    assert program[1].identifier == 'y'
    assert program[2].identifier == 'fu'

Se alienta al estudiante a implementar estos tests por sí mismo, considerando expectativas y ajustes hasta que los tests pasen exitosamente. Esto no sólo refuerza el conocimiento adquirido, sino que también fomenta la habilidad de resolución de problemas y familiarización con el desarrollo de software orientado a pruebas.

Este enfoque meticuloso no sólo cubre las bases técnicas, sino que también ofrece un camino claro para seguir explorando y perfeccionando habilidades en el desarrollo de parsers y entender con mayor profundidad la estructura de un lenguaje de programación. ¡Adelante!

Carlos Eduardo Gomez García

Hace 6 años

Muy bien, mi solución es poco eficiente comparada con la del profesor, pero antes de ponerla, explicaré un par de cosas importantes (tuve que ver la solución del profesor porque no entendía qué pasaba xD) . Mi idea era que, en program.statements estaban guardados cada uno de los statements, por lo que basándome en la clase LetStatement, debería tener un nombre disponible, así que mi idea era hacer esto:

self.assertEqual(program.statements[0].name, "x")
self.assertEqual(program.statements[1].name, "y")
self.assertEqual(program.statements[2].name, "foo")

Sin embargo, me salía un error de que name no existía en el statement y yo estaba de "¡¿Cómo así que noe existe?! No tas viendo que ahí está definido dentro de la clase?" . Quería hacer prints desde los tests para debuguear, pero no podía usar la función print() desde los tests, no se imprimía nada, de ahi descubrí que si quieres usar prints en los tests tienes que correr este comando:

mypy . && nosetests -s

Así se imprime lo que quiera debuguear, gracias a esto descrubrí que cada statement era un string, y por eso no estaba definida la propiedad name... ¡Pues claro!, LetStatement tiene el dunder method __str__ que hace que cada vez que se consulte una instancia de statement esta devuelva un string... revisando el código del profesor ví que el estaba usando una función llamada cast(), no sé exactamente lo que hace pero intuyo que esa función convierte ese string generado por el dunder method a una instancia de LetStatement, así que aplicándolo, llegue a esta conclusión:

self.assertEqual(cast(LetStatement, program.statements[0]).name, "x")
self.assertEqual(cast(LetStatement, program.statements[1]).name, "y")
self.assertEqual(cast(LetStatement, program.statements[2]).name, "foo")

Todo bien pero... en el atributo name se guarda una instancia de Identifier, así que tenía que acceder a su value (propiedad de la clase Identifier).

self.assertEqual(cast(LetStatement, program.statements[0]).name.value, "x")
self.assertEqual(cast(LetStatement, program.statements[1]).name.value, "y")
self.assertEqual(cast(LetStatement, program.statements[2]).name.value, "foo")

Pero soprresa, Identifier también tiene un dunder method xD Así que al final mi solución quedó así jaja:

self.assertEqual(cast(Identifier, cast(LetStatement, program.statements[0]).name).value, "x")
self.assertEqual(cast(Identifier, cast(LetStatement, program.statements[1]).name).value, "y")
self.assertEqual(cast(Identifier, cast(LetStatement, program.statements[2]).name).value, "foo")

Y solo hay que importar los módulos requeridos:

from typing import (
    cast
)

from lpp.ast import (
    Identifier,
    LetStatement,
    Program,
)

Después vi el código del profesor y el lo hizo con listas y bah! xD Al menos lo logré jaja, una hora para lograrlo:'D

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 funciones advanced y expected tokens