Introducci贸n al desarrollo de int茅rpretes y lenguajes de programaci贸n

1

Aprende a desarrollar lenguajes de programaci贸n con int茅rpretes

2

Desarrolla LPP o Lenguaje de Programaci贸n Platzi

Construcci贸n del lexer o tokenizador

3

驴Qu茅 es an谩lisis l茅xico? Funcionamiento del lexer y tokens

4

Estructura y definici贸n de tokens en Python

5

Lectura de caracteres y tokens

6

Tokens ilegales, operadores de un solo car谩cter y delimitadores

7

Reconocimiento y diferenciaci贸n entre letras y n煤meros

8

Declaraci贸n y ejecuci贸n de funciones

9

Extensi贸n del lexer: condicionales, operaciones y booleanos

10

Operadores de dos caracteres

11

Primera versi贸n del REPL con tokens

Construcci贸n del parser o analizador sint谩ctico

12

驴Qu茅 es un parser y AST?

13

Estructura y definici贸n de nodos del AST en Python

14

Parseo del programa o nodo principal

15

Parseo de assignment statements

16

Parseo de let statements

17

Parseo de errores

18

Parseo del return statement

19

T茅cnicas de parsing y pratt parsing

20

Pruebas del AST

21

Implementaci贸n del pratt parser

22

Parseo de Identifiers: testing

23

Parseo de Identifiers: implementaci贸n

24

Parseo de enteros

25

Prefix operators: negaci贸n y negativos

26

Infix operators y orden de las operaciones: testing

27

Infix operators y orden de las operaciones: implementaci贸n

28

Parseo de booleanos

29

Desaf铆o: testing de infix operators y booleanos

30

Parseo de expresiones agrupadas

31

Parseo de condicionales: testing y AST

32

Parseo de condicionales: implementaci贸n

33

Parseo de declaraci贸n de funciones: testing

34

Parseo de declaraci贸n de funciones: AST e implementaci贸n

35

Parseo de llamadas a funciones: testing y AST

36

Parseo de llamadas a funciones: implementaci贸n

37

Completando los TODOs o pendientes del lexer

38

Segunda versi贸n del REPL con AST

Evaluaci贸n o an谩lisis sem谩ntico

39

Significado de s铆mbolos

40

Estrategias de evaluaci贸n para int茅rpretes de software

41

Representaci贸n de objetos

42

Evaluaci贸n de expresiones: enteros

43

Evaluaci贸n de expresiones: booleanos y nulos

44

Evaluaci贸n de expresiones: prefix

45

Evaluaci贸n de expresiones: infix

46

Evaluaci贸n de condicionales

47

Evaluaci贸n del return statement

48

Manejo de errores

49

Ambiente

50

Bindings

51

Evaluaci贸n de funciones

52

Llamadas a funciones

Mejora del int茅rprete

53

Implementaci贸n de strings

54

Operaciones con strings

55

Built-in functions: objeto y tests

56

Built-in functions: evaluaci贸n

Siguientes pasos

57

Retos para expandir tu int茅rprete

58

Contin煤a con el Curso de Creaci贸n de Compiladores de Software

A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Parseo de enteros

24/58
Recursos

Aportes 7

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Para mi caso, quise probar que al tener ambas expresiones (identificadores y enteros) se estuviera devolviendo bien la cadena, sin embargo, gracias a este test me di cuenta que en el archivo ast.py est谩bamos devolviendo el statement sin 鈥;鈥 desde el dunder methos de __str__, eso hac铆a que el test fallara porque 鈥渇oo鈥 era diferente de 鈥渇oo;鈥 (lo expectado), as铆 que lo primero que hice fue arreglar el dunder method __str__ de la clase ExpressionStatement:

    def __str__(self) -> str:
        return f"{str(self.expression)};"

Y por 煤ltimo, ahora si puse mis tests que revisan ambas expresiones, integers e identificadores 馃槃

    def test_expression_statement(self) -> None:

        program: Program = Program(statements=[

            ExpressionStatement(

                token=Token(TokenType.IDENT, literal="foobar"),

                expression=Identifier(
                    token=Token(TokenType.IDENT, literal="foobar"),
                    value="foobar"
                )

            ),

            ExpressionStatement(

                token=Token(TokenType.INT, literal="5"),

                expression=Identifier(
                    token=Token(TokenType.INT, literal="5"),
                    value="5"
                )

            )

        ])

        program_str = str(program)
        self.assertEquals(program_str, "foobar;5;")

Hola a todos, esta fue mi soluci贸n al reto:

deftest_integer_expressions(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal='cinco'),
                    value='cinco'
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal='5'),
                    value=5
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, 'variable cinco = 5;')

Aqu铆 esta el reto, aunque no estoy del todo claro si lo hice bien, agradecer铆a mucho si alguien pudiera corroborar el test que hice

    def test_intergers_in_statements(self) ->None:
        program: Program = Program(statements=[
            LetStatement(
                token = Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token = Token(TokenType.IDENT, literal='chocolates'),
                    value= 'chocolates'
                ),
                value= Identifier(
                    token = Token(TokenType.INT, literal='10'),
                    value= '10'
                ),
            ),
            ReturnStatement(
                token = Token(TokenType.RETURN, literal='regresa'),
                return_value= Identifier(
                    token = Token(TokenType.INT, literal='5'),
                    value= '5'
                ),
            )
        ])

        expected_statement: List[str] = [
            'variable chocolates = 10;',
            'regresa 5;'
        ]
        self.assertEquals(str(program.statements[0]), expected_statement[0])
        self.assertEquals(str(program.statements[1]), expected_statement[1])


LPP languaje powerfull --Pues es el curso mas 鈥減rofundo鈥 que he visto en Platzi, no se si ser茅 capaz de entenderlo todo.

Aqui les dejo el reto, hice tres funciones para probar esto

variable mi_var = 8;
regresa 8;
8;
    def test_return_statement_with_integer(self) -> None:
        program: Program = Program(statements=[
            ReturnStatement(
                token=Token(TokenType.RETURN, literal='regresa'),
                return_value=Integer(
                    token=Token(TokenType.INT, '6'),
                    value=6
                ),
            )
        ])

        program_str = str(program)
        self.assertEquals(program_str, 'regresa 6;')

    def test_integer_expressions(self) -> None:
        program: Program = Program(statements=[
            ExpressionStatement(
                token=Token(TokenType.INT, literal='5'),
                expression=Integer(
                    token=Token(TokenType.INT, literal='5'),
                    value=5
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, '5')

    def test_let_statement_with_integer(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal='mi_var'),
                    value='mi_var'
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal='8'),
                    value=8
                )
            )
        ])

        program_str = str(program)
        self.assertEquals(program_str, 'variable mi_var = 8;')

Quise pasar por aqu铆 como hice para crear un tipo de token float, pero parece que escrib铆 mucho y no se public贸, as铆 que pas贸 el link del repo donde lo estoy subiendo para los que se quieran guiar. Aqui

Yo lo hice de esta forma

def test_integer_in_let_and_return_statement(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(
                    TokenType.LET,
                    literal="var"
                ),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal="mi_num"),
                    value="mi_num"
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal="5"),
                    value=5
                )
            ),
            ReturnStatement(
                token=Token(TokenType.RETURN, literal="regresa"),
                return_value=Identifier(
                    token=Token(TokenType.IDENT, literal="mi_num"),
                    value="mi_num"
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, 'var mi_num = 5;regresa mi_num;')