Declaración y ejecución de funciones

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

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

Aprende a desarrollar lenguajes de programación con intérpretes

Desarrolla LPP o Lenguaje de Programación Platzi

Construcción del lexer o tokenizador

¿Qué es análisis léxico? Funcionamiento del lexer y tokens

Estructura y definición de tokens en Python

Lectura de caracteres y tokens

Tokens ilegales, operadores de un solo carácter y delimitadores

Reconocimiento y diferenciación entre letras y números

Declaración y ejecución de funciones

Extensión del lexer: condicionales, operaciones y booleanos

Operadores de dos caracteres

Primera versión del REPL con tokens

Construcción del parser o analizador sintáctico

¿Qué es un parser y AST?

Estructura y definición de nodos del AST en Python

Parseo del programa o nodo principal

Parseo de assignment statements

Parseo de let statements

Parseo de errores

Parseo del return statement

Técnicas de parsing y pratt parsing

Pruebas del AST

Implementación del pratt parser

Parseo de Identifiers: testing

Parseo de Identifiers: implementación

Parseo de enteros

Prefix operators: negación y negativos

Infix operators y orden de las operaciones: testing

Infix operators y orden de las operaciones: implementación

Parseo de booleanos

Desafío: testing de infix operators y booleanos

Parseo de expresiones agrupadas

Parseo de condicionales: testing y AST

Parseo de condicionales: implementación

Parseo de declaración de funciones: testing

Parseo de declaración de funciones: AST e implementación

Parseo de llamadas a funciones: testing y AST

Parseo de llamadas a funciones: implementación

Completando los TODOs o pendientes del lexer

Segunda versión del REPL con AST

Evaluación o análisis semántico

Significado de símbolos

Estrategias de evaluación para intérpretes de software

Representación de objetos

Evaluación de expresiones: enteros

Evaluación de expresiones: booleanos y nulos

Evaluación de expresiones: prefix

Evaluación de expresiones: infix

Evaluación de condicionales

Evaluación del return statement

Manejo de errores

Ambiente

Bindings

Evaluación de funciones

Llamadas a funciones

Mejora del intérprete

Implementación de strings

Operaciones con strings

Built-in functions: objeto y tests

Built-in functions: evaluación

Siguientes pasos

Retos para expandir tu intérprete

Continúa con el Curso de Creación de Compiladores de Software

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

Aportes 12

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

RetaxMaster

hace 4 años

No se vale, el reto ya estaba resuelto xD Prácticamente el lexer ya es capaz de identificar la mayoría de tokens de nuestro lenguaje, ya solo era cuestión de escribir el test jajaja:

def test_function_call(self) -> None:
        
        source: str = """
            variable resultado = suma(dos, tres);
        """
        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []

        for i in range(10):

            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.LET, "variable"),
            Token(TokenType.IDENT, "resultado"),
            Token(TokenType.ASSIGN, "="),
            Token(TokenType.IDENT, "suma"),
            Token(TokenType.LPAREN, "("),
            Token(TokenType.IDENT, "dos"),
            Token(TokenType.COMMA, ","),
            Token(TokenType.IDENT, "tres"),
            Token(TokenType.RPAREN, ")"),
            Token(TokenType.SEMICOLON, ";"),
        ]

        self.assertEquals(tokens, expected_tokens)

Por cierto, en mi caso cambiaré el keyword “procedimiento” por el keyword “funcion”, a mi parecer la palabra “procedimiento” es una palabra más complicada de entender cuando estás aprendiendo a programar jajaja, la palabra “funcion” es más fácil uwu

diananerd

Profe Platzi

hace 4 años

Que curioso, las funciones en LPP no tienen un token para retorno, pero retornan.

Jaime Rafael Norato Corredor

hace 4 años

cree esta función para optimizar mis test, para ahorrame las 4 lineas que siempre se repiten en todos los tests, y así solo me concentro en el listado de tokens que debe evaluar mi test.

    def validate_tes(self, source: str, expected_tokens: List[Token]) -> None:
        lexer: Lexer = Lexer(source)

        token: List[Token] = []
        for i in range(len(expected_tokens)):
            token.append(lexer.next_token())

        self.assertEquals(token, expected_tokens)

