Implementación de Operadores de Dos Caracteres en Lexer

Cursos Empresas Blog Live Conf Precios

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

Implementación de Operadores de Dos Caracteres en Lexer

Resumen

Construir un lexer capaz de leer operadores de un solo carácter es apenas el primer paso. Cuando tu lenguaje necesita distinguir entre asignación (=) e igualdad (==), o entre negación (!) y desigualdad (!=), el lexer debe aprender a mirar hacia adelante antes de decidir qué token emitir. Aquí se explica exactamente cómo lograrlo usando dos funciones clave: peek character y make two character token.

¿Por qué el lexer necesita ver el siguiente carácter?

Hasta este punto, el lexer lee carácter por carácter y produce tokens individuales. El problema aparece con los operadores de dos caracteres [0:10]: cuando el lexer encuentra un =, no sabe si se trata de una asignación o del inicio de un == (igualdad). Lo mismo ocurre con !, que puede ser negación o el comienzo de != (desigualdad).

En lenguajes como JavaScript o Python, el doble igual (==) representa el test de igualdad, mientras que el igual simple (=) es asignación. El lexer debe replicar esa distinción.

Para resolverlo, se aprovechan las dos variables que ya existen en el lexer: position y read position [0:40]. La primera indica dónde estamos; la segunda apunta al carácter que viene después. Ahora se entiende por qué eran necesarias ambas variables desde el diseño inicial.

¿Cómo implementar el test para operadores de dos caracteres?

Siguiendo la metodología de desarrollo guiado por pruebas, se crea un test llamado test_two_character_operator [1:16]. El source de entrada es:

10 == 10; 10 != 9;

La lista de tokens esperados contiene ocho elementos:

INT(10), EQUALS, INT(10), SEMICOLON.
INT(10), NOT_EQUALS, INT(9), SEMICOLON.

Antes de ejecutar el test, es necesario agregar los nuevos token types al archivo de token [2:18]:

EQUALS se ubica en orden alfabético.
NOT_EQUALS se coloca después de NEGATION.

Al correr el test sin más cambios, el lexer reporta que esperaba un EQUALS pero encontró un ASSIGN [2:38]. Esto confirma que el lexer aún no sabe leer dos caracteres seguidos.

¿Cómo funcionan peek character y make two character token?

Dentro del archivo lexer.py se modifica la lógica para los símbolos = y ! [2:55].

¿Qué hace peek character?

La función peek_character no recibe parámetros y retorna un string [4:02]. Su lógica es directa:

python def peek_character(self) -> str: if self.read_position >= len(self.source): return '' return self.source[self.read_position]

Si read_position supera la longitud del source, ya no hay nada que leer y devuelve una cadena vacía.
En caso contrario, devuelve el carácter en read_position sin avanzar la posición actual.

¿Qué hace make two character token?

Esta función recibe un token_type como parámetro y retorna un token compuesto [4:36]:

python def make_two_character_token(self, token_type: TokenType) -> Token: prefix = self.character self.read_character() suffix = self.character return Token(token_type, f'{prefix}{suffix}')

Guarda el carácter actual como prefijo.
Llama a read_character() para avanzar al siguiente carácter.
Guarda el nuevo carácter actual como sufijo.
Concatena ambos y crea el token con el tipo correspondiente.

La llamada a read_character() en medio es fundamental: permite que el lexer se posicione correctamente para la siguiente iteración [5:00].

¿Cómo se conecta todo en el lexer?

Cuando el lexer encuentra =:

Usa peek_character() para ver si el siguiente también es =.
Si lo es, genera un token EQUALS con make_two_character_token.
Si no, genera un token ASSIGN normal.

La misma lógica aplica para !:

Si el siguiente carácter es =, genera NOT_EQUALS.
Si no, genera NEGATION.

Tras corregir un pequeño error tipográfico en la línea 114 detectado por los propios tests [5:28], todas las pruebas pasan correctamente.

¿Qué puede hacer ahora el lexer completo?

Con esta implementación, el lexer ya reconoce [5:42]:

Operadores de un carácter: asignación, negación, suma, resta.
Operadores de dos caracteres: igualdad y desigualdad.
Keywords: si, si_no, variable, regresa, verdadero, falso, procedimiento.
Delimitadores: paréntesis, llaves, comas, puntos y comas.
Literales: enteros e identificadores.

