lib/spfte/outitf.c

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

/*
 * This module replaces the old "writedata" routines in nutmeg.
 * Unlike the writedata routines, the OUT routines are only called by
 * the simulator routines, and only call routines in nutmeg.  The rest
 * of nutmeg doesn't deal with OUT at all.
 */

#include "spice.h"
#include "ftedefs.h"
#include "inpdefs.h"
#include "ftegraph.h"
#include "spfteext.h"
#include "plotext.h"
#include "iferrmsg.h"
#include "outdata.h"

#define DOUBLE_PRECISION    15

typedef struct dataDesc {
    char *name;         /* The name of the vector. */
    int type;           /* The type. */
    bool regular;       /* Is this given to us? */
    int outIndex;       /* If regular then the index. */
    char *specName;     /* The device name if special. */
    char *specParamName;/* The parameter name if special. */
    int specIndex;      /* For sensitivity, if special. */
    int specType;
    GENERIC *specFast;
    int refIndex;       /* The index of our ref vector. */
    struct dvec *vec;
} dataDesc;

typedef struct runDesc {
    GENERIC *analysis;
    GENERIC *circuit;
    char *name;
    char *type;
    int numData;
    int refIndex;
    dataDesc *data;
    bool writeOut;
    bool binary;
    struct plot *runPlot;
    FILE *fp;
    long pointPos;      /* where to write pointCount */
    int pointCount;     /* running count of output points */
    int numPoints;      /* num points expected, -1 if not known */
    int isComplex;
    int windowCount;
} runDesc;

/* signal the simulator to end analysis as if finished */
bool OUTendit;

static struct sOUTcontrol OUTcntrl;

#ifdef __STDC__
static void out_destroy(void);
static int  addDataDesc(runDesc*,char*,int,int);
static int  addSpecialDesc(runDesc*,char*,char*,char*,int);
static void addPointToFile(runDesc*,IFvalue*,IFvalue*);
static void addPointToPlot(runDesc*,IFvalue*,IFvalue*,bool);
static void fileInit(runDesc*);
static void fileStartPoint(FILE*,bool,int);
static void fileAddRealValue(FILE*,bool,double);
static void fileAddComplexValue(FILE*,bool,IFcomplex);
static void fileEndPoint(FILE*,bool);
static void fileEnd(runDesc*);
static void plotInit(runDesc*,double,double,double,struct plot*);
static void plotAddRealValue(dataDesc*,double,bool);
static void plotAddComplexValue(dataDesc*,IFcomplex,bool);
static void plotEnd(runDesc*);
static bool parseSpecial(char*,char*,char*,char*);
static bool name_eq(char*,char*);
static bool getSpecial(dataDesc*,runDesc*,IFvalue*);
static void freeRun(runDesc*);
#else
static void out_destroy();
static int  addDataDesc();
static int  addSpecialDesc();
static void addPointToFile();
static void addPointToPlot();
static void fileInit();
static void fileStartPoint();
static void fileAddRealValue();
static void fileAddComplexValue();
static void fileEndPoint();
static void fileEnd();
static void plotInit();
static void plotAddRealValue();
static void plotAddComplexValue();
static void plotEnd();
static bool parseSpecial();
static bool name_eq();
static bool getSpecial();
static void freeRun();
#endif

static bool shouldstop = false; /* Tell simulator to stop next time it asks. */
static bool printinfo = false;    /* Print informational "error messages". */


char *
OUTcntrlInit()
{
    /* return the OUTcntrl structure */
    OUTcntrl.out_destroy    = out_destroy;
    OUTcntrl.out_rundesc    = NULL;
    OUTcntrl.out_check      = false;
    OUTcntrl.out_usecurplot = false;
    OUTcntrl.out_keepplot   = false;
    OUTcntrl.out_points     = NULL;
    OUTcntrl.out_index      = 0;
    OUTcntrl.out_max        = 0;
    OUTcntrl.out_fail       = 0;
    OUTcntrl.out_evaluate   = NULL;
    OUTcntrl.out_end        = NULL;
    return (char *)&OUTcntrl;
}


