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

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

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

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

Clase 36 de 58

Clase 36 / 58

Recursos

¿Cómo definir la precedencia de una llamada a función?

Para resolver funciones de manera efectiva en cualquier lenguaje de programación, es esencial establecer precedencias. La precedencia define el orden de evaluación de las expresiones. En este caso, el objetivo es asignar la precedencia de llamada a un token específico, que en este contexto es el paréntesis izquierdo. Esto se debe a que indica el comienzo de una llamada de función, lo cual posee la precedencia más alta entre los operadores.

Una vez establecida, esta precedencia garantiza que las funciones se evalúen correctamente antes que otros operadores, incluidos el de multiplicación y adición. Esta técnica esencial asegura que nuestra lógica de programación se implemente de manera adecuada.

¿Cómo implementar la función de análisis parse call y parse call arguments?

En la construcción de un parser, necesitamos implementar funciones que nos permitan analizar llamadas a funciones, generando nodos que respeten la sintaxis establecida. La función parse call es la encargada de recibir una expresión y devolver una llamada correcta. La estructura básica de esta función es generar un nodo de manera que mantenga el token actual y pueda gestionar los argumentos con una función auxiliar llamada parse call arguments.

parse call

Esta función se encarga de:

Verificar que el token actual no sea none.
Crear un nuevo nodo que reciba el current token y la expresión como parámetros.
Inicializar una lista de argumentos a través de parse call arguments.

def parse_call(self, function: Expression) -> Call:
    token = self.current_token  # Almacena el current token
    self.next_token()
    arguments = self.parse_call_arguments()
    return Call(token, function, arguments)

parse call arguments

La función parse call arguments se encarga de identificar y organizar cada argumento dentro de una lista. La implementación sigue una lógica secuencial:

Inicializar una lista vacía para los argumentos.
Verificar si el peeking token es un paréntesis derecho, en cuyo caso retorna una lista vacía.
Usar el operador walrus para procesar cada expresión de argumento, añadiéndolo a la lista cuando no es none.
Manejar múltiples argumentos separados por comas.
Verificar la existencia de un paréntesis derecho para detectar cualquier error de sintaxis.

def parse_call_arguments(self) -> List[Expression]:
    arguments = []
    if self.peek_token_is(TokenType.RPAREN):
        self.next_token()
        return arguments

    self.next_token()
    while expression := self.parse_expression(Precedences.LOWEST):
        arguments.append(expression)
        if not self.peek_token_is(TokenType.COMMA):
            break
        self.next_token()  # Avanza para llegar a la coma
        self.next_token()  # Avanza hacia el nuevo argumento

    if not self.expect_peek(TokenType.RPAREN):
        return []

    return arguments

¿Cómo registrar la función de análisis en el parser?

Finalmente, para integrar la funcionalidad de análisis de llamadas a funciones, necesitamos asociar la función parse call con los operadores que manejan el paréntesis izquierdo. Esto se puede lograr a través del método register infix functions:

self.register_infix_function(TokenType.LPAREN, self.parse_call)

Con esto, cada vez que el parser encuentra un paréntesis izquierdo, sabe que es necesario analizar una llamada a función. La implementación de los tests asegura que cada parte del código cumpla con las expectativas y la sintaxis previamente definida.

Recordar: si tienes dudas o comentarios, la comunidad está lista para ayudarte. Siempre están disponibles espacios como los comentarios para generar discusiones ricas y constructivas sobre estos temas. ¡Continúa tu aprendizaje y explora más este fascinante mundo de los parsers en programación!

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 llamadas a funciones en un parser con AST