inp.c

spice中支持多层次元件模型仿真的可单独运行的插件源码

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1985 Wayne A. Christopher
**********/

/*
 * Stuff for dealing with spice input decks and command scripts, and
 * the listing routines.
 */

#include "spice.h"
#include "cpdefs.h"
#include "inpdefs.h"
#include "ftedefs.h"
#include "ftedata.h"
#include "fteinp.h"
#include "suffix.h"

static char *readline();
static bool doedit();

/* Do a listing. Use is listing [expanded] [logical] [physical] [deck] */

void
com_listing(wl)
    wordlist *wl;
{
    int type = LS_LOGICAL;
    bool expand = false;
    char *s;

    if (ft_curckt) {
        while (wl) {
            s = wl->wl_word;
            switch (*s) {
                case 'l':
                case 'L':
                    type = LS_LOGICAL;
                    break;
                case 'p':
                case 'P':
                    type = LS_PHYSICAL;
                    break;
                case 'd':
                case 'D':
                    type = LS_DECK;
                    break;
                case 'e':
                case 'E':
                    expand = true;
                    break;
                default:
                    fprintf(cp_err,
                    "Error: bad listing type %s\n", s);
            }
            wl = wl->wl_next;
        }
        if (type != LS_DECK)
            fprintf(cp_out, "\t%s\n\n", ft_curckt->ci_name);
        inp_list(cp_out, expand ? ft_curckt->ci_deck :
                ft_curckt->ci_origdeck, ft_curckt->ci_options,
                type);
    } else
        fprintf(cp_err, "Error: no circuit loaded.\n");
    return;
}

static char *
upper(string)
    register char *string;
{

    static char buf[BSIZE_SP];
    register char *s;

    if (string) {
	strncpy(buf, string, BSIZE_SP - 1);
	buf[BSIZE_SP - 1] = 0;
	inp_casefix(buf);
    } else {
	strcpy(buf, "<null>");
    }

    return buf;

}

/* Provide an input listing on the specified file of the given
 * card deck.  The listing should be of either LS_PHYSICAL or LS_LOGICAL
 * or LS_DECK lines as specified by the type parameter.
 */

void
inp_list(file, deck, extras, type)
    FILE *file;
    struct line *deck, *extras;
    int type;
{
    struct line *here;
    struct line *there;
    struct line *tmp, *next;
    bool renumber;
    bool useout = (file == cp_out);
    int i = 1;

    if (useout)
        out_init();
    (void) cp_getvar("renumber", VT_BOOL, (char *) &renumber);
    if (type == LS_LOGICAL) {
top1:       for (here = deck; here; here = here->li_next) {
            if (renumber)
                here->li_linenum = i;
            i++;
            if (ciprefix(".end", here->li_line) &&
                    !isalpha(here->li_line[4]))
                continue;
            if (*here->li_line != '*') {
                if (useout) {
                    sprintf(out_pbuf, "%6d : %s\n",
                            here->li_linenum,
                            upper(here->li_line));
            out_send(out_pbuf);
/*                    out_printf("%6d : %s\n",
                            here->li_linenum,
                            upper(here->li_line)); */
                } else
                    fprintf(file, "%6d : %s\n",
                            here->li_linenum,
                            upper(here->li_line));
                if (here->li_error) {
                    if (useout) {
                        out_printf("%s\n",
                                here->li_error);
                    } else
                        fprintf(file, "%s\n",
                            here->li_error, file);
                }
            }
        }
        if (extras) {
            deck = extras;
            extras = NULL;
            goto top1;
        }
        if (useout) {
/*            out_printf("%6d : .end\n", i); */
            sprintf(out_pbuf, "%6d : .end\n", i);
        out_send(out_pbuf);
        } else
            fprintf(file, "%6d : .end\n", i);
    } else if ((type == LS_PHYSICAL) || (type == LS_DECK)) {
top2:       for (here = deck; here; here = here->li_next) {
            if ((here->li_actual == NULL) || (here == deck)) {
                if (renumber)
                    here->li_linenum = i;
                i++;
                if (ciprefix(".end", here->li_line) &&
                        !isalpha(here->li_line[4]))
                    continue;
                if (type == LS_PHYSICAL) {
                    if (useout) {
                        sprintf(out_pbuf, "%6d : %s\n",
                            here->li_linenum,
                            upper(here->li_line));
            out_send(out_pbuf);
                    } else
                        fprintf(file, "%6d : %s\n",
                            here->li_linenum,
                            upper(here->li_line));
                } else {
                    if (useout)
                        out_printf("%s\n",
                            upper(here->li_line));
                    else
                        fprintf(file, "%s\n",
                            upper(here->li_line));
                }
                if (here->li_error && (type == LS_PHYSICAL)) {
                    if (useout)
                        out_printf("%s\n",
                            here->li_error);
                    else
                        fprintf(file, "%s\n",
                            here->li_error);
                }
            } else {
                for (there = here->li_actual; there;
                        there = there->li_next) {
                    there->li_linenum = i++;
                    if (ciprefix(".end", here->li_line) &&
                            isalpha(here->li_line[4]))
                        continue;
                    if (type == LS_PHYSICAL) {
                        if (useout) {
                            sprintf(out_pbuf, "%6d : %s\n",
                                there->li_linenum,
                                upper(there->li_line));
                out_send(out_pbuf);
                        } else
                            fprintf(file, "%6d : %s\n",
                                there->li_linenum,
                                upper(there->li_line));
                    } else {
                        if (useout)
                            out_printf("%s\n",
                                upper(there->li_line));
                        else
                            fprintf(file, "%s\n",
                                upper(there->li_line));
                    }
                    if (there->li_error && 
                            (type == LS_PHYSICAL)) {
                        if (useout)
                            out_printf("%s\n",
                            there->li_error);
                        else
                            fprintf(file, "%s\n",
                            there->li_error);
                    }
                }
                here->li_linenum = i;
            }
        }
        if (extras) {
            deck = extras;
            extras = NULL;
            goto top2;
        }
        if (type == LS_PHYSICAL) {
            if (useout) {
                sprintf(out_pbuf, "%6d : .end\n", i);
                out_send(out_pbuf);
            } else
                fprintf(file, "%6d : .end\n", i);
        } else {
            if (useout)
                out_printf(".end\n");
            else
                fprintf(file, ".end\n");
        }
    } else
        fprintf(cp_err, "inp_list: Internal Error: bad type %d\n", 
                type);
    return;
}