y en el test del reto se vería así:

    def test_function_call(self) -> None:
        source: str = """
            variable resultado = suma(dos, tres);
        """

        expected_tokens: List[Token] = [
            Token(TokenType.LET, 'variable'),
            Token(TokenType.IDENT, 'resultado'),
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.IDENT, 'suma'),
            Token(TokenType.RPAREN, '('),
            Token(TokenType.IDENT, 'dos'),
            Token(TokenType.COMMA, ','),
            Token(TokenType.IDENT, 'tres'),
            Token(TokenType.LPAREN, ')'),
            Token(TokenType.SEMICOLON, ';'),
        ]

        self.validate_tes(source, expected_tokens)

y al rescribir todo mi lexer_test.py me quedo de la siguiente forma:

from typing import List
from unittest import TestCase
from typing import List
from lpp.token import (
    Token,
    TokenType
)
from lpp.lexer import Lexer


class LexerTest(TestCase):

    def test_illegal(self) -> None:
        source: str = '¡¿@'

        expected_tokens: List[Token] = [
            Token(TokenType.ILLEGAL, '¡'),
            Token(TokenType.ILLEGAL, '¿'),
            Token(TokenType.ILLEGAL, '@')
        ]

        self.validate_tes(source, expected_tokens)

    def test_one_character_operator(self) -> None:
        source: str = '=+'

        expected_tokens: List[Token] = [
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.PLUS, '+'),
        ]

        self.validate_tes(source, expected_tokens)

    def test_eof(self) -> None:
        source: str = '+'

        expected_tokens: List[Token] = [
            Token(TokenType.PLUS, '+'),
            Token(TokenType.EOF, ''),
        ]

        self.validate_tes(source, expected_tokens)

    def test_delimiters(self) -> None:
        source = '(){},;'

        expected_tokens: List[Token] = [
            Token(TokenType.RPAREN, '('),
            Token(TokenType.LPAREN, ')'),
            Token(TokenType.RBRACE, '{'),
            Token(TokenType.LBRACE, '}'),
            Token(TokenType.COMMA, ','),
            Token(TokenType.SEMICOLON, ';'),
        ]

        self.validate_tes(source, expected_tokens)

    def test_assignment(self) -> None:
        source = 'variable cinco = 5;'

        expected_tokens: List[Token] = [
            Token(TokenType.LET, 'variable'),
            Token(TokenType.IDENT, 'cinco'),
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.INT, '5'),
            Token(TokenType.SEMICOLON, ';'),
        ]

        self.validate_tes(source, expected_tokens)

    def test_function_declaration(self) -> None:
        source = '''
            variable suma = procedimiento(x, y) {
                x + y;
            };
        '''

        expected_tokens: List[Token] = [
            Token(TokenType.LET, 'variable'),
            Token(TokenType.IDENT, 'suma'),
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.FUNCTION, 'procedimiento'),
            Token(TokenType.RPAREN, '('),
            Token(TokenType.IDENT, 'x'),
            Token(TokenType.COMMA, ','),
            Token(TokenType.IDENT, 'y'),
            Token(TokenType.LPAREN, ')'),
            Token(TokenType.RBRACE, '{'),
            Token(TokenType.IDENT, 'x'),
            Token(TokenType.PLUS, '+'),
            Token(TokenType.IDENT, 'y'),
            Token(TokenType.SEMICOLON, ';'),
            Token(TokenType.LBRACE, '}'),
            Token(TokenType.SEMICOLON, ';'),
        ]

        self.validate_tes(source, expected_tokens)

    def test_function_call(self) -> None:
        source: str = """
            variable resultado = suma(dos, tres);
        """

        expected_tokens: List[Token] = [
            Token(TokenType.LET, 'variable'),
            Token(TokenType.IDENT, 'resultado'),
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.IDENT, 'suma'),
            Token(TokenType.RPAREN, '('),
            Token(TokenType.IDENT, 'dos'),
            Token(TokenType.COMMA, ','),
            Token(TokenType.IDENT, 'tres'),
            Token(TokenType.LPAREN, ')'),
            Token(TokenType.SEMICOLON, ';'),
        ]

        self.validate_tes(source, expected_tokens)

    def validate_tes(self, source: str, expected_tokens: List[Token]) -> None:
        lexer: Lexer = Lexer(source)

        token: List[Token] = []
        for i in range(len(expected_tokens)):
            token.append(lexer.next_token())

        self.assertEquals(token, expected_tokens)

