#!/usr/bin/env python3
# Script to read all files in a directory of SPECTRE-compatible device model
# files, and convert them to a form that is compatible with ngspice.

import csv
import glob
import json
import os
import pprint
import re
import sys
import textwrap

from collections import defaultdict


WIDTH=200


def usage():
    print('spectre_to_spice.py <path_to_spectre> <path_to_spice>')
    print('    [-nocmt] [-debug] [-ignore=file1,file2,...]')

# Check if a parameter value is a valid number (real, float, integer)
# or is some kind of expression.

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

# Parse a parameter line.  If "inparam" is true, then this is a continuation
# line of an existing parameter statement.  If "insub" is not true, then the
# paramters are global parameters (not part of a subcircuit).
#
# If inside a subcircuit, remove the keyword "parameters".  If outside,
# change it to ".param"

def parse_param_line(line, inparam, insub, iscall, ispassed):

    # Regexp patterns
    parm1rex = re.compile('[ \t]*parameters[ \t]*(.*)')
    parm2rex = re.compile('[ \t]*params:[ \t]*(.*)')
    parm3rex = re.compile('[ \t]*\+[ \t]*(.*)')
    parm4rex = re.compile('[ \t]*([^= \t]+)[ \t]*=[ \t]*([^ \t]+)[ \t]*(.*)')
    parm5rex = re.compile('[ \t]*([^= \t]+)[ \t]*(.*)')
    parm6rex = re.compile('[ \t]*([^= \t]+)[ \t]*=[ \t]*([\'{][^\'}]+[\'}])[ \t]*(.*)')
    rtok = re.compile('([^ \t\n]+)[ \t]*(.*)')

    fmtline = []

    if iscall:
        rest = line
    elif inparam:
        pmatch = parm3rex.match(line)
        if pmatch:
            fmtline.append('+')
            rest = pmatch.group(1)
        else:
            return '', ispassed
    else:
        pmatch = parm1rex.match(line)
        if pmatch:
            if insub:
                fmtline.append('+')
            else:
                fmtline.append('.param')
            rest = pmatch.group(1)
        else:
            pmatch = parm2rex.match(line)
            if pmatch:
                if insub:
                    fmtline.append('+')
                else:
                    return '', ispassed
                rest = pmatch.group(1)
            else:
                return '', ispassed

    while rest != '':
        if iscall:
            # It is hard to believe this is legal syntax, but there are
            # instances of "x * y" with spaces in the expression and no
            # quotes or braces delimiting the expression.
            rest = re.sub('[ \t]*\*[ \t]*', '*', rest)

        pmatch = parm4rex.match(rest)
        if pmatch:
            if ispassed:
                # End of passed parameters.  Break line and generate ".param"
                ispassed = False
                fmtline.append('\n.param ')

            # If expression is already in single quotes or braces, then catch
            # everything inside the delimiters, including any spaces.
            if pmatch.group(2).startswith("'") or pmatch.group(2).startswith('{'):
                pmatchx = parm6rex.match(rest)
                if pmatchx:
                    pmatch = pmatchx

            fmtline.append(pmatch.group(1))
            fmtline.append('=')
            value = pmatch.group(2)
            rest = pmatch.group(3)

            # Watch for spaces in expressions (have they no rules??!)
            # as indicated by something after a space not being an
            # alphabetical character (parameter name) or '$' (comment)

            needmore = False
            while rest != '':
                rmatch = rtok.match(rest)
                if rmatch:
                    expch = rmatch.group(1)[0]
                    if expch == '$':
                        break
                    elif expch.isalpha() and not needmore:
                        break
                    else:
                        needmore = False
                        value += rmatch.group(1)
                        rest = rmatch.group(2)
                        if any((c in '+-*/({^~!') for c in rmatch.group(1)[-1]):
                            needmore = True
                        if rest != '' and any((c in '+-*/(){}^~!') for c in rest[0]):
                            needmore = True
                else:
                    break

            if is_number(value):
                fmtline.append(value)
            elif value.strip().startswith("'"):
                fmtline.append(value)
            else:
                # It is not possible to know if a spectre expression continues
                # on another line without some kind of look-ahead, but check
                # if the parameter ends in an operator.
                lastc = value.strip()[-1]
                if any((c in '*+-/,(') for c in lastc):
                    fmtline.append('{' + value)
                else:
                    fmtline.append('{' + value + '}')

            # These parameter sub-expressions are related to monte carlo
            # simulation and are incompatible with ngspice.  So put them
            # in an in-line comment.  Avoid double-commenting things that
            # were already in-line comments.

            if rest != '':
                nmatch = parm4rex.match(rest)
                if not nmatch:
                    if rest.lstrip().startswith('$ '):
                        fmtline.append(rest)
                    elif rest.strip() != '':
                        fmtline.append(' $ ' + rest.replace(' ', '').replace('\t', ''))
                    rest = ''
        else:
            # Match to a CDL subckt parameter that does not have an '=' and so
            # assumes that the parameter is always passed, and therefore must
            # be part of the .subckt line.  A parameter without a value is not
            # legal SPICE, so supply a default value of 1.

            pmatch = parm5rex.match(rest)
            if pmatch:
                # NOTE:  Something that is not a parameter name should be
                # extended from the previous line.  Note that this parsing is
                # not rigorous and is possible to break. . .
                if any((c in '+-*/(){}^~!') for c in pmatch.group(1).strip()):
                    fmtline.append(rest)
                    if not any((c in '*+-/,(') for c in rest.strip()[-1]):
                        fmtline.append('}')
                    rest = ''
                else:
                    # Parameter name must have a value.  Set default 1
                    fmtline.append(pmatch.group(1) + '=1')
                    ispassed = True
                    rest = pmatch.group(2)
            else:
                break

    finalline = ' '.join(fmtline)

    # ngspice does not understand round(), so replace it with the equivalent
    # floor() expression.

    finalline = re.sub('round\\(', 'floor(0.5+', finalline)

    # use of "no" and "yes" as parameter values is not allowed in ngspice.

    finalline = re.sub('sw_et[ \t]*=[ \t]*{no}', 'sw_et=0', finalline)
    finalline = re.sub('sw_et[ \t]*=[ \t]*{yes}', 'sw_et=1', finalline)
    finalline = re.sub('isnoisy[ \t]*=[ \t]*{no}', 'isnoisy=0', finalline)
    finalline = re.sub('isnoisy[ \t]*=[ \t]*{yes}', 'isnoisy=1', finalline)

    # Use of "m" in parameters is forbidden.  Specifically look for "{N*m}".
    # e.g., replace "mult = {2*m}" with "mult = 2".  Note that this usage
    # is most likely an error in the source.

    finalline = re.sub('\{([0-9]+)\*[mM]\}', r'\1', finalline)

    return finalline, ispassed