static void
out_destroy()
{
    if (OUTcntrl.out_rundesc) {
        freeRun((runDesc*)OUTcntrl.out_rundesc);
        OUTcntrl.out_rundesc = NULL;
    }
    OUTcntrl.out_check      = false;
    OUTcntrl.out_usecurplot = false;
    OUTcntrl.out_keepplot   = false;
    OUTcntrl.out_points     = NULL;
    OUTcntrl.out_index      = 0;
    OUTcntrl.out_max        = 0;
    OUTcntrl.out_fail       = 0;
    OUTcntrl.out_evaluate   = NULL;
    OUTcntrl.out_end        = NULL;
}


int
OUTbeginPlot(outdp)

GENERIC *outdp;
{
    struct sOUTdata *outd = (struct sOUTdata*)outdp;
    struct plot *plot = NULL;
    runDesc *run;
    char **saves;
    char *cktName;
    bool *savesused;
    int numsaves;
    int i, j, depind;
    char namebuf[BSIZE_SP], parambuf[BSIZE_SP], depbuf[BSIZE_SP];
    bool saveall = true;
    extern char *kw_printinfo;

    shouldstop = false;

    if (OUTcntrl.out_check) {
        OUTcntrl.out_index = 0;
    }
    if (OUTcntrl.out_usecurplot) {
        plot = plot_cur;
    }
    if (OUTcntrl.out_keepplot && OUTcntrl.out_rundesc) {
        *outd->plotPtr = (GENERIC*)OUTcntrl.out_rundesc;
        return (OK);
    }

    if (ft_curckt && ft_curckt->ci_ckt == outd->circuitPtr)
        cktName = ft_curckt->ci_name;
    else {
        /* hack for test system interface */
        if (outd->circuitPtr == NULL)
            cktName = (char*)outd->refName + (strlen(outd->refName) + 1);
        else
            cktName = "circuit name";
    }

    /* Check to see if we want to print informational data. */
    if (cp_getvar(kw_printinfo, VT_BOOL, (char *) &printinfo))
    fprintf(cp_err, "(debug printing enabled)\n");

    run = alloc(struct runDesc);
    *outd->plotPtr = (GENERIC*)run;

    /* First fill in some general stuff. */
    run->analysis = outd->analysisPtr;
    run->circuit = outd->circuitPtr;
    run->name = copy(cktName);
    run->type = copy(outd->analName);
    if (outd->numPts <= 0)
        run->numPoints = 1;
    else
        run->numPoints = outd->numPts;

    if (OUTcntrl.out_check) {
        run->numPoints = 1;
    }
    if (OUTcntrl.out_keepplot) {
        OUTcntrl.out_rundesc = (char*)run;
    }

    /* Now let's see which of these things we need.  First toss in the
     * reference vector.  Then toss in anything that getSaves() tells
     * us to save that we can find in the name list.  Finally unpack
     * the remaining saves into parameters.
     */
    numsaves = ft_getSaves(&saves);
    if (numsaves) {
        savesused = (bool *) tmalloc(sizeof (bool) * numsaves);
        saveall = false;
        for (i = 0; i < numsaves; i++)
            if (cieq(saves[i], "all")) {
                saveall = true;
                savesused[i] = true;
                break;
            }
    }

    /* Pass 0. */
    if (outd->refName) {
        addDataDesc(run, outd->refName, outd->refType, -1);
        for (i = 0; i < numsaves; i++)
            if (name_eq(saves[i], outd->refName)) {
                savesused[i] = true;
            }
    }
    else {
        run->refIndex = -1;
    }

    /* Pass 1. */
    if (numsaves && !saveall) {
        for (i = 0; i < numsaves; i++) {
            for (j = 0; j < outd->numNames; j++)
                if (name_eq(saves[i], outd->dataNames[j])) {
                    addDataDesc(run, outd->dataNames[j],
                            outd->dataType, j);
                    savesused[i] = true;
                    break;
                }
        }
    }
    else {
        for (i = 0; i < outd->numNames; i++)
            if (!outd->refName ||
                    !name_eq(outd->dataNames[i], outd->refName)) {
                addDataDesc(run, outd->dataNames[i], outd->dataType, i);
            }
    }

    /* Pass 2. */
    for (i = 0; i < numsaves; i++) {
        if (savesused[i])
            continue;
        if (!parseSpecial(saves[i], namebuf, parambuf, depbuf)) {
            if (numsaves == 1 && !saves[0])
                fprintf(cp_err, "Warning: no variables saved\n");
            else
                fprintf(cp_err, "Warning: can't parse '%s': ignored\n",
                    saves[i]);
            continue;
        }
        /* Now, if there's a dep variable, do we already have it? */
        if (*depbuf) {
            for (j = 0; j < run->numData; j++)
                if (name_eq(depbuf, run->data[j].name))
                    break;
            if (j == run->numData) {
                /* Better add it. */
                for (j = 0; j < outd->numNames; j++)
                    if (name_eq(depbuf, outd->dataNames[j]))
                        break;
                if (j == outd->numNames) {
                    fprintf(cp_err,
            "Warning: can't find '%s': value '%s' ignored\n",
                        depbuf, saves[i]);
                    continue;
                }
                addDataDesc(run, outd->dataNames[j], outd->dataType, j);
                savesused[i] = true;
                depind = j;
            }
            else
                depind = run->data[j].outIndex;
        }
        addSpecialDesc(run, saves[i], namebuf, parambuf, depind);
    }

    if (numsaves)
        txfree((char*)savesused);

    /* Now that we have our own data structures built up, let's see what
     * nutmeg wants us to do.
     */
    run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary,
            run->type, run->name);

    if (run->writeOut)
        fileInit(run);
    else
        plotInit(run,outd->initValue,outd->finalValue,outd->step,plot);

    if (outd->refName && run->runPlot)
        run->runPlot->pl_ndims = 1;

    return (OK);
}


