def eval_comparison(cmp_func, lp, l_tal: en.Type, rp, r_tal: en.Type,
env) -> int:
if l_tal.type_name in PRIMITIVE_TYPES and r_tal.type_name in PRIMITIVE_TYPES and not en.is_array(l_tal) and \
not en.is_array(r_tal):
l_len = PRIMITIVE_TYPES[l_tal.type_name]
r_len = PRIMITIVE_TYPES[r_tal.type_name]
lb = mem.MEMORY.get(lp, l_len)
rb = mem.MEMORY.get(rp, r_len)
if l_tal.type_name == "int":
if r_tal.type_name == "int":
cmp = typ.int_cmp_int(lb, rb)
return cmp_func(cmp)
elif l_tal.type_name == "char":
if r_tal.type_name == "char":
cmp = typ.char_cmp_char(lb, rb)
return cmp_func(cmp)
elif l_tal.type_name[0] == "*":
l_ptr_b = mem.MEMORY.get(lp, l_tal.total_len())
# l_ptr = typ.bytes_to_int(l_ptr_b)
if r_tal.type_name[0] == "*":
r_ptr_b = mem.MEMORY.get(rp, r_tal.total_len())
# r_ptr = typ.bytes_to_int(r_ptr_b)
# print(l_ptr_b ,r_ptr_b)
cmp = typ.int_cmp_int(l_ptr_b, r_ptr_b)
return cmp_func(cmp)
else:
raise lib.TypeException(
"Comparing pointer type '{}' to primitive type '{}'".format(
en.type_to_readable(l_tal), en.type_to_readable(r_tal)))
else:
print(2131212321)
def int_op_any(lv: bytes, right_ptr: int, right_tal: en.Type,
op_set: dict) -> int:
if right_tal.type_name in op_set:
rv = mem.MEMORY.get(right_ptr, right_tal.total_len())
op_func = op_set[right_tal.type_name]
res = op_func(lv, rv)
return mem.MEMORY.allocate(res)
elif right_tal.type_name[0] == "*":
rv = mem.MEMORY.get(right_ptr, PTR_LEN)
op_func = op_set["int"]
res = op_func(lv, rv)
return mem.MEMORY.allocate(res)
else:
raise lib.TypeException("Cannot operates int with {}".format(
en.type_to_readable(right_tal)))
def basic_arithmetic(op_set: dict, left_ptr: int, left_tal: en.Type,
right_ptr: int, right_tal: en.Type,
env: en.Environment) -> int:
if left_tal.type_name in op_set:
left_len = left_tal.total_len()
lv = mem.MEMORY.get(left_ptr, left_len)
# print(right_ptr)
return int_op_any(lv, right_ptr, right_tal, op_set[left_tal.type_name])
elif left_tal.type_name[0] == "*":
ptr_len = mem.MEMORY.pointer_length
lv = mem.MEMORY.get(left_ptr, ptr_len)
return int_op_any(lv, right_ptr, right_tal, op_set["int"])
else:
raise lib.TypeException("Cannot operates {}".format(
en.type_to_readable(right_tal)))
def get_indexing_location_and_unit_len(node: ast.IndexingNode,
env: en.Environment) -> (int, int):
l_ptr = evaluate(node.call_obj, env)
l_tal = get_tal_of_node_self(node, env)
if en.is_array(l_tal):
depth = index_node_depth(node)
unit_length = l_tal.total_len()
for i in range(depth):
unit_length //= l_tal.array_lengths[i]
elif l_tal.type_name[0] == "*":
ptr_b = mem.MEMORY.get(l_ptr, PTR_LEN)
l_ptr = typ.bytes_to_int(ptr_b)
unit_length = mem.MEMORY.get_type_size(l_tal.type_name[1:])
else:
raise lib.TypeException("Type '{}' not supporting indexing".format(
en.type_to_readable(l_tal)))
arg_ptr = evaluate(node.arg, env) # arg type must be int
arg_b = mem.MEMORY.get(arg_ptr, mem.MEMORY.get_type_size("int"))
arg_v = typ.bytes_to_int(arg_b)
return l_ptr + arg_v * unit_length, unit_length
def call_function(func_group: dict, orig_args: list, call_env: en.Environment):
arg_types = []
for orig_arg in orig_args:
tal = get_tal_of_evaluated_node(orig_arg, call_env)
arg_types.append(tal)
types_id = en.args_type_hash(arg_types)
func = func_group[types_id]
rtn_type = func.r_tal
rtn_len = rtn_type.total_len()
rtn_loc = mem.MEMORY.allocate_empty(rtn_len)
scope = en.FunctionEnvironment(func.outer_scope)
mem.MEMORY.push_stack()
for i in range(len(orig_args)):
param: ParameterPair = func.params[i]
orig_arg = orig_args[i]
p = evaluate(orig_arg, call_env)
tal = param.tal
total_len = tal.total_len()
arg_ptr = mem.MEMORY.allocate_empty(total_len)
scope.define_var(param.name, tal, arg_ptr)
mem.MEMORY.mem_copy(p, arg_ptr, total_len)
r = evaluate(func.body, scope)
if rtn_len > 0 and r is None:
raise lib.TypeException(
"Missing return statement of a function declared to return type '{}'"
.format(en.type_to_readable(rtn_type)))
mem.MEMORY.mem_copy(r, rtn_loc, rtn_len)
mem.MEMORY.restore_stack()
return rtn_loc
def typeof(env: en.Environment, node: ast.Node):
tal = get_tal_of_evaluated_node(node, env)
s = en.type_to_readable(tal)
print(s)
def __str__(self):
return "Function({}) -> {}".format(
[en.type_to_readable(par.tal) for par in self.params],
en.type_to_readable(self.r_tal))