Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

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:0010:01

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

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

Clase 6 de 58

Clase 6 / 58

Recursos

¿Cómo expandir un léxer con pruebas y operadores?

Expandir un léxer es una tarea crucial en el desarrollo de un compilador eficiente. En esta etapa, deseamos robustecer nuestra capacidad para manejar varias funciones, como operadores de un solo carácter, delimitadores y el fin del archivo. Si estás aprendiendo a través de GitHub, asegúrate de seguir en la rama adecuada para este tema específico.

¿Cómo probamos operadores de un solo carácter?

Para iniciar con los operadores simples, primero construimos una prueba. Este test se dirige a operadores de un solo carácter como asignación y suma. La estructura de esta prueba será similar a las anteriores:

def test_one_character_operator():
    source = "=+"
    lexer = Lexer(source)
    tokens = [token for token in lexer]
    expected_tokens = [TokenType.ASSIGN, TokenType.PLUS]
    assert tokens == expected_tokens

Inicialización del léxer: Tomamos la cadena fuente que contiene = y +.
Generación de tokens esperados: Esperamos obtener assign y plus.
Verificación con assert: Comprobamos que los tokens devueltos sean los esperados.

¿Qué hacemos si el token es ilegal?

Si los tokens encontrados no son los esperados, inicialmente el léxer los marcaba como ilegales. Para solucionarlo, importamos el módulo de expresiones regulares re en Python y ajustamos el método next_token del léxer para que reconozca los operadores:

import re

def next_token(self):
    if re.match(r"^=$", self.character):
        return TokenType.ASSIGN, self.character
    elif re.match(r"^\+$", self.character):
        return TokenType.PLUS, self.character
    else:
        return TokenType.ILLEGAL, self.character

¿Cómo probamos el fin del archivo?

Creamos otra prueba que valida cómo el léxer maneja el final del archivo (EOF). La prueba siguiente verificará que el léxer devuelva EOF apropiadamente:

def test_end_of_file():
    source = "+"
    lexer = Lexer(source)
    tokens = [token for token in lexer]
    expected_tokens = [TokenType.PLUS, TokenType.EOF]
    assert tokens == expected_tokens

¿Por qué es imprescindible manejar delimitadores?

Los delimitadores tales como paréntesis, llaves y comas son comunes en las expresiones regulares y deben manejarse adecuadamente en nuestro léxer. El desafío final consiste en implementar un test que compruebe que nuestro léxer puede reconocer y devolver los tokens correspondientes a los delimitadores.

El test debería incluir:

def test_delimiters():
    source = "( ){ } , ;"
    lexer = Lexer(source)
    tokens = [token for token in lexer]
    expected_tokens = [TokenType.LPAREN, TokenType.RPAREN, TokenType.LBRACE, TokenType.RBRACE, TokenType.COMMA, TokenType.SEMICOLON]
    assert tokens == expected_tokens

Este test sirve como una excelente oportunidad práctica para aplicar conocimientos sobre expresiones regulares y manejo de tokens dentro de un léxer. Además, motiva a seguir explorando, escribiendo y comparando su código con soluciones disponibles en GitHub para enriquecer el aprendizaje. ¡Adelante, cada avance es un paso más hacia el dominio del análisis léxico!

Daniel Mercado

Hace 4 años

Yo estoy haciendo el proyecto con Deno y TypeScript.

Tests:

import { assertEquals } from "https://deno.land/std@0.168.0/testing/asserts.ts"

import { Token, TokenType } from '../src/token.ts'
import { Lexer } from '../src/lexer.ts'

Deno.test("lexer test", async (t) => {
    await t.step("test illegal", () => {
        const source = "!¿@"
        const lexer = new Lexer(source)

        const tokens: Token[] = []
        for (let i = 0; i < source.length; i++) {
            tokens.push(lexer.nextToken())
        }

        const expected_tokens = [
            new Token(TokenType.ILLEGAL, '!'),
            new Token(TokenType.ILLEGAL, '¿'),
            new Token(TokenType.ILLEGAL, '@'),
        ]

        assertEquals(tokens, expected_tokens)
    })

    await t.step('test one character operator', () => {
        const source = '+='
        const lexer = new Lexer(source)

        const tokens: Token[] = []
        for (let i = 0; i < source.length; i++) {
            tokens.push(lexer.nextToken())
        }

        const expected_tokens = [
            new Token(TokenType.PLUS, '+'),
            new Token(TokenType.ASSIGN, '='),
        ]

        assertEquals(tokens, expected_tokens)
    })
})

Tokens:

export enum TokenType {
    ASSIGN,
    COMMA,
    EOF,
    FUNCTION,
    IDENT,
    ILLEGAL,
    INT,
    LBRACE,
    LET,
    LPAREN,
    PLUS,
    RBRACE,
    RPAREN,
    SEMICOLON,
}

export class Token {
    tokenType: TokenType
    literal: string

    constructor(tokenType: TokenType, literal: string) {
        this.tokenType = tokenType
        this.literal = literal
    }

    public toString(): string {
        return `Type: ${this.tokenType}, Literal: ${this.literal}`
    }
}

Lexer:

import { Token, TokenType } from "./token.ts"

export class Lexer {
    private source: string
    private chraacter: string
    private readPosition: number
    private position: number

    private TOKENS: { [key: string]: TokenType } = {
        '=': TokenType.ASSIGN,
        ',': TokenType.COMMA,
        ';': TokenType.SEMICOLON,
        '+': TokenType.PLUS,
        '{': TokenType.LBRACE,
        '}': TokenType.RBRACE,
        '(': TokenType.LPAREN,
        ')': TokenType.RPAREN,
        'let': TokenType.LET,
        'fn': TokenType.FUNCTION,
        '': TokenType.EOF,
    }

    constructor(source: string) {
        this.source = source
        this.chraacter = ''
        this.readPosition = 0
        this.position = 0

        this.readCharacter()
    }

    nextToken(): Token {
        const tokenType: TokenType = this.TOKENS[this.chraacter] ?? TokenType.ILLEGAL
        const token = new Token(tokenType, this.chraacter)
        this.readCharacter()
        return token
    }

    private readCharacter(): void {
        if (this.readPosition >= this.source.length) this.chraacter = ''
        else this.chraacter = this.source[this.readPosition]

        this.position = this.readPosition
        this.readPosition++
    }
}

Comentarios (15)15 comentarios

Diana Martinez

Hace 6 años

Andrés Xavier Vargas Vera

Hace 5 años

Kenny Emmanuel Lajara Aquino

Carlos Pavajeau

Carlos Eduardo Gomez García

José De Jesús Ávalos Leal

Hace 3 años

Carlos Nexans

Hace 2 años

luimarco daniel Carrascal Diaz

Oscar Bucio Barrera

Abrahan Gil

Humberto Pérez

Jherom Chacon

Jorge Vidoni

Isaac Reyes

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

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python