El siguiente paso será construir un REPL (Read-Eval-Print Loop) para interactuar directamente con el intérprete, enviándole statements y expresiones en tiempo real [6:25]. ¿Ya modificaste algo en tu propio lenguaje? Comparte cómo va tu lexer y qué se siente programar en español.

Comentarios

Fabián Vega Alcota

student

Hice varios cambios a mi código, en sí estoy creando o más bien intentando crear un lenguaje que llamaré SigmaF, tengo planeado que sea del paradigma funcional, y está muy basada en Haskell, un lenguaje que me gusta bastante. Aquí les dejo un link a mi repositorio, por si tienen curiosidad o si les intereso mi proyecto ;) https://github.com/FabianVegaA/sigmaF/tree/dev

Carlos Eduardo Gomez García

teacher

Vengo del futuro a extender los tokens que acepta el Lexer (para tener un lenguaje con más operadores, no es spoiler :D) para que ahora acepte <= y >= (menor o igual que) y "mayor o igual que": . Primero, tenemos que añadir los tokens a la lista de tokens en token.py: .

GE = auto() # Gretater Than or Equal To (>=)
LE = auto() # Less Than or Equal To (<=)

. Después, en los matches donde revisamos los caracteres "<" y ">", tenemos que agregar las condicionales para aceptar los tokens de doble caracter:

elif match(r"^<$", self._character):

    # Aquí revisamos si el siguiente token es "=", por lo que tendríamos un "<="
    if self._peek_character() == "=":
        token = self._make_two_character_token(TokenType.LE)

    else:
        token = Token(TokenType.LT, self._character)

elif match(r"^>$", self._character):

    # Aquí revisamos si el siguiente token es "=", por lo que tendríamos un ">="
    if self._peek_character() == "=":
        token = self._make_two_character_token(TokenType.GE)

    else:
        token = Token(TokenType.GT, self._character)

Con eso basta por ahora, no es necesario, pero recomiendo agregar los tests al lexer, pueden ver mis tests para estos operadores aquí: . Test Two Characters Operators . Durante el curso no se hace ninguna implementación para estos operadores (el LPP original del profesor no los soporta), pero pueden ir buscando mis aportes donde yo les iré dando el código junto con sus tests para que puedan implementar estos operadores al LPP :D. Yo ya tengo el lenguaje funcionando con estos operadores así que trust me jaja

Carlos Pavajeau

student

Pongo el código de mi Lexer.

from re import match
from cantte.token import TokenType, Token, lookup_token_type


