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

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:0022:20

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

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

Clase 53 de 58

Clase 53 / 58

Recursos

¿Cómo se añaden strings a un intérprete?

Crear un intérprete funcional requiere varios pasos y uno de ellos es la implementación de las estructuras de datos que acostumbramos ver en los lenguajes de programación, como los strings. Integrar strings en un intérprete implica tratarlos como secuencias de caracteres. Para hacerlo, debemos recorrer todo el pipeline del intérprete: generar nuevos tokens, modificar el lexer, crear nodos de AST, ajustar el parser y modificar el evaluador para que reconozca este nuevo tipo de nodo. En este contexto, desarrollar tests para cada una de estas partes constituye un paso vital para garantizar el correcto funcionamiento del intérprete.

¿Qué pasos se siguen para modificar el lexer?

El lexer es responsable de convertir el source code en una lista de tokens que el resto del intérprete pueda procesar. Incluir soporte para strings en el lexer implica:

Definir un nuevo tipo de token que pueda identificar características específicas de las cadenas, como las comillas dobles que las delimitan.
Leer una secuencia completa de caracteres desde el inicio hasta el cierre de las comillas dobles usando un método que pueda extraer el string en sí.
Crear tests que verifiquen que el lexer genera los tokens esperados al procesar strings, como se demuestra en el siguiente pseudocódigo:

# Pseudocódigo básico para representación
def test_string():
    source = '"foo"; "Platzi es la mejor escuela de CS";'
    tokens_esperados = [
        Token(type="STRING", value="foo"),
        Token(type="SEMICOLON"),
        Token(type="STRING", value="Platzi es la mejor escuela de CS"),
        Token(type="SEMICOLON"),
    ]
    assert lexer(source) == tokens_esperados

¿Cómo se implementan los nodos de AST?

Una vez que el lexer ha generado los tokens, el parser lo traduce en un Abstract Syntax Tree (AST), una estructura que describe el programa en términos de sus operaciones y datos. Para ampliar el parser y aceptar strings:

Crear un nuevo nodo de AST llamado StringLiteral que extiende Expression.
Implementar un método parseStringLiteral en el parser, ligando el nuevo tipo de token con esta función.
Definir cómo debe verse el string al ser representado, usualmente usando el valor del literal o el token del nodo:

class StringLiteral(Expression):
    def __init__(self, token, value):
        self.token = token
        self.value = value

    def __str__(self):
        return self.value

¿Cómo se evalúan los strings en el intérprete?

Finalmente, una vez modificados el lexer y el parser, debemos actualizar el evaluador del intérprete para manejar adecuadamente los strings:

Crear un nuevo objeto String.
Asegurar que la función principal del evaluador reconozca cuándo debe construir un objeto de tipo String a partir de un nodo StringLiteral.
Implementar las funciones de type e inspect para el nuevo tipo, como se muestra:

class String(Object):
    def __init__(self, value):
        self.value = value

    def type(self):
        return "STRING"

    def inspect(self):
        return self.value

Con estos pasos, el intérprete no solo puede procesar strings, sino que queda listo para futuras expansiones, como la implementación de operaciones sobre las cadenas y revisión de la semántica de las mismas en procedimientos y funciones más avanzadas. La importancia de construir sobre una base robusta se evidencia cuando se trata de mejorar la funcionalidad de nuestro lenguaje a medida que crece en complejidad y potencia. Rica en detalles y organizada eficientemente, esta aproximación es la clave para construir un intérprete que pueda evolucionar sin dificultades.

Carlos Eduardo Gomez García

Hace 6 años

Por cierto, por si les interesa, esto únicamente nos permite usar comillas dobles dentro del LPP, si quieren agregar el soporte para comillas simples dentro de LPP, solo tienen que poner este regexp en su condición del lexer: r"^\"|'$ . Debería quedar así:

elif match(r"^\"|'$", self._character):
    literal = self._read_string()

    return Token(TokenType.STRING, literal)

Básicamente ese regexp hace match con comillas dobles y comillas simples . Y después, la función _read_string debería quedar así

def _read_string(self) -> str:

    # Vemos con cuál comilla se abrió este string, así en el while podemos buscar la misma comilla de cierre
    quote_type = self._character

    # Ahorita estamos en la comilla, así que leemos un caracter para avanzar hacia el string
    self._read_character()

    initial_position = self._position

    # Leemos hasta que encontremos el tipo de comilla con el que abrio el string o hasta que se acabe el archivo
    while self._character != quote_type \
            and self._read_position <= len(self._source):

        self._read_character()

    string =  self._source[initial_position:self._position]
    self._read_character()
    return string

Y listo, con eso ya pueden usar comillas simples y dobles dentro de LPP :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 Strings en un Intérprete de Lenguaje de Programación