lib/spfte/dotcards.c

/***************************************************************************
JSPICE3 adaptation of Spice3e2 - 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
****************************************************************************/

/*
 * Spice-2 compatibility stuff for .plot, .print, .four, and .width.
 */

#include "spice.h"
#include "ftedefs.h"
#include "fteinp.h"
#include "spfteext.h"

#ifdef __STDC__
static void fixdotplot(wordlist*);
static void fixdotprint(wordlist*);
static char *fixem(char*);
static bool setcplot(char*);
static wordlist *gettoks(char*);
#else
static void fixdotplot();
static void fixdotprint();
static char *fixem();
static bool setcplot();
static wordlist *gettoks();
#endif

bool ft_acctprint = false;
bool ft_listprint = false;
bool ft_nodesprint = false;
bool ft_optsprint = false;


/* Extract all the .save lines */

void
ft_dotsaves()
{
    wordlist *iline, *wl = NULL;
    char *s;

    if (!ft_curckt) /* Shouldn't happen. */
        return;

    for (iline = ft_curckt->ci_commands; iline; iline = iline->wl_next) {
        if (ciprefix(".save", iline->wl_word)) {
            s = iline->wl_word;
            advtok(&s);
            wl = wl_append(wl, gettoks(s));
        }
    }
    if (wl) {
        com_save(wl);
        wl_free(wl);
    }
    /* If there aren't any .saves, all vectors will be saved,
     * which is the default action for rawfiles when com_save()
     * isn't called.
     */
    return;
}


/* Go through the dot lines given and make up a big "save" command with
 * all the node names mentioned. Note that if a node is requested for
 * one analysis, it is saved for all of them.
 */

void
ft_savedotargs()
{
    wordlist *w, *wl = NULL, *iline;
    char *s;

    if (!ft_curckt) /* Shouldn't happen. */
        return;

    for (iline = ft_curckt->ci_commands; iline; iline = iline->wl_next) {
        s = iline->wl_word;
        if (ciprefix(".print", s) || ciprefix(".plot", s) ||
                ciprefix(".four", s)) {
            advtok(&s);
            advtok(&s);
            if (!(w = gettoks(s)))
                fprintf(cp_err, "Warning: no nodes given: %s\n",
                    iline->wl_word);
            wl = wl_append(wl, w);
        }
    }
    if (wl) {
        com_save(wl);
        wl_free(wl);
    }
    fprintf(cp_err, "Warning: no .print, .plot, or .four lines in input.\n");
}


/* Execute the .whatever lines found in the deck, after we are done running.
 * We'll be cheap and use cp_lexer to get the words.  This should make us
 * spice-2 compatible.  If terse is true then there was a rawfile, so don't
 * print lots of junk.
 */

void
ft_cktcoms(terse)