def get_param_names(line):
    # Find parameter names in a ".param" line and return a list of them.
    # This is used to check if a bare word parameter name is passed to
    # a capacitor or resistor device in the position of a value but
    # without delimiters, so that it cannot be distinguished from a
    # model name.  There are only a few instances of this, so this
    # routine is not rigorously checking all parameters, just entries
    # on lines with ".param".
    parmrex = re.compile('[ \t]*([^= \t]+)[ \t]*=[ \t]*([^ \t]+)[ \t]*(.*)')
    rest = line
    paramnames = []
    while rest != '':
        pmatch = parmrex.match(rest)
        if pmatch:
            paramnames.append(pmatch.group(1))
            rest = pmatch.group(3)
        else:
            break
    return paramnames

def convert_file(in_file, out_file, nocmt, ignore='', debug=False):
    #if in_file.endswith('monte.cor') or in_file.endswith('models.all'):
    #    print("Skipping", in_file)
    #    return

    if in_file in ignore:
        print('Skipping ', in_file)
        return

    print("Starting to convert", in_file)

    # Regexp patterns
    setsoarex = re.compile('[ \t]*\.setsoa[ \t]+', re.IGNORECASE)
    statrex = re.compile('[ \t]*statistics[ \t]*\{(.*)')
    simrex = re.compile('[ \t]*simulator[ \t]+([^= \t]+)[ \t]*=[ \t]*(.+)')
    insubrex = re.compile('[ \t]*inline[ \t]+subckt[ \t]+([^ \t\(]+)[ \t]*\(([^)]*)')
    cdlsubrex = re.compile('\.?subckt[ \t]+([^ \t\(]+)[ \t]*\(([^)]*)')
    endsubrex = re.compile('[ \t]*ends[ \t]*(.*)')
    endonlysubrex = re.compile('[ \t]*ends[ \t]*')
    modelrex = re.compile('[ \t]*model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+\{(.*)')
    cdlmodelrex = re.compile('[ \t]*model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+(.*)')
    binrex = re.compile('[ \t]*([0-9]+):[ \t]+type[ \t]*=[ \t]*(.*)')
    shincrex = re.compile('\.inc[ \t]+')
    isexprrex = re.compile('[^0-9a-zA-Z_]')
    paramrex = re.compile('\.param[ \t]+(.*)')

    stdsubrex = re.compile('\.subckt[ \t]+([^ \t]+)[ \t]+(.*)')
    stdmodelrex = re.compile('\.model[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]*(.*)')
    stdendsubrex = re.compile('\.ends[ \t]+(.+)')
    stdendonlysubrex = re.compile('\.ends[ \t]*')

    # Devices (resistor, capacitor, subcircuit as resistor or capacitor)
    caprex = re.compile('c([^ \t]+)[ \t]*\(([^)]*)\)[ \t]*capacitor[ \t]*(.*)', re.IGNORECASE)
    resrex = re.compile('r([^ \t]+)[ \t]*\(([^)]*)\)[ \t]*resistor[ \t]*(.*)', re.IGNORECASE)
    cdlrex = re.compile('[ \t]*([npcrdlmqx])([^ \t]+)[ \t]*\(([^)]*)\)[ \t]*([^ \t]+)[ \t]*(.*)', re.IGNORECASE)
    stddevrex = re.compile('[ \t]*([cr])([^ \t]+)[ \t]+([^ \t]+[ \t]+[^ \t]+)[ \t]+([^ \t]+)[ \t]*(.*)', re.IGNORECASE)
    stddev2rex = re.compile('[ \t]*([cr])([^ \t]+)[ \t]+([^ \t]+[ \t]+[^ \t]+)[ \t]+([^ \t\'{]+[\'{][^\'}]+[\'}])[ \t]*(.*)', re.IGNORECASE)
    stddev3rex = re.compile('[ \t]*([npcrdlmqx])([^ \t]+)[ \t]+(.*)', re.IGNORECASE)

    in_dir = os.path.dirname(in_file)

    with open(in_file, 'r') as ifile:
        idata = ifile.read()

    in_s8xfile = '../../s8x/Models/'+os.path.basename(in_file)

    def include(m):
        incfile = m.group('file')
        print("  Includes", incfile)
        if incfile == in_s8xfile or incfile.endswith('sonos_tteol.cor'):
            s8xpath = os.path.abspath(os.path.join(in_dir, incfile))
            print("  Pulling", s8xpath, "({}) into".format(incfile), in_file)
            return open(s8xpath).read()
        else:
            return m.group(0)

    idata = RE_TRAILING_WS.sub('', idata)
    idata = RE_INCLUDE.sub(include, idata)

    if nocmt:
        speclines = rewrite_comments(out_file, idata)
    else:
        speclines = idata.splitlines()

    insub = False
    inparam = False
    inmodel = False
    inpinlist = False
    isspectre = False
    ispassed = False
    spicelines = []
    calllines = []
    modellines = []
    paramnames = []
    savematch = None
    blockskip = 0
    subname = ''
    subnames = []
    modname = ''
    modtype = ''

    # For future reference:  A much better approach to this is to first contatenate
    # all continuation lines by replacing the "+" with "\n", which can be treated
    # as whitespace in any regexp.  This makes parsing continuation lines much
    # simpler, as there is no need to do any "look-ahead" to check what's on the
    # next line(s).  At the end, all "\n" in strings can be replaced by "\n+",
    # which preserves the original formatting of the continuation lines.

    for line in speclines:

        # Item 1a.  C++-style // comments get replaced with * comment character
        if line.strip().startswith('//'):
            # Replace the leading "//" with SPICE-style comment "*".
            if modellines != []:
                modellines.append(line.strip().replace('//', '*', 1))
            elif calllines != []:
                calllines.append(line.strip().replace('//', '*', 1))
            else:
                spicelines.append(line.strip().replace('//', '*', 1))
            continue

        # Item 1b.  In-line C++-style // comments get replaced with $ comment character
        elif ' //' in line:
            line = line.replace(' //', ' $ ', 1)
        elif '//' in line:
            line = line.replace('//', ' $ ', 1)
        elif '\t//' in line:
            line = line.replace('\t//', '\t$ ', 1)

        # Item 2.  Handle SPICE-style comment lines
        if line.strip().startswith('*'):
            if modellines != []:
                modellines.append(line.strip())
            elif calllines != []:
                calllines.append(line.strip())
            else:
                spicelines.append(line.strip())
            continue

        # Item 4.  Flag continuation lines
        if line.strip().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() == '':
            if modellines != []:
                modellines.append(line.strip())
            elif calllines != []:
                calllines.append(line.strip())
            else:
                spicelines.append(line.strip())
            continue

        # Item 5.  Count through { ... } blocks that are not SPICE syntax
        if blockskip > 0:
            # Warning:  Assumes one brace per line, may or may not be true
            if '{' in line:
                blockskip = blockskip + 1
            elif '}' in line:
                blockskip = blockskip - 1
                if blockskip == 0:
                    spicelines.append('* ' + line)
                    continue

        if blockskip > 0:
            spicelines.append('* ' + line)
            continue

        # Item 6.  Handle continuation lines
        if contline:
            if inparam:
                # Continue handling parameters
                fmtline, ispassed = parse_param_line(line, inparam, insub, False, ispassed)
                if fmtline != '':
                    if modellines != []:
                        modellines.append(fmtline)
                    elif calllines != []:
                        calllines.append(fmtline)
                    else:
                        spicelines.append(fmtline)
                    continue

        # Item 7.  Regexp matching

        # Catch "simulator lang="
        smatch = simrex.match(line)
        if smatch:
            if smatch.group(1) == 'lang':
                if smatch.group(2) == 'spice':
                    isspectre = False
                elif smatch.group(2) == 'spectre':
                    isspectre = True
            continue

        # If inside a subcircuit, remove "parameters".  If outside,
        # change it to ".param"
        fmtline, ispassed = parse_param_line(line, inparam, insub, False, ispassed)
        if fmtline != '':
            inparam = True
            spicelines.append(fmtline)
            continue

        # ".setsoa" not handled by ngspice (comment it out)
        smatch = setsoarex.match(line)
        if smatch:
            spicelines.append('* ' + line)
            continue

        # statistics---not sure if it is always outside an inline subcircuit
        smatch = statrex.match(line)
        if smatch:
            if '}' not in smatch.group(1):
                blockskip = 1
                spicelines.append('* ' + line)
                continue

        # model---not sure if it is always inside an inline subcircuit
        iscdl = False
        if isspectre:
            mmatch = modelrex.match(line)
            if not mmatch:
                mmatch = cdlmodelrex.match(line)
                if mmatch:
                    iscdl = True
        else:
            mmatch = stdmodelrex.match(line)

        if mmatch:
            modname = mmatch.group(1)
            modtype = mmatch.group(2)

            if isspectre and '}' in mmatch.group(1):
                savematch = mmatch
                inmodel = 1
                # Continue to "if inmodel == 1" block below
            else:
                fmtline, ispassed = parse_param_line(mmatch.group(3), True, False, True, ispassed)
                if isspectre and (modtype == 'resistor' or modtype == 'r2'):
                    modtype = 'r'
                modellines.append('.model ' + modname + ' ' + modtype + ' ' + fmtline)
                if fmtline != '':
                    inparam = True

                inmodel = 2
                continue

        if not insub:
            # Things to parse if not in a subcircuit
            imatch = insubrex.match(line) if isspectre else None

            if not imatch:
                # Check for spectre format subckt or CDL format .subckt lines
                imatch = cdlsubrex.match(line)

            if not imatch:
                if not isspectre:
                    # Check for standard SPICE format .subckt lines
                    imatch = stdsubrex.match(line)

            if imatch:
                # If a model block is pending, then dump it
                if modellines != []:
                    for line in modellines:
                        spicelines.append(line)
                    modellines = []
                    inmodel = False

                insub = True
                ispassed = True
                subname = imatch.group(1)
                subnames.append(subname)
                if isspectre:
                    devrex = re.compile(subname + '[ \t]*\(([^)]*)\)[ \t]*([^ \t]+)[ \t]*(.*)', re.IGNORECASE)
                else:
                    devrex = re.compile(subname + '[ \t]*([^ \t]+)[ \t]*([^ \t]+)[ \t]*(.*)', re.IGNORECASE)
                # If there is no close-parenthesis then we should expect it on
                # a continuation line
                inpinlist = True if ')' not in line else False
                # Remove parentheses groups from subcircuit arguments
                spicelines.append('.subckt ' + ' ' + subname + ' ' + imatch.group(2))
                continue

        else:
            # Things to parse when inside of an "inline subckt" block

            if inpinlist:
                # Watch for pin list continuation line.
                if isspectre:
                    if ')' in line:
                        inpinlist = False
                    pinlist = line.replace(')', '')
                    spicelines.append(pinlist)
                else:
                    spicelines.append(line)
                continue

            else:
                if isspectre:
                    ematch = endsubrex.match(line)
                    if not ematch:
                        ematch = endonlysubrex.match(line)
                else:
                    ematch = stdendsubrex.match(line)
                    if not ematch:
                        ematch = stdendonlysubrex.match(line)

                if ematch:
                    try:
                        endname = ematch.group(1).strip()
                    except:
                        pass
                    else:
                        if endname != subname and endname != '':
                            print('Error:  "ends" name does not match "subckt" name!')
                            print('"ends" name = ' + endname)
                            print('"subckt" name = ' + subname)
                    if len(calllines) > 0:
                        line = calllines[0]
                        if modtype.startswith('bsim'):
                            line = 'M' + line
                        elif modtype.startswith('nmos'):
                            line = 'M' + line
                        elif modtype.startswith('pmos'):
                            line = 'M' + line
                        elif modtype.startswith('res'):
                            line = 'R' + line
                        elif modtype.startswith('cap'):
                            line = 'C' + line
                        elif modtype.startswith('pnp'):
                            line = 'Q' + line
                        elif modtype.startswith('npn'):
                            line = 'Q' + line
                        elif modtype.startswith('d'):
                            line = 'D' + line
                        spicelines.append(line)

                        for line in calllines[1:]:
                            spicelines.append(line)
                        calllines = []

                    # Last check:  Do any model types confict with the way they
                    # are called within the subcircuit?  Spectre makes it very
                    # hard to know what type of device is being instantiated. . .

                    for modelline in modellines:
                        mmatch = stdmodelrex.match(modelline)
                        if mmatch:
                            modelname = mmatch.group(1).lower().split('.')[0]
                            modeltype = mmatch.group(2).lower()
                            newspicelines = []
                            for line in spicelines:
                                cmatch = stddev3rex.match(line)
                                if cmatch:
                                    devtype = cmatch.group(1).lower()
                                    if modelname in cmatch.group(3):
                                        if devtype == 'x':
                                            if modeltype == 'pnp' or modeltype == 'npn':
                                                line = 'q' + line[1:]
                                            elif modeltype == 'c' or modeltype == 'r':
                                                line = modeltype + line[1:]
                                            elif modeltype == 'd':
                                                line = modeltype + line[1:]
                                            elif modeltype == 'nmos' or modeltype == 'pmos':
                                                line = 'm' + line[1:]
                                newspicelines.append(line)
                            spicelines = newspicelines

                    # Now add any in-circuit models
                    spicelines.append('')
                    for line in modellines:
                        spicelines.append(line)
                    modellines = []

                    # Complete the subcircuit definition
                    spicelines.append('.ends ' + subname)

                    insub = False
                    inmodel = False
                    subname = ''
                    paramnames = []
                    continue

            # Check for close of model
            if isspectre and inmodel:
                if '}' in line:
                    inmodel = False
                    continue

            # Check for devices R and C.
            dmatch = caprex.match(line)
            if dmatch:
                fmtline, ispassed = parse_param_line(dmatch.group(3), True, insub, True, ispassed)
                if fmtline != '':
                    inparam = True
                    spicelines.append('c' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + fmtline)
                    continue
                else:
                    spicelines.append('c' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + dmatch.group(3))
                    continue

            dmatch = resrex.match(line)
            if dmatch:
                fmtline, ispassed = parse_param_line(dmatch.group(3), True, insub, True, ispassed)
                if fmtline != '':
                    inparam = True
                    spicelines.append('r' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + fmtline)
                    continue
                else:
                    spicelines.append('r' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + dmatch.group(3))
                    continue

            cmatch = cdlrex.match(line)
            if not cmatch:
                if not isspectre or 'capacitor' in line or 'resistor' in line:
                    cmatch = stddevrex.match(line)

            if cmatch:
                ispassed = False
                devtype = cmatch.group(1)
                devmodel = cmatch.group(4)

                # Handle spectreisms. . .
                if devmodel == 'capacitor':
                    devtype = 'c'
                    devmodel = ''
                elif devmodel == 'resistor':
                    devtype = 'r'
                    devmodel = ''
                elif devtype.lower() == 'n' or devtype.lower() == 'p':
                    # May be specific to SkyWater models, or is it a spectreism?
                    devtype = 'x' + devtype

                # If a capacitor or resistor value is a parameter or expression,
                # it must be enclosed in single quotes.  Otherwise, if the named
                # device model is a subcircuit, then the devtype must be "x".

                elif devtype.lower() == 'c' or devtype.lower() == 'r':
                    if devmodel in subnames:
                        devtype = 'x' + devtype
                    else:
                        devvalue = devmodel.split('=')
                        if len(devvalue) > 1:
                            if "'" in devvalue[1] or "{" in devvalue[1]:
                                # Re-parse this catching everything in delimiters,
                                # including spaces.
                                cmatch2 = stddev2rex.match(line)
                                if cmatch2:
                                    cmatch = cmatch2
                                    devtype = cmatch.group(1)
                                    devmodel = cmatch.group(4)
                                    devvalue = devmodel.split('=')

                            if  isexprrex.search(devvalue[1]):
                                if devvalue[1].strip("'") == devvalue[1]:
                                    devmodel = devvalue[0] + "='" + devvalue[1] + "'"
                        else:
                            if devmodel in paramnames or isexprrex.search(devmodel):
                                if devmodel.strip("'") == devmodel:
                                    devmodel = "'" + devmodel + "'"

                fmtline, ispassed = parse_param_line(cmatch.group(5), True, insub, True, ispassed)
                if fmtline != '':
                    inparam = True
                    # "perim" in diodes is not permitted by ngspice
                    if devtype == 'd':
                        fmtline = re.sub('[ \t]+perim[ \t]*=[ \t]*[^ \t]+', '', fmtline)
                    spicelines.append(devtype + cmatch.group(2) + ' ' + cmatch.group(3) + ' ' + devmodel + ' ' + fmtline)
                    continue
                else:
                    spicelines.append(devtype + cmatch.group(2) + ' ' + cmatch.group(3) + ' ' + devmodel + ' ' + cmatch.group(5))
                    continue
            else:
                 # SkyWater-specific handling for model nvhv and pvhv, which
                 # call the _base subcircuit as type 'm'.
                 cmatch = stddev3rex.match(line)
                 if cmatch:
                     devtype = cmatch.group(1)
                     if devtype.lower() == 'm':
                         devname = cmatch.group(2)
                         if devname == 'ain1':
                             line = 'x' + line

            # Check for a .param line and collect parameter names
            pmatch = paramrex.match(line)
            if pmatch:
                paramnames.extend(get_param_names(pmatch.group(1)))

            # Check for a line that begins with the subcircuit name

            dmatch = devrex.match(line)
            if dmatch:
                fmtline, ispassed = parse_param_line(dmatch.group(3), True, insub, True, ispassed)
                if fmtline != '':
                    inparam = True
                    calllines.append(subname + ' ' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + fmtline)
                    continue
                else:
                    calllines.append(subname + ' ' + dmatch.group(1) + ' ' + dmatch.group(2) + ' ' + dmatch.group(3))
                    continue

        if inmodel == 1 or inmodel == 2:
            # This line should have the model bin, if there is one, and a type.
            if inmodel == 1:
                bmatch = binrex.match(savematch.group(3))
                savematch = None
            else:
                bmatch = binrex.match(line)

            if bmatch:
                bin = bmatch.group(1)
                type = bmatch.group(2)

                if type == 'n':
                    convtype = 'nmos'
                elif type == 'p':
                    convtype = 'pmos'
                else:
                    convtype = type

                # If there is a binned model then it replaces any original
                # model line that was saved.
                if modellines[-1].startswith('.model'):
                    modellines = modellines[0:-1]
                modellines.append('')
                modellines.append('.model ' + modname + '.' + bin + ' ' + convtype)
                continue

            else:
                fmtline, ispassed = parse_param_line(line, True, True, False, ispassed)
                if fmtline != '':
                    modellines.append(fmtline)
                    continue

        # Copy line as-is
        spicelines.append(line)

    # Make sure any pending model lines are taken care of
    if modellines != []:
        for line in modellines:
            spicelines.append(line)
        modellines = []
        inmodel = False

    output = '\n'.join(spicelines)
    output = cleanup_spice_data(output)
    if not output.strip():
        print("Skipping empty file:", outfile)
        return

    # Output the result to out_file.
    print("Writing", out_file)
    assert not os.path.exists(out_file), out_file
    with open(out_file, 'w') as ofile:
        ofile.write(output)


