forked from pragdave/cs3342_smurf
-
Notifications
You must be signed in to change notification settings - Fork 0
/
interpreter.py
145 lines (124 loc) · 5.5 KB
/
interpreter.py
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
from arpeggio import PTNodeVisitor
from binding import Binding
class Interpreter(PTNodeVisitor):
def evaluate_code(self, node):
g_binding = Binding({}, None)
for exp in node.expressions:
value = exp.accept(self, g_binding)
return value
def evaluate_function_call(self, node, bindings):
params = node.args.accept(self, bindings)
func_name = node.name.accept(self, bindings)
funcBinding = Binding(func_name[0].parent)
funcBinding.bindings = func_name[0].bindings.copy()
function = func_name[1]
for x in range(len(params)):
funcBinding.setValue(list(funcBinding.bindings.keys())[x],params[x])
return function.accept(self, funcBinding)
def evaluate_brace_block(self, node, bindings):
for exp in node.expressions:
value = exp.accept(self, bindings)
return value
def evaluate_func_definition(self, node, bindings):
new_binding = node.func_binding.accept(self, bindings)
return new_binding
def evaluate_parameters(self, node, bindings):
func_binding = Binding(bindings)
for p in node.params:
func_binding.createVal(p.accept(self, bindings))
return func_binding
def evaluate_arguments(self, node, bindings):
argList = []
for a in node.args:
argList.append(map(a.accept(self, bindings), node.args))
return argList
def evaluate_let_decl(self, node, bindings):
for let in node.expressions:
if isinstance(let, str):
bindings.setValue(let, 0)
else:
let.accept(self, bindings)
def evaluate_assignment(self, node, bindings):
left = node.name.accept(self, bindings)
right = node.value.accept(self, bindings)
bindings.setValue(left, right)
def evaluate_var_decl(self, node, bindings):
return bindings.setValue(node.name.accept(self, bindings), 0)
def evaluate_var_value(self, node, bindings):
name = node.name
value = bindings.getValue(name)
return value
def evaluate_print_smurf(self, node, bindings):
printer = ""
for i in node.to_print:
printer += str(i.accept(self, bindings))
if(len(node.to_print) > 1):
printer += "|"
print("Print: {}".format(printer))
def evaluate_if_expr(self, node, bindings):
boolean = node.if_expr.accept(self, bindings)
if boolean == 1:
return node.if_expr.accept(self, bindings)
else:
return node.else_expr.accept(self, bindings)
def evaluate_if(self, node, bindings):
boolean = int(node.if_bool.accept(self, bindings))
if boolean == 1:
return node.if_expr.accept(self, bindings)
def evaluate_arith_expr(self, node, bindings):
val = node.lhs.accept(self, bindings)
for i in range(1, len(node.expressions), 2):
if(node.expressions[i-1] == '+'):
val += node.expressions[i].accept(self, bindings)
elif(node.expressions[i-1] == '-'):
val -= node.expressions[i].accept(self, bindings)
if len(node.expressions) > 2:
print("({} {} {})".format(node.expressions[i-1].accept(self, bindings), node.lhs.accept(self, bindings), node.expressions[i].accept(self, bindings)))
print(val)
else:
print("({} {} {})".format(node.expressions[i-1], node.lhs.accept(self, bindings), node.expressions[i].accept(self, bindings)))
print(val)
return int(val)
def evaluate_mult_term(self, node, bindings):
val = node.lhs.accept(self, bindings)
if str(type(val)) == 'NoneType':
print("not valid input")
return
for i in range(1, len(node.expressions), 2):
if(node.expressions[i-1] == '*'):
val *= node.expressions[i].accept(self, bindings)
elif(node.expressions[i-1] == '/'):
val /= node.expressions[i].accept(self, bindings)
if len(node.expressions) > 2:
print("({} {} {})".format(node.expressions[i-1].accept(self, bindings), node.lhs.accept(self, bindings), node.expressions[i].accept(self, bindings)))
print(val)
else:
print("{} {} {}".format(node.expressions[i-1], node.lhs.accept(self, bindings), node.expressions[i].accept(self, bindings)))
print(val)
return int(val)
def evaluate_bool_expr(self, node, bindings):
left = node.lhs.accept(self, bindings)
right = node.rhs.accept(self, bindings)
print("{} {} {}".format(str(node.op), left, right))
if(node.op == '=='):
return int(left == right)
elif(node.op == '!='):
return int(left != right)
elif(node.op == '<='):
return int(left <= right)
elif(node.op == '<'):
return int(left < right)
elif(node.op == '>='):
return int(left >= right)
elif(node.op == '>'):
return int(left > right)
def evaluate_integer(self, node, bindings):
if(node.sign == '-'):
return -1*(int(node.value))
return int(node.value)
def evaluate_identifier(self, node, bindings):
try:
val = bindings.getValue(node.ident.accept(self, bindings))
except:
val = node.ident
return val