lib/spfte/spiceif.c

/***************************************************************************
JSPICE3 adaptation of Spice3f2 - Copyright (c) Stephen R. Whiteley 1992
Copyright 1990 Regents of the University of California.  All rights reserved.
Authors: 1985 Wayne A. Christopher
         1992 Stephen R. Whiteley
****************************************************************************/

/*
 * Interface routines. These are specific to spice. The only changes to FTE
 * that should be needed to make FTE work with a different simulator is
 * to rewrite this file. What each routine is expected to do can be
 * found in the programmer's manual. This file should be the only one
 * that includes spice header files.
 */

#include "spice.h"
#include "ftedefs.h"
#include "ftedebug.h"
#include "spfteext.h"
#include "inpdefs.h"
#include "fteinp.h"
#include "jobdefs.h"
#include "iferrmsg.h"
#include "util.h"

#ifdef __STDC__
static int get_anal(char*);
static void set_options(void);
static struct variable *parmtovar(IFvalue*,IFparm*);
static IFparm * parmlookup(IFdevice*,GENinstance*,GENmodel*,char*);
static IFvalue *doask(char*,int,GENinstance*,GENmodel*,IFparm*,int);
static int finddev(char*,char*,GENERIC**,GENERIC**);
#else
static int get_anal();
static void set_options();
static struct variable *parmtovar();
static IFparm * parmlookup();
static IFvalue *doask();
static int finddev();
#endif


char *
if_inpdeck(deck, tab)

/* Input a single deck, and return a pointer to the circuit. */
struct line *deck;
char **tab;
{
    GENERIC *ckt;
    int err, i, j;
    struct line *ll;
    IFuid taskUid;
    IFuid optUid;
    int which;

    for (i = 0, ll = deck; ll; ll = ll->li_next)
        i++;
    *tab = (char *)INPtabInit(i);
    ft_curckt->ci_symtab = *tab;
    if ((err = (*(ft_sim->newCircuit))(&ckt)) != OK) {
        ft_sperror(err, "CKTinit");
        return (NULL);
    }
    err =
        IFnewUid(ckt,&taskUid,(IFuid)NULL,"default",UID_TASK,(GENERIC**)NULL);
    if (err) {
        ft_sperror(err,"newUid");
        return (NULL);
    }
    err =
        (*(ft_sim->newTask))(ckt,(GENERIC**)&(ft_curckt->ci_defTask),taskUid);
    if (err) {
        ft_sperror(err,"newTask");
        return (NULL);
    }
    which = get_anal("options");
    if (which != -1) {
        err = IFnewUid(ckt,&optUid,(IFuid)NULL,"options",UID_ANALYSIS,
                (GENERIC**)NULL);
        if (err) {
            ft_sperror(err,"newUid");
            return (NULL);
        }
        err = (*(ft_sim->newAnalysis))(ckt,which,optUid,
                (GENERIC**)&(ft_curckt->ci_defOpt),
                (GENERIC*)ft_curckt->ci_defTask);
        if (err) {
            ft_sperror(err,"createOptions");
            return (NULL);
        }
        ft_curckt->ci_curOpt = ft_curckt->ci_defOpt;
    }
    ft_curckt->ci_curTask = ft_curckt->ci_defTask;
    INPpas1((GENERIC *) ckt, (card *) deck->li_next,(INPtables *)*tab);
    INPpas2((GENERIC *) ckt, (card *) deck->li_next,
            (INPtables *) *tab,ft_curckt->ci_defTask);
    INPkillMods();
    return (ckt);
}


int
if_run(what, args)

/* Do a run of the circuit, of the given type. Type "resume" is special --
 * it means to resume whatever simulation that was in progress. The
 * return value of this routine is 0 if the exit was ok, and 1 if there was
 * a reason to interrupt the circuit (interrupt typed at the keyboard,
 * error in the simulation, etc).
 * args may be the entire command line,
 * e.g. "tran 1 10 20 uic",
 * or only the arguments that follow "what".
 */