bool terse;
{
    wordlist *coms, *command, *cl;
    char *plottype, *s;
    struct dvec *v;
    struct dvlist *dl0, *dl;
    static wordlist twl = { "col", NULL, NULL } ;
    int i;

    if (!ft_curckt)
        return;
    if (!ft_curckt->ci_commands)
        goto nocmds;
    coms = ft_curckt->ci_commands;
    cp_interactive = false;

    out_init();

    /* Circuit name */
    out_printf("Circuit: %s\nDate: %s\n\n", ft_curckt->ci_name,
        datestring());
    out_printf("\n");

    /* Listing */
    if (ft_listprint) {
        if (terse)
            out_printf(".options: no listing, rawfile was generated.\n");
        else
            inp_list(cp_out, ft_curckt->ci_deck, ft_curckt->ci_options,
                LS_DECK);
    }

    /* If there was a .op line, then we have to do the .op output. */
    if (setcplot("op")) {
        if (terse) {
            out_printf("\nOP information in rawfile.\n");
        }
        else {
            out_printf("\nOperating point information:\n\n");
            out_printf("\tNode\tVoltage\n");
            out_printf("\t----\t-------\n");

            v = vec_fromplot("all",plot_cur);
            vec_sort(v);
            dl0 = v->v_link2;

            for (dl = dl0; dl; dl = dl->dl_next) {
                v = dl->dl_dvec;
                if (!isreal(v)) {
                    fprintf(cp_err,
                "Internal error: op vector %s not real\n", v->v_name);
                    continue;
                }
                if (v->v_type == SV_VOLTAGE)
                    out_printf("\t%s\t%s\n", v->v_name,
                        printnum(v->v_realdata[0]));
            }
            out_printf("\n\tSource\tCurrent\n");
            out_printf("\t------\t-------\n\n");
            for (dl = dl0; dl; dl = dl->dl_next) {
                v = dl->dl_dvec;
                if (v->v_type == SV_CURRENT)
                    out_printf("\t%s\t%s\n", v->v_name,
                        printnum(v->v_realdata[0]));
            }
            out_printf("\n");
        }
    }

    if (setcplot("tf")) {
        wordlist all;

        if (terse)
            out_printf("TF information in rawfile.\n");
        else {
            out_printf("Transfer function information:\n");
            all.wl_next = NULL;
            all.wl_word = "all";
            com_print(&all);
            out_printf("\n");
        }
    }

    /* Now all the '.' lines */
    while (coms) {
        cl = command = cp_lexer(coms->wl_word);
        if (!command)
            goto bad;
        if (eq(command->wl_word, ".width")) {
            do {
                command = command->wl_next;
            } while (command && !ciprefix("out", command->wl_word));
            if (command) {
                s = strchr(command->wl_word, '=');
                if (!s || !s[1]) {
                    fprintf(cp_err,
                        "Error: bad line %s\n", coms->wl_word);
                    coms = coms->wl_next;
                    wl_free(cl);
                    continue;
                }
                i = atoi(++s);
                cp_vset("width", VT_NUM, (char *) &i);
            }
        }
        else if (eq(command->wl_word, ".print")) {
            if (terse) {
                out_printf(
                "\n.print line ignored since rawfile was produced\n");
            }
            else {
                command = command->wl_next;
                if (!command) {
                    fprintf(cp_err, "Error: bad line %s\n", coms->wl_word);
                    coms = coms->wl_next;
                    wl_free(cl);
                    continue;
                }
                plottype = command->wl_word;
                command = command->wl_next;
                fixdotprint(command);
                twl.wl_next = command;
                if (setcplot(plottype))
                    com_print(&twl);
                else
                    fprintf(cp_err,
                        "Error: no %s plot found\n", plottype);
                out_printf("\n\n");
            }
        }
        else if (eq(command->wl_word, ".plot")) {
            if (terse) {
                out_printf(
                "\n.plot line ignored since rawfile was produced\n");
            }
            else {
                command = command->wl_next;
                if (!command) {
                    fprintf(cp_err, "Error: bad line %s\n", coms->wl_word);
                    coms = coms->wl_next;
                    wl_free(cl);
                    continue;
                }
                plottype = command->wl_word;
                command = command->wl_next;
                fixdotplot(command);
                if (setcplot(plottype))
                    com_asciiplot(command);
                else
                    fprintf(cp_err,
                        "Error: no %s plot found\n", plottype);
                out_printf("\n\n");
            }
        }
        else if (ciprefix(".four", command->wl_word)) {
            if (terse)
                out_printf(
                    ".fourier line ignored since rawfile was produced.\n");
            else if (setcplot("tran")) {
                com_fourier(command->wl_next);
                out_printf("\n\n");
            }
            else {
                out_printf(
                    "No transient data available for fourier analysis");
            }
        }
        else if (!eq(command->wl_word, ".save")
            && !eq(command->wl_word, ".op")
            && !eq(command->wl_word, ".tf"))
            goto bad;
        wl_free(cl);
        coms = coms->wl_next;
    }

nocmds:
    /* Now the node table */
    if (ft_nodesprint)
        ;

    /* The options */
    if (ft_optsprint) {
        fprintf(cp_err, "Options:\n\n");
        cp_vprint();
        (void) putc('\n', cp_out);
    }

    /* And finally the accounting info. */
    if (ft_acctprint) {
        static wordlist ww = { "everything", NULL, NULL } ;
        com_rusage(&ww);
    }
    else
        com_rusage((wordlist *) NULL);

    out_printf("\n");
    return;

bad:
    fprintf(cp_err, "Internal Error: ft_cktcoms: bad commands\n");
    return;
}


/* These routines make sure that the arguments to .plot and .print in
 * spice2 decks are acceptable to spice3. The things we look for are:
 *  trailing (a,b) in .plot -> xlimit a b
 *  vm(x) -> mag(v(x))
 *  vp(x) -> ph(v(x))
 *  v(x,0) -> v(x)
 *  v(0,x) -> -v(x)
 */

static void
fixdotplot(wl)