/* The routine to source a spice input deck. We read the deck in, take out
 * the front-end commands, and create a CKT structure. Also we filter out
 * the following cards: .save, .width, .four, .print, and .plot, to perform
 * after the run is over.
 */

void
inp_spsource(fp, comfile, filename)
    FILE *fp;
    bool comfile;
    char *filename;
{
    struct line *deck, *dd, *ld;
    struct line *realdeck, *options;
    char *tt, name[BSIZE_SP], *s, *t;
    bool nosubckts, commands = false;
    wordlist *wl = NULL, *end = NULL, *wl_first = NULL;
    wordlist *controls = NULL;
    FILE *lastin, *lastout, *lasterr;
    char c;

    inp_readall(fp, &deck);
    if (!deck)
        return;
    
    if (!comfile)
        options = inp_getopts(deck);

    realdeck = inp_deckcopy(deck);

    if (!comfile) {
        /* Save the title before INPgetTitle gets it. */
        tt = copy(deck->li_line);
        if (!deck->li_next)
            fprintf(cp_err, "Warning: no lines in input\n");
    }
    (void) fclose(fp);

    /* Now save the IO context and start a new control set.  After
     * we are done with the source we'll put the old file descriptors 
     * back.  I guess we could use a FILE stack, but since this routine
     * is recursive anyway.
     */
    lastin = cp_curin;
    lastout = cp_curout;
    lasterr = cp_curerr;
    cp_curin = cp_in;
    cp_curout = cp_out;
    cp_curerr = cp_err;

    cp_pushcontrol();

    /* We should now go through the deck and execute front-end 
     * commands and remove them. Front-end commands are enclosed by
     * the cards .control and .endc, unless comfile
     * is true, in which case every line must be a front-end command.
     * There are too many problems with matching the first word on
     * the line.
     */
    ld = deck;
    if (comfile) {
        /* This is easy. */
        for (dd = deck; dd; dd = ld) {
            ld = dd->li_next;
            if ((dd->li_line[0] == '*') && (dd->li_line[1] != '#'))
                continue;
            if (!ciprefix(".control", dd->li_line) &&
                    !ciprefix(".endc", dd->li_line))
                if (dd->li_line[0] == '*')
                    (void) cp_evloop(dd->li_line + 2);
                else
                    (void) cp_evloop(dd->li_line);
            tfree(dd->li_line);
            tfree(dd);
        }   
    } else {
        for (dd = deck->li_next; dd; dd = ld->li_next) {
	    for (s = dd->li_line; (c = *s) && c <= ' '; s++)
		;
            if (c == '*' && (s != deck->li_line || s[1] != '#')) {
                ld = dd;
                continue;
            }
            (void) strncpy(name, dd->li_line, BSIZE_SP);
            for (s = name; *s && isspace(*s); s++)
                ;
            for (t = s; *t && !isspace(*t); t++)
                ;
            *t = '\0';

            if (ciprefix(".control", dd->li_line)) {
                ld->li_next = dd->li_next;
                tfree(dd->li_line);
                tfree(dd);
                if (commands)
                    fprintf(cp_err, 
                    "Warning: redundant .control card\n");
                else
                    commands = true;
            } else if (ciprefix(".endc", dd->li_line)) {
                ld->li_next = dd->li_next;
                tfree(dd->li_line);
                tfree(dd);
                if (commands)
                    commands = false;
                else
                    fprintf(cp_err, 
                    "Warning: misplaced .endc card\n");
            } else if (commands || prefix("*#", dd->li_line)) {
                wl = alloc(struct wordlist);
                if (controls) {
                    wl->wl_next = controls;
                    controls->wl_prev = wl;
                    controls = wl;
                } else
                    controls = wl;
                if (prefix("*#", dd->li_line))
                    wl->wl_word = copy(dd->li_line + 2);
                else
                    wl->wl_word = dd->li_line;
                ld->li_next = dd->li_next;
                tfree(dd);
            } else if (!*dd->li_line) {
                /* So blank lines in com files don't get
                 * considered as circuits.
                 */
                ld->li_next = dd->li_next;
                tfree(dd->li_line);
                tfree(dd);
            } else {
                inp_casefix(s);
                inp_casefix(dd->li_line);
                if (eq(s, ".width") || ciprefix(".four", s) || eq(s, ".plot")
			|| eq(s, ".print") || eq(s, ".save")
                        || eq(s, ".op") || eq(s, ".tf"))
		{
                    if (end) {
                        end->wl_next = alloc(struct wordlist);
                        end->wl_next->wl_prev = end;
                        end = end->wl_next;