Implementación de Condicionales en Parser de Lenguaje

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:05

Implementación de Condicionales en Parser de Lenguaje

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

Clase 32 de 58

Clase 32 / 58

Recursos

¿Cómo implementar la función de análisis parseIf?

Bienvenidos a esta fascinante clase sobre cómo implementar funciones de análisis de sintaxis en programación. En esta sesión, abordaremos el método para desarrollar una función parseIf, crucial para manejar las condicionales en un lenguaje de programación.

¿Qué se debe considerar al iniciar la implementación?

Para comenzar, es esencial establecer un vínculo entre los tokens y las funciones necesarias. Esto se lleva a cabo al registrar la función y al crear una estructura que permita verificar la sintaxis correcta de las condicionales. La verificación incluye elementos como paréntesis y corchetes, asegurando que estén bien colocados en una condición.

¿Cómo se registra e inicia parseIf?

En el entorno de código, se debe iniciar registrando parseIf en la función registerPrefix. Esto se hace declarando que, al encontrar un token de tipo if, el sistema debe dirigirse a parseIf, aunque aún no esté implementado. El registro se realiza de la siguiente manera:

registerPrefix(TokenType.IF, parseIf)

¿Cómo abordar la implementación de parseIf?

Una vez registrado, se implementa la función parseIf. Primero, se verifica que el token actual de un if no sea None, creando una nueva instancia de IfExpression. Esta se inicializa con el token actual y se procede a verificar si el token esperado es un paréntesis izquierdo (TokenType.LEFTPAREN), lo cual es crítico para evitar un error de sintaxis.

def parseIf():
    if self.currentToken is None:
        return None
    
    ifExpression = IfExpression(token=self.currentToken)
    
    if not expectToken(TokenType.LEFTPAREN):
        return None

¿Cómo manejar condiciones complejas?

Una vez confirmado el paréntesis inicial, se avanza al siguiente token. La propiedad condition del ifExpression se asigna a la expresión que sigue, que puede ser compleja, utilizando la función parseExpression.

self.advanceToken()
ifExpression.condition = parseExpression(self.lowestPrecedence)

Se asegura que después de parsear la expresión, el siguiente token sea un paréntesis derecho, asegurando así el cierre adecuado de la condición.

¿Qué sucede después de la condición?

Tras una correcta condición, se espera un corchete izquierdo (TokenType.LEFTBRACE) para iniciar el bloque asociado al if. Si esto falla, se vuelve a tratar como un error de sintaxis.

Si el corchete inicial es correcto, se utiliza una función auxiliar parseBlock para analizar el bloque de statements dentro del if.

if not expectToken(TokenType.LEFTBRACE):
    return None

ifExpression.consequence = parseBlock()

¿Cómo desarrollar los bloques con parseBlock?

La función parseBlock es responsable de crear un BlockStatement. Se verifica que el token actual no sea None, y se avanza al siguiente token. En un bucle while, se analiza cada statement hasta encontrarse un corchete derecho o el final del archivo.

def parseBlock():
    if self.currentToken is None:
        return None
    
    block = BlockStatement(token=self.currentToken)
    self.advanceToken()
    
    while not currentTokenIs(TokenType.RIGHTBRACE) and not currentTokenIs(TokenType.EOF):
        statement = parseStatement()
        if statement:
            block.statements.append(statement)
        self.advanceToken()

    return block

¿Qué desafíos se presentan y cuál es tu papel?

Un gran reto en la construcción de un analizador sintáctico es manejar correctamente las alternativas de if-else. Aunque hemos cubierto if, desarrollar las alternativas es tu desafío. Diseña un test que valide estas alternativas y crea funciones necesarias para ello.

Recuerda, si no encuentras solución a la primera, intenta nuevamente. Y si aún encuentras dificultades, toda implementación en un branch de GitHub está disponible para comparar tu enfoque con ejemplos testados. Invierte tiempo en experimentar, porque es en estos desafíos donde el aprendizaje cobra mayor sentido.

Reflexiones finales: integra y comparte

El proceso de parseo, aunque desafiante, es una técnica poderosa en ciencias de la computación, incluso para entender otras disciplinas. Estás invitado a compartir tus ideas y reflexiones en los comentarios: ¿cómo mejoras el parseo en otros proyectos? ¿Qué ideas inesperadas surgieron durante el proceso? ¡Continúa explorando este vasto campo, lleno de infinitas posibilidades!

Resumen

¿Cómo implementar la función de análisis parseIf?

¿Qué se debe considerar al iniciar la implementación?

¿Cómo se registra e inicia parseIf?

registerPrefix(TokenType.IF, parseIf)

¿Cómo abordar la implementación de parseIf?

def parseIf():
    if self.currentToken is None:
        return None
    
    ifExpression = IfExpression(token=self.currentToken)
    
    if not expectToken(TokenType.LEFTPAREN):
        return None

¿Cómo manejar condiciones complejas?

self.advanceToken()
ifExpression.condition = parseExpression(self.lowestPrecedence)

Se asegura que después de parsear la expresión, el siguiente token sea un paréntesis derecho, asegurando así el cierre adecuado de la condición.