RE_MULTI_NEWLINE = re.compile('\\n+')
RE_BSIM4 = re.compile('^NEW BSIM4 Parameters\\(([^)]*)\\)$', flags=re.I|re.M)

RE_DUP_LINES = re.compile('^(?P<l>.+)$\\n*(?P=l)', flags=re.M)


def strip_comment(cmt):
    """

    >>> strip_comment(['  // File created for mismatch simulations.'])
    'File created for mismatch simulations.'

    >>> strip_comment(['//', '// DC IV MOS PARAMETERS', '//'])
    'DC IV MOS PARAMETERS'

    >>> strip_comment(['// ****', '//', '//  ROUT PARAMETERS', '//'])
    'ROUT PARAMETERS'

    >>> strip_comment([
    ...   '**  models for resistance and capacitances **',
    ...   '**             this is lrhc corner         **',
    ...   '*********************************************',
    ...   '**********************************************',
    ...   '**    tolerances of different layers        **',
    ...   '**********************************************',
    ... ])
    'models for resistance and capacitances\\n           this is lrhc corner\\n  tolerances of different layers'

    >>> strip_comment(['// **PARAMETERS FOR ASYMMETRIC AND BIAS-DEPENDENT RDS MODEL******'])
    'PARAMETERS FOR ASYMMETRIC AND BIAS-DEPENDENT RDS MODEL'

    >>> strip_comment(['// NEW BSIM4 Parameters(Model Selectors)'])
    'BSIM4 - Model Selectors'

    """
    if not cmt:
        return ''
    cmt = list(cmt)

    for i, c in enumerate(cmt):
        cmt[i] = c.lstrip()

    # Remove the comment character
    if cmt[0].startswith('*'):
        p = '*'
    elif cmt[0].startswith('//'):
        p = '//'
    elif cmt[0].startswith('$'):
        p = '$'
    else:
        raise ValueError('Unknown starting comment: '+repr(cmt[0]))

    for i, c in enumerate(cmt):
        assert c.startswith(p), repr((p, i, c))+'\n'+pprint.pformat(cmt, width=100)
        if c.endswith(p):
            cmt[i] = c[len(p):-len(p)]
        else:
            cmt[i] = c[len(p):]

    # Remove boxes around stuff
    # This should also cover full lines of a single character like '*****' or '#####'
    for i, c in enumerate(cmt):
        if len(c) <= 2:
            continue
        c = c.strip()
        while c and c[0] == c[-1] and not c[0].isalnum() and c[0] != ' ':
            c = c[1:-1]
        cmt[i] = c

    for i, c in enumerate(cmt):
        cmt[i] = c.strip('*')

    # Find the longest prefix
    if len(cmt) > 1:
        p = os.path.commonprefix(cmt)
        for i, c in enumerate(cmt):
            cmt[i] = c[len(p):].rstrip()

    cmt = '\n'.join(cmt)
    cmt = textwrap.dedent(cmt).strip()

    cmt = RE_MULTI_NEWLINE.sub('\n', cmt)

    # Fix a spelling mistake...
    cmt = cmt.replace('PARAMTERS', 'PARAMETERS')

    # Strip out the BSIM4 parameters comment
    cmt = RE_BSIM4.sub('BSIM4 - \\1', cmt)

    return cmt


