Implementación de Operadores y Condicionales en Lexer de Platzi

Clase 9 de 58 • Curso de Creación de Lenguajes de Programación: Intérpretes

Resumen

¿Cómo extender el léxico para condicionales y booleanos?

El desarrollo de un intérprete para el lenguaje de programación Platzi requiere que ampliemos nuestras capacidades continuamente. Hasta ahora, hemos hecho grandes avances en el manejo de variables, operadores básicos y funciones. Sin embargo, el enfoque ahora está en expandir nuestro léxer para incluir operadores adicionales y diálogo condicional.

¿Cómo se implementan los operadores adicionales?

Para empezar, debemos implementar una serie de pruebas y modificaciones en nuestro sistema. El enfoque aquí es crear un nuevo test llamado test control statement, con el fin de corroborar si nuestros condicionales generan las consecuencias correctas.

Pruebas necesarias:
- Debemos definir un source y tokenizar el siguiente string: si 5 menor que 10 regresa verdadero, si no regresa falso.
- Esto requiere implementar keywords como sí, regresa, verdadero, falso, y también definir un operador de comparación como <.
Cambio en el método next token:
- Modificando el método next token en el léxer, podemos determinar dónde se ubican cada uno de los operadores y ajustar nuestras expresiones regulares.
Actualización en lookup token type:
- En el módulo token.py, dentro del método lookup token type, añadimos las nuevas keywords a reconocer, como: falso, verdadero, sí (equivalente a if), si no (equivalente a else), y regresa (como return).

¿Qué cambios se realizan en el archivo de tokens?

La manipulación del archivo token.py es crucial para determinar los tipos de token extendidos.

Definición de nuevos token types:
- Añadimos else, false, if, return y true en nuestro enum de token types, siguiendo un orden alfabético para facilitar futuras revisiones.
Implementación del operador <:
- Introducimos una expresión regular dentro de next token para reconocer el operador < y construimos un token correspondiente al tipo less than.

¿Cómo se crea un test para operadores de un solo carácter?

El último paso incluye ajustar el test one character operator para verificar si los nuevos operadores son reconocidos correctamente.

Operadores a implementar:
- Además de los ya existentes de asignación y suma, añadimos: resta, división, multiplicación, menor que, mayor que y negación.
Modificación y prueba:
- Ajustamos los tokens esperados en el test y modificamos el código dentro de next token para identificar estos caracteres.

Esta serie de implementaciones garantiza que nuestro intérprete no solo reconozca elementos básicos, sino que pueda procesar condiciones y operadores fundamentales. Prueba estas nuevas características y comparte tus hallazgos en los comentarios. ¡Mantén siempre el entusiasmo por el aprendizaje y el crecimiento en programación!

Carlos Eduardo Gomez García

teacher•

Reto resuelto! :D . Primero escribo el test expectando los tokens:

def test_one_character_operator(self) -> None:

        source: str = "=+"
        source: str = "=+-/*<>!"
        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []
        for i in range(len(source)):
            tokens.append(lexer.next_token())
        expected_tokens: List[Token] = [
            Token(TokenType.ASSIGN, "="),
            Token(TokenType.PLUS, "+"),
            Token(TokenType.MINUS, "-"),
            Token(TokenType.DIVISION, "/"),
            Token(TokenType.MULTIPLICATION, "*"),
            Token(TokenType.LT, "<"),
            Token(TokenType.GT, ">"),
            Token(TokenType.NEGATION, "!"),
        ]

        self.assertEquals(tokens, expected_tokens)

Después, en la lista de token types se agregan los nuevos tokens:

DIVISION = auto()
GT = auto() # Gretater Than (>)
MINUS = auto() # Resta
MULTIPLICATION = auto()
NEGATION = auto() # Negación (!)

Después se añaden las condiciones al lexer para que pueda retornar los tokens correctos (hay que escapar la multiplicación):

        elif match(r"^-$", self._character):
            token = Token(TokenType.MINUS, self._character)

        elif match(r"^/$", self._character):
            token = Token(TokenType.DIVISION, self._character)

        elif match(r"^\*$", self._character):
            token = Token(TokenType.MULTIPLICATION, self._character)

        elif match(r"^<$", self._character):
            token = Token(TokenType.LT, self._character)

        elif match(r"^>$", self._character):
            token = Token(TokenType.GT, self._character)

        elif match(r"^!$", self._character):
            token = Token(TokenType.NEGATION, self._character)