char *what;
wordlist *args;
{
    GENERIC *ckt = (GENERIC *)ft_curckt->ci_ckt;
    INPtables *tab = (INPtables *)ft_curckt->ci_symtab;
    int err;
    struct line deck;
    char buf[BSIZE_SP], *tmp;
    int j;
    int which;
    IFuid specUid,optUid;

    /* First parse the line... */
    if (eq(what,"sens") || eq(what, "tran") || eq(what, "ac") ||
        eq(what, "dc")  || eq(what, "op")   || eq(what, "pz") ||
        eq(what,"disto")|| eq(what,"tf")    || eq(what, "noise")) {

        if (args) {
            tmp = wl_flatten(args);
            if (ciprefix(what,tmp))
                (void) sprintf(buf, ".%s", tmp);
            else
                (void) sprintf(buf, ".%s %s", what, tmp);
            txfree(tmp);
        }
        else
            (void) sprintf(buf, ".%s", what);

        deck.li_next = deck.li_actual = NULL;
        deck.li_error = NULL;
        deck.li_linenum = 0;
        deck.li_line = buf;

        if (ft_curckt->ci_specTask) {
            err = (*(ft_sim->deleteTask))(ckt, ft_curckt->ci_specTask);
            if (err) {
                ft_sperror(err,"deleteTask");
                return (2);
            }
        }
        err = IFnewUid(ckt,&specUid,(IFuid)NULL,"special",
                UID_TASK,(GENERIC**)NULL);
        if (err) {
            ft_sperror(err,"newUid");
            return (2);
        }
        err = (*(ft_sim->newTask))(ckt,
                (GENERIC**)&(ft_curckt->ci_specTask),specUid);
        if (err) {
            ft_sperror(err,"newTask");
            return (2);
        }
        which = get_anal("options");
        if (which != -1) {
            err = IFnewUid(ckt,&optUid,(IFuid)NULL,"options",
                    UID_ANALYSIS,(GENERIC**)NULL);
            if (err) {
                ft_sperror(err,"newUid");
                return (2);
            }
            err = (*(ft_sim->newAnalysis))(ckt,which,optUid,
                    (GENERIC**)&(ft_curckt->ci_specOpt),
                    (GENERIC*)ft_curckt->ci_specTask);
            if (err) {
                ft_sperror(err,"createOptions");
                return (2);
            }
            ft_curckt->ci_curOpt = ft_curckt->ci_specOpt;
            set_options();
        }
        ft_curckt->ci_curTask = ft_curckt->ci_specTask;

        INPpas2(ckt, (card *) &deck, tab, ft_curckt->ci_specTask);
        if (deck.li_error) {
            /* INP produdes an E_EXISTS error here... Don't
             * make this fatal...
             */
            fprintf(cp_err, "Warning: %s\n", deck.li_error);
        }
    }
    if ( eq(what,"run") ) {
        ft_curckt->ci_curTask = ft_curckt->ci_defTask;
        ft_curckt->ci_curOpt = ft_curckt->ci_defOpt;
    }

    if (  (eq(what, "tran"))  ||
          (eq(what, "ac"))    ||
          (eq(what, "dc"))    ||
          (eq(what, "op"))    ||
          (eq(what, "pz"))    ||
          (eq(what, "disto")) ||
          (eq(what, "sens"))  ||
          (eq(what, "noise")) ||
          (eq(what, "tf"))    ||
          (eq(what, "run")) )  {
        if ((err =
                (*(ft_sim->doAnalyses))(ckt, 1, ft_curckt->ci_curTask)) != OK) {
            if (err == E_PAUSE)
                 return (1);
            else {
                 ft_sperror(err, "doAnalyses");
                 return (2);
            }
        }
    }
    else if (eq(what, "resume")) {
        if ((err =
                (*(ft_sim->doAnalyses))(ckt, 0, ft_curckt->ci_curTask)) != OK) {
            if (err == E_PAUSE)
                return (1);
            else {
                ft_sperror(err, "doAnalyses");
                return (2);
            }
        }
    }
    else {
        fprintf(cp_err, "if_run: Internal Error: bad run type %s\n", what);
            return (2);
    }
    return (0);
}


static int
get_anal(string)
char *string;
{
    int i;

    for (i = 0; i < ft_sim->numAnalyses; i++) {
        if (strcmp(ft_sim->analyses[i]->name,string) == 0) {
            return (i);
        }
    }
    return (-1);
}


static void
set_options()