RE_BIN = re.compile('([^,]+),\\s+Bin\\s+([^,]+),(.*)')

RE_PARAM = re.compile('[\w\s+.()/-]*((PARAMETERS)|(SELECTORS))[\w\s+.()/-]*', flags=re.I)
RE_PARAM_END = re.compile('PARAMETERS$', flags=re.I)
RE_FIX_CASE = re.compile('\\b([A-Z][A-Z][A-Z][A-Z][A-Z]*)\\b')

RE_UNITS = re.compile('Units:\\w*(.*)', flags=re.I)

# for L>=4 and W<=0.75
RE_L_AND_W = re.compile('((L[\s<>]=)|(W[\s<>]=))')


# 'High Density 3-terminal Vertical Parallel Plate Capacitor (for S8P ONLY)\nFixed layout is here:\n$depot/icm/proj/s8rf2/dev/opus/s8rf2/s8rf2_xcmvpp_hd5_atlas_fingercap2_l5'
# '3-terminal Vertical Parallel Plate Capacitor /w LI-M5 Shield (for S8P ONLY)\nThis is the ~100fF fixed capacitor model\nFixed layout is here:\ndepot/icm/proj/s8rf2/dev/opus/s8rf2/s8rf2_xcmvpp11p5x11p7_m3_lim5shield/layout'

