def return_transformer(node, resources): _validate_restrictions(node) rtseq = resources.get_rtseq() expression = utils.generic_ast_node_transform(node.value, resources) stripped_expression = expression[:expression.find("[")] if expression.find( "[") != -1 else expression if isinstance(node.value, (ast.Name, ast.Attribute, ast.Subscript)): src_var_name = utils.get_variable_name_from_node(node.value) if resources.has_variable( str(src_var_name )) and not resources.has_channel_ref(stripped_expression): rt_expression = expression return_default_value = resources.get_variable_py_value( src_var_name) # In case of "return var[0]" the default value is saved as a list, so make sure to not return list type # because those cannot be return variables. # The len check is there to not get index error in case of empty lists -> for that I don't know yet # what the solution is, so I will leave it like this (Arnold) if isinstance(return_default_value, ArrayType): if len(return_default_value.value): return_default_value = return_default_value[0] else: raise TranslateError(_errormessages.invalid_return_value) elif isinstance(node.value, (ast.Num, ast.Call)): return_default_value = utils.get_value_from_node(node.value, resources) if isinstance(return_default_value, ArrayType): raise TranslateError(_errormessages.invalid_return_type) rt_expression = expression else: raise TranslateError(_errormessages.invalid_return_value) var_name = rtseqapi.add_return_variable(rtseq, '__ret_var__', return_default_value) rtseqapi.add_assignment(resources.get_current_block(), var_name, rt_expression) return "return " + str(expression)
def _decorator_to_arg(node, resources): arg_name = def_value = by_value = None if not len(node.args) == 3: raise errors.TranslateError(_errormessages.invalid_param_decorator) # this is a decorator param definition. First parameter is the string for the name. if utils.is_node_ast_str(node.args[0]): arg_name = utils.get_value_from_str_node(node.args[0]) # second is the default value try: def_value = utils.get_value_from_node(node.args[1], resources) except errors.TranslateError: # def_value won't get assigned anything if an error occurs, which will trigger the exception later. pass # third is whether to pass by ref or by value valid_types = [ast.Name, ast.Attribute] if isinstance(node.args[2], tuple(valid_types)): by_value_str = utils.get_variable_name_from_node(node.args[2]) by_value_str = getattr(_decorators.NivsParam, by_value_str.split('.')[-1], by_value_str) by_value = BooleanValue(by_value_str).value elif 'NameConstant' in dir(ast) and utils.is_node_ast_nameconstant( node.args[2]): by_value = utils.get_value_from_nameconstant_node(node.args[2]) if arg_name is None or def_value is None or by_value is None: raise errors.TranslateError(_errormessages.invalid_param_decorator) return _param(arg_name, def_value, by_value)
def raise_if_invalid_invert_operand(node, resources): invalid_operand = False try: if isinstance(utils.get_value_from_node(node, resources).value, (bool, float)): invalid_operand = True except errors.TranslateError: pass if invalid_operand: raise errors.TranslateError(_errormessages.invalid_operand_for_unary_invert_operator)
def raise_if_invalid_bool_operand(node, resources): invalid_operand = False try: if not isinstance(utils.get_value_from_node(node, resources).value, bool): invalid_operand = True except errors.TranslateError: pass if invalid_operand: raise errors.TranslateError(_errormessages.invalid_operand_for_boolean_operator)
def assign_transformer(node, resources): node_value = None initial_channel_ref_declaration = False lhs = node.targets[0] rtseq_var_name = utils.generic_ast_node_transform(lhs, resources) # the left hand side can only be a variable name or a name with an attribute (var.value) if isinstance(lhs, ast.Name): variable_name = utils.get_variable_name_from_node(lhs) # if the variable already exists this kind of assignment is invalid, use var.value instead if resources.has_variable(variable_name): raise TranslateError(_errormessages.variable_reassignment) elif isinstance(lhs, ast.Attribute): # in case of var[0].value get rid of the [0] part and search in the dictionary for var stripped_rtseq_var_name = rtseq_var_name[:rtseq_var_name.find("[")] if rtseq_var_name.find("[") != -1 \ else rtseq_var_name variable_name = resources.get_variable_py_name(stripped_rtseq_var_name) else: raise TranslateError(_errormessages.variable_reassignment) rtseq = resources.get_rtseq() block = resources.get_current_block() if not resources.has_variable(variable_name): # new local variable node_value = utils.get_value_from_node(node.value, resources) if isinstance( node_value, (_datatypes.ChannelReference, _datatypes.VectorChannelReference)): initial_channel_ref_declaration = True channel_name = utils.get_channel_name(node.value.args[0]) rtseq_var_name = rtseqapi.to_channel_ref_name(variable_name) resources.add_channel_ref( variable_name, channel_name, rtseq_var_name, isinstance(node_value, _datatypes.ArrayType)) elif isinstance(node_value, _datatypes.DataType): rtseq_var_name = rtseqapi.add_local_variable( rtseq, variable_name, node_value) # add the local variable's accessor to the resources resources.add_variable(variable_name, node_value, rtseq_var_name) resources.add_variable(variable_name + ".value", node_value, rtseq_var_name) else: raise TranslateError(_errormessages.init_var_invalid_type) transformed_node_value = utils.generic_ast_node_transform( node.value, resources) rtseq_var_name = resources.get_variable_rtseq_name( variable_name) if not rtseq_var_name else rtseq_var_name if not initial_channel_ref_declaration: if isinstance(node_value, _datatypes.ArrayType): if transformed_node_value.count(',') > 0: value_list = transformed_node_value.split(',') for index, val in enumerate(value_list): rtseqapi.add_assignment( block, rtseq_var_name + "[" + str(index) + "]", val) else: rtseqapi.add_assignment(block, rtseq_var_name, transformed_node_value)
def raise_if_negative_binary_operator_operand(node, resources): invalid_operand = False if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub): invalid_operand = True else: try: value = utils.get_value_from_node(node, resources).value if value < 0: invalid_operand = True except errors.TranslateError: pass if invalid_operand: raise errors.TranslateError(_errormessages.negative_operand_for_binary_operator)
def attribute_transformer(node, resources): var_name = utils.get_variable_name_from_node(node) if resources.has_variable(var_name): if isinstance(node.value, ast.Subscript): return utils.generic_ast_node_transform(node.value, resources) else: return resources.get_variable_rtseq_name(var_name) try: # Try to get the value of the node in case it's a DataType(x).value style. node_value = utils.get_value_from_node(node.value, resources) return str(node_value) except errors.TranslateError: # If we get a TranslateError it's because it wasn't a DataType(x).value, so move on. pass built_exp = utils.generic_ast_node_transform(node.value, resources) + '.' + node.attr if built_exp in symbols._symbols: return symbols._symbols[built_exp] else: raise errors.TranslateError(_errormessages.unknown_identifier % var_name)