compilers/example01.py at main · LazaroDGM/compilers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
from tools.parserLL1 import parser_LL1_generator, evaluate_parse
from tools.lexer import Lexer
from tools.pycompiler import Grammar, Terminal, NonTerminal, Token
from tools.ast import Node, BinaryNode, get_printer

class ConstantNumberNode(Node):
    def __init__(self, lex):
        self.lex = lex
        self.value = float(lex)

    def evaluate(self):
        return self.value

class PlusNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue + rvalue

class MinusNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue - rvalue

class StarNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue * rvalue

class DivNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue / rvalue

class PowNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue ** rvalue


class Language01:
    def __init__(self) -> None:
        ########################################################
        #                 GRAMATICA 01  LL(1)                  #
        #                     ATRIBUTADA                       #
        ########################################################
        G = Grammar()
        E = G.NonTerminal('E', True)
        T, F, X, Y = G.NonTerminals('T F X Y')
        plus, minus, star, div, opar, cpar, num = G.Terminals('+ - * / ( ) num')


        E %= T + X, lambda h,s: s[2], None, lambda h,s: s[1]

        X %= plus + T + X, lambda h, s: s[3], None, None, lambda h,s: PlusNode(h[0], s[2])
        X %= minus + T + X, lambda h, s: s[3], None, None, lambda h,s: MinusNode(h[0], s[2])
        X %= G.Epsilon, lambda h, s: h[0]

        T %= F + Y, lambda h, s: s[2], None, lambda h, s: s[1]

        Y %= star + F + Y, lambda h,s: s[3], None, None, lambda h, s: StarNode(h[0], s[2])
        Y %= div + F + Y, lambda h,s: s[3], None, None, lambda h, s: DivNode(h[0], s[2])
        Y %= G.Epsilon, lambda h, s: h[0]

        F %= num, lambda h, s: ConstantNumberNode(s[1]), None
        F %= opar + E + cpar, lambda h, s: s[2], None, None, None

        ########################################################
        # ==================================================== #
        ########################################################


        ########################################################
        #                        LEXER                         #
        ########################################################
        lexer = Lexer(
            [
                (num, '(1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*|0'),

                ('space', '( |\t|\n)+'),

                (plus, '\+'),
                (minus, '-'),
                (star, '\*'),
                (div, '/'),

                (opar, '\('),
                (cpar, '\)'),
            ], G.EOF
        )
        self.lexer = lexer
        ########################################################
        #                    PARSER LL(1)                      #
        ########################################################
        parser = parser_LL1_generator(G)
        self.parser = parser

        ########################################################
        #                       PRINTER                        #
        ########################################################
        self.printer = get_printer(AtomicNode=ConstantNumberNode, BinaryNode=BinaryNode)


    ####################################
    #                AST               #
    ####################################
    def Build_AST(self, text, verbose=False):
        all_tokens = self.lexer(text)
        tokens = list(filter(lambda token: token.token_type != 'space', all_tokens))
        left_parse = self.parser(tokens)
        ast = evaluate_parse(left_parse, tokens)

        if verbose:
            self.Print(ast)
        return ast

    ####################################
    #           EVALUATE               #
    ####################################
    def Evaluate(self, text, verbose= False):
        ast = self.Build_AST(text, verbose)
        result = ast.evaluate()

        return result


    def Print(self, ast):
        print(self.printer(ast))