compilers/example04.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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
from tools.shift_reduce import LR1Parser, 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 EqualComparerNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue == rvalue

class NotEqualComparerNode(BinaryNode):
    @staticmethod
    def operate(lvalue, rvalue):
        return lvalue != rvalue

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 Language04:
    def __init__(self) -> None:
        ########################################################
        #                 GRAMATICA 04  LR(1)                  #
        ########################################################
        G = Grammar()
        S = G.NonTerminal('S', True)
        E,T,F = G.NonTerminals('E T F')
        plus, minus, star, div, opar, cpar, num = G.Terminals('+ - * / ( ) int')
        equal_comp, not_equal_comp = G.Terminals('== !=')

        S %= E + equal_comp + E, lambda h,s: EqualComparerNode(s[1], s[3])
        S %= E + not_equal_comp + E, lambda h,s: NotEqualComparerNode(s[1], s[3])

        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, '/'),

                (equal_comp, '=='),
                (not_equal_comp, '!='),

                (opar, '\('),
                (cpar, '\)'),
            ], G.EOF
        )
        self.lexer = lexer
        ########################################################
        #                    PARSER LR(1)                      #
        ########################################################
        parser = LR1Parser(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

    ####################################
    #              VALID               #
    ####################################
    def is_Valid(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)
        return True

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