¿Qué sucede después de la condición?

Tras una correcta condición, se espera un corchete izquierdo (TokenType.LEFTBRACE) para iniciar el bloque asociado al if. Si esto falla, se vuelve a tratar como un error de sintaxis.

Si el corchete inicial es correcto, se utiliza una función auxiliar parseBlock para analizar el bloque de statements dentro del if.

if not expectToken(TokenType.LEFTBRACE):
    return None

ifExpression.consequence = parseBlock()

¿Cómo desarrollar los bloques con parseBlock?

def parseBlock():
    if self.currentToken is None:
        return None
    
    block = BlockStatement(token=self.currentToken)
    self.advanceToken()
    
    while not currentTokenIs(TokenType.RIGHTBRACE) and not currentTokenIs(TokenType.EOF):
        statement = parseStatement()
        if statement:
            block.statements.append(statement)
        self.advanceToken()

    return block

¿Qué desafíos se presentan y cuál es tu papel?

Reflexiones finales: integra y comparte

def _test_block(self,
                    block: Block,
                    statements_number,
                    expected_identifiers: List[str]) -> None:


        self.assertIsInstance(block, Block)
        self.assertEquals(len(block.statements), statements_number)
        self.assertEquals(len(expected_identifiers), len(block.statements))

        # Recorro cada statement junto a los expected identifiers
        for statement, identifier in zip(block.statements, expected_identifiers):

            statement = cast(ExpressionStatement, statement)

            assert statement.expression is not None
            self._test_identifier(statement.expression, identifier)

...
# Test consequence
assert if_expression.consequence is not None

# Aquí uso la helper function
self._test_block(if_expression.consequence, 1, ["z"]) 

# Test alternative
self.assertIsNone(if_expression.alternative)
...

def test_if_else_expression(self) -> None:

    source: str = 'si (a > b) { x } si_no { z; x; }'

    lexer: Lexer = Lexer(source)
    parser: Parser = Parser(lexer)

    program: Program = parser.parse_program()

    self._test_program_statements(parser, program, 1)

    # Test correct node types
    if_expression = cast(If, cast(ExpressionStatement, program.statements[0]).expression)
    self.assertIsInstance(if_expression, If)

    # Test condition
    assert if_expression.condition is not None

    self._test_infix_expression(cast(Expression, if_expression.condition), "a", ">", "b")

    # Test consequence
    assert if_expression.consequence is not None
    self._test_block(if_expression.consequence, 1, ["x"])

    # Test alternative
    assert if_expression.alternative is not None
    self._test_block(if_expression.alternative, 2, ["z", "x"])

if_expression.consequence = self._parse_block()

# Estamos en el "}", si el siguiente token es el else, entonces lo parseamos
assert self._peek_token is not None
if self._peek_token.token_type == TokenType.ELSE:

    self._advance_tokens()
    # Si el siguiente token no es una llave de apertura, hay un error de sintaxis
    if not self._expected_token(TokenType.LBRACE):
        return None

    if_expression.alternative = self._parse_block()

return if_expression

def _test_block(self,
                    block: Block,
                    statements_number,
                    expected_identifiers: List[str]) -> None:


        self.assertIsInstance(block, Block)
        self.assertEquals(len(block.statements), statements_number)
        self.assertEquals(len(expected_identifiers), len(block.statements))

        # Recorro cada statement junto a los expected identifiers
        for statement, identifier in zip(block.statements, expected_identifiers):

            statement = cast(ExpressionStatement, statement)

            assert statement.expression is not None
            self._test_identifier(statement.expression, identifier)

...
# Test consequence
assert if_expression.consequence is not None

# Aquí uso la helper function
self._test_block(if_expression.consequence, 1, ["z"]) 

# Test alternative
self.assertIsNone(if_expression.alternative)
...

def test_if_else_expression(self) -> None:

    source: str = 'si (a > b) { x } si_no { z; x; }'

    lexer: Lexer = Lexer(source)
    parser: Parser = Parser(lexer)

    program: Program = parser.parse_program()

    self._test_program_statements(parser, program, 1)

    # Test correct node types
    if_expression = cast(If, cast(ExpressionStatement, program.statements[0]).expression)
    self.assertIsInstance(if_expression, If)

    # Test condition
    assert if_expression.condition is not None

    self._test_infix_expression(cast(Expression, if_expression.condition), "a", ">", "b")

    # Test consequence
    assert if_expression.consequence is not None
    self._test_block(if_expression.consequence, 1, ["x"])

    # Test alternative
    assert if_expression.alternative is not None
    self._test_block(if_expression.alternative, 2, ["z", "x"])

if_expression.consequence = self._parse_block()

# Estamos en el "}", si el siguiente token es el else, entonces lo parseamos
assert self._peek_token is not None
if self._peek_token.token_type == TokenType.ELSE:

    self._advance_tokens()
    # Si el siguiente token no es una llave de apertura, hay un error de sintaxis
    if not self._expected_token(TokenType.LBRACE):
        return None

    if_expression.alternative = self._parse_block()

return if_expression

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 Condicionales en Parser de Lenguaje