def function_return(self):
return_value = self._operand.pop()
if return_value is None:
raise BigError("Error on retrun data")
check_data = cube.compare_types(Operator.RETURN, return_value.type_var,
self.active_function.return_type)
if check_data:
result = FluffyVariable(
None,
type_var=self.active_function.return_type,
addr=address.set_addr(kind=self.active_function.return_type))
quadruple = QuadruplePack(Operator.RETURN,
l_value=return_value,
r_value=None,
result=result)
self._quadruple.add(quadruple)
else:
raise BigError.mismatch_operator(
"Return type {} does't correspond to the return type of function {} "
.format(return_value.type_var,
self.active_function.return_type))
def _check_top(self):
# len(self._operator)> 0
r_operand = self._operand.pop()
r_type = r_operand.type_var
l_operand = self._operand.pop()
l_type = l_operand.type_var
oper = self._operator.pop()
check_types = cube.compare_types(oper, l_type, r_type)
if check_types:
val_result = address.set_addr(check_types)
result = FluffyVariable(None,
type_var=check_types,
addr=val_result)
# Generate Quadruple
quadruple = QuadruplePack(oper, l_operand, r_operand, result)
# Push _quadruple to list
self._quadruple.add(quadruple)
# Add result position of _quadruple to the operand list
self._operand.append(result)
else:
raise BigError.mismatch_operator("{} {} {} ".format(
l_type.name, oper.name, r_type.name))
def jump_false(self):
# if len(self._operand) == 0:
self._jumps.append(self._quadruple.index)
result = self._operand.pop()
if result is None:
print(self._operand)
raise BigError("The stack is empty")
if result.type_var != Types.BOOLEAN:
raise BigError.mismatch_operator(
"The operation doesn't return a boolean value")
# Generate GotoFalse, return to fill the address
self._quadruple.add(QuadruplePack(Operator.GOTOF, result, None, None))