RE_CAP = re.compile('(?P<desc1>.*)\\(for S8P ONLY\\)(?P<desc2>.*)Fixed layout is here:(?P<oldp>.*?)/(?P<p>[^/]*)((?:/layout)|$)', flags=re.DOTALL|re.I)

UNIT_MAPPING = {
    '1/c':           '1/coulomb',
    '1/c^2':         '1/coulomb^2',
    '1/oc':          '1/celsius',
    '1/volt':        'volt',
    'a':             'amper',
    'a/m':           'amper/meter',
    'a/m^2':         'amper/meter^2',
    'angstrom':      'angstrom',
    'c':             'coulomb',
    'ev':            'electron-volt',
    'ev/c':          'electron-volt/coulomb',
    'ev/k':          'electron-volt/kelvin',
    'farads/m':      'farad/meter',
    'farads/m^2':    'farad/meter^2',
    'f/m':           'farad/meter',
    'f/m^2':         'farad/meter^2',
    'm':             'meter',
    'meter':         'meter',
    'f/um':          'farad/micrometer',
    'f/um^2':        'farad/micrometer^2',
    'v':             'volt',
    'v/c':           'volt/coulomb',
    # Long replacements
    'ohms (ohms/m^2 if area defined in netlist)': 'ohm (ohm/meter^2 if area defined)',
    'temerature in oc passed from eldo *.temp statements': 'celsius',
}


