| #!/usr/bin/env python3 |
| # |
| # rename_project.py --- Perform all tasks required for renaming a project. |
| # |
| # In the context of this script, "renaming" a project means changing the |
| # 'ip-name' entry in the JSON file and all that that implies. To create a |
| # new project with an existing ip-name is essentially a trivial process of |
| # renaming the parent directory. |
| # |
| # Note that when a catalog entry is generated in the marketplace, the entry's |
| # default name is taken from the parent directory name, not the ip-name. The |
| # resulting entry name is irrelevant to most everything except how and where |
| # the IP is listed in the catalog. The read-only IP version has the name of |
| # the ip-name. Implies it is important that ip-name does not collide with |
| # the ip-name of anything else in the marketplace catalog (but this is not |
| # currently enforced). |
| # |
| # Modified 12/20/2018: New protocol is that the .json file is always called |
| # 'project.json' and does not take the name of the parent directory. This |
| # makes projects more portable. |
| # |
| import shutil |
| import json |
| import stat |
| import sys |
| import os |
| import re |
| |
| """ |
| This module converts an entire project from one ip-name to another, making |
| sure that all filenames and file contents are updated. |
| """ |
| |
| def copy_meta_with_ownership(src, dst, follow_symlinks=False): |
| # Copy file metadata using copystat() and preserve ownership through stat calls. |
| file_stat = os.stat(src) |
| owner = file_stat[stat.ST_UID] |
| group = file_stat[stat.ST_GID] |
| shutil.copystat(src, dst) |
| os.chown(dst, owner, group, follow_symlinks=follow_symlinks) |
| |
| def rename_json(project_path, json_file, new_name, orig_name = ''): |
| # Make sure we have the full absolute path to the project |
| fullpath = os.path.abspath(project_path) |
| # Project directory name is the last component of the full path |
| dirname = os.path.split(fullpath)[1] |
| # Get contents of the file, then recast the ip-name and rewrite it. |
| with open(json_file, 'r') as ifile: |
| datatop = json.load(ifile) |
| |
| # Find ip-name and replace it |
| if 'data-sheet' in datatop: |
| dsheet = datatop['data-sheet'] |
| if 'ip-name' in dsheet: |
| ipname = dsheet['ip-name'] |
| if ipname == orig_name: |
| dsheet['ip-name'] = new_name |
| elif orig_name == '': |
| dsheet['ip-name'] = new_name |
| else: |
| print('Error: original name ' + orig_name + ' specified in command line,') |
| print('but ip-name is ' + ipname + ' in the datasheet.') |
| return ipname |
| |
| # Change name of file. This must match the name of the directory whether |
| # or not the directory name matches the IP name. |
| # (New protocol from Dec. 2018: JSON file is now always named 'project.json') |
| |
| opath = os.path.split(json_file)[0] |
| # oname = opath + '/' + dirname + '.json' |
| oname = opath + '/project.json' |
| |
| with open(oname, 'w') as ofile: |
| json.dump(datatop, ofile, indent = 4) |
| |
| # Remove original file. Avoid destroying the file if rename_project happens |
| # to be called with the same name for old and new. |
| if (json_file != oname): |
| copy_meta_with_ownership(json_file, oname) |
| os.remove(json_file) |
| |
| # Return the original IP name |
| return ipname |
| |
| def rename_netlist(netlist_path, orig_name, new_name): |
| # All netlists can be regenerated on the fly, so remove any that are |
| # from orig_name |
| if not os.path.exists(netlist_path): |
| return |
| |
| filelist = os.listdir(netlist_path) |
| for file in filelist: |
| rootname = os.path.splitext(file)[0] |
| fullpath = netlist_path + '/' + file |
| if rootname == orig_name: |
| if os.path.isdir(fullpath): |
| rename_netlist(fullpath, orig_name, new_name); |
| else: |
| print('Removing netlist file ' + file) |
| os.remove(fullpath) |
| |
| def rename_magic(magic_path, orig_name, new_name): |
| # remove old files that will get regenerated: comp.out, comp.json, any *.log |
| # move any file beginnng with orig_name to the same file with new_name |
| filelist = os.listdir(magic_path) |
| |
| # All netlists can be regenerated on the fly, so remove any that are |
| # from orig_name |
| for file in filelist: |
| rootname, fext = os.path.splitext(file) |
| |
| if file == 'comp.out' or file == 'comp.json': |
| os.remove(magic_path + '/' + file) |
| elif rootname == orig_name: |
| if fext == '.spc' or fext == '.spice': |
| print('Removing netlist file ' + file) |
| os.remove(magic_path + '/' + file) |
| elif fext == '.ext' or fext == '.lef': |
| os.remove(magic_path + '/' + file) |
| else: |
| shutil.move(magic_path + '/' + file, magic_path + '/' + new_name + fext) |
| |
| elif fext == '.log': |
| os.remove(magic_path + '/' + file) |
| |
| def rename_verilog(verilog_path, orig_name, new_name): |
| filelist = os.listdir(verilog_path) |
| |
| # The root module name can remain as the original (may not match orig_name |
| # anyway), but the verilog file containing it gets renamed. |
| # To be done: Any file (e.g., simulation testbenches, makefiles) referencing |
| # the file must be modified to match. These may be in subdirectories, so |
| # walk the filesystem from verilog_path. |
| |
| for file in filelist: |
| rootname, fext = os.path.splitext(file) |
| if rootname == orig_name: |
| if fext == '.v' or fext == '.sv': |
| shutil.move(verilog_path + '/' + file, verilog_path + '/' + new_name + fext) |
| |
| def rename_electric(electric_path, orig_name, new_name): |
| # <project_name>.delib gets renamed |
| |
| filelist = os.listdir(electric_path) |
| for file in filelist: |
| rootname, fext = os.path.splitext(file) |
| if rootname == orig_name: |
| shutil.move(electric_path + '/' + file, electric_path + '/' + new_name + fext) |
| |
| delib_path = electric_path + '/' + new_name + '.delib' |
| if os.path.exists(delib_path): |
| filelist = os.listdir(delib_path) |
| for file in filelist: |
| if os.path.isdir(file): |
| continue |
| rootname, fext = os.path.splitext(file) |
| if rootname == orig_name: |
| # Read and do name substitution where orig_name occurs |
| # in 'H', 'C', and 'L' statements. The top-level should not appear in |
| # an 'I' (instance) statement. |
| with open(delib_path + '/' + file, 'r') as ifile: |
| contents = ifile.read() |
| contents = re.sub('H' + orig_name + '\|', 'H' + new_name + '|', contents) |
| contents = re.sub('C' + orig_name + ';', 'C' + new_name + ';', contents) |
| contents = re.sub('L' + orig_name + '\|' + orig_name, 'L' + new_name + '|' + new_name, contents) |
| |
| oname = new_name + fext |
| with open(delib_path + '/' + oname, 'w') as ofile: |
| ofile.write(contents) |
| |
| # Copy ownership and permissions from the old file |
| # Remove the original file |
| copy_meta_with_ownership(delib_path + '/' + file, delib_path + '/' + oname) |
| os.remove(delib_path + '/' + file) |
| |
| elif rootname == 'header': |
| # Read and do name substitution where orig_name occurs in 'H' statements. |
| with open(delib_path + '/' + file, 'r') as ifile: |
| contents = ifile.read() |
| contents = re.sub('H' + orig_name + '\|', 'H' + new_name + '|', contents) |
| |
| with open(delib_path + '/' + file + '.tmp', 'w') as ofile: |
| ofile.write(contents) |
| |
| copy_meta_with_ownership(delib_path + '/' + file, delib_path + '/' + file + '.tmp') |
| os.remove(delib_path + '/' + file) |
| shutil.move(delib_path + '/' + file + '.tmp', delib_path + '/' + file) |
| |
| # Top level routine (call this one) |
| |
| def rename_project_all(project_path, new_name, orig_name=''): |
| # project_path is the original full path to the project in the user's design space. |
| # |
| # new_name is the new name to give to the project. It is assumed to have been |
| # already checked for uniqueness against existing names |
| |
| # Original name is determined from the 'ip-name' field in the JSON file |
| # unless it is specified as a separate argument. |
| |
| proj_name = os.path.split(project_path)[1] |
| json_path = project_path + '/project.json' |
| |
| # The JSON file is assumed to have the name "project.json" always. |
| # However, if the project directory just got named, or if the project pre-dates |
| # December 2018, then that may not be true. If json_path does not exist, look |
| # for any JSON file containing a data-sheet entry. |
| |
| if not os.path.exists(json_path): |
| json_path = '' |
| filelist = os.listdir(project_path) |
| for file in filelist: |
| if os.path.splitext(file)[1] == '.json': |
| with open(project_path + '/' + file) as ifile: |
| datatop = json.load(ifile) |
| if 'data-sheet' in datatop: |
| json_path = project_path + '/' + file |
| break |
| |
| if os.path.exists(json_path): |
| if (orig_name == ''): |
| orig_name = rename_json(project_path, json_path, new_name) |
| else: |
| test_name = rename_json(project_path, json_path, new_name, orig_name) |
| if test_name != orig_name: |
| # Refusing to make a change because the orig_name didn't match ip-name |
| return |
| else: |
| if (orig_name == ''): |
| orig_name = proj_name |
| |
| if orig_name == new_name: |
| print('Warning: project old and new names are the same; nothing to change.', file=sys.stderr) |
| return |
| |
| # Each subroutine renames a specific group of files. |
| electric_path = project_path + '/elec' |
| if os.path.exists(electric_path): |
| rename_electric(electric_path, orig_name, new_name) |
| |
| magic_path = project_path + '/mag' |
| if os.path.exists(magic_path): |
| rename_magic(magic_path, orig_name, new_name) |
| |
| verilog_path = project_path + '/verilog' |
| if os.path.exists(verilog_path): |
| rename_verilog(verilog_path, orig_name, new_name) |
| |
| # Maglef is deprecated in anything but readonly IP and PDKs, but |
| # handle for backwards compatibility. |
| maglef_path = project_path + '/maglef' |
| if os.path.exists(maglef_path): |
| rename_magic(maglef_path, orig_name, new_name) |
| |
| netlist_path = project_path + '/spi' |
| if os.path.exists(netlist_path): |
| rename_netlist(netlist_path, orig_name, new_name) |
| rename_netlist(netlist_path + '/pex', orig_name, new_name) |
| rename_netlist(netlist_path + '/cdl', orig_name, new_name) |
| rename_netlist(netlist_path + '/lvs', orig_name, new_name) |
| |
| # To be done: handle qflow directory if it exists. |
| |
| print('Renamed project ' + orig_name + ' to ' + new_name + '; done.') |
| |
| # If called as main, run rename_project_all. |
| |
| if __name__ == '__main__': |
| |
| # Divide up command line into options and arguments |
| options = [] |
| arguments = [] |
| for item in sys.argv[1:]: |
| if item.find('-', 0) == 0: |
| options.append(item) |
| else: |
| arguments.append(item) |
| |
| # Need two arguments: path to directory, and new project name. |
| |
| if len(arguments) < 2: |
| print("Usage: rename_project.py <project_path> <new_name> [<orig_name>]") |
| elif len(arguments) >= 2: |
| project_path = arguments[0] |
| new_name = arguments[1] |
| |
| if len(arguments) == 3: |
| orig_name = arguments[2] |
| rename_project_all(project_path, new_name, orig_name) |
| else: |
| rename_project_all(project_path, new_name) |
| |