Espero les sirva, y cualquier aporte o comentario adicional , bienvenido sea 😃

Raúl Humberto Peñate Ramírez

hace 4 meses

tuvo bueno ` def test_function_call(``self``) -> None: source: ``str`` = 'bolado resultado = suma(dos, tres);'` ` lexer: Lexer = Lexer(source)` ` tokens: List[Token] = [] for i in range(10): tokens.append(lexer.next_token())` ` expected_tokens: List[Token] = [ Token(TokenType.LET, 'bolado'), Token(TokenType.IDENT, 'resultado'), Token(TokenType.ASSIGN, '='), Token(TokenType.IDENT, 'suma'), Token(TokenType.LPAREN, '('), Token(TokenType.IDENT, 'dos'), Token(TokenType.COMMA, ','), Token(TokenType.IDENT, 'tres'), Token(TokenType.RPAREN, ')'), Token(TokenType.SEMICOLON, ';'), ] ``self``.assertEqual(tokens, expected_tokens)`

luimarco daniel Carrascal Diaz

hace 10 meses

tamalito

Oscar Bucio Barrera

hace 2 años

    # Challenge 2
    def test_function_call(self) -> None:
        source: str = 'variable resultado = suma(dos, tres);'
        lexer: Lexer = Lexer(source)
        
        tokens: List[Token] = []
        for i in range(10):
            tokens.append(lexer.next_token())
        
        expected_tokens: List[Token] = [
            Token(TokenType.LET, 'variable'),
            Token(TokenType.IDENT, 'resultado'),
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.IDENT, 'suma'),
            Token(TokenType.LPAREN, '('),
            Token(TokenType.IDENT, 'dos'),
            Token(TokenType.COMMA, ','),
            Token(TokenType.IDENT, 'tres'),
            Token(TokenType.RPAREN, ')'),
            Token(TokenType.SEMICOLON, ';'),

        ]

        self.assertEquals(tokens, expected_tokens)

karakurisnm

hace 2 años

Mi solución

def test_function_call(self) -> None:
    source: str = 'variable resultado = suma(dos, tres);'
    lexer: Lexer = Lexer(source)

    tokens: List[Token] = []
    token = lexer.next_token()
    while token != Token(TokenType.EOF, ''):
        tokens.append(token)
        token = lexer.next_token()

    expected_tokens: List[Token] = [
        Token(TokenType.LET, 'variable'),
        Token(TokenType.IDENT, 'resultado'),
        Token(TokenType.ASSIGN, '='),
        Token(TokenType.IDENT, 'suma'),
        Token(TokenType.LPAREN, '('),
        Token(TokenType.IDENT, 'dos'),
        Token(TokenType.COMMA, ','),
        Token(TokenType.IDENT, 'tres'),
        Token(TokenType.RPAREN, ')'),
        Token(TokenType.SEMICOLON, ';'),
    ]
    self.assertEquals(tokens, expected_tokens)

karakurisnm

hace 2 años

De esta manera podemos evitar contar los tokens

	tokens: List[Token] = []
        token = lexer.next_token()
        while token != Token(TokenType.EOF, ''):
            tokens.append(token)
            token = lexer.next_token()

en lugar de

        tokens: List[Token] = []
        for i in range(5):
            tokens.append(lexer.next_token())

espero sea util

Jherom Chacon

hace 4 años

Bueno de lo fácil que era no estoy seguro de que esté bien

Jherom Chacon

hace 4 años

Reto

Jherom Chacon

hace 4 años

Agregando el Keyword procedimiento

Jherom Chacon

hace 4 años

Implementación del test test_function_declaration