| #!/usr/bin/env python3 |
| import re |
| import argparse |
| RECT_REGEX = r"\s*RECT\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+;\s+" |
| SIZE_REGEX = r"^\s*SIZE\s+(-?\d+\.?\d*)\s+BY\s+(-?\d+\.?\d*)\s+;$" |
| LAYER_REGEX = r'LAYER\s+(\S+)\s+;\s+((RECT\s+-?\d+\.?\d*\s+-?\d+\.?\d*\s+-?\d+\.?\d*\s+-?\d+\.?\d*\s+;\s+)*)' |
| PINS_REGEX = r'PIN\s+(\S+).*PORT\s+(.*;\s+)END.*END\s+\1\n' |
| PLACED_COMP_REGEX = r"^\s*-\s+([^\s]+)\s+([^\s]+)\s+\+\s+PLACED\s+\(\s(-?\d+)\s(-?\d+)\s\)\s+([NEWS])\s+;$" |
| PIN_IGNORE = ['VSS', 'VDD', 'PAD', 'in3v', 'vdd'] |
| NETS_IGNORE = ['vdd', 'vss'] |
| NETSECTION_REGEX = r"^NETS\s+\S+\s+;\s+(.*)END NETS\s+" |
| # \s+([NEWS])\s+;$" |
| def getMacroPins(content, macro_name): |
| """ |
| -> (macro_size(sz_x, sz_y), pins:{layer:array of rectangles} ) |
| """ |
| macro = [s for s in content if macro_name in s][0] |
| pins = re.findall(PINS_REGEX, macro, re.M | re.DOTALL) |
| size = re.findall(SIZE_REGEX, macro, re.M | re.DOTALL) |
| pins_ds = {} |
| ds = {} |
| for pin in pins: |
| name = pin[0] |
| #print(pin[1]) |
| layers = re.findall(LAYER_REGEX, pin[1], re.M | re.DOTALL) |
| for layer in layers: |
| layer_name = layer[0] |
| rectangles_s = re.findall(RECT_REGEX, layer[1], re.M | re.DOTALL) |
| rectangles = [] |
| for rectangle in rectangles_s: |
| rectangles.append(tuple([float(num) for num in rectangle])) |
| pins_ds.setdefault(name, []) |
| pins_ds[name] += [(layer_name, rectangles)] |
| ds["pins"] = pins_ds |
| ds["_sz_x"] = float(size[0][0]) |
| ds["_sz_y"] = float(size[0][1]) |
| # print(ds) |
| return ds |
| def getDefComponents(comp_section): |
| placed_comps = re.findall(PLACED_COMP_REGEX, comps_section, re.M | re.DOTALL) |
| ds = {} |
| for comp in placed_comps: |
| ds[comp[0]] = {} |
| ds[comp[0]]["macro"] = comp[1] |
| ds[comp[0]]["pos"] = (int(comp[2]), int(comp[3])) |
| ds[comp[0]]["orientation"] = comp[4] |
| # print(ds) |
| return ds |
| def getNetsDict(def_file): |
| nets_section = re.findall(NETSECTION_REGEX, content, re.M | re.DOTALL) |
| |
| nets = filter(None, nets_section[0].replace('\n', ' ').split("- ")) |
| nets_dict = {} |
| for net in nets: |
| net_name = re.findall(r"\s*(\S+).*;",net) |
| if any(net_name[0].find(net_ignore) != -1 for net_ignore in NETS_IGNORE): |
| continue |
| connections = re.findall(r"\(\s+(.*?)\s+\)",net) |
| connections = [connection.replace('\\','') for connection in connections] |
| nets_dict[net_name[0]] = connections |
| #print(net_name, connections) |
| |
| return nets_dict |
| |
| parser = argparse.ArgumentParser( |
| description='Pads to ios') |
| parser.add_argument('--inputLef', '-il', required=True, help='Input Lef', nargs='+') |
| parser.add_argument('--inputDef', '-id', required=True, help='Input Def', nargs='+') |
| parser.add_argument('--inputDefNets', '-idn', required=True, help='Input Def') |
| args = parser.parse_args() |
| # parsing netsdef |
| f = open(args.inputDefNets) |
| content = f.read() |
| f.close() |
| nets_dict = getNetsDict(content) |
| |
| # parsing lef |
| f = open(args.inputLef[0]) |
| content = f.read() |
| f.close() |
| pattern = r"^MACRO.*?^END\s\S+" |
| all_macros_content = re.findall(pattern, content, re.M | re.DOTALL) |
| # parsing def |
| f = open(args.inputDef[0]) |
| content = f.read() |
| f.close() |
| pattern = r"^COMPONENTS.*?^END COMPONENTS$" |
| comps_section = re.findall(pattern, content, re.M | re.DOTALL)[0] # extract COMPONENTS section |
| comps = getDefComponents(comps_section) ## |
| pin_section = """""" |
| pin_cnt = 0 |
| macro_db = {} |
| for comp in comps: |
| if (comp.find('FILL') != -1): |
| continue |
| comp_data = comps[comp] |
| macro_data = macro_db.setdefault(comp_data["macro"], getMacroPins(all_macros_content, comp_data["macro"])) |
| sz_x = macro_data["_sz_x"] |
| sz_y = macro_data["_sz_y"] |
| pos_x = comp_data["pos"][0] |
| pos_y = comp_data["pos"][1] |
| orientation = comp_data["orientation"] |
| if orientation == "E": |
| pos_y += int(sz_x*1000) |
| elif orientation == "W": |
| pos_x += int(sz_y*1000) |
| elif orientation == "S": |
| pos_y += int(sz_y*1000) |
| pos_x += int(sz_x*1000) |
| for pin in macro_data["pins"]: |
| if any(pin.find(pin_ignore) != -1 for pin_ignore in PIN_IGNORE): |
| continue |
| pin_data = macro_data["pins"][pin] |
| # print(pin_data) |
| #pin_tag = comp+"."+comp_data["macro"]+'.'+pin |
| pin_tag = comp+" "+pin |
| found = False |
| for net in nets_dict: |
| if pin_tag in nets_dict[net]: |
| pin_tag = net |
| found = True |
| break |
| if not found: |
| continue |
| pin_cnt += 1 |
| pin_section += "- %s + NET %s\n+ PLACED ( %d %d ) %s" % \ |
| (pin_tag, pin_tag, pos_x, pos_y, orientation) |
| for layer in pin_data: |
| layer_name = layer[0] |
| for rect in layer[1]: |
| pin_section += "\n+ LAYER %s ( %d %d ) ( %d %d )" % \ |
| (layer_name, rect[0]*1000, rect[1]*1000, rect[2]*1000, rect[3]*1000) + ' ' |
| pin_section += ";\n\n" |
| pin_section = "PINS %d ;\n%s\nEND PINS" % (pin_cnt, pin_section) |
| print(pin_section) |
