Merge branch 'master' of 192.168.0.7:/home/tim/gitsrc/open_pdks/
diff --git a/VERSION b/VERSION index 8955a01..8b54409 100644 --- a/VERSION +++ b/VERSION
@@ -1 +1 @@ -1.0.26 +1.0.28
diff --git a/common/fix_subckt_params.py b/common/fix_subckt_params.py new file mode 100755 index 0000000..f986119 --- /dev/null +++ b/common/fix_subckt_params.py
@@ -0,0 +1,269 @@ +#!/bin/env python3 +# +# fix_subckt_params.py -- +# +# Modify SPICE subcircuit definitions in files where parameters are listed +# in a ".param" block in the subcircuit and are therefore local parameters +# that cannot be passed to the subcircuit, and move them into the subcircuit +# pin list as parameters that can be passed to the subcircuit. +# +# The arguments are <path_to_input>, <path_to_output>, and <param> ... +# <path_to_input> should be the path to a single file, while +# <path_to_output> is the path to a directory where the split files will +# be put. <params> ... is a whitespace-separated (i.e., one parameter, +# one argument) list of parameter names that should be moved up from the +# ".param" section to the ".subckt" line. If <param> is preceded with "-", +# then the parameter will be moved from the .subckt line down to the +# .param section. + +import os +import sys +import re +import glob + +def usage(): + print('fix_subckt_params.py <path_to_input> <path_to_output> <param> ...') + print('where:') + print(' <path_to_input> is the path to the input file to parse') + print(' <path_to_output> is the directory to place the modified input file') + print(' <param> ... is a space-separated list of parameters that should') + print(' be in the subcircuit line and not the .param block') + +# Parse a parameter line for parameters, and divide into two parts, +# returned as a list. If a parameter name matches an entry in 'params', +# it goes in the second list. Otherwise, it goes in the first list. +# The first list is returned as-is minus any parameters that were split +# into the second list. The second list must begin with '+', as it will +# be output as a continuation line for the subcircuit. + +def param_split(line, params, debug): + # Regexp patterns + parm1rex = re.compile('(\.param[ \t]+)(.*)') + parm2rex = re.compile('(\+[ \t]*)(.*)') + parm3rex = re.compile('([^= \t]+)([ \t]*=[ \t]*[^ \t]+[ \t]*)(.*)') + parm4rex = re.compile('([^= \t]+)([ \t]*)(.*)') + + part1 = '' + part2 = '' + + if debug: + print('Diagnostic: param line in = "' + line + '"') + + pmatch = parm1rex.match(line) + if pmatch: + part1 = pmatch.group(1) + rest = pmatch.group(2) + else: + pmatch = parm2rex.match(line) + if pmatch: + rest = pmatch.group(2) + else: + # Could not parse; return list with line and empty string + return [line, ''] + + while rest != '': + pmatch = parm3rex.match(rest) + if pmatch: + rest = pmatch.group(3) + pname = pmatch.group(1) + if pname in params: + if part2 == '': + part2 = '+ ' + part2 += pname + pmatch.group(2) + else: + if part1 == '': + part1 = '+ ' + part1 += pname + pmatch.group(2) + else: + pmatch = parm4rex.match(rest) + if pmatch: + rest = pmatch.group(3) + pname = pmatch.group(1) + if pname in params: + if part2 == '': + part2 = '+ ' + part2 += pname + pmatch.group(2) + else: + if part1 == '': + part1 = '+ ' + part1 += pname + pmatch.group(2) + + if debug: + print('Diagnostic: param line out = "' + part1 + '" and "' + part2 + '"') + return [part1, part2] + +def convert_file(in_file, out_path, params, debug): + + # Regexp patterns + paramrex = re.compile('\.param[ \t]+(.*)') + subrex = re.compile('\.subckt[ \t]+([^ \t]+)[ \t]+([^ \t]*)') + modelrex = re.compile('\.model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+(.*)') + endsubrex = re.compile('\.ends[ \t]+(.+)') + increx = re.compile('\.include[ \t]+') + + with open(in_file, 'r') as ifile: + inplines = ifile.read().splitlines() + + insubckt = False + inparam = False + inmodel = False + inpinlist = False + + # Output lines + spicelines = [] + paramlines = [] + subparams = [] + + for line in inplines: + + # Item 1. Handle comment lines + if line.startswith('*'): + spicelines.append(line.strip()) + continue + + # Item 2. Flag continuation lines. + if line.startswith('+'): + contline = True + else: + contline = False + if line.strip() != '': + if inpinlist: + inpinlist = False + if inparam: + # Dump additional subcircuit parameters and clear + if subparams: + spicelines.extend(subparams) + subparams = [] + + # Dump parameters to file contents and clear + spicelines.extend(paramlines) + paramlines = [] + inparam = False + + # Item 3. Handle blank lines like comment lines + if line.strip() == '': + if inparam: + paramlines.append(line) + else: + spicelines.append(line) + continue + + # Item 4. Handle continuation lines + # Remove lines that have a continuation mark and nothing else. + if contline: + if inparam: + # Continue handling parameters + if insubckt: + # Find subcircuit parameters and record what line they were found on + psplit = param_split(line, params, debug) + if psplit[0]: + paramlines.append(psplit[0]) + if psplit[1]: + subparams.append(psplit[1]) + else: + paramlines.append(line) + else: + if line.strip() != '+': + spicelines.append(line) + continue + + # Item 5. Regexp matching + + # parameters + pmatch = paramrex.match(line) + if pmatch: + inparam = True + if insubckt: + # Find subcircuit parameters and record what line they were found on + psplit = param_split(line, params, debug) + if psplit[0]: + paramlines.append(psplit[0]) + if psplit[1]: + subparams.append(psplit[1]) + else: + paramlines.append(line) + continue + + # model + mmatch = modelrex.match(line) + if mmatch: + spicelines.append(line) + continue + inmodel = 2 + continue + + if not insubckt: + # Things to parse if not in a subcircuit + + imatch = subrex.match(line) + if imatch: + insubckt = True + inpinlist = True + spicelines.append(line) + continue + + else: + # Things to parse when inside of a ".subckt" block + + if inpinlist: + spicelines.append(line) + continue + + else: + ematch = endsubrex.match(line) + if ematch: + spicelines.append(line) + insubckt = False + inmodel = False + continue + + # Copy line as-is + spicelines.append(line) + + # Output the result to out_file. + out_file = os.path.split(in_file)[1] + with open(out_path + '/' + out_file, 'w') as ofile: + for line in spicelines: + print(line, file=ofile) + +if __name__ == '__main__': + debug = False + + if len(sys.argv) == 1: + print("No options given to fix_subckt_params.py.") + usage() + sys.exit(0) + + optionlist = [] + arguments = [] + + for option in sys.argv[1:]: + if option.find('-', 0) == 0: + optionlist.append(option) + else: + arguments.append(option) + + if len(arguments) < 3: + print("Wrong number of arguments given to fix_subckt_params.py.") + usage() + sys.exit(0) + + if '-debug' in optionlist: + debug = True + + inpath = arguments[0] + outpath = arguments[1] + params = arguments[2:] + + if not os.path.exists(inpath): + print('No such source file ' + inpath) + sys.exit(1) + + if not os.path.isfile(inpath): + print('Input path ' + inpath + ' is not a file.') + sys.exit(1) + + convert_file(inpath, outpath, params, debug) + + print('Done.') + exit(0)
diff --git a/common/print_subckt_params.py b/common/print_subckt_params.py new file mode 100755 index 0000000..c8f75eb --- /dev/null +++ b/common/print_subckt_params.py
@@ -0,0 +1,243 @@ +#!/bin/env python3 +# +# print_subckt_params.py -- +# +# Print a list of subcircuit parameters, dividing them into those which +# are declared on the subcircuit line, and those that are declared inside +# the scope of the subcircuit. +# +# The single argument is <path_to_input> +# <path_to_input> should be the path to a single file. + +import os +import sys +import re +import glob + +def usage(): + print('print_subckt_params.py <path_to_input>') + print('where:') + print(' <path_to_input> is the path to the input file to parse') + +def parse_pins(line, debug): + # Regexp patterns + subrex = re.compile('\.subckt[ \t]+[^ \t]+[ \t]+(.*)') + parm1rex = re.compile('([^= \t]+)[ \t]*=[ \t]*[^ \t]+[ \t]*(.*)') + parm2rex = re.compile('([^= \t]+)[ \t]*(.*)') + + params = [] + + pmatch = subrex.match(line) + if pmatch: + rest = pmatch.group(1) + else: + # Could not parse + return [] + + while rest != '': + if rest.startswith('$ '): + break + pmatch = parm1rex.match(rest) + if pmatch: + rest = pmatch.group(2) + params.append(pmatch.group(1)) + else: + pmatch = parm2rex.match(rest) + if pmatch: + # This is a pin, so don't list it + rest = pmatch.group(2) + + return params + +# Parse a parameter line for parameters, and divide into two parts, +# returned as a list. If a parameter name matches an entry in 'params', +# it goes in the second list. Otherwise, it goes in the first list. +# The first list is returned as-is minus any parameters that were split +# into the second list. The second list must begin with '+', as it will +# be output as a continuation line for the subcircuit. + +def param_parse(line, debug): + # Regexp patterns + parm1rex = re.compile('\.param[ \t]+(.*)') + parm2rex = re.compile('\+[ \t]*(.*)') + parm3rex = re.compile('([^= \t]+)[ \t]*=[ \t]*[^ \t]+[ \t]*(.*)') + parm4rex = re.compile('([^= \t]+)[ \t]*(.*)') + + if debug: + print('Diagnostic: param line in = "' + line + '"') + + params = [] + + pmatch = parm1rex.match(line) + if pmatch: + rest = pmatch.group(1) + else: + pmatch = parm2rex.match(line) + if pmatch: + rest = pmatch.group(1) + else: + # Could not parse; return list with line and empty string + return [] + + while rest != '': + if rest.startswith('$ '): + break + pmatch = parm3rex.match(rest) + if pmatch: + rest = pmatch.group(2) + params.append(pmatch.group(1)) + else: + pmatch = parm4rex.match(rest) + if pmatch: + rest = pmatch.group(2) + params.append(pmatch.group(1)) + + return params + +def parse_file(in_file, debug): + + # Regexp patterns + paramrex = re.compile('\.param[ \t]+(.*)') + subrex = re.compile('\.subckt[ \t]+([^ \t]+)[ \t]+([^ \t]*)') + modelrex = re.compile('\.model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+(.*)') + endsubrex = re.compile('\.ends[ \t]+(.+)') + increx = re.compile('\.include[ \t]+') + + with open(in_file, 'r') as ifile: + inplines = ifile.read().splitlines() + + insubckt = False + inparam = False + inmodel = False + inpinlist = False + + pinparams = [] + paramlist = [] + subname = '' + + for line in inplines: + + # Item 1. Handle comment lines + if line.startswith('*'): + continue + + # Item 2. Flag continuation lines. + if line.startswith('+'): + contline = True + else: + contline = False + if line.strip() != '': + if inpinlist: + inpinlist = False + if inparam: + inparam = False + + # Item 3. Handle blank lines like comment lines + if line.strip() == '': + continue + + # Item 4. Handle continuation lines + # Remove lines that have a continuation mark and nothing else. + if contline: + if inparam: + # Continue handling parameters + if insubckt: + # Find subcircuit parameters and record what line they were found on + if inpinlist: + pinparams.extend(param_parse(line, debug)) + else: + paramlist.extend(param_parse(line, debug)) + + continue + + # Item 5. Regexp matching + + # parameters + pmatch = paramrex.match(line) + if pmatch: + inparam = True + if insubckt: + if inpinlist: + inpinlist = False + # Find subcircuit parameters and record what line they were found on + paramlist.extend(param_parse(line, debug)) + continue + + # model + mmatch = modelrex.match(line) + if mmatch: + inmodel = 2 + continue + + if not insubckt: + # Things to parse if not in a subcircuit + + imatch = subrex.match(line) + if imatch: + insubckt = True + inpinlist = True + subname = imatch.group(1) + pinparams = parse_pins(line, debug) + paramlist = [] + continue + + else: + ematch = endsubrex.match(line) + if ematch: + insubckt = False + inmodel = False + # Print out results + if debug: + print('File: ', end='') + print(in_file) + if debug: + print('Subcircuit: ', end='') + print(subname) + if debug: + print('Callable parameters: ', end='') + if len(pinparams) > 0: + print(' '.join(pinparams)) + else: + print('----') + if debug: + print('Internal parameters: ', end='') + if len(paramlist) > 0: + print(' '.join(paramlist)) + else: + print('----') + print() + continue + +if __name__ == '__main__': + debug = False + + if len(sys.argv) == 1: + print("No options given to print_subckt_params.py.") + usage() + sys.exit(0) + + optionlist = [] + arguments = [] + + for option in sys.argv[1:]: + if option.find('-', 0) == 0: + optionlist.append(option) + else: + arguments.append(option) + + if len(arguments) < 1: + print("Wrong number of arguments given to print_subckt_params.py.") + usage() + sys.exit(0) + + if '-debug' in optionlist: + debug = True + + inpath = arguments[0] + + if not os.path.exists(inpath): + print('No such source file ' + inpath) + sys.exit(1) + + parse_file(inpath, debug) + exit(0)
diff --git a/common/soc_floorplanner.py b/common/soc_floorplanner.py index 18a8995..1cdc52c 100755 --- a/common/soc_floorplanner.py +++ b/common/soc_floorplanner.py
@@ -308,6 +308,18 @@ else: projectpath = pwdname + # Also check for project below the current working directory + + if not os.path.exists(projectpath + '/mag'): + print('No project path, checking subdirectories') + dlist = os.listdir(projectpath) + for dir in dlist: + print('Checking ' + projectpath + '/' + dir) + if os.path.exists(projectpath + '/' + dir + '/mag'): + projectpath = projectpath + '/' + dir + print('Found!') + break + projectroot = os.path.split(projectpath)[0] projectdirname = os.path.split(projectpath)[1]
diff --git a/common/spectre_to_spice.py b/common/spectre_to_spice.py index 820c870..a89cdd4 100755 --- a/common/spectre_to_spice.py +++ b/common/spectre_to_spice.py
@@ -103,6 +103,8 @@ if is_number(value): fmtline.append(value) + elif value.strip().startswith("'"): + fmtline.append(value) else: fmtline.append('{' + value + '}') @@ -310,7 +312,9 @@ # Continue to "if inmodel == 1" block below else: fmtline, ispassed = parse_param_line(mmatch.group(3), True, False, True, ispassed) - modellines.append('.model ' + mmatch.group(1) + ' ' + mmatch.group(2) + ' ' + fmtline) + if isspectre and (modtype == 'resistor' or modtype == 'r2'): + modtype = 'r' + modellines.append('.model ' + modname + ' ' + modtype + ' ' + fmtline) if fmtline != '': inparam = True
diff --git a/common/split_one_spice.py b/common/split_one_spice.py new file mode 100755 index 0000000..c454c8d --- /dev/null +++ b/common/split_one_spice.py
@@ -0,0 +1,425 @@ +#!/bin/env python3 +# +# split_one_spice.py -- +# +# Script that reads a SPICE file that contains multiple models and +# subcircuits, and splits it into one file per subcircuit, with each +# file containing any related in-lined models. +# +# The arguments are <path_to_input> and <path_to_output>. +# <path_to_input> should be the path to a single file, while +# <path_to_output> is the path to a directory where the split files will +# be put. + +import os +import sys +import re +import glob + +def usage(): + print('split_one_spice.py <path_to_input> <path_to_output>') + +def convert_file(in_file, out_path): + + # Regexp patterns + paramrex = re.compile('\.param[ \t]+(.*)') + subrex = re.compile('\.subckt[ \t]+([^ \t]+)[ \t]+([^ \t]*)') + modelrex = re.compile('\.model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+(.*)') + endsubrex = re.compile('\.ends[ \t]+(.+)') + increx = re.compile('\.include[ \t]+') + + with open(in_file, 'r') as ifile: + inplines = ifile.read().splitlines() + + insubckt = False + inparam = False + inmodel = False + inpinlist = False + subname = '' + modname = '' + modtype = '' + + # Keep track of what the subcircuit names are + subnames = [] + filenos = {} + + # Keep track of what parameters are used by what subcircuits + paramlist = {} + + # Enumerate which lines go to which files + linedest = [-1]*len(inplines) + fileno = -1; + lineno = -1; + + for line in inplines: + lineno += 1 + + # Item 1. Handle comment lines + if line.startswith('*'): + linedest[lineno] = fileno + continue + + # Item 2. Flag continuation lines + if line.startswith('+'): + contline = True + else: + contline = False + if line.strip() != '': + if inparam: + inparam = False + if inpinlist: + inpinlist = False + + # Item 3. Handle blank lines like comment lines + if line.strip() == '': + linedest[lineno] = fileno + continue + + # Item 4. Handle continuation lines + if contline: + if inparam: + # Continue handling parameters + linedest[lineno] = fileno + if not insubckt: + # Find (global) parameters and record what line they were found on + ptok = list(item for item in line[1:].strip().split() if item != '=') + for param, value in zip(*[iter(ptok)]*2): + paramlist[param] = lineno + else: + # Find if a global parameter was used. Assign it to this + # subcircuit. If it has already been used, assign it to + # be a common parameter + for param in paramlist: + if param in line[1:]: + checkfile = linedest[paramlist[param]] + if checkfile == -1: + linedest[paramlist[param]] = fileno + elif checkfile != fileno: + linedest[paramlist[param]] = -3 + continue + + # Item 5. Regexp matching + + # parameters + pmatch = paramrex.match(line) + if pmatch: + inparam = True + linedest[lineno] = fileno + if not insubckt: + # Find (global) parameters and record what line they were found on + ptok = list(item for item in pmatch.group(1).split() if item != '=') + for param, value in zip(*[iter(ptok)]*2): + paramlist[param] = lineno + else: + # Find if a global parameter was used. Assign it to this + # subcircuit. If it has already been used, assign it to + # be a common parameter + for param in paramlist: + if param in pmatch.group(1): + checkfile = linedest[paramlist[param]] + if checkfile == -1: + linedest[paramlist[param]] = fileno + if checkfile != fileno: + linedest[paramlist[param]] = -3 + continue + + # model + mmatch = modelrex.match(line) + if mmatch: + modname = mmatch.group(1) + modtype = mmatch.group(2) + + linedest[lineno] = fileno + inmodel = 2 + continue + + if not insubckt: + # Things to parse if not in a subcircuit + + imatch = subrex.match(line) + if imatch: + insubckt = True + subname = imatch.group(1) + fileno = len(subnames) + subnames.append(subname) + filenos[subname] = fileno + + if fileno > 0: + # If this is not the first subcircuit, then add all blank + # and comment lines above it to the same file + + lastno = -1 + tline = lineno - 1 + while tline >= 0: + tinp = inplines[tline] + # Backup through all comment and blank lines + if not tinp.startswith('*') and not tinp.strip() == '': + lastno = linedest[tline] + tline += 1; + break; + tline -= 1; + + while tline < lineno: + # Forward through all blank lines, and assign them to + # the previous subcell. + tinp = inplines[tline] + if tinp.strip() != '': + break; + if linedest[tline] == -1: + linedest[tline] = lastno + tline += 1; + + while tline < lineno: + linedest[tline] = fileno + tline += 1; + else: + # If this is the first subcircuit encountered, then assign + # to it the nearest block of comment lines before it. If + # those comment lines include a parameter or statistics + # block, then abandon the effort. + + # Backup through blank lines immediately above + abandon = False + tline = lineno - 1 + while tline >= 0: + tinp = inplines[tline] + if not tinp.strip() == '': + break; + tline -= 1; + + while tline > 0: + # Backup through the next comment block above + tinp = inplines[tline] + if not tinp.startswith('*'): + tline += 1; + break; + elif tinp.strip('*').strip().startswith('statistics'): + abandon = True + tline -= 1; + + if tline == 0: + abandon = True + + if not abandon: + while tline < lineno: + linedest[tline] = fileno + tline += 1; + + devrex = re.compile(subname + '[ \t]*([^ \t]+)[ \t]*([^ \t]+)[ \t]*(.*)', re.IGNORECASE) + inpinlist = True + linedest[lineno] = fileno + continue + + else: + # Things to parse when inside of a ".subckt" block + + if inpinlist: + # Watch for pin list continuation line. + linedest[lineno] = fileno + continue + + else: + ematch = endsubrex.match(line) + if ematch: + if ematch.group(1) != subname: + print('Error: "ends" name does not match "subckt" name!') + print('"ends" name = ' + ematch.group(1)) + print('"subckt" name = ' + subname) + + linedest[lineno] = fileno + fileno = -1 + + insubckt = False + inmodel = False + subname = '' + continue + else: + linedest[lineno] = fileno + continue + + # Sort subcircuit names + subnames.sort(reverse=True) + + # Look for any lines containing parameters in paramlist. If those lines + # are unassigned (-1), then assign them to the same cell that the parameter + # was assigned to. NOTE: Assumes that there will never be two parameters + # on the same line that were from two different subcircuits that is not + # already marked as a common parameter. + + lineno = -1 + for line in inplines: + lineno += 1 + if linedest[lineno] == -1: + for param in paramlist: + if param in line: + linedest[lineno] = linedest[paramlist[param]] + break + + # Ad hoc method: Look for any lines containing each cell name, and assign + # that line to the cell. That isolates parameters that belong to only one + # cell. Ignore comment lines from line 1 down to the first non-comment line. + # Since all parameters and comment blocks have been handled, this is not + # likely to change anything. + + lineno = -1 + for line in inplines: + lineno = -1 + if not line.startswith('*'): + break + + topcomm = True + for line in inplines: + lineno += 1 + if topcomm and not line.startswith('*'): + topcomm = False + + if not topcomm: + if linedest[lineno] == -1: + for subname in subnames: + subno = filenos[subname] + if subname in line: + linedest[lineno] = subno + break + + # All lines marked -1 except for comment lines should be remarked -3 + # (go into the common file only) + + lineno = -1 + for line in inplines: + lineno += 1 + if linedest[lineno] == -1: + if not line.startswith('*'): + linedest[lineno] = -3 + + # All comment lines that are surrounded by lines marked -3 should + # also be marked -3. This keeps comments that are completely inside + # blocks that are only in the common file out of the individual files. + + lineno = 0 + for line in inplines[1:]: + lineno += 1 + if linedest[lineno] == -1 and linedest[lineno - 1] == -3: + testline = lineno + 1 + while linedest[testline] == -1: + testline += 1 + if linedest[testline] == -3: + testline = lineno + while linedest[testline] == -1: + linedest[testline] = -3 + testline += 1 + + froot = os.path.split(in_file)[1] + for subname in subnames: + subno = filenos[subname] + fext = os.path.splitext(in_file)[1] + + # Guard against one of the split files having the same name as + # the original, since we need to keep the original file. + if subname == os.path.splitext(froot)[0]: + fext = '_split' + fext + + # Output the result to out_file. + with open(out_path + '/' + subname + fext, 'w') as ofile: + firstline = True + lineno = -1 + for line in inplines: + lineno += 1 + if linedest[lineno] == subno or linedest[lineno] == -1: + if firstline: + print('* File ' + subname + fext + ' split from ' + froot + ' by split_one_spice.py', file=ofile) + firstline = False + print(line, file=ofile) + + # Debug: Print one diagnostic file (do this before messing with the + # linedest[] entries in the next step). This debug file shows which + # lines of the file are split into which file, and which lines are + # common. + + ffile = os.path.split(in_file)[1] + froot = os.path.splitext(ffile)[0] + fext = os.path.splitext(ffile)[1] + + with open(out_path + '/' + froot + '_debug' + fext, 'w') as ofile: + for subname in subnames: + subno = filenos[subname] + print(str(subno) + '\t' + subname, file=ofile) + + print('\n', file=ofile) + + lineno = -1 + for line in inplines: + lineno += 1 + print(str(linedest[lineno]) + '\t' + line, file=ofile) + + # Reset all linedest[] entries except the bottommost entry for each subcircuit. + lineno = len(inplines) + subrefs = [0] * len(subnames) + while lineno > 0: + lineno -= 1 + if linedest[lineno] >= 0: + if subrefs[linedest[lineno]] == 0: + subrefs[linedest[lineno]] = 1 + else: + linedest[lineno] = -2 + + # Print the original file, including each of the new files. + # Also print out all lines marked "-1" or "-3" + + with open(out_path + '/' + froot + fext, 'w') as ofile: + lineno = -1 + subno = -1 + for line in inplines: + lineno += 1 + if linedest[lineno] == -1 or linedest[lineno] == -3 : + print(line, file=ofile) + elif linedest[lineno] >= 0: + for subname in subnames: + if filenos[subname] == linedest[lineno]: + fext = os.path.splitext(in_file)[1] + if subname == os.path.splitext(froot)[0]: + fext = '_split' + fext + break + print('.include ' + subname + fext, file=ofile) + subno = linedest[lineno] + +if __name__ == '__main__': + debug = False + + if len(sys.argv) == 1: + print("No options given to split_one_spice.py.") + usage() + sys.exit(0) + + optionlist = [] + arguments = [] + + for option in sys.argv[1:]: + if option.find('-', 0) == 0: + optionlist.append(option) + else: + arguments.append(option) + + if len(arguments) != 2: + print("Wrong number of arguments given to split_one_spice.py.") + usage() + sys.exit(0) + + if '-debug' in optionlist: + debug = True + + inpath = arguments[0] + outpath = arguments[1] + do_one_file = False + + if not os.path.exists(inpath): + print('No such source file ' + inpath) + sys.exit(1) + + if not os.path.isfile(inpath): + print('Input path ' + inpath + ' is not a file.') + sys.exit(1) + + convert_file(inpath, outpath) + + print('Done.') + exit(0)