/* Set the options for the "special" task.  If analysis is initiated with
 * the "run" command, we use the options found in the .options line only,
 * which have already been set (so this routine need not be called).
 * Otherise if an analysis is given, a new task is created.  This routine
 * is called to first set the options found in the .options line, then
 * (laboriously) set any options that were entered with the "set" command.
 * The options set with the "set" command override those set in the
 * .options line.  Note that if "run" is used, the "set" options are
 * ignored.
 */
{
    int i, which, type;
    char *name, *vv;
    double f;
        struct variable *var;
    struct line *opt;


    for (opt = ft_curckt->ci_options; opt; opt = opt->li_next) {
        txfree(opt->li_error);
        opt->li_error = NULL;
        INP2dot(ft_curckt->ci_ckt,(INPtables*)ft_curckt->ci_symtab,
            (card*)opt,NULL,NULL);
    }

    /* set the "set" variables */
    which = get_anal("options");
    if (which == -1) return;

    for (i = 0; i < ft_sim->analyses[which]->numParms; i++) {
        type = ft_sim->analyses[which]->analysisParms[i].dataType;
        if (type & IF_SET) {

            name = ft_sim->analyses[which]->analysisParms[i].keyword;

            if (type & IF_FLAG) {
                if (cp_getvar(name,VT_BOOL,(char*)&f))
                    if_option(ft_curckt->ci_ckt, name, VT_BOOL, (char*)&f);
            }
            else if (type & IF_INTEGER) {
                if (cp_getvar(name,VT_NUM,(char*)&f))
                    if_option(ft_curckt->ci_ckt, name, VT_NUM, (char*)&f);
            }
            else if (type & IF_REAL) {
                if (cp_getvar(name,VT_REAL,(char*)&f))
                    if_option(ft_curckt->ci_ckt, name, VT_REAL, (char*)&f);
            }
            else if (type & IF_STRING) {
                if (cp_getvar(name,VT_STRING,(char*)&f))
                    if_option(ft_curckt->ci_ckt, name, VT_STRING, (char*)&f);
            }
        }
    }
}

static char *unsupported[] = {
    "itl3",
    "itl5",
    "lvltim",
    "maxord",
    "method",
    NULL
} ;

static char *obsolete[] = {
    "limpts",
    "limtim",
    "lvlcod",
    "nomod",
    NULL
} ;


void
if_option(ckt, name, type, value)

/* Set an option in the circuit. Arguments are option name, type, and
 * value (the last a char *), suitable for casting to whatever needed...
 */
char *ckt;
char *name;
int type;
char *value;
{
    IFvalue pval;
    int err, i;
    GENERIC *cc = (GENERIC *) ckt;
    char **vv;
    int which;

    if (eq(name, "acct")) {
        ft_acctprint = true;
            return;
    }
    else if (eq(name, "list")) {
        ft_listprint = true;
            return;
    }
    else if (eq(name, "node")) {
        ft_nodesprint = true;
            return;
    }
    else if (eq(name, "opts")) {
        ft_optsprint = true;
            return;
    }
    else if (eq(name, "nopage")) {
            ft_nopage = true;
            return;
    }

    which = get_anal("options");
    if (which == -1) {
        fprintf(cp_err,"Warning:  .options card unsupported\n");
        return;
    }

    for (i = 0; i < ft_sim->analyses[which]->numParms; i++)
        if (eq(ft_sim->analyses[which]->analysisParms[i].keyword, name) &&
            (ft_sim->analyses[which]->analysisParms[i].dataType & IF_SET))
            break;
    if (i == ft_sim->analyses[which]->numParms) {
        /* See if this is unsupported or obsolete. */
        for (vv = unsupported; *vv; vv++)
            if (eq(name, *vv)) {
                fprintf(cp_err,
            "Warning: option %s is currently unsupported.\n", name);
                return;
            }
        for (vv = obsolete; *vv; vv++)
            if (eq(name, *vv)) {
                fprintf(cp_err,
                "Warning: option %s is obsolete.\n", name);
                return;
            }
        return;
    }

    switch (ft_sim->analyses[which]->analysisParms[i].dataType & IF_VARTYPES) {
        case IF_REAL:
            if (type == VT_REAL)
                pval.rValue = *((double *) value);
            else if (type == VT_NUM)
                pval.rValue = *((int *) value);
            else
                goto badtype;
            break;
        case IF_INTEGER:
            if (type == VT_NUM)
                pval.iValue = *((int *) value);
            else if (type == VT_REAL)
                pval.iValue = *((double *) value);
            else
                goto badtype;
            break;
        case IF_STRING:
            if (type == VT_STRING)
                pval.sValue = copy(value);
            else
                goto badtype;
            break;
        case IF_FLAG:
            /* Do nothing. */
            pval.iValue = 1;
            break;
        default:
            fprintf(cp_err,
            "if_option: Internal Error: bad option type %d.\n",
                    ft_sim->analyses[which]->analysisParms[i].dataType);
    }

    if ((err = (*(ft_sim->setAnalysisParm))(cc, (GENERIC *)ft_curckt->ci_curOpt,
            ft_sim->analyses[which]->analysisParms[i].id, &pval,
            (IFvalue *)NULL)) != OK)
        ft_sperror(err, "setAnalysisParm(options)");

    return;

badtype:
    fprintf(cp_err, "Error: bad type given for option %s --\n", name);
    fprintf(cp_err, "\ttype given was ");
    switch (type) {
        case VT_BOOL:   fputs("boolean", cp_err); break;
        case VT_NUM:    fputs("integer", cp_err); break;
        case VT_REAL:   fputs("real", cp_err); break;
        case VT_STRING: fputs("string", cp_err); break;
        case VT_LIST:   fputs("list", cp_err); break;
        default:        fputs("something strange", cp_err); break;
    }
    fprintf(cp_err, ", type expected was ");
    switch(ft_sim->analyses[which]->analysisParms[i].dataType & IF_VARTYPES) {
        case IF_REAL:   fputs("real.\n", cp_err); break;
        case IF_INTEGER:fputs("integer.\n", cp_err); break;
        case IF_STRING: fputs("string.\n", cp_err); break;
        case IF_FLAG:   fputs("flag.\n", cp_err); break;
        default:        fputs("something strange.\n", cp_err); break;
    }
    if (type == VT_BOOL)
fputs("\t(Note that you must use an = to separate option name and value.)\n",
                    cp_err);
    return;
}