static int
addDataDesc(run, name, type, ind)

runDesc *run;
char *name;
int type;
int ind;
{
    dataDesc *data;

    if (!run->numData)
        run->data = (dataDesc *) tmalloc(sizeof (dataDesc));
    else
        run->data = (dataDesc *) trealloc((char *) run->data,
                sizeof (dataDesc) * (run->numData + 1));
    data = &run->data[run->numData];
    /* so freeRun will get nice NULL pointers for the fields we don't set */
    bzero(data, sizeof(dataDesc));

    data->name = copy(name);
    data->type = type;
    data->regular = true;
    data->outIndex = ind;

    if (ind == -1) {
        /* It's the reference vector. */
        run->refIndex = run->numData;
    }

    run->numData++;

    return (OK);
}


static int
addSpecialDesc(run, name, devname, param, depind)

runDesc *run;
char *name;
char *devname;
char *param;
int depind;
{
    dataDesc *data;
    char *unique;       /* unique char * from back-end */

    if (!run->numData)
        run->data = (dataDesc *) tmalloc(sizeof (dataDesc));
    else
        run->data = (dataDesc *) trealloc((char *) run->data,
                sizeof (dataDesc) * (run->numData + 1));
    data = &run->data[run->numData];
    /* so freeRun will get nice NULL pointers for the fields we don't set */
    bzero(data, sizeof(dataDesc));

    data->name = copy(name);

    unique = devname;
    INPinsert(&unique, (INPtables *) ft_curckt->ci_symtab);
    data->specName = unique;

    data->specParamName = copy(param);

    data->specIndex = depind;
    data->specType = -1;
    data->specFast = NULL;
    data->regular = false;

    run->numData++;

    return (OK);
}


int
OUTdata(plotPtr, refValue, valuePtr)

