Reconocimiento de Funciones en Lexer de Lenguaje de Programación

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:007:46

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

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

Clase 8 de 58

Clase 8 / 58

Recursos

¿Cómo se reconocen las funciones en el lexer?

El desarrollo de un lexer es crucial para la construcción de un lenguaje de programación, y ahora nos encontramos en el emocionante punto de reconocer las funciones dentro de nuestro código. Ya hemos avanzado bastante al poder identificar identificadores, ciertos keywords como "variable" y varios símbolos del lenguaje. Sin embargo, ha llegado el momento de dar un paso más y poder detectar funciones.

Para esto, vamos a implementar un nuevo test que inicialmente debe fallar; esto nos obligará a escribir el código necesario para que este test pueda avanzar. Trabajaremos dentro del branch 8 de nuestro repositorio en GitHub, donde además generaremos un test llamado test function declaration.

En él, definiremos una función que se ve de la siguiente manera:

variable suma es igual a un procedimiento que recibe como parámetros x y y y regresa simplemente x más y.

Esta sintaxis, particular por estar en español, forma parte de nuestro lenguaje y nos permite identificar claramente las funciones.

¿Cómo se implementa y ejecuta el test?

Para comenzar, cargamos el lexer con el source, que es el string de arriba. Aunque solo pasamos strings, es importante recordar que podríamos leer este source directamente de un archivo del sistema. Una vez que tenemos nuestra lista de tokens, vamos a identificar los siguientes 16 tokens:

variable
Identificador suma
Signo de asignación =
Keyword procedimiento (representa function)
Paréntesis de apertura (
Parámetro x
Coma ,
Parámetro y
Paréntesis de cierre )
Corchetes de apertura {
Identificador x
Operador suma +
Identificador y
Punto y coma ;
Corchetes de cierre }
Punto y coma ;

Es crucial incluir las aserciones apropiadas, ya que sin ellas, el test no tiene valor alguno.

¿Qué hacemos cuando el test falla?

Al ejecutar nuestro test, encontramos que no se reconoce la palabra "procedimiento" adecuadamente; se detecta como un identificador. Esto ocurre porque nuestro lexer aún no ha sido instruido para reconocerla como un keyword.

Para solucionarlo, vamos al archivo donde hemos definido nuestros tokens. Allí, agregamos "procedimiento" como un nuevo keyword, asignándole el tipo function. Ahora nuestro lexer podrá identificar correctamente esta palabra.

¿Qué challenge nos espera?

Como cierre, te propongo que implementes un test adicional que llame funciones. Este se denomina test function call y no recibe parámetros ni retorna valores. Así lograrás evaluar el siguiente source:

variable resultado es igual a suma de 2 y 3;

Aquí, los tokens a identificar incluyen:

variable como keyword de tipo let
resultado como identificador
Un operador de asignación
suma como identificador que es seguido por paréntesis, indicando una llamada a función

Aunque el lexer no requiere entender la sintaxis o semántica completa de nuestro lenguaje, este es el trabajo del parser. Este desafío es una excelente forma de poner en práctica lo aprendido e ir familiarizándote más con la dinámica de creación del lenguaje.

Para ayudarte en este proceso de aprendizaje activo, la solución se encuentra disponible en un branch en GitHub, donde puedes comparar tu código con el original. ¡Recuerda compartir tus avances y dificultades en la sección de comentarios para que te podamos brindar apoyo en todo momento!

Jaime Rafael Norato Corredor

Hace 5 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 :)

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

Reconocimiento de Funciones en Lexer de Lenguaje de Programación