void
if_cktfree(ckt, tab)

char *ckt;
char *tab;
{
    GENERIC *cc = (GENERIC *) ckt;

    (*(ft_sim->deleteCircuit))(cc);
    INPtabEnd((INPtables *) tab);
    return;
}


void
if_cktclear()

/* Delete the current circuit.
 * This blows away all the peripheral stuff, unlike if_cktfree() which only
 * frees the ckt structure and input tables.
 */
{
    struct circ *cc;

    if (!ft_curckt) return;
    tfree(ft_curckt->ci_name);
    inp_deckfree(ft_curckt->ci_deck);
    inp_deckfree(ft_curckt->ci_options);
    wl_free(ft_curckt->ci_commands);

    (*(ft_sim->deleteTask))(ft_curckt->ci_ckt,ft_curckt->ci_specTask);
    (*(ft_sim->deleteTask))(ft_curckt->ci_ckt,ft_curckt->ci_defTask);
    va_free(ft_curckt->ci_vars);

    tfree(ft_curckt->ci_filename);

    if (ft_curckt->ci_contblk) {
        for (cc = ft_circuits; cc; cc = cc->ci_next) {
            if (cc == ft_curckt)
                continue;
            if (cc->ci_contblk && eq(cc->ci_contblk,ft_curckt->ci_contblk))
                break;
        }
        if (!cc) {
            if (prefix("#_",ft_curckt->ci_contblk)) {
                cp_freeblock(ft_curckt->ci_contblk);
                ft_curckt->ci_contblk[1] = '#';
                cp_freeblock(ft_curckt->ci_contblk);
            }
        }
        txfree(ft_curckt->ci_contblk);
    }

    if_cktfree(ft_curckt->ci_ckt, (char*)ft_curckt->ci_symtab);
    ft_curckt->ci_devices = cp_kwswitch(CT_DEVNAMES,(char *)NULL);
    ft_curckt->ci_nodes = cp_kwswitch(CT_NODENAMES,(char *)NULL);
    cp_ccfreetrie(ft_curckt->ci_devices);
    cp_ccfreetrie(ft_curckt->ci_nodes);

    if (ft_curckt == ft_circuits) {
        tfree(ft_curckt);
        ft_circuits = ft_curckt = ft_circuits->ci_next;
    }
    else {
        for (cc = ft_circuits; cc; cc = cc->ci_next)
            if (cc->ci_next == ft_curckt)
                break;

        if (!cc) {
            fprintf(cp_err,"Internal Error: cktfree -- not in list\n");
            goto xxx;
        }
        cc->ci_next = ft_curckt->ci_next;
        tfree(ft_curckt);
        ft_curckt = cc;
    }
xxx:
    if (ft_curckt) {
        (void) cp_kwswitch(CT_DEVNAMES, ft_curckt->ci_devices);
        (void) cp_kwswitch(CT_NODENAMES, ft_curckt->ci_nodes);
    }
}