GENERIC *plotPtr;
IFvalue *refValue;
IFvalue *valuePtr;
{
    runDesc *run = (runDesc *) plotPtr;

    if (OUTcntrl.out_check) {

        if (refValue->rValue < OUTcntrl.out_points[OUTcntrl.out_index])
            return (OK);

        addPointToPlot(run,refValue,valuePtr,false);
        if (OUTcntrl.out_evaluate)
            OUTcntrl.out_fail = (*OUTcntrl.out_evaluate)();
        else
            OUTcntrl.out_fail = false;

        OUTcntrl.out_index++;
        if (OUTcntrl.out_fail || OUTcntrl.out_index == OUTcntrl.out_max) {
            OUTendit = true;
        }
        return (OK);
    }

    run->pointCount++;

    if (run->writeOut) {
        addPointToFile(run,refValue,valuePtr);
    }
    else {
        addPointToPlot(run,refValue,valuePtr,true);
        gr_iplot(run->runPlot);
    }

    if (ft_bpcheck(run->runPlot, run->pointCount) == false)
        shouldstop = true;

    vec_gc();
    return (OK);
}


int
OUTsetDims(plotPtr,dims,numDims)

GENERIC *plotPtr;
int *dims, numDims;
{
    runDesc *run = (runDesc *) plotPtr;
    struct dvec *v;
    int i, j;

    if (OUTcntrl.out_check) {
        OUTcntrl.out_index = 0;
        if (OUTcntrl.out_fail)
            OUTendit = true;
        return (OK);
    }

    if (run->writeOut)
        return (OK);

    for (i = 0; i < run->numData; i++) {
        v = run->data[i].vec;
        for (j = 0; j < numDims; j++)
            v->v_dims[j] = dims[j];
        v->v_numdims = numDims;
    }
    return (OK);
}


static void
addPointToFile(run,refValue,valuePtr)

runDesc *run;
IFvalue *refValue;
IFvalue *valuePtr;
{
    int i;
    IFvalue val;

    fileStartPoint(run->fp, run->binary, run->pointCount);

    if (run->refIndex != -1) {
        if (run->isComplex)
            fileAddComplexValue(run->fp, run->binary, refValue->cValue);
        else
            fileAddRealValue(run->fp, run->binary, refValue->rValue);
    }

    for (i = 0; i < run->numData; i++) {
        /* we've already printed reference vec first */
        if (run->data[i].outIndex == -1) continue;

        if (run->data[i].regular) {
            if(run->data[i].type == IF_REAL)
                fileAddRealValue(run->fp, run->binary,
                    valuePtr->v.vec.rVec
                    [run->data[i].outIndex]);
            else if (run->data[i].type == IF_COMPLEX)
                fileAddComplexValue(run->fp, run->binary,
                    valuePtr->v.vec.cVec
                    [run->data[i].outIndex]);
            else
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
        else {
            /* should pre-check instance */
            if (!getSpecial(&run->data[i], run, &val))
                continue;
            if (run->data[i].type == IF_REAL)
                fileAddRealValue(run->fp, run->binary,
                    val.rValue);
            else if (run->data[i].type == IF_COMPLEX)
                fileAddComplexValue(run->fp, run->binary,
                    val.cValue);
            else
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
    }
    fileEndPoint(run->fp, run->binary);
}


static void
addPointToPlot(run,refValue,valuePtr,inc)

runDesc *run;
IFvalue *refValue;
IFvalue *valuePtr;
bool inc; /* increment dvec length if true */
{
    int i;
    IFvalue val;

    for (i = 0; i < run->numData; i++) {
        if (run->data[i].outIndex == -1) {
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                        refValue->rValue,inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                        refValue->cValue,inc);
        }
        else if (run->data[i].regular) {
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                    valuePtr->v.vec.rVec
                    [run->data[i].outIndex],inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                    valuePtr->v.vec.cVec
                    [run->data[i].outIndex],inc);
        }
        else {
            /* should pre-check instance */
            if (!getSpecial(&run->data[i], run, &val))
                continue;
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                        val.rValue,inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                        val.cValue,inc);
            else
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
    }
}


int
OUTendPlot(plotPtr)

GENERIC *plotPtr;
{
    runDesc *run = (runDesc *) plotPtr;

    if (OUTcntrl.out_check) {
        if (OUTcntrl.out_end)
            (*OUTcntrl.out_end)();
        OUTendit = false;
        return (OK);
    }
    else if (OUTcntrl.out_keepplot) {
        return (OK);
    }

    if (run->writeOut)
        fileEnd(run);
    else {
        gr_end_iplot();
        plotEnd(run);
    }

    freeRun(run);

    return (OK);
}