def process_special_comments(cmt):
    """

    >>> process_special_comments(strip_comment(['// NEW BSIM4 Parameters(Mobility Parameters)']))
    ('BSIM4 - Mobility Parameters', 'param', ['BSIM4 - Mobility'])

    >>> process_special_comments('nlowvt_rf_base_m4_b,  Bin 008,   W = 5.05,   L = 0.25')
    ('\\nnlowvt_rf_base_m4_b, Bin 008, W = 5.05, L = 0.25\\n------------------------------------------------', 'bin', [['nlowvt_rf_base_m4_b', 'Bin 008', 'W = 5.05', 'L = 0.25']])

    >>> process_special_comments('Parameters TO Make Model Into Cadflow')
    (False, None, [])

    >>> process_special_comments('DC IV MOS PARAMETERS')
    ('DC IV MOS Parameters', 'param', ['DC IV MOS'])

    >>> process_special_comments('DC IV MOS parameters')
    ('DC IV MOS parameters', 'param', ['DC IV MOS'])

    >>> process_special_comments('GATE INDUCED DRAIN LEAKAGE MODEL PARAMETERS')
    ('Gate Induced Drain Leakage Model Parameters', 'param', ['Gate Induced Drain Leakage Model'])

    >>> process_special_comments('P+ Poly Preres Parameters')
    ('P+ Poly Preres Parameters', 'param', ['P+ Poly Preres'])

    >>> process_special_comments('Units:  F/um')
    ('Units: farad/micrometer', 'units', ['farad/micrometer'])
    >>> process_special_comments(' F/um ')
    ('Units: farad/micrometer', 'units', ['farad/micrometer'])

    >>> process_special_comments('All devices')
    ('All devices', None, [])

    >>> process_special_comments('Not used')
    ('Not used', None, [])

    >>> process_special_comments('All W with L=0.5um')
    ('All W with L=0.5um', None, [])

    >>> process_special_comments('for L>=4 and W<=0.75')
    ('for L>=4 and W<=0.75', None, [])

    >>> process_special_comments('Default Corner File created by discrete_corners\\nNumber of BINS: 1')
    ('Number of bins: 1', None, [])

    >>> process_special_comments('4-terminal Vertical Parallel Plate Capacitor /w LI-M4 fingers and M5 Shield (for S8P ONLY)\\nFixed layout is here:\\ndepot/icm/proj/s8rf2/dev/opus/s8rf2/s8rf2_xcmvpp11p5x11p7_m5shield')
    ('4-terminal Vertical Parallel Plate Capacitor /w LI-M4 fingers and M5 Shield\\nLayout: s8rf2_xcmvpp11p5x11p7_m5shield', None, [])

    >>> process_special_comments("3-terminal Vertical Parallel Plate Capacitor /w LI-M5 Shield (for S8P ONLY)\\nThis is the ~100fF fixed capacitor model\\nFixed layout is here:\\ndepot/icm/proj/s8rf2/dev/opus/s8rf2/s8rf2_xcmvpp11p5x11p7_m3_lim5shield/layout")
    ('3-terminal Vertical Parallel Plate Capacitor /w LI-M5 Shield\\nThis is the ~100fF fixed capacitor model\\nLayout: s8rf2_xcmvpp11p5x11p7_m3_lim5shield', None, [])

    >>> process_special_comments("Include files in ../../../s8x/ directory\\nP+ Poly Preres Corner Parameters")
    ('P+ Poly Preres Corner Parameters', 'param', ['P+ Poly Preres Corner'])


    >>> pprint.pprint(process_special_comments("nhvnativeesd w/l's to match MRGA and pm3 file\\nnhvnativeesd,  Bin 011,   W = 10.0,   L = 2.0\\nnhvnativeesd,  Bin 012,   W = 10.0,   L = 4.0\\nnhvnativeesd,  Bin 013,   W = 10.0,   L = 0.9\\n"))
    ('\\n'
     "nhvnativeesd w/l's to match MRGA and pm3 file\\n"
     'nhvnativeesd, Bin 011, W = 10.0, L = 2.0\\n'
     'nhvnativeesd, Bin 012, W = 10.0, L = 4.0\\n'
     'nhvnativeesd, Bin 013, W = 10.0, L = 0.9\\n'
     '---------------------------------------------',
     'bin',
     [["nhvnativeesd w/l's to match MRGA and pm3 file"],
      ['nhvnativeesd', 'Bin 011', 'W = 10.0', 'L = 2.0'],
      ['nhvnativeesd', 'Bin 012', 'W = 10.0', 'L = 4.0'],
      ['nhvnativeesd', 'Bin 013', 'W = 10.0', 'L = 0.9']])


    #>>> process_special_comments('DIODE DC IV PARAMTERS\\n\\nNEW BSIM4 Parameters(DIODE DC IV parameters)')
    #('* Diode DC IV Parameters', 'param', 'Diode DC IV Parameters')

    Returns:
        new  - Comment value to put in output file, empty string if the comment is discarded.
        str  - comment type
        [d]  - comment data
    """

    if 'rights' in cmt.lower():
        return '', None, []

    # Strip duplicate stuff
    cmt = RE_DUP_LINES.sub(lambda m: m.group('l'), cmt)

    m = RE_BIN.match(cmt)
    if m:
        a = []
        b = []
        for l in cmt.splitlines():
            l = l.strip()
            if not l:
                continue

            if ',' not in l:
                a.append(l)
                b.append([l])
            else:
                d = [v.strip() for v in l.split(',')]
                a.append(', '.join(d))
                b.append(d)
        return '\n'+'\n'.join(a)+'\n'+'-'*max(len(nc) for nc in a), 'bin', b

    m = RE_UNITS.match(cmt)
    if m:
        unit = m.group(1)
        unit = unit.strip().lower()

        unit_new = UNIT_MAPPING.get(unit, None)
        if not unit_new:
            assert unit in UNIT_MAPPING.values(), (unit, unit_new)
            unit_new = new
        return 'Units: ' + unit_new, 'units', [unit_new]

    if 'L' in cmt and 'W' in cmt:
        m = RE_L_AND_W.search(cmt)
        if m:
            return cmt, None, []

    uc = cmt.strip().lower()
    if uc in UNIT_MAPPING:
        unit_new = UNIT_MAPPING[uc]
        return 'Units: ' + unit_new, 'units', [unit_new]

    if '\n' not in uc:
        if 'all' in uc:
            return cmt, None, []

        if 'not used' in uc:
            return cmt, None, []

    if 'number of bins:' in uc:
        before, after = uc.split('number of bins:')
        return 'Number of bins: '+after.strip(), None, []

    if '(for s8p only)\n' in uc:
        m = RE_CAP.match(' '.join(cmt.splitlines()))
        assert m, cmt
        new_cmt = m.group('desc1').strip()
        assert new_cmt, (m, m.groups())
        if m.group('desc2').strip():
            new_cmt += '\n'+m.group('desc2').strip()
        if m.group('p'):
            new_cmt += '\nLayout: '+m.group('p')
        return new_cmt, None, []

    m = RE_PARAM.match(cmt)
    if m and 'cadflow' not in cmt.lower():
        if '\n' in cmt:
            cmt = '\n'.join(s for s in cmt.splitlines() if 'parameters' in s.lower())

        cmt = RE_FIX_CASE.sub(lambda m: m.group(0).title(), cmt)
        ocmt = cmt
        if RE_PARAM_END.search(ocmt):
            ocmt = ocmt[:-len(' Parameters')]
        return cmt, 'param', [ocmt]


    return False, None, []


def convert_comments(idata):
    # Replace all C style // comments with '*' or '$'
    cmt_start = None
    for i, l in enumerate(idata):
        if '//' in l:
            if l.strip().startswith('//'):
                assert '//.' not in l, repr(l)
                idata[i] = '*' + l.lstrip('/')
            else:
                before, after = l.split('//', 1)
                idata[i] = before + '$' + after.lstrip('/')

        #assert '/*' not in l, idata
        assert '*/' not in idata[i], idata[i]+'\n'+'\n'.join(idata)


def get_last_comment(comments):
    i = len(comments)
    while i > 0:
        if comments[i-1].startswith('...'):
            break
        i -= 1
    return comments[i:]


EOF_MARKER = 'EOF\0'