/* Return a string describing an error code. */


/* BLOW THIS AWAY.... */

char *
if_errstring(code)

int code;
{
    return (INPerror(code));
}


struct variable *
spif_getparam(ckt, name, param, ind, keyword)

/* Get a parameter value from the circuit. If name is left unspecified,
 * we want a circuit parameter.  If keywords is not null, a list of
 * matching keywords is built.
 */
char *ckt;
char **name;
char *param;
int ind;
wordlist **keyword;
{
    struct variable *vv, *tv;
    IFvalue *pv;
    IFparm *opt;
    int typecode, i, num;
    GENinstance *dev = (GENinstance *)NULL;
    GENmodel *mod = (GENmodel *)NULL;
    IFdevice *device;
    wordlist *ww;

    if (param && eq(param, "all")) {
        INPinsert(name,(INPtables *)ft_curckt->ci_symtab);
        typecode = finddev(ckt, *name,(GENERIC**) &dev,(GENERIC**) &mod);
        if (typecode == -1) {
            fprintf(cp_err,
                "Error: no such device or model name %s\n", *name);
            return (NULL);
        }
        device = ft_sim->devices[typecode];
        vv = tv = (struct variable*)NULL;
        if (dev) {
            num = *(device->numInstanceParms);
            opt = device->instanceParms;
        }
        else {
            num = *(device->numModelParms);
            opt = device->modelParms;
        }
        if (opt) {
            for (i = 0; i < num; i++, opt++) {
                if (!(opt->dataType & IF_ASK)) continue;
                pv = doask(ckt, typecode, dev, mod, opt, ind);
                if (pv) {
                    if (tv) {
                        if (keyword) {
                             ww->wl_next = alloc(struct wordlist);
                             ww = ww->wl_next;
                             ww->wl_word = copy(opt->keyword);
                        }
                        tv->va_next = parmtovar(pv,opt);
                        tv = tv->va_next;
                    }
                    else {
                        if (keyword) {
                            *keyword = ww = alloc(struct wordlist);
                            ww->wl_word = copy(opt->keyword);
                        }
                        vv = tv = parmtovar(pv,opt);
                    }
                }
                else
                    fprintf(cp_err,
                        "Internal Error: no parameter '%s' on device '%s'\n",
                        device->instanceParms[i].keyword,
                        device->name);
            }
            return (vv);
        }
        else
            return (NULL);
    }
    else if (param) {
        INPinsert(name,(INPtables *)ft_curckt->ci_symtab);
        typecode = finddev(ckt, *name, (GENERIC**)&dev, (GENERIC**)&mod);
        if (typecode == -1) {
            fprintf(cp_err,
                "Error: no such device or model name %s\n", *name);
            return (NULL);
        }
        device = ft_sim->devices[typecode];
        opt = parmlookup(device, dev, mod, param);
        if (!opt) {
            fprintf(cp_err, "Error: no such parameter %s.\n", param);
            return (NULL);
        }
        pv = doask(ckt, typecode, dev, mod, opt, ind);
        if (pv) {
            if (keyword) {
                *keyword = alloc(struct wordlist);
                (*keyword)->wl_word = copy(opt->keyword);
            }
            vv = parmtovar(pv, opt);
        }
        return (vv);
    }
    else
        return (if_getstat(ckt, *name, keyword));
}


/* ARGSUSED */
void
if_setparam(ckt, name, param, val)

char *ckt;
char *name;
char *param;
struct variable *val;
{
}


static struct variable *
parmtovar(pv, opt)

