Introducción al desarrollo de intérpretes y lenguajes de programación

1

Construcción de Intérpretes de Software en Python 3.8

2

Creación de Compiladores e Intérpretes con Lenguaje Platzi

Construcción del lexer o tokenizador

3

Análisis Léxico: Construcción de un Léxer para Intérpretes

4

Definición de Tokens en Lenguaje de Programación Platzi

5

Desarrollo de un Lexer con Test-Driven Development

6

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

7

Lexer: Identificación de Keywords y Tokens Complejos

8

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

9

Implementación de Operadores y Condicionales en Lexer de Platzi

10

Implementación de Operadores de Dos Caracteres en Lexer

11

Creación de un REPL en Python para Lenguaje de Programación

Construcción del parser o analizador sintáctico

12

Construcción de un Parser para el Lenguaje Platzi

13

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python

14

Desarrollo de un AST en Python: Creación de la Clase Programa

15

Parseo de Let Statements en Lenguaje Platzi

16

Implementación de funciones advanced y expected tokens

17

Manejo de Errores en Parsers con Test Driven Development

18

Parseo de Return Statements en Lenguaje Platzi

19

Técnicas de Parsing: Top-Down y Bottom-Up

20

Pruebas de AST para Let y Return Statements en Parsers

21

Pratt Parsing: Implementación y Registro de Funciones en Python

22

Parseo de Identificadores en Lenguajes de Programación

23

Parseo de Expression Statements en Platzi Parser

24

Parseo de Enteros en Lenguaje Platzi

25

Implementación de Operadores Prefijo en Parsers

26

Operadores InFix en Expresiones: Implementación y Pruebas

27

Implementación de Operadores InFix en un Parser

28

Expresiones Booleanas en el Lenguaje de Programación Platzi

29

Evaluación de Precedencia y Testeo de Booleanos en Parsers

30

Evaluación de Expresiones Agrupadas en un Parser

31

Parseo de Condicionales en Lenguaje Platzi

32

Implementación de Condicionales en Parser de Lenguaje

33

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST

34

Construcción de nodos de función en un parser AST

35

Llamadas a Funciones en Lenguajes de Programación

36

Implementación de llamadas a funciones en un parser con AST

37

Parseo de Expresiones en LET y RETURN Statements

38

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

39

Evaluación Semántica en Lenguajes de Programación

40

Estrategias de Evaluación en Lenguajes de Programación

41

Representación de Nodos AST y Objetos en Python

42

Evaluación de Expresiones en JavaScript y Python

43

Implementación del Patrón Singleton para Booleanos y Nulos

44

Evaluación de Prefijos en Lenguaje de Programación Platzi

45

Evaluación de Expresiones Infix en Lenguaje Platzi

46

Evaluación de Condicionales en Lenguaje de Programación Platzi

47

Evaluación y Uso del Return Statement en Programación

48

Manejo de Errores Semánticos en Lenguaje Platzi

49

Declaración y Gestión de Variables en Lenguajes de Programación

50

Manejo de Ambientes y Variables en Lenguajes de Programación

51

Declaración de Funciones en Lenguaje de Programación Platzi

52

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

53

Implementación de Strings en un Intérprete de Lenguaje de Programación

54

Operaciones de Concatenación y Comparación de Strings en Intérprete

55

Implementación de Funciones Built-in en Python

56

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

57

Desarrollo de Lenguaje de Programación y Estructuras de Datos en Python

58

Construcción de un Intérprete en Python desde Cero

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Implementación de Operadores de Dos Caracteres en Lexer

10/58
Recursos

¿Cómo implementar operadores de dos caracteres en un Lexer?

La implementación de operadores de dos caracteres en un lexer es una tarea vital para lograr que un lenguaje de programación pueda interpretar correctamente estas combinaciones. Este artículo te guiará a través del proceso de implementación de operadores como == y !=, fundamentales en lenguajes como JavaScript o Python. No te preocupes; veremos paso a paso lo que necesitas para implementar estos operadores en tu lexer.

El lexer hasta ahora usa variables position y readPosition para manejar el flujo de caracteres. Estas variables permiten prever el carácter siguiente, proporcionando el contexto necesario para identificar operadores de dos caracteres.

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

Crear un test unitario es el primer paso. Aquí configuramos un test llamado testToCharacterOperators. En este test, se definen las expectativas de cómo debería comportarse el lexer con entradas como 10 == 10; o 10 != 9;. Al final, esperamos que el lexer retorne una lista de tokens que incluya números, operadores y delimitadores como el punto y coma.

def testToCharacterOperators():
    source = "10 == 10; 10 != 9;"
    expected_tokens = [
        TokenType.NUMBER, '10',
        TokenType.EQUALS,
        TokenType.NUMBER, '10',
        TokenType.SEMICOLON,
        TokenType.NUMBER, '10',
        TokenType.NOT_EQUALS,
        TokenType.NUMBER, '9',
        TokenType.SEMICOLON
    ]
    lexer = Lexer(source)
    tokens = lexer.tokenize()
    assert tokens == expected_tokens

¿Cómo se manejan los tokens de igualdad y desigualdad?

Para tratar con operadores de dos caracteres como == y !=, debes definir nuevos tipos de tokens llamados equals y not equals. Estos se añaden al archivo de tipos de tokens. Esto permitirá al lexer diferenciar entre una asignación simple = y una evaluación de igualdad ==.

def initializeTokenTypes():
    TokenType.EQUALS = "=="
    TokenType.NOT_EQUALS = "!="

¿Cómo se implementa la anticipación de caracteres?

La función pickCharacter() es fundamental. Permite al lexer 'asomarse' al siguiente carácter sin avanzar la posición actual, una capacidad clave para determinar si un = es seguido por otro =.

def pickCharacter():
    if self.readPosition >= len(self.source):
        return ''
    return self.source[self.readPosition]

¿Cómo crear tokens de dos caracteres?

La función makeToCharacterToken() genera un token cuando se detectan dos caracteres consecutivos que forman un operador. Esta es llamada cuando una comparación == o != es detectada.

def makeToCharacterToken(tokenType):
    prefix = self.currentCharacter
    self.readCharacter()  # Avanza al siguiente carácter
    suffix = self.currentCharacter
    return Token(tokenType, prefix + suffix)

¿Qué sigue después de la implementación del lexer?

¡Felicidades! Has completado una parte importante de tu lexer. Ahora es capaz de leer operadores de un solo y doble carácter, identificar palabras clave, delimitadores y más. Pero esto es solo el comienzo. La implementación de un REPL (Read-Eval-Print Loop) permitirá interactuar directamente con el sistema para evaluar expresiones en tiempo real.

Con esto concluimos la implementación de operadores de dos caracteres en un lexer. Sigue avanzando en tu viaje de aprendizaje, experimenta con tu lexer y considera cómo la programación en español puede hacer que los lenguajes de programación sean más accesibles. ¡Adelante, el mundo del desarrollo espera por ti!

Aportes 10

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Vengo del futuro a extender los tokens que acepta el Lexer (para tener un lenguaje con más operadores, no es spoiler 😄) 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 😄. Yo ya tengo el lenguaje funcionando con estos operadores así que trust me jaja

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()

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 😄

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,

Como segui el approach de iterar en vez de hacer varios if, me quedo así: ```python 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`: ```python 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 ```
```python 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}') ``` ```js ```
```python def test_two_character_operator(self)->None: source:str=''' 10==10; 10!=9; ''' ```
ok

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