| #!/usr/bin/env python3 |
| |
| import argparse |
| import copy |
| import json |
| import pprint |
| import re |
| import sys |
| |
| from pathlib import Path |
| |
| debug = True |
| |
| |
| def get_lib_properties(fname): |
| data = json.load(open(str(fname), "r")) |
| assert len(data) == 1, list(data.keys()) |
| |
| libstr = list(data.keys())[0] |
| assert libstr.startswith('library,'), libstr |
| data = data[libstr] |
| |
| for c in list(data): |
| if c.startswith('cell,'): |
| del data[c] |
| if c.startswith('lu_table_template,') or c.startswith('power_lut_template,'): |
| del data[c] |
| if c.startswith('normalized_driver_waveform,'): |
| del data[c] |
| return libstr, data |
| |
| |
| |
| def filter_lib_properties(data): |
| for c in list(data): |
| if c.startswith('cell,'): |
| del data[c] |
| if c.startswith('lu_table_template,') or c.startswith('power_lut_template,'): |
| del data[c] |
| if c.startswith('normalized_driver_waveform,'): |
| del data[c] |
| |
| |
| RE_FLOAT = re.compile("^-?[0-9]+(\.[0-9]+)?([Ee][+-]?[0-9]+)?$") |
| RE_INT = re.compile("^-?[0-9]+$") |
| |
| |
| def rewrite_broken_quotes(s): |
| """ |
| >>> rewrite_broken_quotes('1, "pf"') |
| '"1","pf"' |
| |
| >>> rewrite_broken_quotes('"CLK GATE","M0"') |
| '"CLK GATE","M0"' |
| |
| >>> rewrite_broken_quotes('"CLK GATE,M0"') |
| '"CLK GATE","M0"' |
| |
| >>> rewrite_broken_quotes('CLK GATE",M0') |
| '"CLK GATE","M0"' |
| |
| >>> rewrite_broken_quotes('XXX') |
| '"XXX"' |
| |
| >>> rewrite_broken_quotes('statetable "CLK GATE SCE') |
| '"statetable","CLK GATE SCE"' |
| |
| """ |
| o = [] |
| |
| s = re.sub('([^,]) "', '\\1,"', s) |
| |
| for b in s.split(","): |
| b = b.strip() |
| if b and b[0] == '"': |
| b = b[1:] |
| if b and b[-1] == '"': |
| b = b[:-1] |
| |
| assert '"' not in b, (b, s) |
| |
| o.append('"%s"' % b) |
| return ",".join(o) |
| |
| |
| def fixup(s): |
| """ |
| >>> fixup('1, "pf"') |
| (1, 'pf') |
| |
| >>> fixup('"vpwr",1.760000') |
| ('vpwr', 1.76) |
| |
| >>> fixup('"VSS",0.000000') |
| ('VSS', 0.0) |
| |
| >>> fixup('Random') |
| 'Random' |
| |
| >>> fixup(0.0) |
| 0.0 |
| |
| >>> fixup('123') |
| 123 |
| |
| >>> fixup('123e6') |
| 123000000.0 |
| |
| >>> fixup('123E-10') |
| 1.23e-08 |
| |
| >>> fixup('ABC, 123H') |
| ('ABC', '123H') |
| |
| >>> fixup([{'v': "7.0", 'w': ""},]) |
| [{'v': 7.0, 'w': ''}] |
| |
| >>> fixup('CLK GATE","M0') |
| ('CLK GATE', 'M0') |
| |
| >>> fixup('CLK GATE", "M0') |
| ('CLK GATE', 'M0') |
| |
| >>> fixup('CLK GATE",M0') |
| ('CLK GATE', 'M0') |
| |
| >>> fixup(" hello") |
| 'hello' |
| |
| >>> fixup("statetable \\"CLK GATE SCE\\",m0") |
| ('statetable', 'CLK GATE SCE', 'm0') |
| |
| """ |
| |
| if isinstance(s, dict): |
| o = {} |
| for k, v in s.items(): |
| k = fixup(k) |
| v = fixup(v) |
| o[k] = v |
| return o |
| |
| if isinstance(s, list): |
| o = [] |
| for i in range(0, len(s)): |
| o.append( fixup(s[i]) ) |
| return o |
| |
| if isinstance(s, str): |
| |
| if ',' in s: |
| s = rewrite_broken_quotes(s) |
| |
| bits = s.split(',') |
| conv = False |
| for i in range(0, len(bits)): |
| v = bits[i].strip() |
| |
| vo = fixup(v) |
| |
| if not conv and vo != v: |
| conv = True |
| |
| bits[i] = vo |
| |
| if conv: |
| return tuple(bits) |
| |
| if s and s[0] == '"': |
| assert s[-1] == '"', s |
| s = s[1:-1] |
| |
| if RE_INT.match(s): |
| return int(s) |
| if RE_FLOAT.match(s): |
| return float(s) |
| |
| s = s.strip() |
| |
| return s |
| |
| |
| |
| class LibertyToJSONParser(): |
| |
| @classmethod |
| def join_duplicate_keys(cls, ordered_pairs) -> dict: |
| '''Converts multiple key-value entries in input sequence to one entry. |
| |
| The function takes all key duplicates, and form an entry with single |
| key and list of values. |
| |
| Parameters |
| ---------- |
| ordered_pairs: list |
| list of pairs key-value |
| |
| Returns |
| ------- |
| dict: dictionary, where values with same keys are grouped into list |
| ''' |
| d = {} |
| for k, v in ordered_pairs: |
| if k in d: |
| if type(d[k]) == list: |
| d[k].append(v) |
| else: |
| if d[k] != v: |
| d[k] = [d[k], v] |
| else: |
| d[k] = v |
| return d |
| |
| @classmethod |
| def load_timing_info_from_lib(cls, libfile: list) -> (dict): |
| '''Reads the LIB file and converts it to dictionary structure. |
| |
| Parameters |
| ---------- |
| libfile: list |
| The lines for input LIB file |
| |
| Returns |
| ------- |
| dict: a dictionary containing the whole structure of the file |
| ''' |
| |
| # regex for indent |
| inddef = r'^(?P<indent>\s*)' |
| |
| # regex for variables |
| vardef = r'([A-Za-z_][a-zA-Z_0-9\-]*)' |
| |
| # regex for floating-point numbers |
| numdef = r'[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?' |
| |
| # regex for all allowed characters in struct definition name |
| alloweddef = r'[^\n\"{{]+' |
| |
| # regex for arrays |
| arrdef = r'(\s*\"\s*(?P<arrvalues>({numdef}(,\s*)?)+)\s*\"\s*,?)'.format(numdef=numdef) # noqa: E501 |
| |
| # REGEX defining the dictionary name in LIB file, i.e. "pin ( QAI )", |
| # "pin(FBIO[22])" or "timing()" |
| structdecl = re.compile(r'{inddef}(?P<type>{vardef})\s*\(\s*(\"(?P<nameq>[^\n{{]+?)?\"|(?P<name>[^\n{{]+?)?)\s*\)'.format(vardef=vardef, inddef=inddef, alloweddef=alloweddef)) # noqa: E501 |
| |
| # REGEX defining global "attribute (entry);" statements |
| attdecl = re.compile(r'{inddef}(?P<attrname>{vardef})\s*\(\s*(\"(?P<attrvalq>[^\n\(\)]+?)\"|(?P<attrval>[^\n\(\)]+?))\s*\)\s*,$'.format(vardef=vardef, inddef=inddef)) # noqa: E501 |
| |
| # REGEX defining array for lu_table_template template breakpoints |
| arrdecl = re.compile(r'{inddef}(?P<arrname>{vardef})\s*\((?P<array>{arrdef}+)\)'.format(vardef=vardef, inddef=inddef, arrdef=arrdef)) # noqa: E501 |
| |
| # REGEX defining arrays |
| subarrdecl = re.compile(arrdef) |
| |
| singlearr = re.compile(r'{inddef}\"(?P<arrname>{vardef})\"\s*:{arrdef}'.format(vardef=vardef, inddef=inddef, arrdef=arrdef)) # noqa: E501 |
| |
| # REGEX defining Liberty `define` statements |
| defdecl = re.compile(r'{inddef}define\s*\(\s*(?P<attribute_name>{vardef})\s*,\s*(?P<group_name>{vardef})\s*,\s*(?P<attribute_type>{vardef})\s*\)\s*,'.format(vardef=vardef, inddef=inddef)) # noqa: E501 |
| |
| # REGEX defining lines with no ending colon |
| nocommadecl = re.compile(r'(?P<content>{inddef}{vardef}\s*:\s*(\"[^\n\"\(\)]+\"|[^\n\s\"\(\),]+))\s*$'.format(inddef=inddef, vardef=vardef)) # noqa: E501 |
| |
| # REGEX defining typical variable name, which is any variable starting |
| # with alphabetic character, followed by [A-Za-z_0-9] characters, and |
| # not within quotes |
| unwrappeddecl = re.compile(r'{inddef}(\"(?P<varnameq>{vardef})\"|(?P<varname>{vardef}))\s*:\s*(\"(?P<varvalueq>[^\n\"{{]*)\"|(?P<varvalue>[^\n\"{{]*))\s*,$'.format(inddef=inddef, vardef=vardef)) # noqa: E501 |
| # vardecl = re.compile(r'(?P<variable>(?<!\"){vardef}(\[[0-9]+\])?(?![^\:]*\"))'.format(vardef=vardef)) # noqa: E501 |
| |
| # join all lines into single string |
| fullfile = '\n'.join(libfile) |
| # remove comments (C/C++ style) |
| #fullfile = re.sub(r'(?:\/\*(.*?)\*\/)|(?:\/\/(.*?)\n)', '', |
| # fullfile, flags=re.DOTALL) |
| |
| fullfile = re.sub(r'(?:\/\*(.*?)\*\/)', '', |
| fullfile, flags=re.DOTALL) |
| |
| fullfile = re.sub(r'(?:\/\/(.*?)\n)', '\n', |
| fullfile, flags=re.DOTALL) |
| |
| # remove comments (Python style) |
| fullfile = re.sub(r'#[^\n]*\n', '', fullfile, flags=re.DOTALL) |
| |
| # remove line breaks |
| fullfile = re.sub(r'\\[\s\n\r\t]*', '', fullfile, flags=re.DOTALL) |
| |
| # replace all tabs with single space |
| fullfile = fullfile.replace('\t', ' ') |
| |
| # move non-whitespace content after } to new line |
| fullfile = re.sub(r'}\s*(?!\n)', '}\n', fullfile, flags=re.DOTALL) |
| |
| # split single string into lines |
| libfile = fullfile.split('\n') |
| fullfile = '' |
| |
| # replace semicolons with commas |
| libfile = [line.replace(';', ',') for line in libfile] |
| |
| # remove empty lines and trailing whitespaces |
| libfile = [line.rstrip() for line in libfile if line.strip()] |
| |
| for i in range(len(libfile)): |
| # add comma if not present |
| # TODO: not sure if this should be accepted or returned as error |
| libfile[i] = nocommadecl.sub(r'\g<content>,', libfile[i]) |
| |
| # parse `define` entries |
| libfile[i] = defdecl.sub( |
| r'\g<indent>"define" : {"attribute_name": ' |
| r'"\g<attribute_name>", "group_name": "\g<group_name>", ' |
| r'"attribute_type": "\g<attribute_type>"}', |
| libfile[i]) |
| |
| # parse array entries to make them JSON-compliant |
| arrmatch = arrdecl.match(libfile[i]) |
| if arrmatch: |
| arrays = '' |
| |
| first = True |
| matches = [match for match in |
| subarrdecl.finditer(arrmatch.group("array"))] |
| for match in matches: |
| if first: |
| if len(matches) == 1: |
| arrays = '{}'.format(match.group('arrvalues')) |
| else: |
| arrays = '[{}]'.format(match.group('arrvalues')) |
| first = False |
| else: |
| arrays += ', [{}]'.format(match.group('arrvalues')) |
| |
| libfile[i] = '{indent}{arrname} : [{arrays}],'.format( |
| indent=arrmatch.group('indent'), |
| arrname=arrmatch.group('arrname'), |
| arrays=arrays) |
| |
| # convert array-like attributes to arrays |
| # log_printer.log('INFO', libfile[i]) |
| libfile[i] = singlearr.sub( |
| r'\g<indent>"\g<arrname>" : [\g<arrvalues>],', |
| libfile[i]) |
| |
| # parse attribute entries |
| attmatch = attdecl.match(libfile[i]) |
| if attmatch: |
| libfile[i] = '{}"comp_attribute {}" : "{}",'.format( |
| attmatch.group("indent"), |
| attmatch.group("attrname"), |
| (attmatch.group("attrval") |
| if attmatch.group("attrval") else |
| attmatch.group("attrvalq")).replace('"', '\\"')) |
| |
| # remove parenthesis from struct names |
| structmatch = structdecl.match(libfile[i]) |
| if structmatch: |
| if structmatch.group("name") or structmatch.group("nameq"): |
| libfile[i] = '{}"{} {}" : {}'.format( |
| structmatch.group("indent"), |
| structmatch.group("type"), |
| (structmatch.group("name") if |
| structmatch.group("name") else |
| structmatch.group("nameq")).replace( |
| '"', '\\"'), |
| '{' if libfile[i].rstrip().endswith('{') else '') |
| else: |
| libfile[i] = structdecl.sub( |
| r'\g<indent>"\g<type> " :', |
| libfile[i]) |
| |
| # wrap all text in quotes |
| unwrappedmatch = unwrappeddecl.match(libfile[i]) |
| if unwrappedmatch: |
| singlearrdef = r'\[?\s*(\[\s*(?P<arrvalues>({numdef}(,\s*)?)+)\s*\])+\s*\]?'.format(numdef=numdef) # noqa: E501 |
| varval = (unwrappedmatch.group('varvalue') |
| if unwrappedmatch.group('varvalue') |
| else unwrappedmatch.group('varvalueq')) |
| varnam = (unwrappedmatch.group('varname') |
| if unwrappedmatch.group('varname') |
| else unwrappedmatch.group('varnameq')) |
| isarray = re.match( |
| singlearrdef, |
| varval) |
| if isarray: |
| libfile[i] = '{}"{}" : {},'.format( |
| unwrappedmatch.group('indent'), |
| varnam, |
| varval.strip()) |
| else: |
| libfile[i] = '{}"{}" : "{}",'.format( |
| unwrappedmatch.group('indent'), |
| varnam, |
| varval.strip()) |
| |
| # add colons after closing braces |
| libfile[i] = libfile[i].replace("}", "},") |
| |
| # remove colons before closing braces |
| fullfile = '\n'.join(libfile) |
| fullfile = re.sub( |
| r',(?P<tmp>\s*})', r'\g<tmp>', |
| fullfile, |
| flags=re.DOTALL) |
| libfile = fullfile.split('\n') |
| fullfile = '' |
| |
| # remove the colon in the end of file |
| libfile[-1] = re.sub(r',\s*', '', libfile[-1]) |
| |
| data = '\n'.join(libfile) |
| timingdict = json.loads( |
| data, object_pairs_hook=cls.join_duplicate_keys) |
| |
| timingdict = fixup(timingdict) |
| |
| return timingdict |
| |
| |
| from liberty_json_rewrite import TO_REMOVE |
| |
| |
| def strip_keys(data): |
| if isinstance(data, dict): |
| do = {} |
| for k, v in data.items(): |
| if k in TO_REMOVE: |
| continue |
| #k = fixup(k) |
| if isinstance(k, str) and ' ' in k: |
| k = k.split(' ', 1) |
| |
| if isinstance(k, (tuple, list)): |
| k = list(k) |
| if ' ' in k[0]: |
| k[0:1] = k[0].split(' ', 1) |
| k = ",".join(k) |
| assert isinstance(k, str), (k, v) |
| do[k] = strip_keys(v) |
| return do |
| |
| elif isinstance(data, list): |
| o = [] |
| for i in data: |
| o.append(strip_keys(i)) |
| return o |
| else: |
| return data |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "input", |
| help="LIB file containing timings", |
| type=Path) |
| parser.add_argument( |
| "--cache", |
| action="store_true", |
| help="Create lib.cache.json file", |
| default=False, |
| ) |
| parser.add_argument( |
| "output", |
| help="The output JSON file containing LIB timings", |
| type=Path, |
| default=None, |
| nargs='?') |
| |
| args = parser.parse_args() |
| if args.cache: |
| cache(args.input) |
| return |
| |
| assert str(args.input).endswith(".lib"), args.input |
| |
| if args.output is None: |
| args.output = Path(str(args.input)+'.json') |
| |
| with open(args.input, 'r') as infile: |
| libfile = infile.readlines() |
| |
| libfile = ['{\n'] + libfile + ['}'] |
| |
| timingdict = (LibertyToJSONParser.load_timing_info_from_lib(libfile)) |
| |
| timingdict = strip_keys(timingdict) |
| |
| with open(args.output, 'w') as out: |
| json.dump(timingdict, out, indent=4, sort_keys=True) |
| |
| |
| |
| def pprint_lib(f, data): |
| print("\n"*3) |
| print(f) |
| pdata = copy.deepcopy(data) |
| filter_lib_properties(pdata) |
| pprint.pprint(pdata) |
| |
| |
| def json_dump(d, f): |
| json.dump(d, f, sort_keys=True, indent=' ') |
| |
| |
| def cache(inputdir): |
| inputdir = str(inputdir) |
| if not inputdir.endswith('/'): |
| inputdir += '/' |
| |
| files = [] |
| for x in Path(inputdir).rglob('*.lib.json'): |
| if 'cds' in str(x): |
| continue |
| |
| f = str(x)[len(inputdir):] |
| files.append(f) |
| |
| files = list(set(files)) |
| files.sort() |
| |
| pprint.pprint(files) |
| |
| lib_data = {} |
| for f in files: |
| if debug: |
| print(f) |
| |
| p = inputdir+f |
| libstr, data = get_lib_properties(p) |
| lib_data[str(f)] = (libstr, data) |
| |
| if debug: |
| pprint_lib(f, data) |
| |
| with open('lib.cache.json', 'w') as f: |
| json_dump(lib_data, f) |
| |
| with open('lib.cache.json', 'w') as f: |
| json_dump(lib_data, f) |
| |
| return |
| |
| |
| if __name__ == '__main__': |
| import doctest |
| fails, _ = doctest.testmod() |
| if fails != 0: |
| sys.exit("Some test failed!") |
| |
| main() |