IFvalue *pv;
IFparm *opt;
{
    struct variable *tv, *vv = alloc(struct variable);
    int i = 0;

    switch (opt->dataType & IF_VARTYPES) {
        case IF_INTEGER:
            vv->va_type = VT_NUM;
            vv->va_num = pv->iValue;
            break;
        case IF_REAL:
        case IF_COMPLEX:
            vv->va_type = VT_REAL;
            vv->va_real = pv->rValue;
            break;
        case IF_STRING:
            vv->va_type = VT_STRING;
            vv->va_string = copy(pv->sValue);
            break;
        case IF_INSTANCE:
            vv->va_type = VT_STRING;
            vv->va_string = copy((char*)pv->uValue);
            break;
        case IF_FLAG:
            vv->va_type = VT_BOOL;
            vv->va_bool = pv->iValue ? true : false;
            break;
        case IF_REALVEC:
            vv->va_type = VT_LIST;
            tv = NULL;
            for (i = 0; i < pv->v.numValue; i++) {
                if (!tv)
                    tv = vv->va_vlist = alloc(struct variable);
                else {
                    tv->va_next = alloc(struct variable);
                    tv = tv->va_next;
                }
                tv->va_type = VT_REAL;
                tv->va_real = (pv->v.vec.rVec)[i];
            }
            break;
        case IF_PARSETREE:
            vv->va_type = VT_STRING;
            vv->va_string = NULL;
            if (pv->tValue)
                vv->va_string = copy(pv->tValue->line);
            break;
        default:
            fprintf(cp_err,
            "parmtovar: Internal Error: bad PARM type %d.\n",
                    opt->dataType);
            tfree(vv);
            return (NULL);
    }

    /* It's not clear whether we want the keyword or the desc here... */
    vv->va_name = copy(opt->description);
    return (vv);
}


static IFparm *
parmlookup(device, dev, mod, param)

/* Extract the IFparm structure from the device.  A match is assumed if
 * param is a case insensitive match of the IFdevice keyword.  If inptr
 * is not NULL, the devices are checked first.  *inptr is NULLed if
 * no matching device is found, and a model is returned if there is a
 * match.
 */
IFdevice *device;
GENinstance *dev;
GENmodel *mod;
char *param;
{
    int i;

    if (dev) {
        for (i = 0; i < *(device->numInstanceParms); i++) {
            if ((device->instanceParms[i].dataType & IF_ASK) &&
                    cieq(param,device->instanceParms[i].keyword))
                return (&device->instanceParms[i]);
        }
    }
    else if (mod) {
        if (device->modelParms == NULL)
            return (NULL);
        for (i = 0; i < *(device->numModelParms); i++)
            if ((device->modelParms[i].dataType & IF_ASK) &&
                    cieq(param,device->modelParms[i].keyword))
                return (&device->modelParms[i]);
    }
    return (NULL);
}


/* ARGSUSED */
static IFvalue *
doask(ckt, typecode, dev, mod, opt, ind)

/* Perform the CKTask call. We have both 'fast' and 'modfast', so the other
 * parameters aren't necessary.
 */
char *ckt;
GENinstance *dev;
GENmodel *mod;
IFparm *opt;
int ind;
{
    static IFvalue pv;
    int err;

    pv.rValue = 0.0;
    pv.iValue = ind;    /* Sometimes this will be junk and ignored... */

    if (dev)
        err = (*(ft_sim->askInstanceQuest))((GENERIC *)ckt, (GENERIC *)dev,
                opt->id, &pv, (IFvalue *)NULL);
    else
        err = (*(ft_sim->askModelQuest))((GENERIC*)ckt, (GENERIC*) mod,
                opt->id, &pv, (IFvalue *)NULL);
    if (err != OK) {
        ft_sperror(err, "doask");
        return (NULL);
    }

    return (&pv);
}


static int
finddev(ck, name, devptr, modptr)

/* Get pointers to a device, its model, and its type number given the name.
 * If there is no such device, try to find a model with that name.
 */
char *ck;
char *name;
GENERIC **devptr;
GENERIC **modptr;
{
    int err;
    int type = -1;

    err =
        (*(ft_sim->findInstance))((GENERIC *)ck,&type,devptr,name,NULL,NULL);
    if (err == OK)
        return (type);

    type = -1;
    *devptr = (GENERIC *)NULL;

    err = (*(ft_sim->findModel))((GENERIC *)ck,&type,modptr,name);
    if (err == OK)
        return(type);

    *modptr = (GENERIC *)NULL;
    return (-1);
}


/* Extract the node and device names from the line and add them to the command
 * completion structure.  This is probably not a good thing to do if it
 * takes too much time.
 */

void
if_setndnames(line)

