def veval(op: 'nodes.UnaryOpType', value: 'values.Value'): if isinstance(value, values.NumberValue): return functions.generate_value_with_same_type(value) if isinstance(value, values.BoolValue): return functions.generate_value_with_same_type(value) if op == nodes.UnaryOpType.Not and isinstance(value, values.ListValue): return values.BoolValue(None) return values.Value()
def veval_ast_aug_assign(astc : 'AstContext', local_field : 'values.Field', graph : 'Graph'): assert(isinstance(astc.nast, gast.gast.AugAssign)) target = veval_ast(astc.c(astc.nast.target), local_field, graph) value = veval_ast(astc.c(astc.nast.value), local_field, graph) binop = nodes.BinOpType.Unknown if isinstance(astc.nast.op, gast.Add): binop = nodes.BinOpType.Add if isinstance(astc.nast.op, gast.Sub): binop = nodes.BinOpType.Sub target_value = target.get_value() if isinstance(target_value, values.NumberValue): node_aug_assign = nodes.NodeValueAugAssign(target_value, value.get_value(), binop, astc.lineno) new_value = functions.generate_value_with_same_type(target_value) target.revise(new_value) node_aug_assign.set_outputs([new_value]) graph.add_node(node_aug_assign) return values.NoneValue() else: node_aug_assign = nodes.NodeAugAssign(target_value, value.get_value(), binop, astc.lineno) target_value.modify(node_aug_assign, None) graph.add_node(node_aug_assign) return values.NoneValue()
def veval_ast_aug_assign(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): assert (isinstance(astc.nast, gast.gast.AugAssign)) lineprop = utils.LineProperty(astc.lineno) target = veval_ast(astc.c(astc.nast.target), local_field, graph) value = veval_ast(astc.c(astc.nast.value), local_field, graph) target_value = try_get_value(target, 'aug_assign', lineprop) value_value = try_get_value(value, 'aug_assign', lineprop) binop = nodes.BinOpType.Unknown if isinstance(astc.nast.op, gast.Add): binop = nodes.BinOpType.Add if isinstance(astc.nast.op, gast.Sub): binop = nodes.BinOpType.Sub node_aug_assign = nodes.NodeAugAssign(target_value, value_value, binop, astc.lineno) graph.add_node(node_aug_assign) # TODO : estimate type new_value = functions.generate_value_with_same_type(target_value) node_aug_assign.set_outputs([new_value]) target.get_ref().revise(new_value)
def vcall(self, module : 'Field', graph : 'Graph', inst : 'values.Object', args = [], line = -1): funcArgs = self.parse_args(args) vargs = self.get_values(funcArgs) node = nodes.NodeCall(self, vargs, line) graph.add_node(node) value = functions.generate_value_with_same_type(vargs[0]) value.name = '@F.{}.{}'.format(line, self.name) node.set_outputs([value]) return values.Object(value)
def veval(op: 'nodes.UnaryOpType', value: 'values.Value'): if isinstance(value, values.NumberValue): if value.internal_value is not None: if op == nodes.UnaryOpType.UAdd: return values.NumberValue(value.internal_value) if op == nodes.UnaryOpType.USub: return values.NumberValue(-value.internal_value) else: return functions.generate_value_with_same_type(value) else: return functions.generate_value_with_same_type(value) if isinstance(value, values.BoolValue): return functions.generate_value_with_same_type(value) if op == nodes.UnaryOpType.Not and isinstance(value, values.ListValue): return values.BoolValue(None) return values.Value()
def vcall(self, module: 'values.Field', graph: 'core.Graph', inst: 'Value', args=[], line=-1): funcArgs = self.parse_args(args) node = nodes.NodeCall(self, [v.value for v in funcArgs], line) graph.add_node(node) value = functions.generate_value_with_same_type(funcArgs[0].value) node.set_outputs([value]) return value
def vcall(self, module : 'Field', graph : 'Graph', inst : 'values.Object', args = [], line = -1): assert(len(args) == 1) node = nodes.NodeCall(self, [inst.get_value()] + [v.obj.get_value() for v in args], line) old_v = inst.get_value() new_v = functions.generate_value_with_same_type(old_v) inst.revise(new_v) new_v.name = '@F.{}.{}'.format(line, self.name) node.set_outputs([new_v]) graph.add_node(node) return values.NoneValue()
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1): funcArgs = self.args.merge_inputs(inst, args) node = nodes.NodeCall(self, funcArgs, line) old_v = inst.get_value() new_v = functions.generate_value_with_same_type(old_v) inst.revise(new_v) new_v.name = '@F.{}.{}'.format(line, self.name) node.set_outputs([new_v]) graph.add_node(node) return values.NoneValue()
def veval(op: 'nodes.BinOpType', left: 'values.Value', right: 'values.Value'): if isinstance(left, values.NumberValue) and isinstance( right, values.NumberValue): return functions.generate_value_with_same_type(left) if isinstance(left, values.ListValue) and isinstance( right, values.ListValue): return functions.generate_value_with_same_type(left) if isinstance(left, values.TupleValue) and isinstance( right, values.TupleValue): return functions.generate_value_with_same_type(left) # for .shape if isinstance(left, values.ListValue) and isinstance( right, values.TupleValue): return functions.generate_value_with_same_type(left) if isinstance(left, values.TensorValue) and isinstance( right, values.TensorValue): return functions.generate_value_with_same_type(left) return values.Value()
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1): assert (inst is None) funcArgs = self.args.merge_inputs(inst, args) vargs = funcArgs.get_value().inputs node = nodes.NodeCall(self, funcArgs, line) graph.add_node(node) value = functions.generate_value_with_same_type(vargs[0]) value.name = '@F.{}.{}'.format(line, self.name) node.set_outputs([value]) return values.ValueRef(value)
def veval_ast_if(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): assert (isinstance(astc.nast, gast.gast.If)) lineprop = utils.LineProperty(astc.lineno) # if condition test = veval_ast(astc.c(astc.nast.test), local_field, graph) test_value = try_get_value(test, 'if', lineprop) id_str = str(utils.get_guid()) if_id = 'if_' + id_str true_id = 'true_' + id_str false_id = 'false_' + id_str # True values.push_history(true_id) true_graph = Graph() true_graph.root_graph = graph.root_graph true_graph.name = 'True' body = veval_ast(astc.c(astc.nast.body), local_field, true_graph) true_value_inputs = values.get_inputs() true_value_outputs = values.get_outputs() values.pop_history() # False values.push_history(false_id) false_graph = Graph() false_graph.root_graph = graph.root_graph false_graph.name = 'False' body = veval_ast(astc.c(astc.nast.orelse), local_field, false_graph) false_value_inputs = values.get_inputs() false_value_outputs = values.get_outputs() values.pop_history() # generate pairs value_pairs = {} for v in true_value_inputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['true_input_value'] = v.input_value value_pairs[key]['true_input_body_value'] = v.value for v in true_value_outputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['true_output_body_value'] = v.value for v in false_value_inputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['false_input_value'] = v.input_value value_pairs[key]['false_input_body_value'] = v.value for v in false_value_outputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['false_output_body_value'] = v.value inputs = [] outputs = [] for k, v in value_pairs.items(): name = v['name'] field = v['field'] input_value = None true_input_body_value = None false_input_body_value = None if 'true_input_value' in v: input_value = v['true_input_value'] elif 'false_input_value' in v: input_value = v['false_input_value'] if input_value is not None: if 'true_input_body_value' in v: true_input_body_value = v['true_input_body_value'] else: true_input_body_value = functions.generate_value_with_same_type( input_value) if 'false_input_body_value' in v: false_input_body_value = v['false_input_body_value'] else: false_input_body_value = functions.generate_value_with_same_type( input_value) true_output_body_value = None false_output_body_value = None output_value = None if 'true_output_body_value' in v: true_output_body_value = v['true_output_body_value'] else: true_output_body_value = true_input_body_value if 'false_output_body_value' in v: false_output_body_value = v['false_output_body_value'] else: false_output_body_value = false_input_body_value # TODO check types between true and false if true_output_body_value is not None or false_output_body_value is not None: output_value = functions.generate_value_with_same_type( true_output_body_value) if input_value is not None: inputs.append(input_value) true_graph.add_input_value(true_input_body_value) false_graph.add_input_value(false_input_body_value) if output_value is not None: outputs.append(output_value) true_graph.add_output_value(true_output_body_value) false_graph.add_output_value(false_output_body_value) if field.get_attribute(name).has_obj(): field.get_attribute(name).get_ref().revise(output_value) else: field.get_attribute(name).revise(values.ValueRef(output_value)) node = nodes.NodeIf(test_value, inputs, true_graph, false_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) return None
def veval_ast_for(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' for target in iter: ... ''' assert (isinstance(astc.nast, gast.gast.For)) lineprop = utils.LineProperty(astc.lineno) # for target in iter: iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph) # get target name target_name = '' if isinstance(astc.nast.target, gast.gast.Name): target_name = astc.nast.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None for_guid = utils.get_guid() for_id = 'for_' + str(for_guid) body_id = 'body_' + str(for_guid) values.push_history(for_id) # body body_graph = Graph() body_graph.name = 'Body_' + str(for_guid) counter_value = values.NumberValue(0) counter_value.name = 'for_counter_' + str(for_guid) cond_value = values.BoolValue(True) cond_value.name = 'for_cond_' + str(for_guid) iter_value = try_get_value(iter_, 'for', lineprop) # create a node to lookup a value from sequence node_forgen = nodes.NodeForGenerator(counter_value, iter_value) # estimate type # TODO : more types if isinstance(iter_value, values.RangeValue): target_value = values.NumberValue(None) target_value.dtype = np.array(0).dtype else: target_value = values.Value() target_obj = values.Object(target_value) node_forgen.set_outputs([target_value]) target_attribute = local_field.get_attribute(target_name) target_attribute.revise(target_obj) body_graph.add_node(node_forgen) # veval body body = veval_ast(astc.c(astc.nast.body), local_field, body_graph) value_inputs = values.get_inputs() value_outputs = values.get_outputs() values.pop_history() inputs = [] outputs = [] # default input for subgraph's input body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) # default output for subgraph's output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) # default output outputs.append(functions.generate_value_with_same_type(iter_value)) # generate pairs value_pairs = {} for v in value_inputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['input_value'] = v.input_value value_pairs[key]['input_body_value'] = v.value for v in value_outputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['output_body_value'] = v.value for k, v in value_pairs.items(): name = v['name'] field = v['field'] if 'input_body_value' in v: inputs.append(v['input_value']) body_graph.add_input_value(v['input_body_value']) else: temp_value1 = functions.generate_value_with_same_type( v['output_body_value']) temp_value2 = functions.generate_value_with_same_type( v['output_body_value']) inputs.append(temp_value1) body_graph.add_input_value(temp_value2) if 'output_body_value' in v: body_graph.add_output_value(v['output_body_value']) output_value = functions.generate_value_with_same_type( v['output_body_value']) outputs.append(output_value) if field.get_attribute(name).has_obj(): field.get_attribute(name).get_obj().revise(output_value) else: field.get_attribute(name).revise(values.Object(output_value)) else: temp_value1 = v['input_body_value'] temp_value2 = functions.generate_value_with_same_type( v['input_body_value']) body_graph.add_output_value(temp_value1) outputs.append(temp_value2) node = nodes.NodeFor(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) return None
def veval_ast_listcomp(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' Ex. [x for x in xx] [elt for target in iter] ''' assert (isinstance(astc.nast, gast.gast.ListComp)) lineprop = utils.LineProperty(astc.lineno) listcomp_guid = str(utils.get_guid()) listcomp_id = 'listcomp_' + listcomp_guid body_id = 'listcomp_body_' + listcomp_guid internal_iter_id = '@internal/iter_' + listcomp_guid generator = astc.nast.generators[0] iter_value = try_get_value( veval_ast(astc.c(generator.iter), local_field, graph), 'generator', lineprop) list_value = values.ListValue() list_obj = values.Object(list_value) node_generate_list = nodes.NodeGenerate('List', [], lineprop) node_generate_list.set_outputs([list_value]) graph.add_node(node_generate_list) # body target_name = '' if isinstance(generator.target, gast.gast.Name): target_name = generator.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None counter_value = values.NumberValue(0) counter_value.name = 'listcomp_counter_' + listcomp_guid cond_value = values.BoolValue(True) cond_value.name = 'listcomp_cond_' + listcomp_guid body_field = values.Field() body_field.set_module(local_field.module) body_field.set_parent(local_field) # set iter with internal name body_field.get_attribute(internal_iter_id).revise(list_obj) values.commit(listcomp_id) body_graph = Graph() body_graph.name = 'Body_' + listcomp_guid node_forgen = nodes.NodeForGenerator(counter_value, iter_value) target_value = values.Value() target_obj = values.Object(target_value) node_forgen.set_outputs([target_value]) body_field.get_attribute(target_name).revise(target_obj) body_graph.add_node(node_forgen) elt = veval_ast(astc.c(astc.nast.elt), body_field, body_graph) elt_obj = try_get_obj(elt, 'listcomp', lineprop) farg = functions.FunctionArg() farg.name = '' farg.obj = elt_obj append_value = list_obj.get_field().get_attribute( 'append').get_obj().get_value() append_value.func.vcall(local_field.module, body_graph, list_obj, [farg], lineprop) values.commit(body_id) body_input_attributes = get_input_attritubtes( body_field, listcomp_id, body_id) + get_input_attritubtes( local_field, listcomp_id, body_id) body_output_attributes = get_output_attritubtes( body_field, listcomp_id, body_id) + get_output_attritubtes( local_field, listcomp_id, body_id) body_input_attributes = filter_attributes(body_input_attributes) body_output_attributes = filter_attributes(body_output_attributes) # get objects whose values are changed value_changed_objs = get_output_objs(body_field, listcomp_id, body_id) + get_output_objs( local_field, listcomp_id, body_id) changed_values = {} for obj in value_changed_objs: in_value = obj.get_value_log(listcomp_id) out_value = obj.get_value_log(body_id) changed_values[in_value] = (obj, out_value) output_attributes_2_values = {} for attribute in body_output_attributes: output_attributes_2_values[attribute] = attribute.get_obj().get_value() # get inputs values.checkout(listcomp_id) input_attributes_2_values = {} for attribute in body_input_attributes: input_attributes_2_values[attribute] = attribute.get_obj().get_value() # Exports values.checkout(listcomp_id) # generate attribute pairs name2attributes = {} for attribute in body_input_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][0] = attribute else: name2attributes[key] = [attribute, None] for attribute in body_output_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][1] = attribute else: name2attributes[key] = [None, attribute] # remove defaule values name_removing = [] defaule_values = [counter_value, cond_value, iter_value] for k, v in name2attributes.items(): if v[0] is not None and input_attributes_2_values[ v[0]] in defaule_values: name_removing.append(k) if v[1] is not None and output_attributes_2_values[ v[1]] in defaule_values: name_removing.append(k) for nr in name_removing: if nr in name2attributes.keys(): name2attributes.pop(nr) # inputs = [] outputs = [] non_volatiles = [] # default input for subgraph's input body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) # default output for subgrap's output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) # default output outputs.append(functions.generate_value_with_same_type(iter_value)) for attributes in name2attributes.values(): name = '' parent = None input_value = None output_value = None if attributes[0] is not None: name = attributes[0].name parent = attributes[0].parent if attributes[1] is not None: name = attributes[1].name parent = attributes[1].parent if attributes[0] is not None: input_value = input_attributes_2_values[attributes[0]] else: # value with same type input_value = functions.generate_value_with_same_type( output_attributes_2_values[attributes[1]]) if attributes[1] is not None: output_value = output_attributes_2_values[attributes[1]] else: if input_attributes_2_values[ attributes[0]] in changed_values.keys(): # change only values output_value = changed_values[input_attributes_2_values[ attributes[0]]] else: # copy value output_value = input_attributes_2_values[attributes[0]] output_value_in_node = functions.generate_value_with_same_type( output_value) inputs.append(input_value) outputs.append(output_value_in_node) body_graph.add_input_value(input_value) body_graph.add_output_value(output_value) if attributes[1] is not None and attributes[1].is_non_volatile: non_volatiles.append( (attribute[1].initial_obj.get_value(), output_value_in_node)) output_obj_in_node = values.Object(output_value_in_node) parent.get_attribute(name).revise(output_obj_in_node) for changed_value_in, changed_obj_value_out in changed_values.items(): if changed_value_in is None: continue if changed_value_in in inputs: continue inputs.append(changed_value_in) body_graph.add_input_value(changed_value_in) body_graph.add_output_value(changed_obj_value_out[1]) value = functions.generate_value_with_same_type( changed_obj_value_out[1]) changed_obj_value_out[0].revise(value) outputs.append(value) node = nodes.NodeListcomp(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) # add non-volatiles for tv, v in non_volatiles: node_nv = nodes.NodeNonVolatileAssign(tv, v) graph.add_node(node_nv) if body_field.get_attribute(internal_iter_id).has_obj(): return body_field.get_attribute(internal_iter_id).get_obj() else: return list_obj
def veval_ast_for(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' for target in iter: ... ''' assert (isinstance(astc.nast, gast.gast.For)) # for target in iter: iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph) # get target name target_name = '' if isinstance(astc.nast.target, gast.gast.Name): target_name = astc.nast.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None for_id = 'for_' + str(utils.get_guid()) body_id = 'body_' + str(utils.get_guid()) values.commit(for_id) # Body body_graph = Graph() body_graph.name = 'Body' counter_value = values.NumberValue(0) counter_value.name = 'for_counter' cond_value = values.BoolValue(True) cond_value.name = 'for_cond' iter_value = iter_.get_value() node_forgen = nodes.NodeForGenerator(counter_value, iter_value) target_value = values.Value() node_forgen.set_outputs([target_value]) target_attribute = local_field.get_attribute(target_name) target_attribute.revise(target_value) body_graph.add_node(node_forgen) body = veval_ast(astc.c(astc.nast.body), local_field, body_graph) values.commit(body_id) body_output_attributes = get_input_attritubtes(local_field, for_id, body_id) body_intput_attributes = get_output_attritubtes(local_field, for_id, body_id) input_attributes_2_values = {} for attribute in body_intput_attributes: input_attributes_2_values[attribute] = attribute.get_value() output_attributes_2_values = {} for attribute in body_output_attributes: output_attributes_2_values[attribute] = attribute.get_value() # Exports values.checkout(for_id) input_attributes = set(body_intput_attributes) inputs = [i.get_value() for i in input_attributes if i.has_value()] output_attributes = body_output_attributes output_attributes.remove(target_attribute) output_attributes = [target_attribute] + output_attributes outputs = [] non_volatiles = [] # default output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) for attribute in output_attributes: name = attribute.name body_graph.add_output_value(output_attributes_2_values[attribute]) value = functions.generate_value_with_same_type( output_attributes_2_values[attribute]) outputs.append(value) if attribute.is_non_volatile: non_volatiles.append((attribute.initial_value, value)) attribute.parent.get_attribute(name).revise(value) # default input ''' body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) inputs.remove(counter_value) inputs.remove(cond_value) inputs.remove(iter_value) ''' for input in inputs: body_graph.add_input_value(input) node = nodes.NodeFor(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) # add non-volatiles for tv, v in non_volatiles: node_nv = nodes.NodeNonVolatileAssign(tv, v) graph.add_node(node_nv) return None
def veval_ast_listcomp(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' Ex. [x for x in xx] [elt for target in iter] ''' assert (isinstance(astc.nast, gast.gast.ListComp)) lineprop = utils.LineProperty(astc.lineno) listcomp_guid = str(utils.get_guid()) listcomp_id = 'listcomp_' + listcomp_guid body_id = 'listcomp_body_' + listcomp_guid internal_counter_id = '@internal/listcomp_counter_' + listcomp_guid internal_list_id = '@internal/listcomp_list_' + listcomp_guid internal_cond_id = '@internal/listcomp_cond_' + listcomp_guid generator = astc.nast.generators[0] iter_value = try_get_value( veval_ast(astc.c(generator.iter), local_field, graph), 'generator', lineprop) list_value = values.ListValue() list_obj = values.ValueRef(list_value) node_generate_list = nodes.NodeGenerate('List', [], lineprop) node_generate_list.set_outputs([list_value]) graph.add_node(node_generate_list) # body target_name = '' if isinstance(generator.target, gast.gast.Name): target_name = generator.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None counter_value = values.NumberValue(None) counter_value.dtype = np.array(0).dtype counter_value.name = internal_counter_id cond_value = values.BoolValue(None) cond_value.name = internal_cond_id # set values with internal name local_field.get_attribute(internal_list_id).revise(list_obj) values.push_history(listcomp_id) body_graph = Graph() body_graph.root_graph = graph.root_graph body_graph.name = 'Body_' + listcomp_guid node_forgen = nodes.NodeForGenerator(counter_value, iter_value) target_ref = iter_value.get_iterator() if target_ref is None: target_ref = values.ValueRef(values.UnknownValue()) if config.show_warnings: print('unknown iteratable type in L.{}'.format(astc.lineno)) target_value = target_ref.get_value() node_forgen.set_outputs([target_ref.get_value()]) local_field.get_attribute(target_name, from_module=False).revise(target_ref) body_graph.add_node(node_forgen) elt = veval_ast(astc.c(astc.nast.elt), local_field, body_graph) elt_obj = try_get_ref(elt, 'listcomp', lineprop) finput = functions.FunctionArgInput() finput.inputs.append(elt_obj) append_value = local_field.get_attribute(internal_list_id).get_ref( ).get_field().get_attribute('append').get_ref().get_value() append_value.func.vcall( local_field.module, body_graph, local_field.get_attribute(internal_list_id).get_ref(), finput, lineprop) value_inputs = values.get_inputs() value_outputs = values.get_outputs() values.pop_history() inputs = [] outputs = [] # default input for subgraph's input body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) # default output for subgraph's output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) # default output outputs.append(functions.generate_value_with_same_type(iter_value)) # generate pairs value_pairs = {} for v in value_inputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['input_value'] = v.input_value value_pairs[key]['input_body_value'] = v.value for v in value_outputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['output_body_value'] = v.value # remove iterator removed_name = str(local_field.id) + '_' + target_value.name del value_pairs[removed_name] for k, v in value_pairs.items(): name = v['name'] field = v['field'] if 'input_body_value' in v: inputs.append(v['input_value']) body_graph.add_input_value(v['input_body_value']) else: temp_value1 = functions.generate_value_with_same_type( v['output_body_value']) temp_value2 = functions.generate_value_with_same_type( v['output_body_value']) inputs.append(temp_value1) body_graph.add_input_value(temp_value2) if 'output_body_value' in v: body_graph.add_output_value(v['output_body_value']) output_value = functions.generate_value_with_same_type( v['output_body_value']) outputs.append(output_value) if field.get_attribute(name).has_obj(): field.get_attribute(name).get_ref().revise(output_value) else: field.get_attribute(name).revise(values.ValueRef(output_value)) else: temp_value1 = v['input_body_value'] temp_value2 = functions.generate_value_with_same_type( v['input_body_value']) body_graph.add_output_value(temp_value1) outputs.append(temp_value2) node = nodes.NodeListcomp(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) return local_field.get_attribute(internal_list_id).get_ref()
def veval_ast_for(astc : 'AstContext', local_field : 'values.Field', graph : 'Graph'): ''' for target in iter: ... ''' assert(isinstance(astc.nast, gast.gast.For)) # for target in iter: iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph) # get target name target_name = '' if isinstance(astc.nast.target, gast.gast.Name): target_name = astc.nast.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None for_id = 'for_' + str(utils.get_guid()) body_id = 'body_' + str(utils.get_guid()) values.commit(for_id) # Body body_graph = Graph() body_graph.name = 'Body' counter_value = values.NumberValue(0) counter_value.name = 'for_counter' cond_value = values.BoolValue(True) cond_value.name = 'for_cond' iter_value = iter_.get_value() # node to lookup a value from sequence node_forgen = nodes.NodeForGenerator(counter_value, iter_value) target_value = values.Value() node_forgen.set_outputs([target_value]) target_attribute = local_field.get_attribute(target_name) target_attribute.revise(target_value) body_graph.add_node(node_forgen) body = veval_ast(astc.c(astc.nast.body), local_field, body_graph) values.commit(body_id) body_input_attributes = get_input_attritubtes(local_field, for_id, body_id) body_output_attributes = get_output_attritubtes(local_field, for_id, body_id) input_attributes_2_values = {} for attribute in body_input_attributes: input_attributes_2_values[attribute] = attribute.get_value() output_attributes_2_values = {} for attribute in body_output_attributes: output_attributes_2_values[attribute] = attribute.get_value() # Exports values.checkout(for_id) # generate attribute pairs name2attributes = {} for attribute in body_input_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][0] = attribute else: name2attributes[key] = [attribute, None] for attribute in body_output_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][1] = attribute else: name2attributes[key] = [None, attribute] # remove defaule values name_removing = [] defaule_values = [counter_value, cond_value, iter_value] for k, v in name2attributes.items(): if v[0] in defaule_values: name_removing.append(k) if v[1] in defaule_values: name_removing.append(k) for nr in name_removing: if nr in name2attributes.keys(): name2attributes.pop(nr) # inputs = [] outputs = [] non_volatiles = [] # default input for subgraph's input body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) # default output for subgrap's output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) # default output outputs.append(functions.generate_value_with_same_type(iter_value)) for attributes in name2attributes.values(): name = '' parent = None input_value = None output_value = None if attributes[0] is not None: name = attributes[0].name parent = attributes[0].parent if attributes[1] is not None: name = attributes[1].name parent = attributes[1].parent if attributes[0] is not None: input_value = input_attributes_2_values[attributes[0]] else: # value with same type input_value = functions.generate_value_with_same_type(output_attributes_2_values[attributes[1]]) if attributes[1] is not None: output_value = output_attributes_2_values[attributes[1]] else: # copy value output_value = input_attributes_2_values[attributes[0]] output_value_in_node = functions.generate_value_with_same_type(output_value) inputs.append(input_value) outputs.append(output_value_in_node) body_graph.add_input_value(input_value) body_graph.add_output_value(output_value) if attributes[1].is_non_volatile: non_volatiles.append((attribute[1].initial_value,output_value_in_node)) attributes[1].parent.get_attribute(name).revise(output_value_in_node) node = nodes.NodeFor(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) # add non-volatiles for tv, v in non_volatiles: node_nv = nodes.NodeNonVolatileAssign(tv, v) graph.add_node(node_nv) return None
def veval_ast_subscript(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' Ex. x[1], x[y,z] ''' assert (isinstance(astc.nast, gast.gast.Subscript)) lineprop = utils.LineProperty(astc.lineno) def veval_with_default(nast, default_value): if nast is None: ret = values.NumberValue(default_value) ret.name = '@SliceDefault' return ret obj = veval_ast(astc.c(nast), local_field, graph) return try_get_value(obj, 'subscript', lineprop) def get_slice_indices(slice): if slice.lower is None and slice.upper is None and slice.step is None: return [] indices = [ veval_with_default(slice.lower, 0), veval_with_default(slice.upper, utils.slice_int_max) ] if slice.step is not None: indices.append(veval_with_default(slice.step, 1)) return indices value = veval_ast(astc.c(astc.nast.value), local_field, graph) value_value = try_get_value(value, 'subscript', lineprop) if isinstance(astc.nast.slice, gast.gast.Index): slice_ = veval_ast(astc.c(astc.nast.slice.value), local_field, graph) slice_value = try_get_value(slice_, 'subscript', lineprop) if isinstance(slice_value, values.TupleValue): # ex. x[1,2] if slice_value.has_constant_value(): values_ = [ try_get_value(x, 'subscript', lineprop) for x in slice_value.get_constant_value() ] node = nodes.NodeGetItem(value_value, values_, line=lineprop) else: if config.show_warnings: print('This subscript is not supported. in L.{}'.format( astc.lineno)) node = nodes.NodeInvalid(line=lineprop) else: # ex. x[1] node = nodes.NodeGetItem(value_value, [slice_value]) ret_value = values.Value() node.set_outputs([ret_value]) graph.add_node(node) return values.ValueRef(ret_value) elif isinstance(astc.nast.slice, gast.gast.Slice): indices = get_slice_indices(astc.nast.slice) node = nodes.NodeSlice(value_value, indices, [len(indices)]) ret_value = functions.generate_value_with_same_type(value_value) node.set_outputs([ret_value]) graph.add_node(node) return values.ValueRef(ret_value) elif isinstance(astc.nast.slice, gast.gast.ExtSlice): indices = [] slice_specs = [] for dim in astc.nast.slice.dims: if isinstance(dim, gast.gast.Index): indices.append( try_get_value( veval_ast(astc.c(dim.value), local_field, graph), 'subscript', lineprop)) slice_specs.append(1) elif isinstance(dim, gast.gast.Slice): ni = get_slice_indices(dim) indices.extend(ni) slice_specs.append(len(ni)) else: assert False, 'Unknown slice: %s in %s' % (dim, nast.slice) node = nodes.NodeSlice(value_value, indices, slice_specs) ret_value = functions.generate_value_with_same_type(value_value) node.set_outputs([ret_value]) graph.add_node(node) return values.ValueRef(ret_value) return None
def veval_ast_for(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' for target in iter: ... ''' assert (isinstance(astc.nast, gast.gast.For)) lineprop = utils.LineProperty(astc.lineno) # for target in iter: iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph) # get target name target_name = '' if isinstance(astc.nast.target, gast.gast.Name): target_name = astc.nast.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None for_id = 'for_' + str(utils.get_guid()) body_id = 'body_' + str(utils.get_guid()) values.commit(for_id) # body body_graph = Graph() body_graph.name = 'Body' counter_value = values.NumberValue(0) counter_value.name = 'for_counter' cond_value = values.BoolValue(True) cond_value.name = 'for_cond' iter_value = try_get_value(iter_, 'for', lineprop) # create a node to lookup a value from sequence node_forgen = nodes.NodeForGenerator(counter_value, iter_value) # estimate type # TODO : more types if isinstance(iter_value, values.RangeValue): target_value = values.NumberValue(None) target_value.dtype = np.array(0).dtype else: target_value = values.Value() target_obj = values.Object(target_value) node_forgen.set_outputs([target_value]) target_attribute = local_field.get_attribute(target_name) target_attribute.revise(target_obj) body_graph.add_node(node_forgen) # veval body body = veval_ast(astc.c(astc.nast.body), local_field, body_graph) values.commit(body_id) # get changed attributes body_input_attributes = get_input_attritubtes(local_field, for_id, body_id) body_output_attributes = get_output_attritubtes(local_field, for_id, body_id) body_input_attributes = filter_attributes(body_input_attributes) body_output_attributes = filter_attributes(body_output_attributes) # get objects whose values are changed value_changed_objs = get_output_objs(local_field, for_id, body_id) changed_values = {} for obj in value_changed_objs: in_value = obj.get_value_log(for_id) out_value = obj.get_value_log(body_id) changed_values[in_value] = out_value # get outputs output_attributes_2_values = {} for attribute in body_output_attributes: output_attributes_2_values[attribute] = attribute.get_obj().get_value() # get inputs values.checkout(for_id) input_attributes_2_values = {} for attribute in body_input_attributes: input_attributes_2_values[attribute] = attribute.get_obj().get_value() # export values.checkout(for_id) # generate attribute pairs name2attributes = {} for attribute in body_input_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][0] = attribute else: name2attributes[key] = [attribute, None] for attribute in body_output_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2attributes.keys(): name2attributes[key][1] = attribute else: name2attributes[key] = [None, attribute] # remove defaule values name_removing = [] defaule_values = [counter_value, cond_value, iter_value] for k, v in name2attributes.items(): if v[0] in defaule_values: name_removing.append(k) if v[1] in defaule_values: name_removing.append(k) for nr in name_removing: if nr in name2attributes.keys(): name2attributes.pop(nr) # inputs = [] outputs = [] non_volatiles = [] # default input for subgraph's input body_graph.add_input_value(counter_value) body_graph.add_input_value(cond_value) body_graph.add_input_value(iter_value) # default output for subgrap's output body_graph.add_output_value(cond_value) body_graph.add_output_value(iter_value) # default output outputs.append(functions.generate_value_with_same_type(iter_value)) for attributes in name2attributes.values(): name = '' parent = None input_value = None output_value = None if attributes[0] is not None: name = attributes[0].name parent = attributes[0].parent if attributes[1] is not None: name = attributes[1].name parent = attributes[1].parent if attributes[0] is not None: input_value = input_attributes_2_values[attributes[0]] else: # value with same type input_value = functions.generate_value_with_same_type( output_attributes_2_values[attributes[1]]) if attributes[1] is not None: output_value = output_attributes_2_values[attributes[1]] else: if input_attributes_2_values[ attributes[0]] in changed_values.keys(): # change only values output_value = changed_values[input_attributes_2_values[ attributes[0]]] else: # copy value output_value = input_attributes_2_values[attributes[0]] output_value_in_node = functions.generate_value_with_same_type( output_value) inputs.append(input_value) outputs.append(output_value_in_node) body_graph.add_input_value(input_value) body_graph.add_output_value(output_value) if attributes[1] is not None and attributes[1].is_non_volatile: non_volatiles.append( (attributes[1].initial_obj.get_value(), output_value_in_node)) output_obj_in_node = values.Object(output_value_in_node) parent.get_attribute(name).revise(output_obj_in_node) for changed_value_in, changed_value_out in changed_values.items(): if changed_value_in is None: continue if changed_value_in in inputs: continue inputs.append(changed_value_in) body_graph.add_input_value(changed_value_in) body_graph.add_output_value(changed_value_out) value = functions.generate_value_with_same_type(changed_value_out) obj.revise(value) outputs.append(value) node = nodes.NodeFor(iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) graph.add_node(node) # add non-volatiles for tv, v in non_volatiles: node_nv = nodes.NodeNonVolatileAssign(tv, v) graph.add_node(node_nv) return None
def veval_ast_for(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): ''' for target in iter: ... ''' assert (isinstance(astc.nast, gast.gast.For)) lineprop = utils.LineProperty(astc.lineno) # for target in iter: iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph) input_iter_value = try_get_value(iter_, 'for', lineprop) body_iter_value = functions.generate_value_with_same_type( input_iter_value, suffix_type=functions.SuffixType.Input) # get target name target_name = '' if isinstance(astc.nast.target, gast.gast.Name): target_name = astc.nast.target.id else: if config.show_warnings: print('This for is not supported. in L.{}'.format(astc.lineno)) return None # unroll? if isinstance(input_iter_value, values.ListValue) and input_iter_value.has_constant_value( ) and input_iter_value.dtype is None: return veval_ast_for_unroll(astc, target_name, input_iter_value, local_field, graph) for_guid = utils.get_guid() for_id = 'for_' + str(for_guid) body_id = 'body_' + str(for_guid) values.push_history(for_id) # body body_graph = Graph() body_graph.root_graph = graph.root_graph body_graph.name = 'Body_' + str(for_guid) # generate a node for input node_input = nodes.NodeInput('input') body_graph.add_node(node_input) body_counter_value = values.NumberValue(None) body_counter_value.dtype = np.array(0).dtype body_counter_value.name = 'for_counter_' + str(for_guid) body_cond_value = values.BoolValue(None) body_cond_value.name = 'for_cond_' + str(for_guid) # create a node to lookup a value from sequence node_forgen = nodes.NodeForGenerator(body_counter_value, body_iter_value) # generate iterator target_ref = input_iter_value.get_iterator() if target_ref is None: target_ref = values.ValueRef(values.UnknownValue()) if config.show_warnings: print('unknown iteratable type in L.{}'.format(astc.lineno)) target_value = target_ref.get_value() node_forgen.set_outputs([target_ref.get_value()]) target_attribute = local_field.get_attribute(target_name) target_attribute.revise(target_ref) body_graph.add_node(node_forgen) # veval body body = veval_ast(astc.c(astc.nast.body), local_field, body_graph) value_inputs = values.get_inputs() value_outputs = values.get_outputs() values.pop_history() inputs = [] outputs = [] node_input_outputs = [] # default input for subgraph's input body_graph.add_input_value(body_counter_value) body_graph.add_input_value(body_cond_value) body_graph.add_input_value(body_iter_value) # default output for subgraph's output body_graph.add_output_value(body_cond_value) body_graph.add_output_value(body_iter_value) # default output outputs.append(functions.generate_value_with_same_type(input_iter_value)) # generate pairs value_pairs = {} for v in value_inputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['input_value'] = v.input_value value_pairs[key]['input_body_value'] = v.value for v in value_outputs: key = str(v.field.id) + '_' + v.name if not (key in value_pairs.keys()): value_pairs[key] = {} value_pairs[key]['field'] = v.field value_pairs[key]['name'] = v.name value_pairs[key]['output_body_value'] = v.value for k, v in value_pairs.items(): name = v['name'] field = v['field'] if 'input_body_value' in v: inputs.append(v['input_value']) body_graph.add_input_value(v['input_body_value']) else: temp_value1 = functions.generate_value_with_same_type( v['output_body_value'], is_dummy_value=True, suffix_type=functions.SuffixType.Dummy) temp_value2 = functions.generate_value_with_same_type( v['output_body_value'], suffix_type=functions.SuffixType.Dummy) inputs.append(temp_value1) body_graph.add_input_value(temp_value2) node_input_outputs.append(temp_value2) if 'output_body_value' in v: body_graph.add_output_value(v['output_body_value']) output_value = functions.generate_value_with_same_type( v['output_body_value']) outputs.append(output_value) if field.get_attribute(name).has_obj(): field.get_attribute(name).get_ref().revise(output_value) else: field.get_attribute(name).revise(values.ValueRef(output_value)) else: temp_value1 = v['input_body_value'] temp_value2 = functions.generate_value_with_same_type( v['input_body_value']) body_graph.add_output_value(temp_value1) outputs.append(temp_value2) node = nodes.NodeFor(input_iter_value, inputs, body_graph, astc.lineno) node.set_outputs(outputs) node_input.set_outputs(node_input_outputs) graph.add_node(node) return None
def veval_ast_if(astc: 'AstContext', local_field: 'values.Field', graph: 'Graph'): assert (isinstance(astc.nast, gast.gast.If)) lineprop = utils.LineProperty(astc.lineno) # if condition test = veval_ast(astc.c(astc.nast.test), local_field, graph) test_value = try_get_value(test, 'if', lineprop) id_str = str(utils.get_guid()) if_id = 'if_' + id_str true_id = 'true_' + id_str false_id = 'false_' + id_str values.commit(if_id) # True condition values.checkout(if_id) true_graph = Graph() true_graph.name = 'True' body = veval_ast(astc.c(astc.nast.body), local_field, true_graph) values.commit(true_id) true_input_attributes = get_input_attritubtes(local_field, if_id, true_id) true_output_attributes = get_output_attritubtes(local_field, if_id, true_id) true_output_objs = get_output_objs(local_field, if_id, true_id) #TODO(durswd): improve true_input_attributes = filter_attributes(true_input_attributes) true_output_attributes = filter_attributes(true_output_attributes) true_output_attributes_2_values = {} for attribute in true_output_attributes: true_output_attributes_2_values[attribute] = attribute.get_obj( ).get_value() # False condition values.checkout(if_id) false_graph = Graph() false_graph.name = 'False' orelse = veval_ast(astc.c(astc.nast.orelse), local_field, false_graph) values.commit(false_id) false_input_attributes = get_input_attritubtes(local_field, if_id, false_id) false_output_attributes = get_output_attritubtes(local_field, if_id, false_id) false_output_objs = get_output_objs(local_field, if_id, false_id) #TODO(durswd): improve false_input_attributes = filter_attributes(false_input_attributes) false_output_attributes = filter_attributes(false_output_attributes) false_output_attributes_2_values = {} for attribute in false_output_attributes: false_output_attributes_2_values[attribute] = attribute.get_obj( ).get_value() # Merge values.checkout(if_id) # Input input_attributes = set(true_input_attributes) | set(false_input_attributes) # remove unexisting values input_attributes = [v for v in input_attributes if v.has_obj()] input_values = [i.get_obj().get_value() for i in input_attributes] # Output name2output_attributes = {} # generate attribute pairs for attribute in true_output_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2output_attributes.keys(): name2output_attributes[key][0] = attribute else: name2output_attributes[key] = [attribute, None] for attribute in false_output_attributes: key = str(attribute.parent.id) + '_' + attribute.name if key in name2output_attributes.keys(): name2output_attributes[key][1] = attribute else: name2output_attributes[key] = [None, attribute] obj2output_values = {} for obj in true_output_objs: if obj.get_value() == None: continue key = obj value = obj.get_value_log(true_id) if key in obj2output_values.keys(): obj2output_values[key][0] = value else: obj2output_values[key] = [value, None] for obj in false_output_objs: if obj.get_value() == None: continue key = obj value = obj.get_value_log(false_id) if key in obj2output_values.keys(): obj2output_values[key][1] = value else: obj2output_values[key] = [None, value] output_attributes = set(true_output_attributes) | set( false_output_attributes) output_values = [] non_volatiles = [] for attribute_pair in name2output_attributes.values(): true_attribute, false_attribute = attribute_pair name = '' parent = None # type: values.Field if true_attribute is not None: name = true_attribute.name parent = true_attribute.parent if false_attribute is not None: name = false_attribute.name parent = false_attribute.parent if true_attribute is not None: true_value = true_output_attributes_2_values[true_attribute] else: if parent.has_attribute(name): true_value = parent.get_attribute(name).get_obj().get_value() if not true_value in input_values: input_values.append(true_value) else: # TODO : it should be better # case # if xxx: # y = 10 # print(y) true_value = false_output_attributes_2_values[false_attribute] if false_attribute is not None: false_value = false_output_attributes_2_values[false_attribute] else: if parent.has_attribute(name): false_value = parent.get_attribute(name).get_obj().get_value() if not false_value in input_values: input_values.append(false_value) else: # TODO : it should be better # case # if xxx: # y = 10 # print(y) false_value = true_output_attributes_2_values[true_attribute] true_graph.add_output_value(true_value) false_graph.add_output_value(false_value) if true_attribute is not None and false_attribute is not None and true_attribute != false_attribute: # dynamic value = functions.generate_value_with_same_type(true_value) output_values.append(value) parent.get_attribute(name).revise(values.Object(value)) elif true_attribute is not None and false_attribute is not None: # change both value = functions.generate_value_with_same_type(true_value) output_values.append(value) if parent.get_attribute(name).is_non_volatile: non_volatiles.append( (parent.get_attribute(name).initial_obj.get_value(), value)) parent.get_attribute(name).revise(values.Object(value)) elif true_attribute in input_attributes: value = functions.generate_value_with_same_type(true_value) if parent.get_attribute(name).is_non_volatile: non_volatiles.append( (parent.get_attribute(name).initial_obj.get_value(), value)) output_values.append(value) parent.get_attribute(name).revise(values.Object(value)) else: value = functions.generate_value_with_same_type(false_value) if parent.get_attribute(name).is_non_volatile: non_volatiles.append( (parent.get_attribute(name).initial_obj.get_value(), value)) output_values.append(value) parent.get_attribute(name).revise(values.Object(value)) for input_value in input_values: true_graph.add_input_value(input_value) false_graph.add_input_value(input_value) for obj, values_pairs in obj2output_values.items(): if not obj.get_value() in input_values: input_values.append(obj.get_value()) value = None true_value = None false_value = None if values_pairs[0] is not None: value = values_pairs[0] true_value = values_pairs[0] if values_pairs[1] is not None: value = values_pairs[1] false_value = values_pairs[1] if true_value is None: true_value = obj.get_value() if false_value is None: false_value = obj.get_value() value = functions.generate_value_with_same_type(value) obj.revise(value) output_values.append(value) true_graph.add_output_value(true_value) false_graph.add_output_value(false_value) node = nodes.NodeIf(test_value, input_values, true_graph, false_graph, astc.lineno) node.set_outputs(output_values) graph.add_node(node) # add non-volatiles for tv, v in non_volatiles: node_nv = nodes.NodeNonVolatileAssign(tv, v) graph.add_node(node_nv) return None