wordlist *wl;
{
    char buf[BSIZE_SP], *s;
    double *d, d1, d2;

    while (wl) {
        wl->wl_word = fixem(wl->wl_word);

        /* Is this a trailing (a,b) ? Note that we require it to be
         * one word.
         */
        if (!wl->wl_next && (*wl->wl_word == '(')) {
            s = wl->wl_word + 1;
            d = ft_numparse(&s, false);
            if (*s != ',') {
                fprintf(cp_err, "Error: bad limits \"%s\"\n",
                    wl->wl_word);
                return;
            }
            d1 = *d;
            s++;
            d = ft_numparse(&s, false);
            if ((*s != ')') || s[1]) {
                fprintf(cp_err, "Error: bad limits \"%s\"\n",
                    wl->wl_word);
                return;
            }
            d2 = *d;
            tfree(wl->wl_word);
            wl->wl_word = copy("xlimit");
            wl->wl_next = alloc(struct wordlist);
            wl->wl_next->wl_prev = wl;
            wl = wl->wl_next;
            (void) strcpy(buf, printnum(d1));
            wl->wl_word = copy(buf);
            wl->wl_next = alloc(struct wordlist);
            wl->wl_next->wl_prev = wl;
            wl = wl->wl_next;
            (void) strcpy(buf, printnum(d2));
            wl->wl_word = copy(buf);
        }
        wl = wl->wl_next;
    }
}


static void
fixdotprint(wl)

wordlist *wl;
{
    while (wl) {
        wl->wl_word = fixem(wl->wl_word);
        wl = wl->wl_next;
    }
}


static char *
fixem(string)

char *string;
{
    char buf[BSIZE_SP], *s, *t, *ss = string;

    if (ciprefix("v(", string) && strchr(string, ',')) {
        for (s = string; *s && (*s != ','); s++)
            ;
        *s++ = '\0';
        for (t = s; *t && (*t != ')'); t++)
            ;
        *t = '\0';
        if (eq(s, "0"))
            (void) sprintf(buf, "v(%s)", string + 2);
        else if (eq(string + 2, "0"))
            (void) sprintf(buf, "-v(%s)", s);
        else
            (void) sprintf(buf, "v(%s)-v(%s)", string + 2, s);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("vm(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        (void) sprintf(buf, "mag(v(%s))", string + 3);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("vp(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        (void) sprintf(buf, "ph(v(%s))", string + 3);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("vi(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        (void) sprintf(buf, "imag(v(%s))", string + 3);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("vr(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        (void) sprintf(buf, "real(v(%s))", string + 3);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("vdb(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        (void) sprintf(buf, "db(v(%s))", string + 4);
        tfree(ss);
        return (copy(buf));
    }
    if (ciprefix("i(", string)) {
        for (s = string; *s && (*s != ')'); s++)
            ;
        *s = '\0';
        string += 2;
        (void) sprintf(buf, "%s#branch", string);
        tfree(ss);
        return (copy(buf));
    }
    return (string);
}


/* Don't bother with ccom strangeness here. */

static bool
setcplot(name)

char *name;
{
    struct plot *pl;

    for (pl = plot_list; pl; pl = pl->pl_next) {
        if (ciprefix(name, pl->pl_typename)) {
            plot_cur = pl;
            return (true);
        }
    }
    return (false);
}


static wordlist *
gettoks(s)

char *s;
{
    char *t, *r, buf[64], buf1[BSIZE_SP];
    wordlist *wl = NULL, *end = NULL;
    bool iflag;

    while (copytok(buf1,&s)) {
        t = buf1;
        if (*t == '(') {
            /* This is a (upper, lower) thing -- ignore. */
            continue;
        }
        if (!strchr(t, '(')) {
            ;
        }
        else if (!strchr(t, ',')) {
            iflag = ((*t == 'i') || (*t == 'I')) ? true : false;
            while (*t != '(')
                t++;
            t++;
            for (r = t; *r && *r != ')'; r++)
                ;
            *r = '\0';
            if (iflag) {
                (void) sprintf(buf, "%s#branch", t);
                t = buf;
            }
        }
        else {
            /* The painful case */
            while (*t != '(')
                t++;
            t++;
            for (r = t; *r && *r != ','; r++)
                ;
            *r = '\0';
            if (end) {
                end->wl_next = alloc(struct wordlist);
                end->wl_next->wl_prev = end;
                end = end->wl_next;
            }
            else
                wl = end = alloc(struct wordlist);
            end->wl_word = copy(t);
            t = r + 1;
            for (r = t; *r && *r != ')'; r++)
                ;
            *r = '\0';
        }
        if (end) {
            end->wl_next = alloc(struct wordlist);
            end->wl_next->wl_prev = end;
            end = end->wl_next;
        }
        else
            wl = end = alloc(struct wordlist);
        end->wl_word = copy(t);
    }
    return (wl);
}