class Lexer:
    def __init__(self, source: str) -> None:
        self._source: str = source
        self._character: str = ''
        self._read_position: int = 0
        self._position: int = 0

        self._read_character()

    def next_token(self) -> Token:
        self._skip_whitespace()

        if self._is_letter(self._character):
            ident_literal: str = self._read_identifier()
            token_type = lookup_token_type(ident_literal)
            token = Token(token_type, ident_literal)
        elif self._is_number(self._character):
            num_literal: str = self._read_number()
            token = Token(TokenType.INT, num_literal)
        else:
            token_type = self._get_token_type()
            if token_type == TokenType.EQUAL or token_type == TokenType.NOT_EQUAL:
                token = self._make_two_character_token(token_type)
            else:
                token = Token(token_type, self._character)
            self._read_character()

        return token

    def _get_token_type(self):
        if match(r'^=$', self._character):
            if self._peek_character() == '=':
                token_type = TokenType.EQUAL
            else:
                token_type = TokenType.ASSIGN
        elif match(r'^\+$', self._character):
            token_type = TokenType.PLUS
        elif match(r'^-$', self._character):
            token_type = TokenType.MINUS
        elif match(r'^\*$', self._character):
            token_type = TokenType.MULTIPLICATION
        elif match(r'^/$', self._character):
            token_type = TokenType.DIVISION
        elif match(r'^$', self._character):
            token_type = TokenType.EOF
        elif match(r'^\($', self._character):
            token_type = TokenType.LPAREN
        elif match(r'^\)$', self._character):
            token_type = TokenType.RPAREN
        elif match(r'^{$', self._character):
            token_type = TokenType.LBRACE
        elif match(r'^}$', self._character):
            token_type = TokenType.RBRACE
        elif match(r'^,$', self._character):
            token_type = TokenType.COMMA
        elif match(r'^;$', self._character):
            token_type = TokenType.SEMICOLON
        elif match(r'^<$', self._character):
            token_type = TokenType.LESS_THAN
        elif match(r'^>$', self._character):
            token_type = TokenType.GREATER_THAN
        elif match(r'^!$', self._character):
            if self._peek_character() == '=':
                token_type = TokenType.NOT_EQUAL
            else:
                token_type = TokenType.NEGATION
        else:
            token_type = TokenType.ILLEGAL

        return token_type

    @staticmethod
    def _is_letter(character: str) -> bool:
        return bool(match(r'^[a-zA-ZñÑ_]$', character))

    @staticmethod
    def _is_number(character: str) -> bool:
        return bool(match(r'^\d$', character))

    def _make_two_character_token(self, token_type: TokenType) -> Token:
        prefix = self._character
        self._read_character()
        suffix = self._character

        return Token(token_type, f'{prefix}{suffix}')

    def _peek_character(self) -> str:
        if self._read_position >= len(self._source):
            return ''
        return self._source[self._read_position]

    def _read_identifier(self) -> str:
        initial_position = self._position

        while self._is_letter(self._character):
            self._read_character()

        return self._source[initial_position:self._position]

    def _read_character(self) -> None:
        if self._read_position >= len(self._source):
            self._character = ''
        else:
            self._character = self._source[self._read_position]

        self._position = self._read_position
        self._read_position += 1

    def _read_number(self) -> str:
        initial_position = self._position

        while self._is_number(self._character):
            self._read_character()

        return self._source[initial_position:self._position]

    def _skip_whitespace(self) -> None:
        while match(r'^\s$', self._character):
            self._read_character()

Carlos Eduardo Gomez García

teacher

Wohh!! Acabo de extender el lexer para añadir un operador de triple igualdad y de diferenciación, los típicos de === y !=== . Primero escribí los tests, para este caso quise esribir dos tests, uno para probar la triple igualdad y otro para porbar la mezcla de los dobles y triples:

    def test_three_character_operator(self) -> None:

        source: str = """
            10 === 10;
            10 !== 9;
        """

        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []

        for i in range(8):

            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.INT, "10"),
            Token(TokenType.SIMILAR, "==="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.DIFF, "!=="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
        ]

        self.assertEquals(tokens, expected_tokens)


    def test_mixed_character_operator(self) -> None:

        source: str = """
            10 === 10;
            10 !== 9;
            10 == 10;
            10 != 9;
        """

        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []

        for i in range(16):

            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.INT, "10"),
            Token(TokenType.SIMILAR, "==="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.DIFF, "!=="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.EQ, "=="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.NOT_EQ, "!="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
        ]

        self.assertEquals(tokens, expected_tokens)

Luego agregué los tokens:

DIFF = auto() # Diferencia (!==)
SIMILAR = auto() # Triple igualdad (===)

Para hacerlos funcionar, modifiqué el lexer para el operador de asignación y de diferencia:

        if match(r"^=$", self._character):

            if self._peek_character() == "=":
                token = self._make_two_character_token(TokenType.EQ)

                if self._peek_character(2) == "=":
                    token = self._make_three_character_token(TokenType.SIMILAR)

                else:
                    token = self._make_two_character_token(TokenType.EQ)

Condición para el operador de diferencia:

        elif match(r"^!$", self._character):

            if self._peek_character() == "=":
                token = self._make_two_character_token(TokenType.NOT_EQ)

                if self._peek_character(2) == "=":
                    token = self._make_three_character_token(TokenType.DIFF)

                else:
                    token = self._make_two_character_token(TokenType.NOT_EQ)

            else:
                token = Token(TokenType.NEGATION, self._character)

Para este caso, tuve que modificar el método _peek_character para que aceptara cuántos espacios se quiere salltar:

def _peek_character(self, skip = 1) -> str:

        if self._read_position >= len(self._source):
            return ""

        return self._source[self._read_position] if skip == 1 else self._source[self._read_position + (skip - 1)]

Y agregué otro método para que construyera el token de 3 caracteres:

