def create_child(self, name=None, properties=None, reference=None): """Create an instance to add to the definition, add it, and return the instance. This functions calls the add_child funciton. parameters ---------- name - (str) the name of this instance properties - (dict) the dictionary which holds the properties Example ------- To create a child: >>> definition = sdn.Definition() >>> child_instance = definition.create_child() >>> child_instance.name = "child_instance" >>> child_instance.reference = reference_definition To create a child with optional parameters >>> child_instance = definition.create_child(name="child_instance", reference=reference_definition) The reference of the instance is the definition that initialized this instance. """ instance = Instance(name, properties) instance.reference = reference self.add_child(instance) return instance
def set_top_instance(self, instance, instance_name='instance'): """Sets the top instance of the design. The instance must not be null and should probably come from this netlist Parameters ---------- instance - (Instance or Definition) the instance to set as the top instance. If a definition is passed into the funciton, creates a new instance with that definition and set it as the top instance. """ assert instance is None or isinstance( instance, Instance) or isinstance( instance, Definition), "Must specify an instance" global_callback._call_netlist_top_instance(self, instance) # TODO: should We have a DRC that makes sure the instance is of a definition contained in netlist? I think no # but I am open to hear other points of veiw. if isinstance(instance, Definition): top = Instance() top.reference = instance instance.name = instance_name self.top_instance = top self.top_instance.name = instance_name else: self._top_instance = instance
def parse_design(self): self.expect(DESIGN) # self.tokenizer.next() instance = Instance() instance['metadata_prefix'] = list() self.elements.append(instance) instance['metadata_prefix'] = ['EDIF'] if self.begin_construct(): self.parse_rename() self.tokenizer.next() else: self.prefix_append('identifier') self.set_attribute(self.parse_identifier()) self.prefix_pop() self.prefix_pop() self.tokenizer.next() self.tokenizer.next() definition_name = self.tokenizer.next() self.tokenizer.next() self.tokenizer.next() library_name = self.tokenizer.next() for library in self.elements[0].libraries: if library['EDIF.identifier'] == library_name: break for definition in library.definitions: if definition['EDIF.identifier'] == definition_name: break instance.reference = definition self.elements.pop() self.elements[0].top_instance = instance self.skip_until_next_construct()
def parse_instance(self): self.append_new_element(Instance()) self.expect(INSTANCE) self.parse_nameDef() if self.begin_construct(): if self.construct_is(VIEW_REF): definition = self.parse_viewRef() instance = self.elements[-1] instance.reference = definition elif self.construct_is(VIEW_LIST): raise NotImplementedError() else: self.expect(VIEW_REF) self.expect_end_construct() while self.begin_construct(): if self.construct_is(PROPERTY): self.parse_property() elif self.construct_is(COMMENT): self.parse_comment() elif self.construct_is(USER_DATA): self.parse_userData() else: self.expect('|'.join([PROPERTY, COMMENT, USER_DATA])) self.expect_end_construct() return self.pop_element()
def _clone(self, memo): """Not api safe clone function clone the instance leaving all references in tact. The instance can then either be ripped or ripped and replaced """ assert self not in memo, "the object should not have been copied twice in this pass" from spydrnet.ir import Instance as InstanceExtended c = InstanceExtended() memo[self] = c c._parent = None for inner_pin, outer_pin in self._pins.items(): new_outer_pin = outer_pin._clone(memo) new_outer_pin._instance = c c._pins[inner_pin] = new_outer_pin c._reference = self._reference c._data = deepcopy(self._data) return c
def test_name_init_shortcut(self): d = Definition('d_name') self.assertEqual(d.name, 'd_name', 'Definition name init shorcut error') l = Library('l_name') self.assertEqual(l.name, 'l_name', 'Library name init shorcut error') n = Netlist('n_name') self.assertEqual(n.name, 'n_name', 'Netlist name init shorcut error') i = Instance('i_name') self.assertEqual(i.name, 'i_name', 'Instance name init shorcut error') c = Cable('c_name') self.assertEqual(c.name, 'c_name', 'Cable name init shorcut error') p = Port('p_name') self.assertEqual(p.name, 'p_name', 'Port name init shorcut error')
def test_if_leaf_shortcut(self): instance = Instance() definition = Definition() instance.reference = definition self.assertEqual(definition.is_leaf(), instance.is_leaf(), 'is_leaf shortcut error') definition.create_cable() instance.reference = definition self.assertEqual(definition.is_leaf(), instance.is_leaf(), 'is_leaf shortcut error')
def test_properties_init_shortcut(self): d = Definition('d_name',{'key1':1, 'key2':'value2' }) self.assertEqual(d['key1'], 1, 'Definition properties init shorcut error') l = Library('l_name',{'key1':'value1', 'key2':'value2' }) self.assertEqual(l['key1'], 'value1', 'Library properties init shorcut error') n = Netlist('n_name',{'key1':'value1', 'key2': 63 }) self.assertEqual(n['key2'], 63, 'Netlist properties init shorcut error') i = Instance('i_name',{'key1':'value1', 'key2':'value2' }) self.assertEqual(i['key1'], 'value1', 'Instance properties init shorcut error') c = Cable('c_name',{'key1':'value1', 'key2':'value2' }) self.assertEqual(c['key2'], 'value2', 'Cable properties init shorcut error') p = Port('p_name',{'key1':'value1', 'key2':'value2' }) self.assertEqual(p['key1'], 'value1', 'Port properties init shorcut error')
def parse_verilog(self): params = dict() token = self.tokenizer.next() line_num = self.tokenizer.line_number self.netlist = Netlist() self.primitive_cell = False top_next = False while token: if token == '`celldefine': self.primitive_cell = True elif self.primitive_cell and token == "`endcelldefine": self.primitive_cell = False elif token == "(": token = self.tokenizer.next() assert token == "*", "unexpected ( with out a *" + " " + str( self.tokenizer.line_number) k, v = self.parse_star_parameters() if k == "STRUCTURAL_NETLIST": top_next = True k = "VERILOG.star." + k params[k] = v elif token == "module": definition = self.parse_module(params, self.netlist) #if netlist.top_instance is None: if top_next == True: instance = Instance() instance.name = definition.name instance.reference = definition self.netlist.top_instance = instance top_next = False elif token[:2] == "//": pass #comment elif token == "primitive": while token != "endprimitive": token = self.tokenizer.next() else: #print("unsorted token", token) pass #unsorted token if self.tokenizer.has_next(): token = self.tokenizer.next() line_num = self.tokenizer.line_number else: token = None for instance, port_map in self.instance_to_port_map.items(): port_pin_map = dict() for port in instance.reference.ports: port_pin_map[port] = [] for pin in instance.pins: port_pin_map[pin.inner_pin.port].append(pin) definition = instance.parent for port_name, cable_list in port_map.items(): index_offset = 0 for cable_name in cable_list: low = None high = None index_offset_initial = index_offset if cable_name[len(cable_name) - 1] == "]" and ( cable_name[0] != "\\" or len(cable_name.split(" ")) > 1): cable_name_real, index = cable_name.split(" ") indicies = index[1:len(index) - 1].split(":") if len(indicies) == 1: low = int(indicies[0]) high = None else: low = min(int(indicies[0]), int(indicies[1])) high = max(int(indicies[0]), int(indicies[1])) else: cable_name_real = cable_name cable_def_list = definition.get_cables(cable_name_real) cable = next(cable_def_list) port_list = instance.reference.get_ports(port_name) port = next(port_list) if low == None and high == None: if len(cable.wires) == len(port_pin_map[port]): for i in range(len(cable.wires)): cable.wires[i].connect_pin( port_pin_map[port][i + index_offset_initial]) index_offset += 1 else: for i in range( min(len(port_pin_map[port]), len(cable.wires))): cable.wires[i].connect_pin( port_pin_map[port][i + index_offset_initial]) index_offset += 1 else: if high == None: # try: cable.wires[low - cable.lower_index].connect_pin( port_pin_map[port][0 + index_offset_initial]) # except Exception: # import pdb; pdb.set_trace() index_offset += 1 else: for i in range(low, high + 1): cable.wires[i - cable.lower_index].connect_pin( port_pin_map[port][i - low + index_offset_initial]) index_offset += 1 return self.netlist
def test_hRef_shortcut(self): item = Instance("myCable") def2 = Definition("Hello") item.reference = def2 hr = HRef(item) self.assertEqual(hr.item.name,item.name,'Href item shorcut error')