basic-interpreter-python/BasicValue.py at main · KLR2002/basic-interpreter-python · 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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

class Value:
    def __init__(self, value, is_none=False):
        self.is_none = is_none
        self.value = value

    def internal_number(self):
        return self.value

    def change_value(self, new_value):
        if new_value is None:
            self.value = None
            self.is_none = True
        else:
            self.value = new_value

    def internal_string(self):
        return str(self.value)

    def internal_array(self):
        return list(self.value)

    def actual_array(self):
        arr = []
        for el in self.internal_array():
            arr.append(el.value)
        return arr

    def internal_float(self):
        return float(self.value)

    def is_string(self):
        return isinstance(self.value, str)

    def is_number(self):
        return isinstance(self.value, int) or isinstance(self.value, float)

    def is_float(self):
        return isinstance(self.value, float)

    def is_array(self):
        return isinstance(self.value, list)

    def check_none(self):
        return self.is_none

    def is_true(self):
        try:
            if self.is_number():
                return self.internal_number() != 0
            else:
                raise ValueError(f"Value {self.value} is not a number")
        except ValueError:
            raise

    def is_false(self):
        try:
            if self.is_number():
                return self.internal_number() == 0
            else:
                raise ValueError(f"Value {self.value} is not a number")
        except ValueError:
            raise

    def arithm_eval(self, right, lam):
        try:
            if self.is_number() and right.is_number():
                return Value(lam(self.internal_number(), right.internal_number()))
            else:
                raise ValueError(f"Some of values is not a number")
        except ValueError:
            raise

    def mul(self, right):
        return self.arithm_eval(right, lambda x, y: x * y)

    def div(self, right):
        return self.arithm_eval(right, lambda x, y: x / y)

    def idiv(self, right):
        return self.arithm_eval(right, lambda x, y: x // y)

    def mod(self, right):
        return self.arithm_eval(right, lambda x, y: x % y)

    def add(self, right):
        if self.is_string() or right.is_string():
            if self.is_array():
                return Value(str(self.actual_array())+str(right.value))
            elif right.is_array():
                return Value(str(self.value) + str(right.actual_array()))

            return Value(str(self.value) + str(right.value))


        return self.arithm_eval(right, lambda x, y: x + y)

    def sub(self, right):
        return self.arithm_eval(right, lambda x, y: x - y)

    def relations_eval(self, right, lam):
        try:
            if self.is_number() and right.is_number():
                if lam(self.internal_number(), right.internal_number()):
                    return Value(1)
                else:
                    return Value(0)
            else:
                raise ValueError(f"Both of values must be ints or strings")
        except ValueError:
            raise

    def gt(self, right):
        return self.relations_eval(right, lambda x, y: x > y)

    def gte(self, right):
        return self.relations_eval(right, lambda x, y: x >= y)

    def lt(self, right):
        return self.relations_eval(right, lambda x, y: x < y)

    def lte(self, right):
        return self.relations_eval(right, lambda x, y: x <= y)

    def eq(self, right):
        if self.is_string() and right.is_string():
            if self.internal_string() == right.internal_string():
                return Value(1)
            else:
                return Value(0)

        return self.relations_eval(right, lambda x, y: x==y)

    def neq(self, right):
        val = self.eq(right)
        if val.internal_number() == 1:
            return Value(0)
        else:
            return Value(1)

    def mnot(self):
        try:
            if self.is_number():
                if self.internal_number() == 0:
                    return Value(1)
                else:
                    return Value(0)
            else:
                raise ValueError(f"Incorrect value")
        except ValueError:
            raise

    def mand(self, right):
        if self.is_true() and right.is_true():
            return Value(1)
        else:
            return Value(0)

    def mor(self, right):
        if self.is_true() or right.is_true():
            return Value(1)
        else:
            return Value(0)

    def exp(self, right):
        try:
            if self.is_number() and right.is_number():
                return Value(round(self.internal_number()**right.internal_number()))
            else:
                raise ValueError(f"Both of values must be numbers")
        except ValueError:
            raise