compilers/example02.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
from tools.shift_reduce import SLR1Parser, evaluate_reverse_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 Language02:
    def __init__(self) -> None:
        ########################################################
        #                 GRAMATICA 02  SLR(1)                 #
        #                     ATRIBUTADA                       #
        ########################################################
        G = Grammar()
        E = G.NonTerminal('E', True)
        T,F = G.NonTerminals('T F')
        plus, minus, star, div, opar, cpar, num = G.Terminals('+ - * / ( ) int')

        E %= E + plus + T, lambda h,s: PlusNode(s[1], s[3])
        E %= E + minus + T, lambda h, s: MinusNode(s[1], s[3])
        E %= T, lambda h, s: s[1]

        T %= T + star + F, lambda h, s: StarNode(s[1], s[3])
        T %= T + div + F, lambda h, s: DivNode(s[1], s[3])
        T %= F, lambda h, s: s[1]

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


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

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

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

                (opar, '\('),
                (cpar, '\)'),
            ], G.EOF
        )
        self.lexer = lexer
        ########################################################
        #                    PARSER SLR(1)                     #
        ########################################################
        parser = SLR1Parser(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))
        right_parse, operations = self.parser(tokens)
        ast = evaluate_reverse_parse(right_parse, operations, 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))