def rewrite_comments(out_file, idata):
    idata = list(idata.splitlines())
    idata.append(EOF_MARKER)
    convert_comments(idata)

    speclines = ['* SKY130 Spice File.']

    comments_raw = []
    comments_nonspecial = []

    comments_special = defaultdict(list)
    comments_special_debug = defaultdict(list)

    for l in idata:
        if l.strip().startswith('*'):
            if not l.startswith('*.'):
                comments_raw.append(l)
                continue

        if not l.strip():
            continue

        if comments_raw and not comments_raw[-1].startswith('...'):
            cmt_last = get_last_comment(comments_raw)
            comments_raw.append('...')

            cmt_clean = strip_comment(cmt_last)

            cmt_new, cmt_type, cmt_value = process_special_comments(cmt_clean)
            if cmt_new:
                cmt_new = textwrap.indent(cmt_new, '* ', lambda line: True)
                print('Replacing comment:', repr('\n'.join(cmt_last)), 'with', repr(cmt_new))
                speclines.append(cmt_new)

            if cmt_type:
                comments_special[cmt_type].extend(cmt_value)
                comments_special_debug[cmt_type].append((cmt_last, cmt_clean, (cmt_new, cmt_type, cmt_value)))
            elif not cmt_new and cmt_clean:
                comments_nonspecial.append(cmt_clean)

        if '$' in l:
            l, cmt = l.split('$', 1)
            comments_raw.append('... $ ' + cmt)

            cmt_clean = cmt.strip()

            cmt_new, cmt_type, cmt_value = process_special_comments(cmt_clean)
            if cmt_new:
                l = "{}$ {}".format(l, cmt_new)
            if cmt_type:
                comments_special[cmt_type].append(cmt_value)
                comments_special_debug[cmt_type].append((cmt, cmt_clean, (cmt_new, cmt_type, cmt_value)))
            elif not cmt_new and cmt_clean:
                comments_nonspecial.append('... $ ' + cmt_clean)

        speclines.append(l)

    assert speclines[-1] == EOF_MARKER, pprint.pformat(speclines, width=WIDTH)
    speclines.pop(-1)
    assert not comments_raw or comments_raw[-1].startswith('...'), pprint.pformat(comments_raw)

    if comments_nonspecial:
        print('Non-special comments:')
        print('-'*10)
        pprint.pprint(comments_nonspecial, width=WIDTH)
        print('-'*10)
        cmt_file = out_file+'.stripped.comments'
        print("Writing stripped comments to:", cmt_file)
        assert not os.path.exists(cmt_file), cmt_file
        with open(cmt_file, 'w') as f:
            for c in comments_nonspecial:
                f.write(c)
                f.write('\n')
                f.write('---\n')

    if comments_special:
        comments_special = dict(comments_special)
        print("Special comments:")
        print('-'*10)
        pprint.pprint(comments_special, width=WIDTH)
        print('-'*10)

        if 'bin' in comments_special:
            def clean(s, a='='):
                s = s.split(a)[-1]
                s = s.strip()
                s = s.lstrip('0')
                if '.' in s:
                    s = s.rstrip('0')
                if len(s) == 0:
                    s = '0'
                elif s[0] == '.':
                    s = '0'+s
                elif s[-1] == '.':
                    s = s+'0'
                return s

            bin_csv = out_file+'.bins.csv'
            with open(bin_csv, 'w', newline='') as f:
                c = csv.writer(f)
                c.writerow(['device','bin','W','L'])
                for r in comments_special['bin']:
                    assert len(r) in (1, 4), r
                    if len(r) == 1:
                        c.writerow(r)
                    else:
                        d, b, w, l = r
                        b = clean(b, ' ')
                        w = clean(w)
                        l = clean(l)
                        c.writerow([d, b, w, l])
            del comments_special['bin']

        for k in comments_special:
            sfile = out_file+'.'+k+'.json'
            with open(sfile, 'w') as f:
                json.dump(comments_special[k], f, sort_keys=True, indent='  ')

    if len(comments_raw) > 1:
        cmt_file = out_file+'.raw.comments'
        print("Writing comments to:", cmt_file)
        assert not os.path.exists(cmt_file), cmt_file
        with open(cmt_file, 'w') as f:
            for c in comments_raw:
                f.write(c)
                f.write('\n')

    return speclines


# * <comment>
RE_CMT_FULL_LINE    = re.compile('\\n(\\*[^\\.]*[^\\n]*\\n)+')

# XXXX $ <comment>
RE_CMT_END_LINE     = re.compile('\\$.*?$', flags=re.MULTILINE)

RE_LINE_PLUS_START  = re.compile('^\\+([ \\t]*)', flags=re.MULTILINE)
RE_LINE_EQUALS      = re.compile('[ \\t]+=[ \\t]+')
RE_CMT_INCLUDE_IG   = re.compile('^\\*\\*Include files in.*\\n', flags=re.MULTILINE)
RE_EXTRA_CMT        = re.compile('^(\\*\\*\\*\\n)+', flags=re.MULTILINE)
RE_BIG_CMT          = re.compile('^\\*\\*\\*(.*)$', flags=re.MULTILINE)
RE_SMALL_CMT        = re.compile('\\n(\\*[ \\t]*\\n)+', flags=re.MULTILINE)
RE_MULTI_NEWLINE    = re.compile('\\n+')
RE_INCLUDE          = re.compile('^\\.inc(lude)?[ \\t]+["\']?(?P<file>[^"\'\\n\\r]+)["\']?$', flags=re.MULTILINE|re.IGNORECASE)
RE_INCLUDE_CMT      = re.compile('^\\*[ \\t]*\\.inc(lude)?[ \\t]+["\']?(?P<file>[^"\'\\n\\r]+)["\']?$', flags=re.MULTILINE|re.IGNORECASE)
RE_TRAILING_WS      = re.compile('[ \\t]+$', flags=re.MULTILINE)

RE_INT             = re.compile('= [ \\t]*(-?[0-9]+)[ \\t]*$', flags=re.MULTILINE)
RE_FIX_SCIENTIFIC  = re.compile('= [ \\t]*(-?)([0-9.]+)[eE]([+\\-]?)([0-9.]+)[ \\t]*$', flags=re.MULTILINE)

RE_CPAR_REMOVE     = re.compile("^.param ((cpar_area)|(cpar_perim)) = '[^']*'\n", flags=re.MULTILINE)


def cleanup_comment(m):
    return '*** ' + ' '.join(m.group(1).strip().split())


def fix_scientific(m):
    """

    >>> RE_FIX_SCIENTIFIC.sub(fix_scientific, '= 0.0')
    '= 0.0'

    >>> RE_FIX_SCIENTIFIC.sub(fix_scientific, '= 0e0')
    '= 0.0e+0'

    >>> RE_FIX_SCIENTIFIC.sub(fix_scientific, '= -2.4222865e-005')
    '= -2.4222865e-5'

    >>> RE_FIX_SCIENTIFIC.sub(fix_scientific, '= 1e+10')
    '= 1.0e+10'

    >>> RE_FIX_SCIENTIFIC.sub(fix_scientific, '= 1e00010')
    '= 1.0e+10'
    """
    neg = m.group(1)
    before = m.group(2)
    sign = m.group(3)
    after = m.group(4)

    while len(before) > 1 and before[0] == '0':
        before = before[1:]
    while len(after) > 1 and after[0] == '0':
        after = after[1:]

    if not sign:
        sign = '+'

    if '.' not in before:
        before += '.0'

    return '= {}{}e{}{}'.format(neg, before, sign, after)