¡Y listo! :D . https://github.com/RetaxMaster/lpp/commit/b935aa10e833565492fea8935a68e4dd87067c66

Fernando Lopez

student•

Tengo un problema y es que al ejecutar el test no me marca todos los errores

Oscar Bucio Barrera

student•

Me paso lo mismo, pone el primero que encuentra, supongo que es por la versión de la libreria de testing. Si te pasa los tests completamente y no te arroja NINGUN error es posible que tengas un error de identación, así me pasó a mi jajaja

Jherom Chacon

student•

Quise incluir el NOT pero lo habíamos agregado como un token inválido al inicio, entonces no fue posible y tuve que corregir.

luimarco daniel Carrascal Diaz

student•

def test_control_statement(self) -> None:
  source: str ='''
    si(5<10){
      regresa verdadero;
    }si_no{
      regresa falso;
    }
  '''
  lexer: Lexer=Lexer(source)
  tokens:List[Token]

luimarco daniel Carrascal Diaz

student•

Daniel Mercado

student•

Esta es mi solucion en Deno con TypeScript: test:

  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.ASSIGN, '='),
      new Token(TokenType.PLUS, '+'),
      new Token(TokenType.MINUS, '-'),
      new Token(TokenType.DIVISION, '/'),
      new Token(TokenType.MULTIPLICATION, '*'),
      new Token(TokenType.LT, '<'),
      new Token(TokenType.RT, '>'),
      new Token(TokenType.NEGATION, '!'),
    ]

    assertEquals(tokens, expected_tokens)
  })

tokens:

