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.
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.
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.
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.
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!
Implementación de Condicionales en Parser de Lenguaje
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.
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!
def test_if_else_expression(self) -> None:
source: str = 'if x > y then {z} else {w}'
# Aqui va el mismo codigo que en test_if_expression
# Test alternative
assert if_expression.alternative is not None
self.assertIsInstance(if_expression.alternative, Block)
self.assertEquals(len(if_expression.alternative.statements), 1)
alternative_statement = cast(
ExpressionStatement, if_expression.alternative.statements[0])
assert alternative_statement.expression is not None
self._test_identifier(alternative_statement.expression, 'w')
Luego implemente lo necesario para parsear else, en parser.py dentro de _parse_if al final antes de return, agregue:
if self._peek_token is not None:
if self._peek_token.token_type == TokenType.ELSE:
self._advance_tokens()
if not self._expected_token(TokenType.LBRACE):
return None
if_expression.alternative = self._parse_block()
La sintaxis de SigmaF es un poco diferente, pero la implementación es casi la misma que para LPP ;)
Vale, comparto mi solución:
.
Para los tests (para no repetir código y poder hacer más tests), lo que hice fue crear un helper llamado el cual testeará todo un bloque de código, le puedes pasar cuántos statements quieres testear y una lista de los identificadores que esperas que esos statements devuelvan, el número de identificadores pasados en la lista deben ser los mismos que el número de statements:
_test_block
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)
Una vez implementado eso, cambié mi test de if para usar este helper:
...
# 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)
...
Y para el test del else hice lo mismo:
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"])
Y para hacer que pase, lo único que hice fue que, en el parser.py pregunto si el siguiente token es un ELSE, (primero se pone el assert de peek_token porque este es opcional y luego mypy se quja :D)
.
Si la condición del siguiente token para un ELSE se cumple, me muevo hacia ese token y verifico que el siguiente token sea una llave de apertura, si sí lo es, pues mandamos a parsear el bloque con la función que hicimos en esta clase jaja.
.
Después miré la solución del profesor y vi que llegamos a lo mismo xD. Juro que no miré el código del profesor antes de resolver el reto!
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