def _make_three_character_token(self, token_type: TokenType) -> Token:

        first = self._character
        self._read_character()
        second = self._character
        self._read_character()
        third = self._character

        return Token(token_type, f"{first}{second}{third}")

Y con eso ya tu lexer ya acepta tokens de 3 caracteres como la triple igualdad o la diferenciación :D

Sergio Ignacio Saborío Segura

student

Estoy muy feliz con este curso, me está ayudando muchísimo en la materia de Compiladores de mi carrera universitaria, aunque tengo que traducir de Python a Java porque me piden que lo haga en Java,

Raúl Humberto Peñate Ramírez

student

Como segui el approach de iterar en vez de hacer varios if, me quedo así:

    def next_token(self) -> Token:
        
        token_dict: Dict[str, TokenType] = {
            r"^=$": TokenType.ASSIGN,
            r"^\!$": TokenType.NOT,
            r"^\+$": TokenType.PLUS,
            r"^\*$": TokenType.MULT,
            r"^\-$": TokenType.MINUS,
            r"^\/$": TokenType.DIV,
            r"^\($": TokenType.LPAREN,
            r"^\)$": TokenType.RPAREN,
            r"^{$": TokenType.LBRACE,
            r"^}$": TokenType.RBRACE,
            r"^,$": TokenType.COMMA,
            r"^;$": TokenType.SEMICOLON,
            r"^>$": TokenType.GT,
            r"^<$": TokenType.LT,
            r"^$": TokenType.EOF,
        }
        
        token = None

        self._skip_whitespace()
        
        if self._is_letter(self._character):
            literal = self._read_identifier()
            token_type = lookup_token_type(literal)
            return Token(token_type, literal)

        if self._is_number(self._character):
            literal = self._read_number()
            return Token(TokenType.INT, literal)
        
        for regex, token_type in token_dict.items():
            if match(regex, self._character):
                if self._check_two_character_operator():
                    token = self._make_two_character_token(self._two_char_token_type)
                    self._two_char_token_type = TokenType.ILLEGAL # Cleaning TokenType 
                    break
                else:
                    token = Token(token_type, self._character)
                    break
            
        if token is None:
            token = Token(TokenType.ILLEGAL, self._character)

        self._read_character()

        return token

Me toco agregar una nueva variable al Lexer:

class Lexer:
    def __init__(self, source: str) -> None:
        ...
        self._two_char_token_type: TokenType = TokenType.ILLEGAL

        self._read_character()

Así que hice una función que itera una lista de posibles sufijos:```python def _check_two_character_operator(self) -> bool: char_suffix: List[str] = [ r"^=$", r"^!$", r"^>$", r"^<$" ]

    for i in range(len(char_suffix)):
        if match(char_suffix[i], self._character):
            return self._save_two_char_type()
    
    return False


Y ya para no complicarme más la vida de lo que ya hice, mejor refactorize esta función pero que retorna si había match y booleano de una vez si existio:```python
    # This func save the token type and returns a boolean in case it existed
    def _save_two_char_type(self) -> bool:
        two_char_dict : Dict[str, TokenType] = {
            r"^==$": TokenType.EQ,
            r"^>=$": TokenType.GT_EQ,
            r"^<=$": TokenType.LT_EQ,
            r"^!=$": TokenType.NOT_EQ,
        }

        prefix = self._character
        suffix = self._peek_character()
        two_char = f'{prefix}{suffix}'

        for regex, token_type in two_char_dict.items():
            if match(regex, two_char):
                self._two_char_token_type = token_type
                return True 
        
        return False

Raúl Humberto Peñate Ramírez

student

Que complicado poner código en esta plataforma xd

luimarco daniel Carrascal Diaz

student

def _peek_two_character_token(self,token_tyoe:Tokentype)->Token:
  prefix=self._character
  self._read_character()
  suffix=self._character
  return Token(token_type, f'{prefix}{suffix}')

luimarco daniel Carrascal Diaz

student

def test_two_character_operator(self)->None:
  source:str='''
    10==10;
    10!=9;
  '''

luimarco daniel Carrascal Diaz

student

Jherom Chacon

student

Si hice algunos cambios, empezando por el test, se me hizo más sencillo validarlos en una única cadena separada por ;

Por otra parte decidí hacer el Diferente a usando <>

Al final todo ha funcionado perfecto

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