Implementación de Operadores de Dos Caracteres en Lexer

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:0012:07

Implementación de Operadores de Dos Caracteres en Lexer

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

Clase 10 de 58

Clase 10 / 58

Recursos

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.

Carlos Eduardo Gomez García

Hace 6 años

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

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

Implementación de Operadores de Dos Caracteres en Lexer