/* The file writing routines. */

static void
fileInit(run)

runDesc *run;
{
    int i;
    char *name, buf[BSIZE_SP];
    int type;

    /* This is a hack. */
    run->isComplex = false;
    for (i = 0; i < run->numData; i++)
        if (run->data[i].type == IF_COMPLEX)
            run->isComplex = true;

    fprintf(run->fp, "Title: %s\n", run->name);
    fprintf(run->fp, "Date: %s\n", datestring());
    fprintf(run->fp, "Plotname: %s\n", run->type);
    fprintf(run->fp, "Flags: %s\n", run->isComplex ? "complex" : "real");
    fprintf(run->fp, "No. Variables: %d\n", run->numData);
    fprintf(run->fp, "No. Points: ");

    fflush(run->fp);        /* Gotta do this for LATTICE. */
    run->pointPos = ftell(run->fp);
    fprintf(run->fp, "0       \n"); /* Save 8 spaces here. */

    fprintf(run->fp, "Command: version %s\n", ft_sim->version);
    fprintf(run->fp, "Variables:\n");

    for (i = 0; i < run->numData; i++) {
        if (isdigit(*run->data[i].name)) {
      (void) sprintf(buf, "v(%s)", run->data[i].name);
          name = buf;
        }
        else {
          name = run->data[i].name;
        }
        if (substring("#branch", name))
            type = SV_CURRENT;
        else if (cieq(name, "time"))
            type = SV_TIME;
        else if (cieq(name, "frequency"))
            type = SV_FREQUENCY;
        else
            type = SV_VOLTAGE;
        fprintf(run->fp, "\t%d\t%s\t%s\n", i, name,
                ft_typenames(type));
    }

    fprintf(run->fp, "%s:\n", run->binary ? "Binary" : "Values");

    return;
}


static void
fileStartPoint(fp, bin, num)

FILE *fp;
bool bin;
int num;
{
    if (!bin)
        fprintf(fp, "%d", num - 1);

    return;
}


static void
fileAddRealValue(fp, bin, value)

FILE *fp;
bool bin;
double value;
{
    if (bin)
        fwrite((char *) &value, sizeof (double), 1, fp);
    else
        fprintf(fp, "\t%.*e\n", DOUBLE_PRECISION, value);

    return;
}


static void
fileAddComplexValue(fp, bin, value)

FILE *fp;
bool bin;
IFcomplex value;
{

    if (bin) {
        fwrite((char *) &value.real, sizeof (double), 1, fp);
        fwrite((char *) &value.imag, sizeof (double), 1, fp);
    }
    else {
        fprintf(fp, "\t%.*e,%.*e\n", DOUBLE_PRECISION, value.real,
            DOUBLE_PRECISION, value.imag);
    }

}


/* ARGSUSED */ /* until some code gets written */
static void
fileEndPoint(fp, bin)

FILE *fp;
bool bin;
{
    return;
}


/* Here's the hack...  Run back and fill in the number of points. */

static void
fileEnd(run)

runDesc *run;
{
    long place;

    if (run->fp == stdout)
        return;
    fflush(run->fp);    /* For LATTICE... */
    place = ftell(run->fp);
    fseek(run->fp, run->pointPos, 0);
    fprintf(run->fp, "%d", run->pointCount);
    fseek(run->fp, place, 0);
    fflush(run->fp);

    return;
}


/* The plot maintenance routines. */

static void
plotInit(run,tstart,tstop,tstep,plot)

runDesc *run;
double tstart, tstop, tstep;
struct plot *plot;
{
    struct plot *pl;
    char buf[100];
    struct dvec *v;
    dataDesc *dd;
    int i;