def cleanup_spice_data(data):
    """

    >>> cleanup_spice_data('''
    ... **Include files in ../../../s8x/ directory
    ... .inc "../../s8x/Models/ss.cor"
    ... ''')
    '.include "../../s8x/Models/ss.cor"\\n'

    >>> cleanup_spice_data('''
    ... .inc "../../s8x/Models/sonos_ttteol.cor"
    ... ''')
    '.include "../../s8x/Models/sonos_ttteol.cor"\\n'

    >>> cleanup_spice_data('''
    ... .inc "models.a"
    ... ''')
    '.include "models.a"\\n'

    >>> cleanup_spice_data('''
    ... .include models.a
    ... ''')
    '.include "models.a"\\n'

    >>> cleanup_spice_data('''
    ... .include 'models.a'
    ... ''')
    '.include "models.a"\\n'

    >>> print(cleanup_spice_data('''
    ... * RF MOS PARAMETERS
    ... .inc "nshort_rf_base_b_fs.cor"
    ... .inc "nlowvt_rf_base_b_fs.cor"
    ... ''').strip())
    * RF MOS PARAMETERS
    .include "nshort_rf_base_b_fs.cor"
    .include "nlowvt_rf_base_b_fs.cor"

    >>> print(cleanup_spice_data('''
    ... + dvt1w = 1147200.0
    ... + vbm = -3
    ... + rdswmin = 0
    ... + rdw = 1
    ... + rdwmin = 0
    ... + rsw = 0
    ... + rswmin = 0
    ... ''').strip())
    + dvt1w = 1147200.0
    + vbm = -3.0
    + rdswmin = 0.0
    + rdw = 1.0
    + rdwmin = 0.0
    + rsw = 0.0
    + rswmin = 0.0

    >>> print(cleanup_spice_data('''
    ... + nsd = 1.0e+020
    ... + alpha1 = 1.0e-10
    ... + pdiblcb = -2.4222865e-005
    ... + alpha1 = 1e-010
    ... ''').strip())
    + nsd = 1.0e+20
    + alpha1 = 1.0e-10
    + pdiblcb = -2.4222865e-5
    + alpha1 = 1.0e-10

    >>> print(cleanup_spice_data('''
    ... + nsd = 1.0e+020
    ... + lint = {1.1932e-008+nshort_lint_diff}
    ... + alpha1 = 1e-010
    ... ''').strip())
    + nsd = 1.0e+20
    + lint = {1.1932e-008+nshort_lint_diff}
    + alpha1 = 1.0e-10

    >>> print(cleanup_spice_data('''
    ... .param vc1 = -25.0e-6
    ... .param vc2 = 90.0e-6
    ... .param carea = 'camimc*(wc)*(lc)'
    ... .param cperim = 'cpmimc*((wc)+(lc))*2'
    ... .param czero = 'carea + cperim' dev/gauss='0.01*2.8*(carea + cperim)/sqrt(wc*lc*mf)'
    ... .param cpar_area = 'mcm4f_ca_w_7_680_s_1_240*(wc)*(lc)*m*1e-12'
    ... .param cpar_perim = 'mcm4f_cf_w_7_680_s_1_240*((wc)+(lc))*m*2*1e-6'
    ... c1      c0       a       'czero*(1+vc1*(v(c0)-v(c1))+vc2*(v(c0)-v(c1))*(v(c0)-v(c1)))'  tc1=0  tc2=0
    ... rs1     a        b1       'r1' tc1=tc1rm4    tc2=tc2rm4
    ... rs2     b1        c1      'r2' tc1=tc1rvia4 tc2=tc2rvia4
    ... .ends sky130_fd_pr__cap_mim_m3_2
    ... ''').strip())
    .param vc1 = -25.0e-6
    .param vc2 = 90.0e-6
    .param carea = 'camimc*(wc)*(lc)'
    .param cperim = 'cpmimc*((wc)+(lc))*2'
    .param czero = 'carea + cperim' dev/gauss='0.01*2.8*(carea + cperim)/sqrt(wc*lc*mf)'
    c1      c0       a       'czero*(1+vc1*(v(c0)-v(c1))+vc2*(v(c0)-v(c1))*(v(c0)-v(c1)))'  tc1=0  tc2=0
    rs1     a        b1       'r1' tc1=tc1rm4    tc2=tc2rm4
    rs2     b1        c1      'r2' tc1=tc1rvia4 tc2=tc2rvia4
    .ends sky130_fd_pr__cap_mim_m3_2


    """

    # "../../s8x/Models/ss.cor"

    data = RE_TRAILING_WS.sub('', data)

    data = RE_LINE_PLUS_START.sub('+ ', data)
    data = RE_LINE_EQUALS.sub(' = ', data)
    data = RE_CMT_INCLUDE_IG.sub('', data)
    data = RE_EXTRA_CMT.sub('', data)
    data = RE_BIG_CMT.sub(cleanup_comment, data)
    data = RE_MULTI_NEWLINE.sub('\n', data)
    data = RE_INCLUDE.sub('.include "\\g<file>"', data)
    data = RE_INCLUDE_CMT.sub('*.include "\\g<file>"', data)

    data = RE_INT.sub('= \\1.0', data)
    data = RE_FIX_SCIENTIFIC.sub(fix_scientific, data)
    data = RE_CPAR_REMOVE.sub('', data)

    iinc = data.find('.inc ')
    assert iinc == -1, (iinc, data[iinc-100:iinc+100])

    data = data.strip()
    if data and data[-1] != '\n':
        data += '\n'

    return data


if __name__ == '__main__':
    import doctest
    fails, _ = doctest.testmod()
    if fails != 0:
        sys.exit("Some test failed")

    if len(sys.argv) == 1:
        print("No options given to spectre_to_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 convert_spectre.py.")
        usage()
        sys.exit(0)

    debug = '-debug' in optionlist
    nocmt = '-nocmt' in optionlist
    try:
        ignore = next(item for item in optionlist if item.split('=')[0] == '-ignore').split('=')[1].split(',')
    except:
        ignore = ''

    specpath = os.path.abspath(arguments[0])
    spicepath = os.path.abspath(arguments[1])
    do_one_file = False

    if not os.path.exists(specpath):
        print('No such source directory ' + specpath)
        sys.exit(1)

    if os.path.isfile(specpath):
        do_one_file = True

    if do_one_file:
        if arguments[1].endswith('/'):
            if not os.path.exists(spicepath):
                print("Creating:", spicepath)
                os.makedirs(spicepath)
            else:
                assert os.path.isdir(spicepath), "Not directory? " + spicepath

            c = os.path.commonprefix([spicepath, specpath])
            spicepath = os.path.join(spicepath, specpath[len(c):].replace('/', '_'))

        if os.path.exists(spicepath):
            print('Error:  File ' + spicepath + ' exists.')
            sys.exit(1)

        convert_file(specpath, spicepath, nocmt, ignore, debug)

    else:
        if not os.path.exists(spicepath):
            os.makedirs(spicepath)

        specfilelist = glob.glob(specpath + '/*')

        for filename in specfilelist:
            if filename.endswith('readme'):
                continue
            if filename.endswith('.tmp'):
                continue
            if filename.endswith('.comments'):
                continue
            fileext = os.path.splitext(filename)[1]

            # Ignore verilog or verilog-A files that might be in a model directory
            if fileext == '.v' or fileext == '.va':
                continue

            # .scs files are purely spectre and meaningless to SPICE, so ignore them.
            if fileext == '.scs':
                continue

            froot = os.path.split(filename)[1]
            print()
            convert_file(filename, spicepath + '/' + froot, nocmt, ignore, debug)
            print()

    exit(0)