export enum TokenType {
  ASSIGN,
  COMMA,
  EOF,
  FUNCTION,
  IDENT,
  ILLEGAL,
  NUMBER,
  LBRACE,
  LET,
  LPAREN,
  PLUS,
  RBRACE,
  RPAREN,
  SEMICOLON,
  RETURN,
  IF,
 ``` LT,
  RT,
  TRUE,
  FALSE,
  ELSE,
  MINUS,
  DIVISION,
  MULTIPLICATION,
  NEGATION
}

export const validCharacters: { [key: string]: TokenType } = {
  ',': TokenType.COMMA,
  ';': TokenType.SEMICOLON,
  '{': TokenType.LBRACE,
  '}': TokenType.RBRACE,
  '(': TokenType.LPAREN,
  ')': TokenType.RPAREN,
  '': TokenType.EOF,
  
  //operators
  '+': TokenType.PLUS,
  '=': TokenType.ASSIGN,
  '<': TokenType.LT,
  '>': TokenType.RT,
  '*': TokenType.MULTIPLICATION,
  '-': TokenType.MINUS,
  '/': TokenType.DIVISION,
  '!': TokenType.NEGATION
}

lexer:

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

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

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

        this.readCharacter()
    }

    nextToken(): Token {
        this.skipWhiteSpace()
        let tokenType: TokenType = TokenType.EOF
        let token: Token = new Token(tokenType, '')

        if (this.isValidCharacter(this.character)) {
            tokenType = validCharacters[this.character]
            token = new Token(tokenType, this.character)
        }
        else if (this.isLetter(this.character)) {
            const literal = this.readIdentifier()
            const tokenType = lookupTokenType(literal)
            return new Token(tokenType, literal)
        }
        else if (this.isNumber(this.character)) {
            const literal = this.readNumber()
            return new Token(TokenType.NUMBER, literal)
        }
        else {
            token = new Token(TokenType.ILLEGAL, this.character)
        }

        this.readCharacter()
        return token
    }

    private readIdentifier(): string {
        const initialPosition = this.position

        while (this.isLetter(this.character)) {
            this.readCharacter()
        }

        return this.source.slice(initialPosition, this.position)
    }

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

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

    private readNumber(): string {
        const initialPosition = this.position

        while (this.isNumber(this.character)) {
            this.readCharacter()
        }

        return this.source.slice(initialPosition, this.position)
    }

    private isLetter(character: string): boolean {
        return /^[a-zA-Z_&]$/.test(character)
    }

    private isValidCharacter(character: string): boolean {
        return Object.keys(validCharacters).includes(character)
    }

    private isNumber(character: string): boolean {
        return /^[0-9.]$/.test(character)
    }

    private skipWhiteSpace(): void {
        while (/^[\s\t]$/.test(this.character)) {
            this.readCharacter()
        }
    }
}

Jherom Chacon

student•

Definición de palabras reservadas para compradores y boleanos

Fabián Vega Alcota

student•

¿Qué pasaría con mayor o igual que '>=', o menor o igual que '<=', también deberías implementarlo como uno solo?

Jherom Chacon

student•

Estaba pensando exactamente lo mismo, hay que implementar para esto algo similar a lo que implementamos ya para determinar literales y palabras reservadas. Aunque esto estará reservado para la próxima clase. En todo caso deben validarse en la cadena antes de la validación individual de operadores simples para evitar choques.

Oscar Bucio Barrera

student•

Aquí mi solución:

def test_one_character_operator(self) -> None: # Test para reconocer los operadores de un caracter
        source: str = '=+/-*<>!'
        lexer: Lexer = Lexer(source) # Inicializamos el Lexer pasandole como argumento el source
        tokens: List[Token] = [] # Se genera la lista de tokens que el lexer debería de devolver
        for i in range(len(source)): # Se hace un loop a lo largo de Lexer y en cada loop se llama a next_token para ir populando o añadiendo cada Token a la lista de tokens
            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.ASSIGN, '='),
            Token(TokenType.PLUS, '+'),
            Token(TokenType.DIV, '/'),
            Token(TokenType.MINUS, '-'),
            Token(TokenType.MULT, '*'),
            Token(TokenType.LT, '<'),
            Token(TokenType.GT, '>'),
            Token(TokenType.EXC, '!'),
        ]
        self.assertEquals(tokens, expected_tokens)

@unique # Se le añade el decorador unique pora saber que los tokens son unicos, un decorador recibe como parametro una funcion, le añade cosas, la ejecuta y retorna a esta misma función pero ya modificada, por eso se dice que retorna una función diferente
class TokenType(Enum):
    # Es buena practica ponerlos en orden alfabetico
    # auto es que no interesa el valor del enum
    ASSIGN = auto()
    COMMA = auto()
    ELSE = auto()
    EOF = auto()
    EXC = auto()
    DIV = auto()
    FALSE = auto()
    FUNCTION = auto()
    GT = auto()
    IDENT = auto()
    IF = auto()
    ILLEGAL = auto()
    INT = auto()
    LBRACE = auto()
    LET = auto()
    LPAREN = auto()
    LT = auto()
    MINUS = auto()
    MULT = auto()
    PLUS = auto()
    RBRACE = auto()
    RETURN = auto()
    RPAREN = auto()
    SEMICOLON = auto()
    TRUE = auto()

Y la implementación en el lexer

def next_token(self) -> Token:

        # Se va a revisar con expresiones regulares
        """
        En Python las expresiones regulares empiezan con cadenas row
        Comience al principio de la cadena, encuentre un igual y que termine en esto, se quiere un igual desde el principio hasta el final
        """
        self._skip_whitespace() # Se ignoraran los espacios en blanco siempre al empezar un nuevo token

        if match(r'^=$', self._character):
            token = Token(TokenType.ASSIGN, self._character)
        elif match(r'^\+$', self._character):  # Se escapa por tener un significado especial en las expresiones regulares
            token = Token(TokenType.PLUS, self._character)
        elif match(r'^$', self._character):
            token = Token(TokenType.EOF, self._character)
        elif match(r'^\($', self._character): # Se escapa por tener un significado especial en las expresiones regulares
            token = Token(TokenType.LPAREN, self._character)
        elif match(r'^\)$', self._character): # Se escapa por tener un significado especial en las expresiones regulares
            token = Token(TokenType.RPAREN, self._character)
        elif match(r'^{$', self._character):
            token = Token(TokenType.LBRACE, self._character)
        elif match(r'^}$', self._character):
            token = Token(TokenType.RBRACE, self._character)
        elif match(r'^,$', self._character):
            token = Token(TokenType.COMMA, self._character)
        elif match(r'^;$', self._character):
            token = Token(TokenType.SEMICOLON, self._character)
        elif match(r'^<$', self._character):
            token = Token(TokenType.LT, self._character)
        elif match(r'^/$', self._character):
            token = Token(TokenType.DIV, self._character)
        elif match(r'^-$', self._character):
            token = Token(TokenType.MINUS, self._character)
        elif match(r'^\*$', self._character): # Se escapa por tener un significado especial en las expresiones regulares
            token = Token(TokenType.MULT, self._character)
        elif match(r'^>$', self._character):
            token = Token(TokenType.GT, self._character)
        elif match(r'^!$', self._character):
            token = Token(TokenType.EXC, self._character)
        # Funciones auxiliares, en lugar de generar una expresion regular se generan funciones auxiliares
        elif self._is_letter(self._character): # Ahora si nos encontramos frente a un caracter lo que se quiere es generar una literal, donde se genera una funcion y luego se conoce que tipo de Token es
            literal = self._read_identifier()
            # Ahora como podemos tener un identifier o keyword se genera esta funcion
            token_type = lookup_token_type(literal) # Esta funcion se genera en token.py

            return Token(token_type, literal) # Se regresa lo que mande la funcion lookup y la literal
        # Se necesita saber si estamos frente a un numero
        elif self._is_number(self._character):
            literal = self._read_number()

            return Token(TokenType.INT, literal)
        else: # Si no reconoce entonces dirá que es un Token ilegal
            token = Token(TokenType.ILLEGAL, self._character)

        """
        Se tiene que escapar especificamente el caracter de suma porque suma significa algo especifico en las expresiones regulares, significa que haga match por lo menos una o mas veces pero aqui no interesa la funcionalidad sino especificamente el caracter, se escapa con la diagonal invertida
        """
        # Escapar: hacer que el caracter sea tomado cómo texto plano en lugar de su significado por defecto en la expreción regular.

        
        # Se necesita correrlo despues de que se genere el token y antes de regresarlo
        self._read_character()
        
        return token # Se regresa el token

Isaac Reyes

student•

Este curso está muy bueno!

Aquí se me había olvidado poner los tokens en la lista y estuve media hora viendo que pasaba xd

# lexer_test.py

def test_one_character_operator(self) -> None:
        source: str = '=+-/*<>!'
        lexer: Lexer = Lexer(source)

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

            expected_tokens: List[Token] = [
                Token(TokenType.ASSIGN, '='),
                Token(TokenType.PLUS, '+'),
                Token(TokenType.MINUS, "-"),
                Token(TokenType.DIVISION, "/"),
                Token(TokenType.MULTIPLICATION, "*"),
                Token(TokenType.LT, "<"),
                Token(TokenType.GT, ">"),
                Token(TokenType.NEGATION, "!"),
            ]

# lexer.py

	# Token '='
        if match(r'^=$', self._character):
            token = Token(TokenType.ASSIGN, self._character)
        # Token '+'
        elif match(r'^\+$', self._character):
            token = Token(TokenType.PLUS, self._character)
        # Token '-'
        elif match(r'^-$', self._character):
            token = Token(TokenType.MINUS, self._character)
        # Token '*'
        elif match(r'^\*$', self._character):
            token = Token(TokenType.MULTIPLICATION, self._character)
        # Token '/'
        elif match(r'^\/$', self._character):
            token = Token(TokenType.DIVISION, self._character)
        # Token '<'
        elif match(r'^<$', self._character):
            token = Token(TokenType.LT, self._character)
        # Token '>'
        elif match(r'^>$', self._character):
            token = Token(TokenType.GT, self._character)
            # Token '!'
        elif match(r'^!$', self._character):
            token = Token(TokenType.NEGATION, self._character)

DIVISION = auto() # /
GT = auto() # >
MINUS = auto() # -
MULTIPLICATION = auto() # *
NEGATION = auto() # !