    if (plot == NULL) {
        pl = plot_alloc(run->type);
        plot_new(pl);
        plot_setcur(pl->pl_typename);
    }
    else
        pl = plot;
    pl->pl_title = copy(run->name);
    pl->pl_name = copy(run->type);
    pl->pl_date = copy(datestring( ));
    pl->pl_ndims = 0;
    pl->pl_start = tstart;
    pl->pl_stop = tstop;
    pl->pl_step = tstep;
    run->runPlot = pl;

    /* This is a hack. */
    /* if any of them are complex, make them all complex */
    run->isComplex = false;
    for (i = 0; i < run->numData; i++) {
      if (run->data[i].type == IF_COMPLEX) run->isComplex = true;
    }

    for (i = 0; i < run->numData; i++) {
        dd = &run->data[i];
        v = alloc(struct dvec);
        if (isdigit(*dd->name)) {
            (void) sprintf(buf, "v(%s)", dd->name);
            v->v_name = copy(buf);
        }
        else
            v->v_name = copy(dd->name);
        if (substring("#branch", v->v_name) || eq(v->v_name,"isweep"))
            v->v_type = SV_CURRENT;
        else if (cieq(v->v_name, "time"))
            v->v_type = SV_TIME;
        else if (cieq(v->v_name, "frequency"))
            v->v_type = SV_FREQUENCY;
        else
            v->v_type = SV_VOLTAGE;
        v->v_length = 0;
        v->v_rlength = run->numPoints;
        v->v_scale = NULL;

        if (!run->isComplex) {
            v->v_flags = VF_REAL;
            v->v_realdata = (double *)
                tmalloc(v->v_rlength * sizeof(double));
        }
        else {
            v->v_flags = VF_COMPLEX;
            v->v_compdata = (complex *)
                tmalloc(v->v_rlength * sizeof(complex));
        }
        vec_newperm(v);
        dd->vec = v;
    }
}


static void
plotAddRealValue(desc, value, inc)

dataDesc *desc;
double value;
bool inc;
{
    struct dvec *v = desc->vec;

    if (isreal(v)) {
        if (!inc) {
            v->v_realdata[0] = value;
            v->v_length = 1;
            return;
        }
        if (v->v_length >= v->v_rlength) {
            v->v_realdata = (double *) trealloc((char *) v->v_realdata,
                sizeof (double) * (v->v_length + 1));
            v->v_rlength = v->v_length + 1;
        }
        v->v_realdata[v->v_length] = value;
    }
    else {
        /* a real parading as a VF_COMPLEX */
        if (!inc) {
            v->v_compdata[0].cx_real = value;
            v->v_compdata[0].cx_imag = (double) 0;
            v->v_length = 1;
            return;
        }
        if (v->v_length >= v->v_rlength) {
            v->v_compdata = (complex *) trealloc((char *) v->v_compdata,
                sizeof (complex) * (v->v_length + 1));
            v->v_rlength = v->v_length + 1;
        }
        v->v_compdata[v->v_length].cx_real = value;
        v->v_compdata[v->v_length].cx_imag = (double) 0;
    }
    v->v_length++;

    return;
}


static void
plotAddComplexValue(desc, value, inc)

dataDesc *desc;
IFcomplex value;
bool inc;
{
    struct dvec *v = desc->vec;

    if (!inc) {
        v->v_compdata[0].cx_real = value.real;
        v->v_compdata[0].cx_imag = value.imag;
        v->v_length = 1;
        return;
    }
    if (v->v_length >= v->v_rlength) {
        v->v_compdata = (complex *) trealloc((char *) v->v_compdata,
            sizeof (complex) * (v->v_length + 1));
        v->v_rlength = v->v_length + 1;
    }
    v->v_compdata[v->v_length].cx_real = value.real;
    v->v_compdata[v->v_length].cx_imag = value.imag;
    v->v_length++;

    return;
}


/* ARGSUSED */ /* until some code gets written */
static void
plotEnd(run)

runDesc *run;
{
    return;
}


/* ParseSpecial takes something of the form "@name[param,index]" and rips
 * out name, param, and index.
 */

static bool
parseSpecial(name, dev, param, ind)

