def make_special_function_input(self): exp = self._operand.pop() if exp is None: raise BigError("No given value to save input") self._quadruple.add(QuadruplePack(SpecialFunction.INPUT, result=exp))
def eval_dim(self): """ Function to evaluate the expression for each dimension. Generates the quadruple of VER (Verification of dimension) and the multiplication of the expression times the m value """ exp = self._operand.pop() dim = self._top_dim() if exp.type_var != Types.INT: raise BigError.invalid_value( "The value of the array {} is not an Integer".format( exp.id_var)) if exp is not None: dimS = FluffyVariable(None, Types.INT, addr=dim.size) dimM = self.add_constants(dim.m, Types.INT) # m dim self._operand.pop() dimInf = self.add_constants(0, Types.INT) # Dimension inferior self._operand.pop() tem = FluffyVariable(None, exp.type_var, addr=address.set_addr(exp.type_var)) # Validate dim and generate VER self._quadruple.add(QuadruplePack(Operator.VER, exp, dimInf, dimS)) self._quadruple.add(QuadruplePack(Operator.TIMES, exp, dimM, tem)) # x m self._operand.append(tem) else: raise BigError("Error in array expression")
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 _fill(self, line=0): actual_quadruple = self._jumps.pop() if actual_quadruple is None: raise BigError("Error, pending quadruples") else: available_quadruple = self._quadruple.index + line address_quadruple = FluffyVariable(None, None, addr=available_quadruple) self._quadruple.fill(actual_quadruple, address_quadruple)
def set_addr(self, kind, g_var=False): if kind not in self.local_address: raise BigError("Error type not defined") # Global variable if g_var: actual_value = self.global_address[kind] self.global_address[kind] += 1 # Local variables else: actual_value = self.local_address[kind] self.local_address[kind] += 1 return actual_value
def create_assignation(self): expression = self._operand.pop() variable = self._operand.pop() if variable is None or expression is None: raise BigError('None Value to assign') comparison = cube.compare_types(Operator.EQUAL, expression.type_var, variable.type_var) if comparison: q = QuadruplePack(Operator.EQUAL, expression, None, variable) self._quadruple.add(q) else: raise BigError.mismatch_assignation( "The expression has type {} and expression has type {} they're incompatible" .format(expression.type_var.name, variable.type_var.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))
def make_special_function(self, action_name, expected_type=None): """ Generic function for crating almost all special function :param action_name: :param expected_type: :return: None, Insert quadruple in stack """ action_name = self.text_to_special_operator(action_name) exp = self._operand.pop() if exp is None: raise BigError("Error getting value for function") if expected_type is not None: if exp.type_var not in expected_type: print(action_name) raise BigError.invalid_type( "Function {} only accepts expression of type {} ".format( action_name.name, [item.name for item in expected_type])) q = QuadruplePack(action_name, None, None, exp) self._quadruple.add(q)
def text_to_type(tp): for t in list(Types): if tp.upper() == t.name: return t raise BigError("Type {} is not a valid one".format(tp))
def text_to_special_operator(op): for e in list(SpecialFunction): if op.upper() == e.name: return e raise BigError("Operator {} is not a valid one".format(op))
def text_to_operator(op): op = match_operators.get(op) for e in list(Operator): if op == e.name: return e raise BigError("Operator {} is not a valid one".format(op))
def get_addr(self, kind, g_var=False): if kind not in self.local_address: raise BigError("Error type not defined") if g_var: return self.global_address[kind] return self.local_address[kind]