2228 lines
71 KiB
C
2228 lines
71 KiB
C
/**********
|
|
Copyright 1990 Regents of the University of California. All rights reserved.
|
|
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group
|
|
Modified: 2000 AlansFixes
|
|
**********/
|
|
|
|
/*------------------------------------------------------------------------------
|
|
* encapsulated string assembly in translate() and finishLine()
|
|
* this string facility (bxx_buffer) mainly abstracts away buffer allocation.
|
|
* this fixes a buffer overflow in finishLine, caused by lengthy descriptions
|
|
* of the kind:
|
|
* B1 1 2 I=v(1)+v(2)+v(3)+...
|
|
* Larice, 22nd Aug 2009
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
/*------------------------------------------------------------------------------
|
|
* Added changes supplied by by H.Tanaka with some tidy up of comments, debug
|
|
* statements, and variables. This fixes a problem with nested .subsck elements
|
|
* that accessed .model lines. Code not ideal, but it seems to work okay.
|
|
* Also took opportunity to tidy a few other items (unused variables etc.), plus
|
|
* fix a few spelling errors in the comments, and a memory leak.
|
|
* SJB 25th March 2005
|
|
*----------------------------------------------------------------------------*/
|
|
|
|
/*------------------------------------------------------------------------------
|
|
* re-written by SDB during 4.2003 to enable SPICE2 POLY statements to be processed
|
|
* properly. This is particularly important for dependent sources, whose argument
|
|
* list changes when POLY is used.
|
|
* Major changes include:
|
|
* -- Added lots of comments which (hopefully) elucidate the steps taken
|
|
* by the program during its processing.
|
|
* -- Re-wrote translate, which does the processing of each card.
|
|
* Please direct comments/questions/complaints to Stuart Brorson:
|
|
* mailto:sdb@cloud9.net
|
|
*-----------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* Expand subcircuits. This is very spice-dependent. Bug fixes by Norbert
|
|
* Jeske on 10/5/85.
|
|
*/
|
|
|
|
/*======================================================================*
|
|
* Expand all subcircuits in the deck. This handles imbedded .subckt
|
|
* definitions. The variables substart, subend, and subinvoke can be used
|
|
* to redefine the controls used. The syntax is invariant though.
|
|
* NOTE: the deck must be passed without the title line.
|
|
* What we do is as follows: first make one pass through the circuit
|
|
* and collect all of the subcircuits. Then, whenever a line that starts
|
|
* with 'x' is found, copy the subcircuit associated with that name and
|
|
* splice it in. A few of the problems: the nodes in the spliced-in
|
|
* stuff must be unique, so when we copy it, append "subcktname:" to
|
|
* each node. If we are in a nested subcircuit, use foo:bar:...:node.
|
|
* Then we have to systematically change all references to the renamed
|
|
* nodes. On top of that, we have to know how many args BJT's have,
|
|
* so we have to keep track of model names.
|
|
*======================================================================*/
|
|
/*#define TRACE*/
|
|
#include "ngspice/ngspice.h"
|
|
#include "ngspice/cpdefs.h"
|
|
#include "ngspice/ftedefs.h"
|
|
#include "ngspice/fteinp.h"
|
|
#include "ngspice/stringskip.h"
|
|
#include "ngspice/compatmode.h"
|
|
|
|
#include <stdarg.h>
|
|
|
|
#ifdef XSPICE
|
|
/* gtri - add - wbk - 11/9/90 - include MIF function prototypes */
|
|
#include "ngspice/mifproto.h"
|
|
/* gtri - end - wbk - 11/9/90 */
|
|
#endif
|
|
|
|
#include "subckt.h"
|
|
#include "variable.h"
|
|
|
|
#include "numparam/numpaif.h"
|
|
|
|
extern void line_free_x(struct card *deck, bool recurse);
|
|
extern int get_number_terminals(char* c);
|
|
|
|
#define line_free(line, flag) \
|
|
do { \
|
|
line_free_x(line, flag); \
|
|
line = NULL; \
|
|
} while(0)
|
|
|
|
|
|
|
|
struct subs;
|
|
static struct card *doit(struct card *deck, wordlist *modnames);
|
|
static int translate(struct card *deck, char *formal, char *actual, char *scname,
|
|
const char *subname, struct subs *subs, wordlist const *modnames);
|
|
struct bxx_buffer;
|
|
static void finishLine(struct bxx_buffer *dst, char *src, char *scname);
|
|
static int settrans(char *formal, char *actual, const char *subname);
|
|
static char *gettrans(const char *name, const char *name_end);
|
|
static int numnodes(const char *line, struct subs *subs, wordlist const *modnames);
|
|
static int numdevs(char *s);
|
|
static wordlist *modtranslate(struct card *deck, char *subname, wordlist *new_modnames);
|
|
static void devmodtranslate(struct card *deck, char *subname, wordlist * const orig_modnames);
|
|
static int inp_numnodes(char c);
|
|
|
|
#define N_GLOBAL_NODES 1005
|
|
|
|
/*---------------------------------------------------------------------
|
|
* table is used in settrans and gettrans -- it holds the netnames used
|
|
* in the .subckt definition (t_old), and in the subcircuit invocation
|
|
* (t_new)
|
|
*--------------------------------------------------------------------*/
|
|
static struct tab {
|
|
char *t_old;
|
|
char *t_new;
|
|
} table[N_GLOBAL_NODES]; /* That had better be enough. */
|
|
|
|
|
|
/*---------------------------------------------------------------------
|
|
* subs is the linked list which holds the .subckt definitions
|
|
* found during processing.
|
|
*--------------------------------------------------------------------*/
|
|
struct subs {
|
|
char *su_name; /* The .subckt name. */
|
|
char *su_args; /* The .subckt arguments, space separated. */
|
|
int su_numargs;
|
|
struct card *su_def; /* Pointer to the .subckt definition. */
|
|
struct subs *su_next;
|
|
};
|
|
|
|
|
|
/* orig_modnames is the list of original model names, modnames is the
|
|
* list of translated names (i.e. after subckt expansion)
|
|
*/
|
|
|
|
/* flag indicating use of the experimental numparams library */
|
|
static bool use_numparams = FALSE;
|
|
|
|
static char start[32], sbend[32], invoke[32], model[32];
|
|
|
|
static char *global_nodes[N_GLOBAL_NODES];
|
|
static int num_global_nodes;
|
|
|
|
|
|
static void
|
|
collect_global_nodes(struct card *c)
|
|
{
|
|
num_global_nodes = 0;
|
|
|
|
global_nodes[num_global_nodes++] = copy("0");
|
|
|
|
#ifdef XSPICE
|
|
global_nodes[num_global_nodes++] = copy("null");
|
|
#endif
|
|
|
|
for (; c; c = c->nextcard)
|
|
if (ciprefix(".global", c->line)) {
|
|
char *s = c->line;
|
|
s = nexttok(s);
|
|
while (*s) {
|
|
if (num_global_nodes == N_GLOBAL_NODES) {
|
|
fprintf(stderr, "ERROR, N_GLOBAL_NODES overflow\n");
|
|
controlled_exit(EXIT_FAILURE);
|
|
}
|
|
char *t = skip_non_ws(s);
|
|
global_nodes[num_global_nodes++] = copy_substring(s, t);
|
|
s = skip_ws(t);
|
|
}
|
|
c->line[0] = '*'; /* comment it out */
|
|
}
|
|
|
|
#ifdef TRACE
|
|
{
|
|
int i;
|
|
printf("***Global node option has been found.***\n");
|
|
for (i = 0; i < num_global_nodes; i++)
|
|
printf("***Global node no.%d is %s.***\n", i, global_nodes[i]);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
free_global_nodes(void)
|
|
{
|
|
int i;
|
|
for (i = 0; i < num_global_nodes; i++)
|
|
tfree(global_nodes[i]);
|
|
num_global_nodes = 0;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------
|
|
inp_subcktexpand is the top level function which translates
|
|
.subckts into mainlined code. Note that there are several things
|
|
we need to do: 1. Find all .subckt definitions & stick them
|
|
into a list. 2. Find all subcircuit invocations (refdes X)
|
|
and replace them with the .subckt definition stored earlier.
|
|
3. Do parameter substitution.
|
|
|
|
The algorithm is as follows:
|
|
1. Define some aliases for .subckt, .ends, etc.
|
|
2. First numparam pass: substitute paramterized tokens by
|
|
intermediate values 1000000001 etc.
|
|
3. Make a list global_nodes[] of global nodes
|
|
4. Clean up parens around netnames
|
|
5. Call doit, which does the actual translation.
|
|
6. Second numparam pass: Do final substitution
|
|
7. Check the results & return.
|
|
inp_subcktexpand takes as argument a pointer to deck, and
|
|
it returns a pointer to the same deck after the new subcircuits
|
|
are spliced in.
|
|
-------------------------------------------------------------------*/
|
|
struct card *
|
|
inp_subcktexpand(struct card *deck) {
|
|
struct card *c;
|
|
wordlist *modnames = NULL;
|
|
|
|
if (!cp_getvar("substart", CP_STRING, start, sizeof(start)))
|
|
strcpy(start, ".subckt");
|
|
if (!cp_getvar("subend", CP_STRING, sbend, sizeof(sbend)))
|
|
strcpy(sbend, ".ends");
|
|
if (!cp_getvar("subinvoke", CP_STRING, invoke, sizeof(invoke)))
|
|
strcpy(invoke, "x");
|
|
if (!cp_getvar("modelcard", CP_STRING, model, sizeof(model)))
|
|
strcpy(model, ".model");
|
|
if (!cp_getvar("modelline", CP_STRING, model, sizeof(model)))
|
|
strcpy(model, ".model");
|
|
|
|
/* use_numparams = cp_getvar("numparams", CP_BOOL, NULL, 0); */
|
|
|
|
use_numparams = TRUE;
|
|
|
|
/* deck has .control sections already removed, but not comments */
|
|
if (use_numparams) {
|
|
|
|
#ifdef TRACE
|
|
fprintf(stderr, "Numparams is processing this deck:\n");
|
|
for (c = deck; c; c = c->nextcard)
|
|
fprintf(stderr, "%3d:%s\n", c->linenum, c->line);
|
|
#endif
|
|
|
|
nupa_signal(NUPADECKCOPY);
|
|
/* get the subckt names from the deck */
|
|
for (c = deck; c; c = c->nextcard) { /* first Numparam pass */
|
|
if (ciprefix(".subckt", c->line)) {
|
|
nupa_scan(c);
|
|
}
|
|
}
|
|
|
|
/* now copy instances */
|
|
for (c = deck; c; c = c->nextcard) { /* first Numparam pass */
|
|
if (*(c->line) == '*') {
|
|
continue;
|
|
}
|
|
c->line = nupa_copy(c);
|
|
}
|
|
|
|
#ifdef TRACE
|
|
fprintf(stderr, "Numparams transformed deck:\n");
|
|
for (c = deck; c; c = c->nextcard)
|
|
fprintf(stderr, "%3d:%s\n", c->linenum, c->line);
|
|
#endif
|
|
|
|
}
|
|
|
|
/* Get all the model names so we can deal with BJTs, etc.
|
|
* Stick all the model names into the doubly-linked wordlist modnames.
|
|
*/
|
|
{
|
|
int nest = 0;
|
|
for (c = deck; c; c = c->nextcard) {
|
|
|
|
if (ciprefix(".subckt", c->line))
|
|
nest++;
|
|
else if (ciprefix(".ends", c->line))
|
|
nest--;
|
|
else if (nest > 0)
|
|
continue;
|
|
|
|
if (ciprefix(model, c->line)) {
|
|
char *s = nexttok(c->line);
|
|
modnames = wl_cons(gettok(&s), modnames);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef TRACE
|
|
{
|
|
wordlist *w;
|
|
printf("Models found:\n");
|
|
for (w = modnames; w; w = w->wl_next)
|
|
printf("%s\n", w->wl_word);
|
|
}
|
|
#endif
|
|
|
|
/* Added by H.Tanaka to find global nodes */
|
|
collect_global_nodes(deck);
|
|
|
|
/* Let's do a few cleanup things... Get rid of ( ) around node lists... */
|
|
for (c = deck; c; c = c->nextcard) { /* iterate on lines in deck */
|
|
|
|
char *s = c->line;
|
|
|
|
if (*s == '*') /* skip comment */
|
|
continue;
|
|
|
|
if (ciprefix(start, s)) { /* if we find .subckt . . . */
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
printf("In inp_subcktexpand, found a .subckt: %s\n", s);
|
|
#endif
|
|
while (*s && *s != '(') /* search opening paren */
|
|
s++;
|
|
|
|
if (*s == '(') {
|
|
int level = 0;
|
|
do {
|
|
/* strip outer parens '(' ')', just the first pair */
|
|
if (*s == '(' && level++ == 0) {
|
|
*s = ' ';
|
|
}
|
|
if (*s == ')' && --level == 0) {
|
|
*s = ' ';
|
|
break;
|
|
}
|
|
} while(*s++);
|
|
}
|
|
} else if (*s == '.') {
|
|
continue; /* skip .commands */
|
|
} else { /* any other line . . . */
|
|
s = skip_non_ws(s);
|
|
s = skip_ws(s);
|
|
|
|
if (*s == '(') {
|
|
int level = 0;
|
|
do {
|
|
/* strip outer parens '(' ')', just the first pair, why ? */
|
|
if (*s == '(' && level++ == 0) {
|
|
*s = ' ';
|
|
}
|
|
if (*s == ')' && --level == 0) {
|
|
*s = ' ';
|
|
break;
|
|
}
|
|
} while(*s++);
|
|
} /* if (*s == '(' . . . */
|
|
} /* any other line */
|
|
} /* for (c = deck . . . */
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
printf("In inp_subcktexpand, about to call doit.\n");
|
|
#endif
|
|
|
|
/* doit does the actual splicing in of the .subckt . . . */
|
|
deck = doit(deck, modnames);
|
|
|
|
free_global_nodes();
|
|
wl_free(modnames);
|
|
|
|
/* Count numbers of line in deck after expansion */
|
|
if (deck) {
|
|
dynMaxckt = 0; /* number of lines in deck after expansion */
|
|
for (c = deck; c; c = c->nextcard)
|
|
dynMaxckt++;
|
|
}
|
|
|
|
/* Now check to see if there are still subckt instances undefined... */
|
|
for (c = deck; c; c = c->nextcard)
|
|
if (ciprefix(invoke, c->line)) {
|
|
fprintf(cp_err, "Error: unknown subckt: %s\n", c->line);
|
|
if (use_numparams)
|
|
nupa_signal(NUPAEVALDONE);
|
|
return NULL;
|
|
}
|
|
|
|
if (use_numparams) {
|
|
/* the NUMPARAM final line translation pass */
|
|
nupa_signal(NUPASUBDONE);
|
|
for (c = deck; c; c = c->nextcard)
|
|
/* 'param' .meas statements can have dependencies on measurement values */
|
|
/* need to skip evaluating here and evaluate after other .meas statements */
|
|
if (ciprefix(".meas", c->line) && strstr(c->line, "param")) {
|
|
;
|
|
} else {
|
|
nupa_eval(c);
|
|
}
|
|
|
|
#ifdef TRACE
|
|
fprintf(stderr, "Numparams converted deck:\n");
|
|
for (c = deck; c; c = c->nextcard)
|
|
fprintf(stderr, "%3d:%s\n", c->linenum, c->line);
|
|
#endif
|
|
|
|
/*nupa_list_params(stdout);*/
|
|
nupa_copy_inst_dico();
|
|
nupa_signal(NUPAEVALDONE);
|
|
}
|
|
|
|
return (deck); /* return the spliced deck. */
|
|
}
|
|
|
|
|
|
static struct card *
|
|
find_ends(struct card *l)
|
|
{
|
|
int nest = 1;
|
|
|
|
while (l->nextcard) {
|
|
|
|
if (ciprefix(sbend, l->nextcard->line)) /* found a .ends */
|
|
nest--;
|
|
else if (ciprefix(start, l->nextcard->line)) /* found a .subckt */
|
|
nest++;
|
|
|
|
if (!nest)
|
|
break;
|
|
|
|
l = l->nextcard;
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
|
|
#define MAXNEST 21
|
|
/*-------------------------------------------------------------------*/
|
|
/* doit does the actual substitution of .subckts. */
|
|
/* It takes two passes: the first extracts .subckts */
|
|
/* and sticks pointer to them into the linked list sss. It does */
|
|
/* the extraction recursively. Then, it look for subcircuit */
|
|
/* invocations and substitutes the stored .subckt into */
|
|
/* the main circuit file. */
|
|
/* It takes as argument a pointer to the deck, and returns a */
|
|
/* pointer to the deck after the subcircuit has been spliced in. */
|
|
/*-------------------------------------------------------------------*/
|
|
static struct card *
|
|
doit(struct card *deck, wordlist *modnames) {
|
|
struct subs *sss = NULL; /* *sss temporarily hold decks to substitute */
|
|
int numpasses = MAXNEST;
|
|
bool gotone;
|
|
int error;
|
|
|
|
/* Save all the old stuff... */
|
|
struct subs *subs = NULL;
|
|
wordlist *xmodnames = modnames;
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
{
|
|
struct card *c;
|
|
printf("In doit, about to start first pass through deck.\n");
|
|
for (c = deck; c; c = c->nextcard)
|
|
printf(" %s\n", c->line);
|
|
}
|
|
#endif
|
|
|
|
{
|
|
/* First pass: xtract all the .subckts and stick pointers to them into sss. */
|
|
|
|
struct card *c = deck;
|
|
struct card *prev_of_c = NULL;
|
|
|
|
while (c) {
|
|
if (ciprefix(sbend, c->line)) { /* if line == .ends */
|
|
fprintf(cp_err, "Error: misplaced %s line: %s\n", sbend,
|
|
c->line);
|
|
return (NULL);
|
|
}
|
|
|
|
if (ciprefix(start, c->line)) { /* if line == .subckt */
|
|
|
|
struct card *prev_of_ends = find_ends(c);
|
|
struct card *ends = prev_of_ends->nextcard;
|
|
|
|
if (!ends) {
|
|
fprintf(cp_err, "Error: no %s line.\n", sbend);
|
|
return (NULL);
|
|
}
|
|
|
|
/* c points to the opening .subckt card */
|
|
/* ends points to the terminating .ends card */
|
|
|
|
|
|
/* Now put the .subckt definition found into sss */
|
|
|
|
{
|
|
char *s = c->line;
|
|
|
|
sss = TMALLOC(struct subs, 1);
|
|
|
|
s = nexttok(s);
|
|
|
|
sss->su_name = gettok(&s);
|
|
sss->su_args = copy(s);
|
|
sss->su_def = c->nextcard;
|
|
|
|
/* count the number of args in the .subckt line */
|
|
sss->su_numargs = 0;
|
|
for (;;) {
|
|
s = skip_ws(s);
|
|
if (*s == '\0')
|
|
break;
|
|
s = skip_non_ws(s);
|
|
sss->su_numargs ++;
|
|
}
|
|
}
|
|
|
|
/* push `sss' onto the `subs' list */
|
|
sss->su_next = subs;
|
|
subs = sss;
|
|
|
|
/* cut the whole .subckt ... .ends sequence from the deck chain */
|
|
|
|
line_free_x(c, FALSE); /* drop the .subckt card */
|
|
c = ends->nextcard;
|
|
|
|
if (prev_of_c)
|
|
prev_of_c->nextcard = c;
|
|
else
|
|
deck = c;
|
|
|
|
if (use_numparams == FALSE) {
|
|
line_free_x(ends, FALSE); /* drop the .ends card */
|
|
prev_of_ends->nextcard = NULL;
|
|
} else {
|
|
ends->line[0] = '*'; /* comment the .ends card */
|
|
ends->nextcard = NULL;
|
|
}
|
|
|
|
} else {
|
|
|
|
prev_of_c = c;
|
|
c = c->nextcard;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* At this point, sss holds the .subckt definition found, subs holds
|
|
* all .subckt defs found, including this one
|
|
*/
|
|
|
|
if (!subs) /* we have found no subckts. Just return. */
|
|
return (deck);
|
|
|
|
/* Otherwise, expand sub-subcircuits recursively. */
|
|
for (sss = subs; sss; sss = sss->su_next) /* iterate through the list of subcircuits */
|
|
if ((sss->su_def = doit(sss->su_def, modnames)) == NULL)
|
|
return (NULL);
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
{
|
|
struct card *c;
|
|
printf("In doit, about to start second pass through deck.\n");
|
|
for (c = deck; c; c = c->nextcard)
|
|
printf(" %s\n", c->line);
|
|
}
|
|
#endif
|
|
|
|
double scale;
|
|
if (!cp_getvar("scale", CP_REAL, &scale, 0))
|
|
scale = 1;
|
|
|
|
error = 0;
|
|
/* Second pass: do the replacements. */
|
|
do { /* while (!error && numpasses-- && gotone) */
|
|
struct card *c = deck;
|
|
struct card *prev_of_c = NULL;
|
|
gotone = FALSE;
|
|
for (; c; prev_of_c = c, c = c->nextcard) {
|
|
if (ciprefix(invoke, c->line)) { /* found reference to .subckt (i.e. component with refdes X) */
|
|
|
|
char *tofree, *tofree2, *s, *t;
|
|
char *scname;
|
|
|
|
gotone = TRUE;
|
|
t = tofree = s = copy(c->line); /* s & t hold copy of component line */
|
|
|
|
/* make scname point to first non-whitepace chars after refdes invocation
|
|
* e.g. if invocation is Xreference, *scname = reference
|
|
*/
|
|
tofree2 = scname = gettok(&s);
|
|
/*scname += strlen(invoke); */
|
|
while ((*scname == ' ') || (*scname == '\t') || (*scname == ':'))
|
|
scname++;
|
|
|
|
/* Now set s to point to last non-space chars in line (i.e.
|
|
* the name of the model invoked
|
|
*/
|
|
while (*s)
|
|
s++;
|
|
s--;
|
|
while ((*s == ' ') || (*s == '\t'))
|
|
*s-- = '\0';
|
|
while ((*s != ' ') && (*s != '\t'))
|
|
s--;
|
|
s++;
|
|
|
|
/* iterate through .subckt list and look for .subckt name invoked */
|
|
for (sss = subs; sss; sss = sss->su_next)
|
|
if (eq(sss->su_name, s))
|
|
break;
|
|
|
|
|
|
/* At this point, sss points to the .subckt invoked,
|
|
* and scname points to the netnames
|
|
* involved.
|
|
*/
|
|
|
|
|
|
/* If no .subckt is found, don't complain -- this might be an
|
|
* instance of a subckt that is defined above at higher level.
|
|
*/
|
|
if (sss) {
|
|
// tprint(sss->su_def);
|
|
struct card *su_deck = inp_deckcopy(sss->su_def);
|
|
/* If we have modern PDKs, we have to reduce the amount of memory required.
|
|
We try to reduce the models to the one really used.
|
|
Otherwise su_deck is full of unused binning models.*/
|
|
if ((newcompat.hs || newcompat.spe) && c->w > 0 && c->l > 0) {
|
|
/* extract wmin, wmax, lmin, lmax */
|
|
struct card* new_deck = su_deck;
|
|
struct card* prev = NULL;
|
|
while (su_deck) {
|
|
if (!ciprefix(".model", su_deck->line)) {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
|
|
char* curr_line = su_deck->line;
|
|
float fwmin, fwmax, flmin, flmax;
|
|
char *wmin = strstr(curr_line, " wmin=");
|
|
if (wmin) {
|
|
int err;
|
|
wmin = wmin + 6;
|
|
fwmin = (float)INPevaluate(&wmin, &err, 0);
|
|
if (err) {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
char *wmax = strstr(curr_line, " wmax=");
|
|
if (wmax) {
|
|
int err;
|
|
wmax = wmax + 6;
|
|
fwmax = (float)INPevaluate(&wmax, &err, 0);
|
|
if (err) {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
|
|
char* lmin = strstr(curr_line, " lmin=");
|
|
if (lmin) {
|
|
int err;
|
|
lmin = lmin + 6;
|
|
flmin = (float)INPevaluate(&lmin, &err, 0);
|
|
if (err) {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
char* lmax = strstr(curr_line, " lmax=");
|
|
if (lmax) {
|
|
int err;
|
|
lmax = lmax + 6;
|
|
flmax = (float)INPevaluate(&lmax, &err, 0);
|
|
if (err) {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
|
|
float csl = (float)scale * c->l;
|
|
/* scale by nf */
|
|
float csw = (float)scale * c->w / c->nf;
|
|
/*fprintf(stdout, "Debug: nf = %f\n", c->nf);*/
|
|
if (csl >= flmin && csl < flmax && csw >= fwmin && csw < fwmax) {
|
|
/* use the current .model card */
|
|
prev = su_deck;
|
|
su_deck = su_deck->nextcard;
|
|
continue;
|
|
}
|
|
else {
|
|
struct card* tmpcard = su_deck->nextcard;
|
|
line_free_x(prev->nextcard, FALSE);
|
|
su_deck = prev->nextcard = tmpcard;
|
|
}
|
|
}
|
|
su_deck = new_deck;
|
|
}
|
|
|
|
if (!su_deck) {
|
|
fprintf(stderr, "\nError: Could not find a model for device %s in subcircuit %s\n",
|
|
scname, sss->su_name);
|
|
controlled_exit(1);
|
|
}
|
|
|
|
struct card *rest_of_c = c->nextcard;
|
|
|
|
/* Now we have to replace this line with the
|
|
* macro definition.
|
|
*/
|
|
|
|
/* Change the names of .models found in .subckts . . . */
|
|
/* prepend the translated model names to the list `modnames' */
|
|
modnames = modtranslate(su_deck, scname, modnames);
|
|
|
|
t = nexttok(t); /* Throw out the subcircuit refdes */
|
|
|
|
/* now invoke translate, which handles the remainder of the
|
|
* translation.
|
|
*/
|
|
if (!translate(su_deck, sss->su_args, t, scname, sss->su_name, subs, modnames))
|
|
error = 1;
|
|
|
|
/* Now splice the decks together. */
|
|
|
|
if (use_numparams == FALSE) {
|
|
line_free_x(c, FALSE); /* drop the invocation */
|
|
if (prev_of_c)
|
|
prev_of_c->nextcard = su_deck;
|
|
else
|
|
deck = su_deck;
|
|
} else {
|
|
c->line[0] = '*'; /* comment the invocation */
|
|
c->nextcard = su_deck;
|
|
}
|
|
|
|
c = su_deck;
|
|
while (c->nextcard)
|
|
c = c->nextcard;
|
|
|
|
c->nextcard = rest_of_c;
|
|
}
|
|
|
|
tfree(tofree);
|
|
tfree(tofree2);
|
|
}
|
|
}
|
|
} while (!error && numpasses-- && gotone);
|
|
|
|
|
|
if (!numpasses) {
|
|
fprintf(cp_err, "Error: infinite subckt recursion\n");
|
|
error = 1;
|
|
}
|
|
|
|
#ifdef TRACE
|
|
/* Added by H.Tanaka to display converted deck */
|
|
{
|
|
struct card *c = deck;
|
|
printf("Converted deck\n");
|
|
for (; c; c = c->nextcard)
|
|
printf("%s\n", c->line);
|
|
}
|
|
{
|
|
wordlist *w = modnames;
|
|
printf("Models:\n");
|
|
for (; w; w = w->wl_next)
|
|
printf("%s\n", w->wl_word);
|
|
}
|
|
#endif
|
|
|
|
wl_delete_slice(modnames, xmodnames);
|
|
|
|
if (error)
|
|
return NULL; /* error message already reported; should free() */
|
|
|
|
|
|
while (subs) {
|
|
struct subs *rest = subs->su_next;
|
|
|
|
tfree(subs->su_name);
|
|
tfree(subs->su_args);
|
|
line_free(subs->su_def, TRUE);
|
|
tfree(subs);
|
|
|
|
subs = rest;
|
|
}
|
|
|
|
return (deck);
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/* Copy a deck, including the actual lines. */
|
|
/*-------------------------------------------------------------------*/
|
|
struct card * inp_deckcopy(struct card *deck) {
|
|
struct card *d = NULL, *nd = NULL;
|
|
|
|
while (deck) {
|
|
if (nd) {
|
|
d->nextcard = TMALLOC(struct card, 1);
|
|
d = d->nextcard;
|
|
} else {
|
|
nd = d = TMALLOC(struct card, 1);
|
|
}
|
|
d->linenum = deck->linenum;
|
|
d->w = deck->w;
|
|
d->l = deck->l;
|
|
d->nf = deck->nf;
|
|
d->line = copy(deck->line);
|
|
if (deck->error)
|
|
d->error = copy(deck->error);
|
|
d->actualLine = inp_deckcopy(deck->actualLine);
|
|
deck = deck->nextcard;
|
|
}
|
|
return (nd);
|
|
}
|
|
|
|
/*
|
|
* Copy a deck, without the ->actualLine lines, without comment lines, and
|
|
* without .control section(s).
|
|
* First line is always copied (except being .control).
|
|
*/
|
|
struct card *inp_deckcopy_oc(struct card * deck)
|
|
{
|
|
struct card *d = NULL, *nd = NULL;
|
|
int skip_control = 0, i = 0;
|
|
|
|
while (deck) {
|
|
/* exclude any command inside .control ... .endc */
|
|
if (ciprefix(".control", deck->line)) {
|
|
skip_control++;
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
else if (ciprefix(".endc", deck->line)) {
|
|
skip_control--;
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
else if (skip_control > 0) {
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
if (nd) { /* First card already found */
|
|
/* d is the card at the end of the deck */
|
|
d = d->nextcard = TMALLOC(struct card, 1);
|
|
}
|
|
else { /* This is the first card */
|
|
nd = d = TMALLOC(struct card, 1);
|
|
}
|
|
d->w = deck->w;
|
|
d->l = deck->l;
|
|
d->nf = deck->nf;
|
|
d->linenum_orig = deck->linenum;
|
|
d->linenum = i++;
|
|
d->line = copy(deck->line);
|
|
if (deck->error) {
|
|
d->error = copy(deck->error);
|
|
}
|
|
d->actualLine = NULL;
|
|
deck = deck->nextcard;
|
|
while (deck && *(deck->line) == '*') { /* skip comments */
|
|
deck = deck->nextcard;
|
|
}
|
|
} /* end of loop over cards in the source deck */
|
|
|
|
return nd;
|
|
} /* end of function inp_deckcopy_oc */
|
|
|
|
/*
|
|
* Copy a deck, without the ->actualLine lines, without comment lines, and
|
|
* without .control section(s).
|
|
* Keep the line numbers.
|
|
*/
|
|
struct card* inp_deckcopy_ln(struct card* deck)
|
|
{
|
|
struct card* d = NULL, * nd = NULL;
|
|
int skip_control = 0;
|
|
|
|
while (deck) {
|
|
/* exclude any command inside .control ... .endc */
|
|
if (ciprefix(".control", deck->line)) {
|
|
skip_control++;
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
else if (ciprefix(".endc", deck->line)) {
|
|
skip_control--;
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
else if (skip_control > 0) {
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
else if (*(deck->line) == '*') {
|
|
deck = deck->nextcard;
|
|
continue;
|
|
}
|
|
|
|
if (nd) { /* First card already found */
|
|
/* d is the card at the end of the deck */
|
|
d = d->nextcard = TMALLOC(struct card, 1);
|
|
}
|
|
else { /* This is the first card */
|
|
nd = d = TMALLOC(struct card, 1);
|
|
}
|
|
d->w = deck->w;
|
|
d->l = deck->l;
|
|
d->nf = deck->nf;
|
|
d->linenum_orig = deck->linenum_orig;
|
|
d->linenum = deck->linenum;
|
|
d->line = copy(deck->line);
|
|
if (deck->error) {
|
|
d->error = copy(deck->error);
|
|
}
|
|
d->actualLine = NULL;
|
|
deck = deck->nextcard;
|
|
} /* end of loop over cards in the source deck */
|
|
|
|
return nd;
|
|
} /* end of function inp_deckcopy_ln */
|
|
|
|
|
|
/*-------------------------------------------------------------------
|
|
* struct bxx_buffer,
|
|
* a string assembly facility.
|
|
*
|
|
* usage:
|
|
*
|
|
* struct bxx_buffer thing;
|
|
* bxx_init(&thing);
|
|
* ...
|
|
* while (...) {
|
|
* bxx_rewind(&thing);
|
|
* ...
|
|
* bxx_putc(&thing, ...)
|
|
* bxx_printf(&thing, ...)
|
|
* bxx_put_cstring(&thing, ...)
|
|
* bxx_put_substring(&thing, ...)
|
|
* ...
|
|
* strcpy(bxx_buffer(&thing)
|
|
* }
|
|
* ..
|
|
* bxx_free(&thing)
|
|
*
|
|
* main aspect:
|
|
* reallocates/extends its buffer itself.
|
|
*
|
|
* note:
|
|
* during asssembly the internal buffer is
|
|
* not necessarily '\0' terminated.
|
|
* but will be when bxx_buffer() is invoked
|
|
*/
|
|
|
|
struct bxx_buffer {
|
|
char *dst;
|
|
char *limit;
|
|
char *buffer;
|
|
};
|
|
|
|
/* must be a power of 2 */
|
|
static const int bxx_chunksize = 1024;
|
|
|
|
static void
|
|
bxx_init(struct bxx_buffer *t)
|
|
{
|
|
/* assert(0 == (bxx_chunksize & (bxx_chunksize - 1))); */
|
|
|
|
t->buffer = TMALLOC(char, bxx_chunksize);
|
|
|
|
t->dst = t->buffer;
|
|
t->limit = t->buffer + bxx_chunksize;
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_free(struct bxx_buffer *t)
|
|
{
|
|
tfree(t->buffer);
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_rewind(struct bxx_buffer *t)
|
|
{
|
|
t->dst = t->buffer;
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_extend(struct bxx_buffer *t, int howmuch)
|
|
{
|
|
int pos = (int)(t->dst - t->buffer);
|
|
int len = (int)(t->limit - t->buffer);
|
|
|
|
/* round up */
|
|
howmuch += (bxx_chunksize - 1);
|
|
howmuch &= ~(bxx_chunksize - 1);
|
|
|
|
len += howmuch;
|
|
|
|
t->buffer = TREALLOC(char, t->buffer, len);
|
|
|
|
t->dst = t->buffer + pos;
|
|
t->limit = t->buffer + len;
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_printf(struct bxx_buffer *t, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
for (;;) {
|
|
int ret;
|
|
int size = (int)(t->limit - t->dst);
|
|
va_start(ap, fmt);
|
|
ret = vsnprintf(t->dst, (size_t) size, fmt, ap);
|
|
va_end(ap);
|
|
if (ret == -1) {
|
|
bxx_extend(t, bxx_chunksize);
|
|
} else if (ret >= size) {
|
|
bxx_extend(t, ret - size + 1);
|
|
} else {
|
|
t->dst += ret;
|
|
break;
|
|
}
|
|
}
|
|
|
|
va_end(ap);
|
|
}
|
|
|
|
|
|
static inline char
|
|
bxx_putc(struct bxx_buffer *t, char c)
|
|
{
|
|
if (t->dst >= t->limit)
|
|
bxx_extend(t, 1);
|
|
return *(t->dst)++ = c;
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_put_cstring(struct bxx_buffer *t, const char *cstring)
|
|
{
|
|
while (*cstring)
|
|
bxx_putc(t, *cstring++);
|
|
}
|
|
|
|
|
|
static void
|
|
bxx_put_substring(struct bxx_buffer *t, const char *str, const char *end)
|
|
{
|
|
while (str < end)
|
|
bxx_putc(t, *str++);
|
|
}
|
|
|
|
|
|
static char *
|
|
bxx_buffer(struct bxx_buffer *t)
|
|
{
|
|
if ((t->dst == t->buffer) || (t->dst[-1] != '\0'))
|
|
bxx_putc(t, '\0');
|
|
return t->buffer;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------------------------------*
|
|
* Translate all of the device names and node names in the .subckt deck. They are
|
|
* pre-pended with subname:, unless they are in the formal list, in which case
|
|
* they are replaced with the corresponding entry in the actual list.
|
|
* The one special case is node 0 -- this is always ground and we don't
|
|
* touch it.
|
|
*
|
|
* Variable name meanings:
|
|
* *deck = pointer to subcircuit definition (lcc) (struct card)
|
|
* formal = copy of the .subckt definition line (e.g. ".subckt subcircuitname 1 2 3") (string)
|
|
* actual = copy of the .subcircuit invocation line (e.g. "Xexample 4 5 6 subcircuitname") (string)
|
|
* scname = refdes (- first letter) used at invocation (e.g. "example") (string)
|
|
* subname = copy of the subcircuit name
|
|
*-------------------------------------------------------------------------------------------*/
|
|
|
|
static void
|
|
translate_node_name(struct bxx_buffer *buffer, const char *scname, const char *name, const char *name_e)
|
|
{
|
|
|
|
const char *t;
|
|
if (!name_e)
|
|
name_e = strchr(name, '\0');
|
|
|
|
t = gettrans(name, name_e);
|
|
if (t) {
|
|
bxx_put_cstring(buffer, t);
|
|
} else {
|
|
bxx_put_cstring(buffer, scname);
|
|
bxx_putc(buffer, '.');
|
|
bxx_put_substring(buffer, name, name_e);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
translate_inst_name(struct bxx_buffer *buffer, const char *scname, const char *name, const char *name_e)
|
|
{
|
|
if (!name_e)
|
|
name_e = strchr(name, '\0');
|
|
|
|
if (tolower_c(*name) != 'x') {
|
|
bxx_putc(buffer, *name);
|
|
bxx_putc(buffer, '.');
|
|
}
|
|
bxx_put_cstring(buffer, scname);
|
|
bxx_putc(buffer, '.');
|
|
bxx_put_substring(buffer, name, name_e);
|
|
}
|
|
|
|
|
|
static int
|
|
translate(struct card *deck, char *formal, char *actual, char *scname, const char *subname, struct subs *subs, wordlist const *modnames)
|
|
{
|
|
struct card *c;
|
|
struct bxx_buffer buffer;
|
|
char *next_name, *name, *t, *nametofree, *paren_ptr;
|
|
int nnodes, i, dim;
|
|
int rtn = 0;
|
|
|
|
bxx_init(&buffer);
|
|
|
|
/* settrans builds the table holding the translated netnames. */
|
|
i = settrans(formal, actual, subname);
|
|
if (i < 0) {
|
|
fprintf(stderr,
|
|
"Too few parameters for subcircuit type \"%s\" (instance: x%s)\n",
|
|
subname, scname);
|
|
goto quit;
|
|
} else if (i > 0) {
|
|
fprintf(stderr,
|
|
"Too many parameters for subcircuit type \"%s\" (instance: x%s)\n",
|
|
subname, scname);
|
|
goto quit;
|
|
}
|
|
|
|
for (c = deck; c; c = c->nextcard) {
|
|
bool got_vnam = FALSE;
|
|
char *s = c->line;
|
|
char dev_type = tolower_c(s[0]);
|
|
|
|
bxx_rewind(&buffer);
|
|
|
|
#ifdef TRACE
|
|
printf("\nIn translate, examining line (dev_type: %c, subname: %s, instance: %s) %s \n", dev_type, subname, scname, s);
|
|
#endif
|
|
|
|
switch (dev_type) {
|
|
|
|
case '.':
|
|
if (ciprefix(".ic", s) || ciprefix(".nodeset", s)) {
|
|
while ((paren_ptr = strchr(s, '(')) != NULL) {
|
|
name = paren_ptr + 1;
|
|
|
|
if ((paren_ptr = strchr(name, ')')) == NULL) {
|
|
fprintf(cp_err, "Error: missing closing ')' for .ic|.nodeset statement %s\n", c->line);
|
|
goto quit;
|
|
}
|
|
|
|
bxx_put_substring(&buffer, s, name);
|
|
translate_node_name(&buffer, scname, name, paren_ptr);
|
|
|
|
s = paren_ptr;
|
|
}
|
|
bxx_put_cstring(&buffer, s); /* rest of line */
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
case '\0':
|
|
case '*':
|
|
case '$':
|
|
continue;
|
|
|
|
#ifdef XSPICE
|
|
/*=================== case A ====================*/
|
|
/* gtri - add - wbk - 10/23/90 - process A devices specially */
|
|
/* since they have a more involved and variable length node syntax */
|
|
|
|
case 'a':
|
|
|
|
/* translate the instance name according to normal rules */
|
|
name = MIFgettok(&s);
|
|
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
/* Now translate the nodes, looking ahead one token to recognize */
|
|
/* when we reach the model name which should not be translated */
|
|
/* here. */
|
|
|
|
next_name = MIFgettok(&s);
|
|
|
|
for (;;) {
|
|
/* rotate the tokens and get the the next one */
|
|
if (name)
|
|
tfree(name);
|
|
name = next_name;
|
|
next_name = MIFgettok(&s);
|
|
|
|
/* if next token is NULL, name holds the model name, so exit */
|
|
if (next_name == NULL)
|
|
break;
|
|
|
|
/* Process the token in name. If it is special, then don't */
|
|
/* translate it. */
|
|
switch (*name) {
|
|
case '[':
|
|
case ']':
|
|
case '~':
|
|
bxx_put_cstring(&buffer, name);
|
|
break;
|
|
|
|
case '%':
|
|
bxx_putc(&buffer, '%');
|
|
/* don't translate the port type identifier */
|
|
if (name)
|
|
tfree(name);
|
|
name = next_name;
|
|
/* vname requires instance translation of token following */
|
|
if (eq(name, "vnam"))
|
|
got_vnam = TRUE;
|
|
next_name = MIFgettok(&s);
|
|
bxx_put_cstring(&buffer, name);
|
|
break;
|
|
|
|
default:
|
|
if (got_vnam) {
|
|
/* after %vnam an instance name is following */
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
got_vnam = FALSE;
|
|
}
|
|
else {
|
|
/* must be a node name at this point, so translate it */
|
|
translate_node_name(&buffer, scname, name, NULL);
|
|
}
|
|
break;
|
|
|
|
}
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
/* copy in the last token, which is the model name */
|
|
if (name) {
|
|
bxx_put_cstring(&buffer, name);
|
|
tfree(name);
|
|
}
|
|
|
|
break; /* case 'a' */
|
|
|
|
/* gtri - end - wbk - 10/23/90 */
|
|
#endif
|
|
|
|
/*================ case E, F, G, H ================*/
|
|
/* This section handles controlled sources and allows for SPICE2 POLY attributes.
|
|
* This is a new section, added by SDB to handle POLYs in sources. Significant
|
|
* changes were made in here.
|
|
* 4.21.2003 -- SDB. mailto:sdb@cloud9.net
|
|
*/
|
|
case 'e':
|
|
case 'f':
|
|
case 'g':
|
|
case 'h':
|
|
|
|
name = gettok(&s); /* name points to the refdes */
|
|
if (!name)
|
|
continue;
|
|
if (!*name) {
|
|
tfree(name);
|
|
continue;
|
|
}
|
|
|
|
/* Here's where we translate the refdes to e.g. F:subcircuitname:57
|
|
* and stick the translated name into buffer.
|
|
*/
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
/* Next iterate over all nodes (netnames) found and translate them. */
|
|
nnodes = numnodes(c->line, subs, modnames);
|
|
|
|
while (--nnodes >= 0) {
|
|
name = gettok_node(&s);
|
|
if (name == NULL) {
|
|
fprintf(cp_err, "Error: too few nodes: %s\n",
|
|
c->line);
|
|
goto quit;
|
|
}
|
|
|
|
translate_node_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
/* Next we handle the POLY (if any) */
|
|
/* get next token */
|
|
t = s;
|
|
next_name = gettok_noparens(&t);
|
|
if ((strcmp(next_name, "POLY") == 0) ||
|
|
(strcmp(next_name, "poly") == 0)) {
|
|
|
|
#ifdef TRACE
|
|
printf("In translate, looking at e, f, g, h found poly\n");
|
|
#endif
|
|
|
|
/* move pointer ahead of '(' */
|
|
if (get_l_paren(&s) == 1) {
|
|
fprintf(cp_err, "Error: no left paren after POLY %s\n",
|
|
c->line);
|
|
tfree(next_name);
|
|
goto quit;
|
|
}
|
|
|
|
nametofree = gettok_noparens(&s);
|
|
dim = atoi(nametofree); /* convert returned string to int */
|
|
tfree(nametofree);
|
|
|
|
/* move pointer ahead of ')' */
|
|
if (get_r_paren(&s) == 1) {
|
|
fprintf(cp_err, "Error: no right paren after POLY %s\n",
|
|
c->line);
|
|
tfree(next_name);
|
|
goto quit;
|
|
}
|
|
|
|
/* Write POLY(dim) into buffer */
|
|
bxx_printf(&buffer, "POLY( %d ) ", dim);
|
|
}
|
|
else
|
|
dim = 1; /* only one controlling source . . . */
|
|
tfree(next_name);
|
|
|
|
/* Now translate the controlling source/nodes */
|
|
nnodes = dim * numdevs(c->line);
|
|
while (--nnodes >= 0) {
|
|
name = gettok_node(&s); /* name points to the returned token */
|
|
if (name == NULL) {
|
|
fprintf(cp_err, "Error: too few devs: %s\n", c->line);
|
|
goto quit;
|
|
}
|
|
|
|
if ((dev_type == 'f') || (dev_type == 'h'))
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
else
|
|
translate_node_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
/* Now write out remainder of line (polynomial coeffs) */
|
|
finishLine(&buffer, s, scname);
|
|
break;
|
|
|
|
default: /* this section handles ordinary components */
|
|
name = gettok_node(&s); /* changed to gettok_node to handle netlists with ( , ) */
|
|
if (!name)
|
|
continue;
|
|
if (!*name) {
|
|
tfree(name);
|
|
continue;
|
|
}
|
|
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
/* FIXME anothet hack: if no models found for m devices, set number of nodes to 4 */
|
|
if (!modnames && *(c->line) == 'm')
|
|
nnodes = get_number_terminals(c->line);
|
|
else
|
|
nnodes = numnodes(c->line, subs, modnames);
|
|
while (--nnodes >= 0) {
|
|
name = gettok_node(&s);
|
|
if (name == NULL) {
|
|
fprintf(cp_err, "Error: too few nodes: %s\n", c->line);
|
|
goto quit;
|
|
}
|
|
|
|
translate_node_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
/* Now translate any devices (i.e. controlling sources).
|
|
* This may be superfluous because we handle dependent
|
|
* source devices above . . . .
|
|
*/
|
|
nnodes = numdevs(c->line);
|
|
while (--nnodes >= 0) {
|
|
name = gettok_node(&s);
|
|
if (name == NULL) {
|
|
fprintf(cp_err, "Error: too few devs: %s\n", c->line);
|
|
goto quit;
|
|
}
|
|
|
|
translate_inst_name(&buffer, scname, name, NULL);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
/* Now we finish off the line. For most components (R, C, etc),
|
|
* this involves adding the component value to the buffer.
|
|
* We also scan through the line for v(something) and
|
|
* i(something)...
|
|
*/
|
|
finishLine(&buffer, s, scname);
|
|
break;
|
|
}
|
|
|
|
tfree(c->line);
|
|
c->line = copy(bxx_buffer(&buffer));
|
|
|
|
#ifdef TRACE
|
|
printf("In translate, translated line = %s \n", c->line);
|
|
#endif
|
|
}
|
|
rtn = 1;
|
|
quit:
|
|
for (i = 0; i < N_GLOBAL_NODES; i++) {
|
|
if (!table[i].t_old && !table[i].t_new)
|
|
break;
|
|
FREE(table[i].t_old);
|
|
FREE(table[i].t_new);
|
|
}
|
|
|
|
bxx_free(&buffer);
|
|
return rtn;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------*
|
|
* finishLine now doesn't handle current or voltage sources.
|
|
* Therefore, it just writes out the final netnames, if required.
|
|
* Changes made by SDB on 4.29.2003.
|
|
*-------------------------------------------------------------------*/
|
|
static void
|
|
finishLine(struct bxx_buffer *t, char *src, char *scname)
|
|
{
|
|
char *buf, *buf_end, which;
|
|
char *s;
|
|
int lastwasalpha;
|
|
|
|
lastwasalpha = 0;
|
|
while (*src) {
|
|
/* Find the next instance of "<non-alpha>[vi]<opt spaces>(" in
|
|
* this string.
|
|
*/
|
|
if (((*src != 'v') && (*src != 'V') &&
|
|
(*src != 'i') && (*src != 'I')) ||
|
|
lastwasalpha) {
|
|
lastwasalpha = isalpha_c(*src);
|
|
bxx_putc(t, *src++);
|
|
continue;
|
|
}
|
|
which = *src;
|
|
s = skip_ws(src + 1);
|
|
if (*s != '(') {
|
|
lastwasalpha = isalpha_c(*src);
|
|
bxx_putc(t, *src++);
|
|
continue;
|
|
}
|
|
src = skip_ws(s + 1);
|
|
lastwasalpha = 0;
|
|
bxx_putc(t, which);
|
|
bxx_putc(t, '(');
|
|
for (buf = src; *src && !isspace_c(*src) && *src != ',' && *src != ')'; )
|
|
src++;
|
|
buf_end = src;
|
|
|
|
if ((which == 'v') || (which == 'V')) {
|
|
translate_node_name(t, scname, buf, buf_end);
|
|
|
|
/* translate the reference node, as in the "2" in "v(4,2)" */
|
|
while (*src && (isspace_c(*src) || *src == ','))
|
|
src++;
|
|
|
|
if (*src && *src != ')') {
|
|
for (buf = src; *src && !isspace_c(*src) && (*src != ')'); )
|
|
src++;
|
|
bxx_putc(t, ',');
|
|
translate_node_name(t, scname, buf, buf_end = src);
|
|
}
|
|
} else {
|
|
/*
|
|
* i(instance_name) --> i(instance_name[0].subckt.instance_name)
|
|
*/
|
|
translate_inst_name(t, scname, buf, buf_end);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------------------*
|
|
* settrans builds the table which holds the old and new netnames.
|
|
* it also compares the number of nets present in the .subckt definition against
|
|
* the number of nets present in the subcircuit invocation. It returns 0 if they
|
|
* match, otherwise, it returns an error.
|
|
*
|
|
* Variable definitions:
|
|
* formal = copy of the .subckt definition line (e.g. ".subckt subcircuitname 1 2 3") (string)
|
|
* actual = copy of the .subcircuit invocation line (e.g. "Xexample 4 5 6 subcircuitname") (string)
|
|
* subname = copy of the subcircuit name
|
|
*------------------------------------------------------------------------------*/
|
|
static int
|
|
settrans(char *formal, char *actual, const char *subname)
|
|
{
|
|
int i;
|
|
|
|
memset(table, 0, N_GLOBAL_NODES * sizeof(*table));
|
|
|
|
for (i = 0; i < N_GLOBAL_NODES; i++) {
|
|
table[i].t_old = gettok(&formal);
|
|
table[i].t_new = gettok(&actual);
|
|
|
|
if (table[i].t_new == NULL) {
|
|
return -1; /* Too few actual / too many formal */
|
|
} else if (table[i].t_old == NULL) {
|
|
if (eq(table[i].t_new, subname))
|
|
break;
|
|
else
|
|
return 1; /* Too many actual / too few formal */
|
|
}
|
|
}
|
|
if (i == N_GLOBAL_NODES) {
|
|
fprintf(stderr, "ERROR, N_GLOBAL_NODES overflow\n");
|
|
controlled_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* compare a substring, with a '\0' terminated string
|
|
* the substring itself is required to be free of a '\0'
|
|
*/
|
|
|
|
static int
|
|
eq_substr(const char *str, const char *end, const char *cstring)
|
|
{
|
|
while (str < end)
|
|
if (*str++ != *cstring++)
|
|
return 0;
|
|
return (*cstring == '\0');
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------------------*
|
|
* gettrans returns the name of the top level net if it is in the list,
|
|
* otherwise it returns NULL.
|
|
*------------------------------------------------------------------------------*/
|
|
static char *
|
|
gettrans(const char *name, const char *name_end)
|
|
{
|
|
int i;
|
|
|
|
if (!name_end)
|
|
name_end = strchr(name, '\0');
|
|
|
|
/* Added by H.Tanaka to translate global nodes */
|
|
for (i = 0; i<num_global_nodes; i++)
|
|
if (eq_substr(name, name_end, global_nodes[i]))
|
|
return (global_nodes[i]);
|
|
|
|
for (i = 0; table[i].t_old; i++)
|
|
if (eq_substr(name, name_end, table[i].t_old))
|
|
return (table[i].t_new);
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/*-------------------------------------------------------------------*/
|
|
static int
|
|
numnodes(const char *line, struct subs *subs, wordlist const *modnames)
|
|
{
|
|
/* gtri - comment - wbk - 10/23/90 - Do not modify this routine for */
|
|
/* 'A' type devices since the callers will not know how to find the */
|
|
/* nodes even if they know how many there are. Modify the callers */
|
|
/* instead. */
|
|
/* gtri - end - wbk - 10/23/90 */
|
|
char c;
|
|
int n;
|
|
|
|
line = skip_ws(line);
|
|
|
|
c = tolower_c(*line);
|
|
|
|
if (c == 'x') { /* Handle this ourselves. */
|
|
const char *xname_e = skip_back_ws(strchr(line, '\0'), line);
|
|
const char *xname = skip_back_non_ws(xname_e, line);
|
|
for (; subs; subs = subs->su_next)
|
|
if (eq_substr(xname, xname_e, subs->su_name))
|
|
return subs->su_numargs;
|
|
/*
|
|
* number of nodes not known so far.
|
|
* lets count the nodes ourselves,
|
|
* assuming `buf' looks like this:
|
|
* xname n1 n2 ... nn subname
|
|
*/
|
|
{
|
|
int nodes = -2;
|
|
while (*line) {
|
|
nodes++;
|
|
line = skip_ws(skip_non_ws(line));
|
|
}
|
|
return (nodes);
|
|
}
|
|
}
|
|
|
|
n = inp_numnodes(c);
|
|
|
|
/* Added this code for variable number of nodes on certain devices. */
|
|
/* The consequence of this code is that the value returned by the */
|
|
/* inp_numnodes(c) call must be regarded as "maximum number of nodes */
|
|
/* for a given device type. */
|
|
/* Paolo Nenzi Jan-2001 */
|
|
|
|
/* If model names equal node names, this code will fail! */
|
|
|
|
if ((c == 'm') || (c == 'p') || (c == 'q') || (c == 'd')) { /* IF this is a mos, cpl, bjt or diode */
|
|
char *s = nexttok(line); /* Skip the instance name */
|
|
int gotit = 0;
|
|
int i = 0;
|
|
|
|
while ((i <= n) && (*s) && !gotit) {
|
|
char *t = gettok_node(&s); /* get nodenames . . . */
|
|
const wordlist *wl;
|
|
for (wl = modnames; wl; wl = wl->wl_next)
|
|
if (model_name_match(t, wl->wl_word)) {
|
|
gotit = 1;
|
|
break;
|
|
}
|
|
i++;
|
|
tfree(t);
|
|
}
|
|
|
|
/* Note: node checks must be done on #_of_node-1 because the */
|
|
/* "while" cycle increments the counter even when a model is */
|
|
/* recognized. This code may be better! */
|
|
|
|
if ((i < 4) && ((c == 'm') || (c == 'q'))) {
|
|
fprintf(cp_err, "Error: too few nodes for MOS or BJT: %s\n", line);
|
|
return (0);
|
|
}
|
|
if ((i < 5) && (c == 'p')) {
|
|
fprintf(cp_err, "Error: too few nodes for CPL: %s\n", line);
|
|
return (0);
|
|
}
|
|
return (i-1); /* compensate the unnecessary increment in the while cycle */
|
|
} else {
|
|
/* for all other elements */
|
|
return (n);
|
|
}
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------*
|
|
* This function returns the number of controlling voltage sources
|
|
* (for F, H) or controlling nodes (for G, E) attached to a dependent
|
|
* source.
|
|
*-------------------------------------------------------------------*/
|
|
static int
|
|
numdevs(char *s)
|
|
{
|
|
|
|
s = skip_ws(s);
|
|
switch (*s) {
|
|
case 'K':
|
|
case 'k':
|
|
return (2);
|
|
|
|
/* two nodes per voltage controlled source */
|
|
case 'G':
|
|
case 'g':
|
|
case 'E':
|
|
case 'e':
|
|
return (2);
|
|
|
|
/* one source per current controlled source */
|
|
case 'F':
|
|
case 'f':
|
|
case 'H':
|
|
case 'h':
|
|
/* 2 lines here added to fix w bug, NCF 1/31/95 */
|
|
case 'W':
|
|
case 'w':
|
|
return (1);
|
|
|
|
default:
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*
|
|
* modtranslate -- translates .model lines found in subckt definitions.
|
|
* Calling arguments are:
|
|
* *c = pointer to the .subckt definition (linked list)
|
|
* *subname = pointer to the subcircuit name used at the subcircuit invocation (string)
|
|
* modtranslate returns the list of model names which have been translated
|
|
*----------------------------------------------------------------------*/
|
|
static wordlist *
|
|
modtranslate(struct card *c, char *subname, wordlist *new_modnames)
|
|
{
|
|
wordlist *orig_modnames = NULL;
|
|
struct card *lcc = c;
|
|
|
|
for (; c; c = c->nextcard)
|
|
if (ciprefix(".model", c->line)) {
|
|
char *model_name, *new_model_name;
|
|
char *t = c->line;
|
|
|
|
#ifdef TRACE
|
|
printf("modtranslate(), translating:\n"
|
|
" \"%s\" -->\n", t);
|
|
#endif
|
|
|
|
/* swallow ".model" */
|
|
t = nexttok(t);
|
|
|
|
model_name = gettok(&t);
|
|
|
|
new_model_name = tprintf("%s:%s", subname, model_name);
|
|
|
|
/* remember the translation */
|
|
orig_modnames = wl_cons(model_name, orig_modnames);
|
|
new_modnames = wl_cons(new_model_name, new_modnames);
|
|
|
|
/* perform the actual translation of this .model line */
|
|
t = tprintf(".model %s %s", new_model_name, t);
|
|
tfree(c->line);
|
|
c->line = t;
|
|
|
|
#ifdef TRACE
|
|
printf(" \"%s\"\n", t);
|
|
printf(" mapped modelname \"%s\" --> \"%s\"\n",
|
|
model_name, new_model_name);
|
|
#endif
|
|
|
|
}
|
|
|
|
if (orig_modnames) {
|
|
devmodtranslate(lcc, subname, orig_modnames);
|
|
wl_free(orig_modnames);
|
|
}
|
|
|
|
return new_modnames;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------*
|
|
* Devmodtranslate scans through the deck, and translates the
|
|
* name of the model in a line held in a .subckt. For example:
|
|
* before: .subckt U1 . . . .
|
|
* Q1 c b e 2N3904
|
|
* after: Q1 c b e U1:2N3904
|
|
*-------------------------------------------------------------------*/
|
|
|
|
static void
|
|
translate_mod_name(struct bxx_buffer *buffer, char *modname, char *subname, struct wordlist *orig_modnames)
|
|
{
|
|
/*
|
|
* Note that we compare against orig_modnames,
|
|
* which is the list of untranslated names of models.
|
|
*/
|
|
wordlist *wlsub = wl_find(modname, orig_modnames);
|
|
|
|
if (!wlsub)
|
|
bxx_printf(buffer, "%s", modname);
|
|
else
|
|
bxx_printf(buffer, "%s:%s", subname, modname);
|
|
}
|
|
|
|
|
|
static void
|
|
devmodtranslate(struct card *s, char *subname, wordlist * const orig_modnames)
|
|
{
|
|
int found;
|
|
|
|
struct bxx_buffer buffer;
|
|
bxx_init(&buffer);
|
|
|
|
|
|
for (; s; s = s->nextcard) {
|
|
|
|
char *t, c, *name, *next_name;
|
|
wordlist *wlsub;
|
|
|
|
bxx_rewind(&buffer);
|
|
|
|
t = s->line;
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug stuff */
|
|
printf("In devmodtranslate, examining line %s.\n", t);
|
|
#endif
|
|
|
|
t = skip_ws(t);
|
|
c = *t; /* set c to first char in line. . . . */
|
|
if (isupper_c(c))
|
|
c = tolower_c(c);
|
|
|
|
switch (c) {
|
|
|
|
#ifdef XSPICE
|
|
|
|
case 'a':
|
|
/* Code for codemodels (dev prefix "A") added by SDB on 6.10.2004.
|
|
* The algorithm is simple. We don't know how many nodes or sources are attached,
|
|
* but the name of the model is always last. Therefore, just iterate through all
|
|
* tokens until the last one is reached. Then translate it.
|
|
*/
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
printf("In devmodtranslate, found codemodel, line= %s\n", t);
|
|
#endif
|
|
|
|
/* first do refdes. */
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
|
|
/* now do remainder of line. */
|
|
next_name = gettok(&t);
|
|
for (;;) {
|
|
name = next_name;
|
|
next_name = gettok(&t);
|
|
|
|
if (next_name == NULL) {
|
|
/* if next_name is NULL, we are at the line end.
|
|
* name holds the model name. Therefore, break */
|
|
break;
|
|
|
|
} else {
|
|
/* next_name holds something. Write name into the buffer and continue. */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
}
|
|
} /* while */
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
#ifdef TRACE
|
|
/* SDB debug statement */
|
|
printf("In devmodtranslate, translated codemodel line= %s\n", buffer);
|
|
#endif
|
|
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
#endif /* XSPICE */
|
|
|
|
case 'r':
|
|
case 'c':
|
|
case 'l':
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get first netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get second netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
|
|
if (*t) { /* if there is a model, process it. . . . */
|
|
name = gettok(&t);
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
if (*t) {
|
|
name = gettok(&t);
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
}
|
|
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
case 'd':
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get first attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get second attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* this can be either a model name or a node name. */
|
|
if (name == NULL) {
|
|
name = copy(""); /* allow 'tfree' */
|
|
} else {
|
|
for (;;) {
|
|
wlsub = wl_find(name, orig_modnames);
|
|
if (wlsub) {
|
|
break;
|
|
} else {
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
if (name == NULL) { /* No token anymore - leave */
|
|
name = copy(""); /* allow 'tfree' */
|
|
break;
|
|
}
|
|
}
|
|
} /* while */
|
|
}
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
case 'u': /* urc transmissionline */
|
|
/* 3 terminal devices */
|
|
case 'w': /* current controlled switch */
|
|
case 'j': /* jfet */
|
|
case 'z': /* hfet, mesa */
|
|
name = gettok(&t);
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
/* 4 terminal devices */
|
|
case 'o': /* ltra */
|
|
case 's': /* vc switch */
|
|
case 'y': /* txl */
|
|
/* Changed gettok() to gettok_node() on 12.2.2003 by SDB
|
|
to enable parsing lines like "S1 10 11 (80,51) SLATCH1"
|
|
which occur in real Analog Devices SPICE models.
|
|
*/
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get first attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get second attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get third attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get fourth attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
bxx_putc(&buffer, ' ');
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
tfree(name);
|
|
break;
|
|
|
|
/* 3-7 terminal mos devices */
|
|
case 'm':
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get first attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get second attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get third attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t);
|
|
|
|
if (!name) {
|
|
break;
|
|
}
|
|
|
|
found = 0;
|
|
while (!found) {
|
|
/* Now, is this a subcircuit model? */
|
|
for (wlsub = orig_modnames; wlsub; wlsub = wlsub->wl_next)
|
|
if (model_name_match(name, wlsub->wl_word)) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
if (!found) { /* name was not a model - was a netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t);
|
|
if (name == NULL) {
|
|
name = copy(""); /* allow 'tfree' */
|
|
break;
|
|
}
|
|
}
|
|
} /* while */
|
|
|
|
if (!found)
|
|
bxx_printf(&buffer, "%s", name);
|
|
else
|
|
bxx_printf(&buffer, "%s:%s", subname, name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
tfree(name);
|
|
break;
|
|
|
|
/* 3-5 terminal bjt devices */
|
|
case 'q':
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get first attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get second attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* get third attached netname */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok_node(&t); /* this can be either a model name or a node name. */
|
|
|
|
if (name == NULL) {
|
|
name = copy(""); /* allow 'tfree' */
|
|
} else {
|
|
for (;;) {
|
|
wlsub = wl_find(name, orig_modnames);
|
|
if (wlsub) {
|
|
break;
|
|
} else {
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
name = gettok(&t);
|
|
if (name == NULL) { /* No token anymore - leave */
|
|
name = copy(""); /* allow 'tfree' */
|
|
break;
|
|
}
|
|
}
|
|
} /* while */
|
|
}
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
/* 4-18 terminal devices */
|
|
case 'p': /* cpl */
|
|
name = gettok(&t); /* get refdes */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
|
|
/* now do remainder of line. */
|
|
next_name = gettok(&t);
|
|
for (;;) {
|
|
name = next_name;
|
|
next_name = gettok(&t);
|
|
if (!next_name || strstr(next_name, "len")) {
|
|
/* if next_name is NULL or len or length, we are at the line end.
|
|
* name holds the model name. Therefore, break */
|
|
break;
|
|
} else {
|
|
/* next_name holds something. Write name into the buffer and continue. */
|
|
bxx_printf(&buffer, "%s ", name);
|
|
tfree(name);
|
|
}
|
|
} /* while */
|
|
|
|
translate_mod_name(&buffer, name, subname, orig_modnames);
|
|
tfree(name);
|
|
bxx_putc(&buffer, ' ');
|
|
|
|
bxx_put_cstring(&buffer, t);
|
|
tfree(s->line);
|
|
s->line = copy(bxx_buffer(&buffer));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bxx_free(&buffer);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*
|
|
* inp_numnodes returns the maximum number of nodes (netnames) attached
|
|
* to the component.
|
|
* This is a spice-dependent thing. It should probably go somewhere
|
|
* else, but... Note that we pretend that dependent sources and mutual
|
|
* inductors have more nodes than they really do...
|
|
*----------------------------------------------------------------------*/
|
|
static int
|
|
inp_numnodes(char c)
|
|
{
|
|
if (isupper_c(c))
|
|
c = tolower_c(c);
|
|
switch (c) {
|
|
case ' ':
|
|
case '\t':
|
|
case '.':
|
|
case 'x':
|
|
case '*':
|
|
case '$':
|
|
return (0);
|
|
|
|
case 'b':
|
|
return (2);
|
|
case 'c':
|
|
return (2);
|
|
case 'd':
|
|
return (3);
|
|
case 'e':
|
|
return (2); /* changed from 4 to 2 by SDB on 4.22.2003 to enable POLY */
|
|
case 'f':
|
|
return (2);
|
|
case 'g':
|
|
return (2); /* changed from 4 to 2 by SDB on 4.22.2003 to enable POLY */
|
|
case 'h':
|
|
return (2);
|
|
case 'i':
|
|
return (2);
|
|
case 'j':
|
|
return (3);
|
|
case 'k':
|
|
return (0);
|
|
case 'l':
|
|
return (2);
|
|
case 'm':
|
|
return (7); /* This means that 7 is the maximun number of nodes */
|
|
case 'o':
|
|
return (4);
|
|
case 'p':
|
|
return (18);/* 16 lines + 2 gnd is the maximum number of nodes for CPL */
|
|
case 'q':
|
|
return (5);
|
|
case 'r':
|
|
return (2);
|
|
case 's':
|
|
return (4);
|
|
case 't':
|
|
return (4);
|
|
case 'u':
|
|
return (3);
|
|
case 'v':
|
|
return (2);
|
|
case 'w':
|
|
return (2); /* change 3 to 2 here to fix w bug, NCF 1/31/95 */
|
|
case 'y':
|
|
return (4);
|
|
case 'z':
|
|
return (3);
|
|
|
|
default:
|
|
fprintf(cp_err, "Warning: unknown device type: %c\n", c);
|
|
return (2);
|
|
}
|
|
}
|