#!/usr/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)