| #!/usr/bin/env python3 |
| # Copyright 2020 The Skywater PDK Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import argparse |
| import glob |
| import os |
| import pprint |
| import re |
| import subprocess |
| import sys |
| import traceback |
| |
| from collections import defaultdict |
| from shutil import copyfile, move |
| from pathlib import Path |
| |
| from common import lib_extract_from_path, version_extract_from_path, lib_extract_from_name, get_cell_directory, extract_version_and_lib_from_path, copy_file_to_output |
| from common import convert_libname, convert_cell_fullname, convert_pinname |
| from verilog2full import Copyright_header |
| |
| superdebug = False |
| debug = True |
| debug_print = lambda x: print(x) if debug else 0 |
| |
| Copyright_header = """/*\n |
| * Copyright 2020 The SkyWater PDK Authors\n |
| *\n |
| * Licensed under the Apache License, Version 2.0 (the "License");\n |
| * you may not use this file except in compliance with the License.\n |
| * You may obtain a copy of the License at\n |
| *\n |
| * https://www.apache.org/licenses/LICENSE-2.0\n |
| *\n |
| * Unless required by applicable law or agreed to in writing, software\n |
| * distributed under the License is distributed on an "AS IS" BASIS,\n |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n |
| * See the License for the specific language governing permissions and\n |
| * limitations under the License.\n |
| */\n |
| \n |
| """ |
| |
| def prepend_copyright(filename): |
| with open(filename, 'r+') as f: |
| content = f.read() |
| content = content.replace(Copyright_header, '') |
| f.seek(0, 0) |
| f.write(Copyright_header + content) |
| |
| |
| def _magic_tcl_header(ofile, gdsfile): |
| print('#!/bin/env wish', file=ofile) |
| print('drc off', file=ofile) |
| print('gds readonly true', file=ofile) |
| print('gds rescale false', file=ofile) |
| print('tech unlock *', file=ofile) |
| print('cif warning default', file=ofile) |
| print('gds read ' + gdsfile, file=ofile) |
| |
| |
| def magic_get_cells(input_gds, input_techfile): |
| destdir, gdsfile = os.path.split(input_gds) |
| tcl_path = destdir + '/get_cells.tcl' |
| |
| # Generate a tcl script for Magic |
| with open(tcl_path, 'w') as ofile: |
| _magic_tcl_header(ofile, gdsfile) |
| print('quit -noprompt', file=ofile) |
| return run_magic(destdir, tcl_path, input_techfile) |
| |
| |
| def magic_rename_cells(input_gds, input_techfile, cell_list): |
| destdir, gdsfile = os.path.split(input_gds) |
| tcl_path = destdir + '/rename_cells.tcl' |
| |
| # Generate a tcl script for Magic |
| with open(tcl_path, 'w') as ofile: |
| _magic_tcl_header(ofile, gdsfile) |
| |
| # Rename the cells |
| for src_cell, dst_cell in cell_list: |
| escaped_src_cell = '{'+src_cell+'}' |
| escaped_dst_cell = '{'+dst_cell+'}' |
| print(f'load {escaped_src_cell}', file=ofile) |
| if src_cell != dst_cell: |
| print(f'cellname rename {escaped_src_cell} {escaped_dst_cell}', file=ofile) |
| print(f'save {escaped_dst_cell}', file=ofile) |
| |
| print('quit -noprompt', file=ofile) |
| return run_magic(destdir, tcl_path, input_techfile) |
| |
| |
| def magic_split_gds(input_gds, input_techfile, cell_list): |
| destdir, gdsfile = os.path.split(input_gds) |
| tcl_path = destdir + '/split_gds.tcl' |
| |
| # Generate a tcl script for Magic |
| with open(tcl_path, 'w') as ofile: |
| _magic_tcl_header(ofile, gdsfile) |
| |
| # Write out the cells |
| for cell in cell_list: |
| escaped_cell = '{'+cell+'}' |
| print(f'load {escaped_cell}', file=ofile) |
| print(f'gds write {escaped_cell}', file=ofile) |
| print(f'lef write {escaped_cell}', file=ofile) |
| print(f'save {escaped_cell}', file=ofile) |
| |
| print('quit -noprompt', file=ofile) |
| return run_magic(destdir, tcl_path, input_techfile) |
| |
| |
| FATAL_ERROR = re.compile('Error parsing') |
| READING_REGEX = re.compile('Reading "([^"]*)".') |
| |
| |
| def run_magic(destdir, tcl_path, input_techfile): |
| mproc = subprocess.run(['magic', '-dnull', '-noconsole', |
| '-T', input_techfile, os.path.abspath(tcl_path)], |
| stdin = subprocess.DEVNULL, |
| stdout = subprocess.PIPE, |
| stderr = subprocess.STDOUT, |
| cwd = destdir, |
| universal_newlines = True) |
| assert mproc.stdout |
| |
| max_cellname_width = 0 |
| output_by_cells = [('', [])] |
| fatal_errors = [] |
| for line in mproc.stdout.splitlines(): |
| if line.startswith('CIF file read warning: Input off lambda grid by 1/2; snapped to grid'): |
| continue |
| m = FATAL_ERROR.match(line) |
| if m: |
| fatal_errors.append(line) |
| m = READING_REGEX.match(line) |
| if m: |
| cell_name = m.group(1) |
| max_cellname_width = max(max_cellname_width, len(cell_name)) |
| output_by_cells.append((cell_name, [])) |
| output_by_cells[-1][-1].append(line) |
| |
| for cell, lines in output_by_cells: |
| prefix = "magic " + cell.ljust(max_cellname_width) + ':' |
| for l in lines: |
| is_error = 'rror' in l |
| if superdebug or (debug and is_error): |
| print(prefix, l) |
| |
| assert not mproc.stderr, mproc.stderr |
| |
| if fatal_errors: |
| msg = 'ERROR: Magic had fatal errors in output:\n' + "\n".join(fatal_errors) |
| raise SystemError(msg) |
| |
| if mproc.returncode != 0: |
| msg = 'ERROR: Magic exited with status ' + str(mproc.returncode) |
| print(msg) |
| raise SystemError(msg) |
| |
| return output_by_cells |
| |
| |
| class Rewriter: |
| |
| other_replacements = [ |
| (re.compile('S8PIR[_-]10R', re.I), |
| lambda m: 'SKY130'), |
| (re.compile('S8', re.I), |
| lambda m: 'SKY130'), |
| ] |
| |
| def __init__(self, original_path): |
| self._cache_libname = None |
| self._cache_cellname = {} |
| self._cache_string = {} |
| |
| self.structures_reset() |
| |
| self.old_lib, self.new_lib, self.version = extract_version_and_lib_from_path(original_path) |
| |
| self.rewrite_string = self.rewrite_generic_string |
| |
| def structures(self): |
| return dict(self._structures) |
| |
| def structures_usecount(self): |
| structs = list(self._structures_instances.items()) |
| max_count = max(c for n, c in structs) |
| structs.sort(key=lambda x: (max_count-x[1], x[1])) |
| return structs |
| |
| def structures_reset(self): |
| self._structures = {} |
| self._structures_instances = {} |
| self._structures_pins = {} |
| self._structure_last = None |
| |
| def replacements(self): |
| r = [] |
| r.append((self._cache_libname, self.new_lib)) |
| r.extend(self._cache_cellname.items()) |
| r.extend(self._cache_string.items()) |
| |
| return dict(r) |
| |
| def rewrite_library_name(self, s): |
| if self._cache_libname is not None: |
| assert s == self._cache_libname, (s, self._cache_libname) |
| else: |
| self._cache_libname = s |
| return self.new_lib |
| |
| def set_library_name(self, s): |
| return |
| |
| def _convert_cell(self, old_name, is_real_structure=True): |
| if '$$' in old_name: |
| old_cellname, number = old_name.split('$$', 1) |
| self.rewrite_structure_name(old_cellname, False) |
| |
| new_name = convert_cell_fullname(old_name, self.new_lib) |
| assert new_name.startswith(self.new_lib), (new_name, self.new_lib) |
| assert old_name not in self._cache_cellname, (old_name, self._cache_cellname) |
| self._cache_cellname[old_name] = new_name |
| |
| def pins(self, s): |
| return self._structures_pins[s] |
| |
| def rewrite_structure_name(self, s, is_real_structure=True): |
| assert (not is_real_structure) or (s in self._structures), s |
| if s not in self._cache_cellname: |
| self._convert_cell(s, is_real_structure) |
| ns = self._cache_cellname[s] |
| if is_real_structure: |
| assert s in self._structures, repr((s, ns))+'\n'+pprint.pformat(self._structures) |
| assert self._structures[s] is None, repr((sn, self._structures[s]))+'\n'+pprint.pformat(self._structures) |
| self._structures[s] = ns |
| |
| return ns |
| |
| def set_structure_name(self, sn): |
| assert sn not in self._structures, sn+'\n'+pprint.pformat(self._structures) |
| |
| if debug: |
| if self._structure_last != None: |
| print("Clearing current structure (was", self._structure_last+")") |
| print() |
| |
| self._structures[sn] = None |
| self._structures_instances[sn] = 0 |
| self._structures_pins[sn] = [] |
| self._structure_last = sn |
| |
| if debug: |
| print() |
| print("Setting current structure to", self._structure_last) |
| |
| def set_instance_struct(self, s): |
| assert s in self._structures, (s, self._structures) |
| self._structures_instances[s] += 1 |
| if debug: |
| if self._structure_last != None: |
| print("Clearing current structure (was", self._structure_last+")") |
| print() |
| self._structure_last = None |
| |
| def rewrite_instance_struct(self, s): |
| assert s in self._cache_cellname, (s, self._cache_cellname) |
| return self._cache_cellname[s] |
| |
| def rewrite_pin_name(self, s): |
| assert self._structure_last is not None, s |
| pn = convert_pinname(s.upper()) |
| print(" Rewriting pin on", self._structure_last, "from", repr(s), "to", repr(pn)) |
| self._structures_pins[self._structure_last].append(pn) |
| return pn |
| |
| overrides = { |
| ('sky130_fd_sc_hvl','scs8ls', 'inv_2'): 'scs8hvl_inv_2', |
| ('sky130_fd_sc_hvl','scs8ls', 'inv_4'): 'scs8hvl_inv_4', |
| ('sky130_fd_sc_ls', 'scs8ms', 'tapvgndnovpb_1'): 'scs8ls_tapvgndnovpb_1', |
| ('sky130_fd_sc_ls', 'scs8lp', 'diode_2'): 'scs8ls_diode_2', |
| ('sky130_fd_sc_ls', 'scs8lp', 'tap_2'): 'scs8ls_tap_2', |
| ('sky130_fd_sc_ls', 'scs8ms', 'tapvgnd2_1'): 'scs8ls_tapvgnd2_1', |
| ('sky130_fd_sc_ls', 'scs8ms', 'tapvgnd_1'): 'scs8ls_tapvgnd_1', |
| ('sky130_fd_sc_ls', 'scs8ms', 'tapvpwrvgnd_1'): 'scs8ls_tapvpwrvgnd_1', |
| ('sky130_fd_sc_ms', 'scs8ls', 'clkdlyinv3sd1_1'): 'scs8ms_clkdlyinv3sd1_1', |
| ('sky130_fd_sc_ms', 'scs8ls', 'clkdlyinv3sd2_1'): 'scs8ms_clkdlyinv3sd2_1', |
| ('sky130_fd_sc_ms', 'scs8ls', 'clkdlyinv3sd3_1'): 'scs8ms_clkdlyinv3sd3_1', |
| ('sky130_fd_sc_ms', 'scs8ls', 'clkdlyinv5sd1_1'): 'scs8ms_clkdlyinv5sd1_1', |
| ('sky130_fd_sc_ms', 'scs8lp', 'dlygate4s15_1'): 'scs8ms_dlygate4s15_1', |
| ('sky130_fd_sc_ms', 'scs8ls', 'tap_1'): 'scs8ms_tap_1', |
| ('sky130_fd_sc_ms', 'scs8lp', 'tap_2'): 'scs8ms_tap_2', |
| } |
| |
| def rewrite_generic_string(self, old_str): |
| if old_str in self._cache_string: |
| return self._cache_string[old_str] |
| |
| # Is this a simple cell name string? |
| if old_str in self._cache_cellname: |
| cell_fullname = self._cache_cellname[old_str] |
| lib_name, cell_name = cell_fullname.split('__', 1) |
| print("Rewriting string (cell name) from", repr(old_str), "to", repr(cell_name)) |
| return cell_name |
| |
| # Check this isn't for a different library.... |
| ext_libname, ext_cellname = lib_extract_from_name(old_str) |
| okey = (self.new_lib, ext_libname, ext_cellname) |
| if okey in self.overrides: |
| override = self.overrides[okey] |
| print('Overriding {} with {}'.format(old_str, override)) |
| return self.rewrite_generic_string(override) |
| elif (self.new_lib, ext_libname) == ('sky130_fd_sc_hdll', 'scs8hd'): |
| override = 'scs8hdll_'+ext_cellname |
| print('Overriding {} with {}'.format(old_str, override)) |
| return self.rewrite_generic_string(override) |
| else: |
| assert ext_libname is None or ext_libname == self.old_lib, ( |
| old_str, ext_libname, ext_cellname, self.old_lib) |
| |
| # Does this string contain a cell name? |
| new_str = old_str |
| for old_cellname, new_cellname in self._cache_cellname.items(): |
| if old_cellname in new_str: |
| new_str = new_str.replace(old_cellname, new_cellname) |
| |
| # Does this contain other things needed to replaced? |
| for regex, rep in self.other_replacements: |
| new_str = regex.sub(rep, new_str) |
| |
| self._cache_string[old_str] = new_str |
| print("Rewriting string from", repr(old_str), "to", repr(new_str)) |
| return new_str |
| |
| def set_string_type(self, i): |
| if i == 5: |
| if superdebug: |
| print("Next string is a pin name on", self._structure_last) |
| self.rewrite_string = self.rewrite_pin_name |
| else: |
| if superdebug: |
| print("Next string is a generic string") |
| self.rewrite_string = self.rewrite_generic_string |
| |
| |
| |
| def replace_gds_strings(gds_filename, call_rewrite_on_rtypes, rewriter): |
| source = gds_filename |
| dest = gds_filename |
| |
| sourcedir, gdsinfile = os.path.split(source) |
| destdir, gdsoutfile = os.path.split(dest) |
| |
| with open(source, 'rb') as ifile: |
| gdsdata = bytearray(ifile.read()) |
| |
| # If we are rewriting the structure names, we need to rewrite the instances |
| # which point to the structure. |
| if 'structure_name' in call_rewrite_on_rtypes: |
| call_rewrite_on_rtypes.append('instance_struct') |
| |
| rtype_mapping = { |
| 2: 'library_name', # libname |
| 6: 'structure_name', # strname - Structure Definition Name |
| 18: 'instance_struct',# sname - Instance's structure |
| 22: 'string_type', # Indicates what the next string is in reference too.. |
| 25: 'string', # string |
| } |
| rtype_rmapping = {v:k for k,v in rtype_mapping.items()} |
| |
| call_set_on_rtype = ['structure_name', 'instance_struct', 'string_type'] |
| |
| for r in call_rewrite_on_rtypes: |
| assert r in rtype_rmapping, r |
| |
| datalen = len(gdsdata) |
| if superdebug: |
| print('Original data length = ' + str(datalen)) |
| dataptr = 0 |
| while dataptr < datalen: |
| # Read stream records up to any string, then search for search text. |
| bheader = gdsdata[dataptr:dataptr + 2] |
| reclen = int.from_bytes(bheader, 'big') |
| newlen = reclen |
| |
| # The GDS files seem to occasionally end up with trailing zero bytes. |
| if newlen == 0: |
| if debug: |
| print("{:10d} (of {:10d} - {:10d} left)".format(dataptr, datalen, datalen-dataptr), 'Found zero-length record at position in', source) |
| if superdebug: |
| print('Remaining data', repr(gdsdata[dataptr:])) |
| for i in range(dataptr, datalen): |
| if gdsdata[i] != 0: |
| raise SystemError('Found non-zero pad byte at {} ({}): {}'.format(i, hex(i), repr(gdsdata[i]))) |
| break |
| |
| rtype = gdsdata[dataptr + 2] |
| rtype_name = rtype_mapping.get(rtype, '??? - {}'.format(rtype)) |
| datatype = gdsdata[dataptr + 3] |
| |
| # FIXME: Hack to use different method for pin names... |
| if datatype == 2 and rtype_name in call_set_on_rtype: |
| assert datatype == 2, (rtype, datatype) |
| value = int.from_bytes(gdsdata[dataptr+4:dataptr+6], 'big') |
| if superdebug: |
| print( |
| "{:10d} (of {:10d} - {:10d} left)".format(dataptr, datalen, datalen-dataptr), |
| 'Record type = {:15s} '.format(rtype_name), |
| value, |
| ) |
| getattr(rewriter, 'set_'+rtype_name)(value) |
| |
| # Datatype 6 is STRING |
| if datatype == 6: |
| bstring = gdsdata[dataptr + 4: dataptr + reclen] |
| |
| if bstring[-1] == 0: |
| # Was original string padded with null byte? If so, |
| # remove the null byte. |
| decoded = bstring[:-1].decode('ascii') |
| else: |
| decoded = bstring.decode('ascii') |
| |
| if rtype_name in call_set_on_rtype: |
| getattr(rewriter, 'set_'+rtype_name)(decoded) |
| |
| if rtype_name in call_rewrite_on_rtypes: |
| skipped = False |
| repstring = getattr(rewriter, 'rewrite_'+rtype_name)(decoded) |
| else: |
| skipped = True |
| repstring = decoded |
| assert repstring is not None |
| |
| changed = (decoded != repstring) |
| if superdebug: |
| print( |
| "{:10d} (of {:10d} - {:10d} left)".format(dataptr, datalen, datalen-dataptr), |
| 'Record type = {:15s} '.format(rtype_name), |
| 'Skipped = {:5s}'.format(str(skipped)), |
| end=" ", |
| ) |
| if changed: |
| print(repr(decoded), '->', repr(repstring)) |
| else: |
| print(repr(decoded), '==', repr(repstring)) |
| |
| brepstring = repstring.encode('ascii') |
| newlen = len(brepstring) + 4 |
| |
| # Record sizes must be even |
| if newlen % 2 != 0: |
| brepstring += b'\x00' |
| newlen += 1 |
| |
| if changed: |
| #before = gdsdata[0:dataptr] |
| #after = gdsdata[dataptr + reclen:] |
| |
| bnewlen = newlen.to_bytes(2, byteorder='big') |
| brtype = rtype.to_bytes(1, byteorder='big') |
| bdatatype = datatype.to_bytes(1, byteorder='big') |
| |
| # Assemble the new record |
| newrecord = bnewlen + brtype + bdatatype + brepstring |
| |
| # Reassemble the GDS data around the new record |
| #gdsdata = before + newrecord[0:newlen] + after |
| gdsdata[dataptr:dataptr+reclen] = newrecord[0:newlen] |
| |
| # Adjust the data end location |
| datalen += (newlen - reclen) |
| |
| # Advance the pointer past the data |
| dataptr += newlen |
| |
| with open(dest, 'wb') as ofile: |
| ofile.write(gdsdata) |
| |
| |
| def strings_get(pathname): |
| string_counts = {} |
| lines = subprocess.check_output( |
| "strings {} | sort | uniq -c".format(pathname), shell=True).decode('utf-8').splitlines() |
| for l in lines: |
| c, s = l.strip().split(' ', 1) |
| string_counts[s] = int(c) |
| return string_counts |
| |
| |
| def strings_print(h, strings): |
| max_len = max(len(s) for s in strings.keys()) |
| max_count = max(strings.values()) |
| print() |
| print(h) |
| print("---") |
| for s, c in sorted(strings.items(), key=lambda x: (max_count-x[-1], x[0])): |
| print(" ", s.rjust(max_len)+':', c) |
| print("---") |
| |
| |
| def filemain(input_path, temp_dir, techfile, final_dir): |
| assert not os.path.exists(temp_dir), temp_dir+" exists!" |
| os.makedirs(temp_dir) |
| |
| global debug_print |
| |
| tmp_gds = temp_dir + '/input.gds' |
| copyfile(input_path, tmp_gds) |
| |
| rewriter = Rewriter(input_path) |
| |
| # First rewrite the cell names |
| if debug: |
| print() |
| print("Rewriting library and structure names") |
| print("-------------------------------------") |
| replace_gds_strings(tmp_gds, ['library_name', 'structure_name'], rewriter) |
| if debug: |
| print("-------------------------------------") |
| |
| cell_rewrites = list(rewriter.structures().items()) |
| if not cell_rewrites: |
| print("WARNING: No cells found!") |
| return |
| |
| pprint.pprint(cell_rewrites) |
| |
| # Write out the cell list |
| with open(temp_dir + '/cells.list', 'w') as f: |
| max_len = max(len(s) for s in cell_rewrites) |
| for from_str, to_str in sorted(cell_rewrites): |
| f.write(" {:s} -> {:s}".format(from_str.rjust(max_len), to_str)) |
| f.write('\n') |
| |
| # Second rewrite any remaining strings. |
| # ----- |
| # The strings could have references to cell names and there is no guarantee |
| # that the cell instance definition will appear before a string which |
| # happens to contain the name. |
| # Hence, we want to know all the cell rewrites before rewriting strings. |
| if debug: |
| print() |
| print("Rewriting strings (inc pin names)") |
| print("-------------------------------------") |
| rewriter.structures_reset() |
| replace_gds_strings(tmp_gds, ['string'], rewriter) |
| if debug: |
| print("-------------------------------------") |
| |
| if debug: |
| strings_print("Strings in GDS file:", strings_get(tmp_gds)) |
| |
| structs = list(rewriter.structures_usecount()) |
| with open(temp_dir + '/structures.list', 'w') as f: |
| f.write("Structures ({} found)\n".format(len(structs))) |
| f.write("----------------------\n") |
| for name, count in structs: |
| f.write("{:10d} {:s}\n".format(count, name)) |
| for pin in rewriter.pins(name): |
| f.write("{:10s} - {}\n".format('', pin)) |
| f.write('\n') |
| for name, count in structs: |
| with open(os.path.join(temp_dir, name+'.gds.pins'), 'w') as f: |
| for pin in rewriter.pins(name): |
| f.write(pin) |
| f.write('\n') |
| with open(os.path.join(temp_dir, name+'.lef.pins'), 'w') as f: |
| for pin in rewriter.pins(name): |
| f.write(pin) |
| f.write('\n') |
| |
| # Write out the rewrite list |
| with open(temp_dir + '/rewrite.list', 'w') as f: |
| r = rewriter.replacements() |
| max_len = max(len(x) for x in r) |
| for from_str, to_str in sorted(r.items()): |
| f.write(from_str.rjust(max_len)) |
| f.write(" -> ") |
| f.write(to_str) |
| f.write('\n') |
| |
| filtered_cells = [] |
| for name in rewriter.structures(): |
| if 'libcell' in name: |
| continue |
| if 'vcells' in name: |
| continue |
| filtered_cells.append(name) |
| filtered_cells.sort() |
| |
| # Split apart the GDS file |
| output_by_cells = magic_split_gds(tmp_gds, os.path.abspath(techfile), filtered_cells) |
| |
| for new_cellname in filtered_cells: |
| lef_file = os.path.join(temp_dir, new_cellname+'.lef') |
| lef_pin_file = os.path.join(temp_dir, new_cellname+'.lef.pins') |
| gds_file = os.path.join(temp_dir, new_cellname+'.gds') |
| gds_pin_file = os.path.join(temp_dir, new_cellname+'.gds.pins') |
| assert os.path.exists(lef_file), ("Missing lef:", lef_file) |
| assert os.path.exists(gds_file), ("Missing gds:", gds_file) |
| |
| # LEF file -> output |
| prepend_copyright(lef_file) |
| final_path = copy_file_to_output( |
| lef_file, final_dir, rewriter.new_lib, rewriter.version, new_cellname, okay_exists=True) |
| # LEF PINS file -> output |
| if final_path: |
| copy_file_to_output( |
| lef_pin_file, final_dir, rewriter.new_lib, rewriter.version, new_cellname) |
| |
| # GDS file -> output |
| subprocess.check_call(CHANGE_GDS_DATE+" 1 0 "+gds_file, shell=True) |
| copy_file_to_output( |
| gds_file, final_dir, rewriter.new_lib, rewriter.version, new_cellname) |
| |
| # GDS PINS file -> output |
| copy_file_to_output( |
| gds_pin_file, final_dir, rewriter.new_lib, rewriter.version, new_cellname) |
| |
| return |
| |
| |
| __dir__ = os.path.dirname(os.path.realpath(__file__)) |
| CHANGE_GDS_DATE = os.path.join(__dir__, 'change_gds_date.py') |
| |
| |
| def main(args, infile): |
| if not os.path.isfile(infile): |
| all_input_files = sorted(infile.rglob('*.gds')) |
| for f in all_input_files: |
| f = str(f) |
| main(args, os.path.join(infile, f)) |
| else: |
| infile = str(infile) |
| if 'scs8' in infile and 'oa' not in infile: |
| print("Skipping", infile) |
| return 0 |
| if 'vcells_drc' in infile: |
| print("Skipping", infile) |
| return 0 |
| path = os.path.abspath(infile) |
| ver = version_extract_from_path(path) |
| if ver is None: |
| ver = 'XXXX' |
| else: |
| ver = "v{}.{}.{}".format(*ver) |
| |
| filename = os.path.basename(path) |
| tempdir = os.path.join(args.temp, 'gds_split', filename, ver) |
| print() |
| print() |
| print("Processing", filename, "in", tempdir) |
| print('-'*75) |
| try: |
| filemain(path, tempdir, args.techfile, str(args.output)) |
| except Exception as e: |
| sys.stdout.flush() |
| sys.stderr.flush() |
| |
| traceback.print_exc(file=sys.stdout) |
| |
| # Write error to stdout |
| sys.stdout.write('\n') |
| sys.stdout.write('\n') |
| sys.stdout.write('Error while processing: ') |
| sys.stdout.write(infile) |
| sys.stdout.write('\n') |
| sys.stdout.flush() |
| |
| # Write error to stderr too |
| sys.stderr.write('\n') |
| sys.stderr.write('\n') |
| sys.stderr.write('Error while processing: ') |
| sys.stderr.write(infile) |
| sys.stderr.write('\n') |
| sys.stderr.flush() |
| |
| raise |
| |
| print('-'*75) |
| |
| |
| if __name__ == "__main__": |
| import doctest |
| fails, _ = doctest.testmod() |
| if fails != 0: |
| sys.exit("Some test failed") |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "input", |
| help="The path to the source directory/file", |
| type=Path) |
| parser.add_argument( |
| "output", |
| help="The path to the output directory", |
| type=Path) |
| parser.add_argument( |
| "techfile", |
| help="Full path to the techfile", |
| type=str) |
| parser.add_argument( |
| "temp", |
| help="The path to the temp directory", |
| type=Path) |
| args = parser.parse_args() |
| main(args, args.input) |