char *name;
char *dev;
char *param;
char *ind;
{
    char *s;

    *dev = *param = *ind = '\0';

    if (*name != '@')
        return (false);
    name++;

    s = dev;
    while (*name && (*name != '['))
        *s++ = *name++;
    *s = '\0';
    if (!*name)
        return (true);
    name++;

    s = param;
    while (*name && (*name != ',') && (*name != ']'))
        *s++ = *name++;
    *s = '\0';
    if (*name == ']')
        return (!name[1] ? true : false);
    else if (!*name)
        return (false);
    name++;

    s = ind;
    while (*name && (*name != ']'))
        *s++ = *name++;
    *s = '\0';
    if (*name && !name[1])
        return (true);
    else
        return (false);
}


/* This routine must match two names with or without a V() around them. */

static bool
name_eq(n1, n2)

char *n1, *n2;
{
    char *s;

    if (!n1 || !n2)
        return (false);
    s = strchr(n1,'(');
    if (s)
        n1 = s+1;
    s = strchr(n2,'(');
    if (s)
        n2 = s+1;

    for ( ; ; n1++,n2++) {
        if ((*n1 == 0 || *n1 == ')') && (*n2 == 0 || *n2 == ')'))
            return (true);
        if (*n1 != *n2)
            break;
    }
    return (false);
}


static bool
getSpecial(desc, run, val)

dataDesc *desc;
runDesc *run;
IFvalue *val;
{
    IFvalue selector;
    struct variable *vv;

    selector.iValue = desc->specIndex;
    if (INPaName(desc->specParamName, val, run->circuit, &desc->specType,
            desc->specName, &desc->specFast, ft_sim, &desc->type,
            &selector) == OK) {
        desc->type &= (IF_REAL | IF_COMPLEX);   /* mask out other bits */
        return (true);
    }
    if (vv = if_getstat(run->circuit, &desc->name[1],
        (wordlist **)NULL)) {
            /* skip @ sign */
        desc->type = IF_REAL;
        if (vv->va_type == VT_REAL)
            val->rValue = vv->va_real;
        else if (vv->va_type == VT_NUM)
            val->rValue = vv->va_num;
        else if (vv->va_type == VT_BOOL)
            val->rValue = (vv->va_bool ? 1.0 : 0.0);
        else {
            return (false); /* not a real */
        }
        tfree(vv);
        return (true);
    }
    return (false);
}


static void
freeRun(run)

runDesc *run;
{

    int i;

    for (i = 0; i < run->numData; i++) {
      txfree(run->data[i].name);
      txfree(run->data[i].specParamName);
    }
    txfree((char*)run->data);
    txfree(run->type);
    txfree(run->name);
    txfree((char*)run);

}


int
OUTstopnow()
{
    static REQUEST reqst = { checkup_option, 0 };

    if (!ft_batchmode)
        DevInput(&reqst, 0);
    if (ft_intrpt || shouldstop) {
        ft_intrpt = shouldstop = false;
        return (1);
    }
    else
        return (0);
}


/* Print out error messages. */

static struct mesg {
        char *string;
        long flag;
} msgs[] = {
        { "Warning", ERR_WARNING } ,
        { "Fatal error", ERR_FATAL } ,
        { "Panic", ERR_PANIC } ,
        { "Note", ERR_INFO } ,
        { NULL, 0 }
} ;


int
OUTerror(flags,format,names)

int flags;
char *format;
IFuid *names;
{

    struct mesg *m;
    char buf[BSIZE_SP], *s, *bptr;
    int nindex = 0;

    if ((flags == ERR_INFO) && !printinfo)
        return (OK);

    for (m = msgs; m->flag; m++)
        if (flags & m->flag)
            fprintf(cp_err, "%s: ", m->string);

    for (s = format, bptr = buf; *s; s++) {
        if (*s == '%' && (s == format || *(s-1) != '%') && *(s+1) == 's') {
            strcpy(bptr, names[nindex]);
            bptr += strlen(names[nindex]);
            s++;
            nindex++;
        }
        else {
            *bptr++ = *s;
        }
    }
    *bptr = '\0';
    fprintf(cp_err, "%s\n", buf);
    fflush(cp_err);
    return (OK);
}