char *line;
{
    int i;
    char buf[BSIZE_SP];

    while (isspace(*line))
        line++;

    if (!*line || (*line == '*'))
        return;
    if (*line == '.') {
        line++;
        if (prefix("model",line)) {
            copytok(buf,&line);
            copytok(buf,&line);
            cp_addkword(CT_DEVNAMES, buf);
        }
        return;
    }
    copytok(buf,&line);
    cp_addkword(CT_DEVNAMES, buf);

/* inefficient and not very useful */
/*
    if (!(i = inp_numnodes(*buf)))
        return;
    if ((*buf == 'q') || (*buf == 'Q'))
        i = 3;

    while (i-- > 0) {
        if (copytok(buf,&line))
            cp_addkword(CT_NODENAMES, buf);
    }
    return;
*/
}


struct variable *
if_getstat(ckt, name, keyword)

/* Get the statistic called 'name'.  If this is NULL get all statistics
 * available.  If keyword is not null, it returns a wordlist of actual
 * keyword matches.  A match is assumed if name is a case insensitive
 * prefix of the keyword.
 */
char *ckt;
char *name;
wordlist **keyword;
{
    int i;
    struct variable *v, *vars;
    IFvalue parm;
    int which;
    wordlist *ww;

    which = get_anal("options");
    if (which == -1) {
        fprintf(cp_err,"Warning:  statistics unsupported\n");
        return(NULL);
    }

    if (name) {
        for (i = 0; i < ft_sim->analyses[which]->numParms; i++)
            if (ciprefix(name,
                ft_sim->analyses[which]->analysisParms[i].keyword))
                break;
        if (i == ft_sim->analyses[which]->numParms)
            return (NULL);
        if ((*(ft_sim->askAnalysisQuest))(ckt, ft_curckt->ci_curTask,
                ft_sim->analyses[which]->analysisParms[i].id, &parm,
                (IFvalue *)NULL) == -1) {
            goto error;
        }
        if (keyword) {
            *keyword = alloc(struct wordlist);
            (*keyword)->wl_word = copy(
                ft_sim->analyses[which]->analysisParms[i].keyword);
        }
        return (parmtovar(&parm,
            &(ft_sim->analyses[which]->analysisParms[i])));
    }
    else {
        for (i = 0, vars = v = NULL;
                i < ft_sim->analyses[which]->numParms; i++) {
            if (!(ft_sim->analyses[which]->analysisParms[i].dataType&IF_ASK)) {
                continue;
            }
            if ((*(ft_sim->askAnalysisQuest))(ckt, ft_curckt->ci_curTask,
                    ft_sim->analyses[which]->analysisParms[i].id,
                    &parm, (IFvalue *)NULL) == -1) {
                goto error;
            }
            if (v) {
                if (keyword) {
                    ww->wl_next = alloc(struct wordlist);
                    ww = ww->wl_next;
                    ww->wl_word = copy(
                        ft_sim->analyses[which]->analysisParms[i].keyword);
                }
                v->va_next = parmtovar(&parm,
                        &(ft_sim->analyses[which]->analysisParms[i]));
                v = v->va_next;
            }
            else {
                if (keyword) {
                    *keyword = ww = alloc(struct wordlist);
                    ww->wl_word = copy(
                        ft_sim->analyses[which]->analysisParms[i].keyword);
                }
                vars = v = parmtovar(&parm,
                    &(ft_sim->analyses[which]->analysisParms[i]));
            }
        }
        return (vars);
    }
error:
        fprintf(cp_err,"if_getstat: Internal Error: can't get %s.\n",name);
        return NULL;
}


wordlist *
GetAnalysisFromDeck()
{
    wordlist *tl1 = NULL;
    int numjobs;

    if (!(*ft_sim->findAnalysis)(ft_curckt->ci_ckt,&numjobs,
        (GENERIC**)NULL,(IFuid)NULL,ft_curckt->ci_defTask,(IFuid)NULL)) {

        if (numjobs != 1)
            return (NULL);

        /* one analysis specified in file */
        ft_curckt->ci_curTask = ft_curckt->ci_defTask;
        ft_curckt->ci_curOpt = ft_curckt->ci_defOpt;
        tl1 = alloc(wordlist);
        tl1->wl_word = copy("run");
    }
    return (tl1);
}


int
InProgress()
{
    return (ft_curckt && ft_curckt->ci_inprogress);
}


int
IsIplot()
{
    struct dbcomm *d;
    extern struct dbcomm *dbiplot;

    for (d = dbiplot; d; d = d->db_next) {
        if (d->db_type == DB_IPLOT) return (true);
        if (d->db_type == DB_IPLOTALL) return (true);
    }
    return (false);
}