static int
dot_pz(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
char *steptype; /* ac analysis, type of stepping function */
NG_IGNORE(gnode);
/* .pz nodeI nodeG nodeJ nodeK {V I} {POL ZER PZ} */
which = ft_find_analysis("PZ");
if (which == -1) {
LITERR("Pole-zero analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Pole-Zero Analysis", &foo, task));
parm = INPgetValue(ckt, &line, IF_NODE, tab);
GCA(INPapName, (ckt, which, foo, "nodei", parm));
parm = INPgetValue(ckt, &line, IF_NODE, tab);
GCA(INPapName, (ckt, which, foo, "nodeg", parm));
parm = INPgetValue(ckt, &line, IF_NODE, tab);
GCA(INPapName, (ckt, which, foo, "nodej", parm));
parm = INPgetValue(ckt, &line, IF_NODE, tab);
GCA(INPapName, (ckt, which, foo, "nodek", parm));
INPgetTok(&line, &steptype, 1); /* get V or I */
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, steptype, &ptemp));
INPgetTok(&line, &steptype, 1); /* get POL, ZER, or PZ */
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, steptype, &ptemp));
return (0);
}
static int
dot_tf(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
char *name; /* the resistor's name */
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
int which; /* which analysis we are performing */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
/* .tf v( node1, node2 ) src */
/* .tf vsrc2 src */
which = ft_find_analysis("TF");
if (which == -1) {
LITERR("Transfer Function analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Transfer Function", &foo, task));
INPgetTok(&line, &name, 0);
/* name is now either V or I or a serious error */
if (*name == 'v' && strlen(name) == 1) {
if (*line != '(' ) {
/* error, bad input format */
}
INPgetNetTok(&line, &nname1, 0);
INPtermInsert(ckt, &nname1, tab, &node1);
ptemp.nValue = node1;
GCA(INPapName, (ckt, which, foo, "outpos", &ptemp));
if (*line != ')') {
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
ptemp.nValue = node2;
GCA(INPapName, (ckt, which, foo, "outneg", &ptemp));
ptemp.sValue = tprintf("V(%s,%s)", nname1, nname2);
GCA(INPapName, (ckt, which, foo, "outname", &ptemp));
} else {
ptemp.nValue = gnode;
GCA(INPapName, (ckt, which, foo, "outneg", &ptemp));
ptemp.sValue = tprintf("V(%s)", nname1);
GCA(INPapName, (ckt, which, foo, "outname", &ptemp));
}
} else if (*name == 'i' && strlen(name) == 1) {
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "outsrc", &ptemp));
} else {
LITERR("Syntax error: voltage or current expected.\n");
return 0;
}
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "insrc", &ptemp));
return (0);
}
static int
dot_ac(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
char *steptype; /* ac analysis, type of stepping function */
NG_IGNORE(gnode);
/* .ac {DEC OCT LIN} NP FSTART FSTOP */
which = ft_find_analysis("AC");
if (which == -1) {
LITERR("AC small signal analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "AC Analysis", &foo, task));
INPgetTok(&line, &steptype, 1); /* get DEC, OCT, or LIN */
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, steptype, &ptemp));
tfree(steptype);
parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* number of points */
GCA(INPapName, (ckt, which, foo, "numsteps", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstart */
GCA(INPapName, (ckt, which, foo, "start", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstop */
GCA(INPapName, (ckt, which, foo, "stop", parm));
return (0);
}
static int
dot_dc(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
char *name; /* the resistor's name */
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
NG_IGNORE(gnode);
/* .dc SRC1NAME Vstart1 Vstop1 Vinc1 [SRC2NAME Vstart2 */
/* Vstop2 Vinc2 */
which = ft_find_analysis("DC");
if (which == -1) {
LITERR("DC transfer curve analysis unsupported\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "DC transfer characteristic", &foo, task));
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "name1", &ptemp));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vstart1 */
GCA(INPapName, (ckt, which, foo, "start1", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vstop1 */
GCA(INPapName, (ckt, which, foo, "stop1", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vinc1 */
GCA(INPapName, (ckt, which, foo, "step1", parm));
if (*line) {
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "name2", &ptemp));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vstart2 */
GCA(INPapName, (ckt, which, foo, "start2", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vstop2 */
GCA(INPapName, (ckt, which, foo, "stop2", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* vinc2 */
GCA(INPapName, (ckt, which, foo, "step2", parm));
}
return 0;
}
/*SP: Steady State Analyis */
static int
dot_pss(char *line, void *ckt, INPtables *tab, struct card *current,
void *task, void *gnode, JOB *foo)
{
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
char *nname; /* the oscNode name */
CKTnode *nnode; /* the oscNode node */
int which; /* which analysis we are performing */
char *word; /* something to stick a word of input into */
NG_IGNORE(gnode);
/* .pss Fguess StabTime OscNode <UIC>*/
which = ft_find_analysis("PSS");
if (which == -1) {
LITERR("Periodic steady state analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Periodic Steady State Analysis", &foo, task));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Fguess */
GCA(INPapName, (ckt, which, foo, "fguess", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* StabTime */
GCA(INPapName, (ckt, which, foo, "stabtime", parm));
INPgetNetTok(&line, &nname, 0);
INPtermInsert(ckt, &nname, tab, &nnode);
ptemp.nValue = nnode;
GCA(INPapName, (ckt, which, foo, "oscnode", &ptemp)); /* OscNode given as string */
parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* PSS points */
GCA(INPapName, (ckt, which, foo, "points", parm));
parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* PSS harmonics */
GCA(INPapName, (ckt, which, foo, "harmonics", parm));
parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* SC iterations */
GCA(INPapName, (ckt, which, foo, "sc_iter", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Steady coefficient */
GCA(INPapName, (ckt, which, foo, "steady_coeff", parm));
if (*line) {
INPgetTok(&line, &word, 1); /* uic? */
if (strcmp(word, "uic") == 0) {
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, "uic", &ptemp));
} else {
fprintf(stderr,"Error: unknown parameter %s on .pss - ignored\n", word);
}
}
return (0);
}
void INP2G(void *ckt, INPtables * tab, card * current)
{
/* Gname <node> <node> <node> <node> <val> */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
void *node3; /* the third node's node pointer */
void *node4; /* the fourth node's node pointer */
int error; /* error code temporary */
void *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package resistance into */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid of default model to be created */
type = INPtypelook("VCCS");
if (type < 0) {
LITERR("Device type VCCS not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetNetTok(&line, &nname4, 1);
INPtermInsert(ckt, &nname4, tab, &node4);
if (!tab->defGmod) {
/* create default G model */
IFnewUid(ckt, &uid, (IFuid) NULL, "G", UID_MODEL, (void **) NULL);
IFC(newModel, (ckt, type, &(tab->defGmod), uid));
}
IFC(newInstance, (ckt, tab->defGmod, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
IFC(bindNode, (ckt, fast, 4, node4));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
if (waslead) {
ptemp.rValue = leadval;
GCA(INPpName, ("gain", &ptemp, ckt, type, fast));
}
}
void INP2T(CKTcircuit *ckt, INPtables * tab, card * current)
{
/* Tname <node> <node> <node> <node> [TD=<val>]
* [F=<val> [NL=<val>]][IC=<val>,<val>,<val>,<val>] */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
CKTnode *node3; /* the third node's node pointer */
CKTnode *node4; /* the fourth node's node pointer */
int error; /* error code temporary */
GENinstance *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid for default model */
type = INPtypelook("Tranline");
if (type < 0) {
LITERR("Device type Tranline not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetNetTok(&line, &nname4, 1);
INPtermInsert(ckt, &nname4, tab, &node4);
if (!tab->defTmod) {
/* create deafult T model */
IFnewUid(ckt, &uid, NULL, "T", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defTmod), uid));
}
IFC(newInstance, (ckt, tab->defTmod, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
IFC(bindNode, (ckt, fast, 4, node4));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
}
static int
dot_tran(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
double dtemp; /* random double precision temporary */
char *word; /* something to stick a word of input into */
NG_IGNORE(gnode);
/* .tran Tstep Tstop <Tstart <Tmax> > <UIC> */
which = ft_find_analysis("TRAN");
if (which == -1) {
LITERR("Transient analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Transient Analysis", &foo, task));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Tstep */
GCA(INPapName, (ckt, which, foo, "tstep", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* Tstop */
GCA(INPapName, (ckt, which, foo, "tstop", parm));
if (*line) {
dtemp = INPevaluate(&line, &error, 1); /* tstart? */
if (error == 0) {
ptemp.rValue = dtemp;
GCA(INPapName, (ckt, which, foo, "tstart", &ptemp));
dtemp = INPevaluate(&line, &error, 1); /* tmax? */
if (error == 0) {
ptemp.rValue = dtemp;
GCA(INPapName, (ckt, which, foo, "tmax", &ptemp));
}
}
}
if (*line) {
INPgetTok(&line, &word, 1); /* uic? */
if (strcmp(word, "uic") == 0) {
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, "uic", &ptemp));
} else {
LITERR(" Error: unknown parameter on .tran - ignored\n");
}
tfree(word);
}
return (0);
}
static int
dot_sens(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
char *name; /* the resistor's name */
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
char *steptype; /* ac analysis, type of stepping function */
which = ft_find_analysis("SENS");
if (which == -1) {
LITERR("Sensitivity unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Sensitivity Analysis", &foo, task));
/* Format is:
* .sens <output>
* + [ac [dec|lin|oct] <pts> <low freq> <high freq> | dc ]
*/
/* Get the output voltage or current */
INPgetTok(&line, &name, 0);
/* name is now either V or I or a serious error */
if (*name == 'v' && strlen(name) == 1) {
if (*line != '(') {
LITERR("Syntax error: '(' expected after 'v'\n");
return 0;
}
INPgetNetTok(&line, &nname1, 0);
INPtermInsert(ckt, &nname1, tab, &node1);
ptemp.nValue = node1;
GCA(INPapName, (ckt, which, foo, "outpos", &ptemp));
if (*line != ')') {
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
ptemp.nValue = node2;
GCA(INPapName, (ckt, which, foo, "outneg", &ptemp));
ptemp.sValue = tprintf("V(%s,%s)", nname1, nname2);
GCA(INPapName, (ckt, which, foo, "outname", &ptemp));
} else {
ptemp.nValue = gnode;
GCA(INPapName, (ckt, which, foo, "outneg", &ptemp));
ptemp.sValue = tprintf("V(%s)", nname1);
GCA(INPapName, (ckt, which, foo, "outname", &ptemp));
}
} else if (*name == 'i' && strlen(name) == 1) {
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "outsrc", &ptemp));
} else {
LITERR("Syntax error: voltage or current expected.\n");
return 0;
}
INPgetTok(&line, &name, 1);
if (name && !strcmp(name, "pct")) {
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, "pct", &ptemp));
INPgetTok(&line, &name, 1);
}
if (name && !strcmp(name, "ac")) {
INPgetTok(&line, &steptype, 1); /* get DEC, OCT, or LIN */
ptemp.iValue = 1;
GCA(INPapName, (ckt, which, foo, steptype, &ptemp));
parm = INPgetValue(ckt, &line, IF_INTEGER, tab); /* number of points */
GCA(INPapName, (ckt, which, foo, "numsteps", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstart */
GCA(INPapName, (ckt, which, foo, "start", parm));
parm = INPgetValue(ckt, &line, IF_REAL, tab); /* fstop */
GCA(INPapName, (ckt, which, foo, "stop", parm));
return (0);
} else if (name && *name && strcmp(name, "dc")) {
/* Bad flag */
LITERR("Syntax error: 'ac' or 'dc' expected.\n");
return 0;
}
return (0);
}
void INP2R(void *ckt, INPtables * tab, card * current)
{
/* parse a resistor card */
/* Rname <node> <node> [<val>][<mname>][w=<val>][l=<val>][ac=<val>] */
int mytype; /* the type we determine resistors are */
int type = 0; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *saveline; /* ... just in case we need to go back... */
char *name; /* the resistor's name */
char *model; /* the name of the resistor's model */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
double val; /* temp to held resistance */
int error; /* error code temporary */
int error1; /* secondary error code temporary */
INPmodel *thismodel; /* pointer to model structure describing our model */
void *mdfast = NULL; /* pointer to the actual model */
void *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package resistance into */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid for default model */
char *s,*t;/* Temporary buffer and pointer for translation */
int i;
#ifdef TRACE
printf("In INP2R()\n");
printf(" Current line: %s\n",current->line);
#endif
mytype = INPtypelook("Resistor");
if (mytype < 0) {
LITERR("Device type Resistor not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1); /* Rname */
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1); /* <node> */
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1); /* <node> */
INPtermInsert(ckt, &nname2, tab, &node2);
val = INPevaluate(&line, &error1, 1); /* [<val>] */
/* either not a number -> model, or
* follows a number, so must be a model name
* -> MUST be a model name (or null)
*/
saveline = line; /* save then old pointer */
#ifdef TRACE
printf("Begining tc=xxx yyyy search and translation in '%s'\n", line);
#endif /* TRACE */
/* This routine translates "tc=xxx yyy" to "tc=xxx tc2=yyy".
This is a re-write of the routine originally proposed by Hitoshi tanaka.
In my version we simply look for the first occurence of 'tc' followed
by '=' followed by two numbers. If we find it then we splice in "tc2=".
sjb - 2005-05-09 */
for(s=line; *s; s++) { /* scan the remainder of the line */
/* reject anything other than "tc" */
if(*s!='t') continue;
s++;
if(*s!='c') continue;
s++;
/* skip any white space */
while(isspace(*s)) s++;
/* reject if not '=' */
if(*s!='=') continue;
s++;
/* skip any white space */
while(isspace(*s)) s++;
/* if we now have +, - or a decimal digit then assume we have a number,
otherwise reject */
if((*s!='+') && (*s!='-') && !isdigit(*s)) continue;
s++;
/* look for next white space or null */
while(!isspace(*s) && *s) s++;
/* reject whole line if null (i.e not white space) */
if(*s==0) break;
s++;
/* remember this location in the line.
Note that just before this location is a white space character. */
t = s;
/* skip any additional white space */
while(isspace(*s)) s++;
/* if we now have +, - or a decimal digit then assume we have the
second number, otherwise reject */
if((*s!='+') && (*s!='-') && !isdigit(*s)) continue;
/* if we get this far we have met all are criterea,
so now we splice in a "tc2=" at the location remembered above. */
/* first alocate memory for the new longer line */
i = strlen(current->line); /* length of existing line */
line = tmalloc(i + 4 + 1); /* alocate enough for "tc2=" & terminating NULL */
if(line == NULL) {
/* failed to allocate memory so we recover rather crudely
by rejecting the translation */
line = saveline;
break;
}
/* copy first part of line */
i -= strlen(t);
strncpy(line,current->line,i);
line[i]=0; /* terminate */
/* add "tc2=" */
strcat(line, "tc2=");
/* add rest of line */
strcat(line, t);
/* calculate our saveline position in the new line */
saveline = line + (saveline - current->line);
/* replace old line with new */
tfree(current->line);
current->line = line;
line = saveline;
}
#ifdef TRACE
printf("(Translated) Res line: %s\n",current->line);
#endif
INPgetTok(&line, &model, 1);
if (*model) {
/* token isn't null */
if (INPlookMod(model)) {
/* If this is a valid model connect it */
INPinsert(&model, tab);
thismodel = (INPmodel *) NULL;
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (mytype != thismodel->INPmodType) {
LITERR("incorrect model type for resistor");
return;
}
mdfast = thismodel->INPmodfast;
type = thismodel->INPmodType;
}
} else {
tfree(model);
/* It is not a model */
line = saveline; /* go back */
type = mytype;
if (!tab->defRmod) { /* create default R model */
IFnewUid(ckt, &uid, (IFuid) NULL, "R", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defRmod), uid));
}
mdfast = tab->defRmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
} else {
tfree(model);
/* The token is null and a default model will be created */
type = mytype;
if (!tab->defRmod) {
/* create default R model */
IFnewUid(ckt, &uid, (IFuid) NULL, "R", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defRmod), uid));
}
IFC(newInstance, (ckt, tab->defRmod, &fast, name));
}
if (error1 == 0) { /* got a resistance above */
ptemp.rValue = val;
GCA(INPpName, ("resistance", &ptemp, ckt, type, fast))
}
///<param name = "*ckt"> THe current circuit </param>
///<param name = "*name"> The name of the model </param>
///<param name = "**model"> The parse model structure </param>
///<param name = "*tab"> The current symbol table </param>
char *INPgetMod(GENERIC * ckt, char *name, INPmodel **model, INPtables *tab)
{
INPmodel *modtmp;
IFvalue * val;
register int j;
char * line;
char *parm;
char *err = NULL;
char *temp;
int error;
for (modtmp = modtab; modtmp != (INPmodel *)NULL; modtmp = ((modtmp)->INPnextModel))
{
if (strcmp((modtmp)->INPmodName, name) == 0)
{
/* found the model in question - now instantiate if necessary */
/* and return an appropriate pointer to it */
if (modtmp->INPmodType < 0)
{
/* illegal device type, so can't handle */
*model = (INPmodel *)NULL;
err = (char *)MALLOC((35 + strlen(name)) * sizeof(char));
(void)sprintf(err, "Unknown device type for model %s \n", name);
return(err);
}
if (!((modtmp)->INPmodUsed))
{
/* not already defined, so create & give parameters */
error = (*(ft_sim->newModel))(ckt, (modtmp)->INPmodType, &((modtmp)->INPmodfast), (modtmp)->INPmodName);
if (error)
return(INPerror(error));
/* parameter isolation, identification, binding */
line = ((modtmp)->INPmodLine)->line;
INPgetTok(&line, &parm, 1); /* throw away '.model' */
INPgetTok(&line, &parm, 1); /* throw away 'modname' */
while (*line != 0)
{
INPgetTok(&line, &parm, 1);
if (!*parm)
continue;
for (j = 0; j < (*(*(ft_sim->devices)[(modtmp)->INPmodType]).numModelParms); j++)
{
if (strcmp(parm, ((*(ft_sim->devices)[(modtmp)->INPmodType]).modelParms[j].keyword)) == 0)
{
val = INPgetValue(ckt, &line, ((*(ft_sim->devices)[(modtmp)->INPmodType]).modelParms[j].dataType), tab);
error = (*(ft_sim->setModelParm))(ckt, ((modtmp)->INPmodfast), (*(ft_sim->devices)[(modtmp)->INPmodType]).modelParms[j].id, val, (IFvalue*)NULL);
if (error)
return(INPerror(error));
break;
}
}
if (strcmp(parm, "level") == 0)
{
/* just grab the level number and throw away */
/* since we already have that info from pass1 */
val = INPgetValue(ckt, &line, IF_REAL, tab);
}
else if (j >= (*(*(ft_sim->devices)[(modtmp)->INPmodType]).numModelParms))
{
temp = (char *)MALLOC((40 + strlen(parm)) * sizeof(char));
(void)sprintf(temp, "unrecognized parameter (%s) - ignored\n", parm);
err = INPerrCat(err, temp);
}
FREE(parm);
}
(modtmp)->INPmodUsed = 1;
(modtmp)->INPmodLine->error = err;
}
*model = modtmp;
return((char *)NULL);
}
}
/* didn't find model - ERROR - return model */
*model = (INPmodel *)NULL;
err = (char *)MALLOC((60 + strlen(name)) * sizeof(char));
(void)sprintf(err, " unable to find definition of model %s - default assumed \n", name);
return(err);
}
void INP2W(CKTcircuit *ckt, INPtables * tab, card * current)
{
/* Wname <node> <node> <vctrl> [<modname>] [IC] */
/* CURRENT CONTROLLED SWITCH */
int mytype; /* the type we determine resistors are */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *model; /* the name of the resistor's model */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
int error; /* error code temporary */
INPmodel *thismodel; /* pointer to model structure describing our model */
GENmodel *mdfast; /* pointer to the actual model */
GENinstance *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* pointer to a value structure for functions to return */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid for default model */
mytype = INPtypelook("CSwitch");
if (mytype < 0) {
LITERR("Device type CSwitch not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
parm = INPgetValue(ckt, &line, IF_INSTANCE, tab);
ptemp.uValue = parm->uValue;
INPgetTok(&line, &model, 1);
INPinsert(&model, tab);
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (mytype != thismodel->INPmodType) {
LITERR("incorrect model type");
return;
}
type = mytype;
mdfast = (thismodel->INPmodfast);
} else {
type = mytype;
if (!tab->defWmod) {
/* create deafult W model */
IFnewUid(ckt, &uid, NULL, "W", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defWmod), uid));
}
mdfast = tab->defWmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
GCA(INPpName, ("control", &ptemp, ckt, type, fast));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
if (waslead) {
/* ignore a number */
}
}
void INP2D(CKTcircuit *ckt, INPtables * tab, card * current)
{
/* Dname <node> <node> <model> [<val>] [OFF] [IC=<val>] */
int mytype; /* the type we looked up */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
int error; /* error code temporary */
GENinstance *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package resistance into */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* the name of the model */
INPmodel *thismodel; /* pointer to model description for user's model */
GENmodel *mdfast; /* pointer to the actual model */
IFuid uid; /* uid of default model */
mytype = INPtypelook("Diode");
if (mytype < 0) {
LITERR("Device type Diode not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetTok(&line, &model, 1);
INPinsert(&model, tab);
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if ((mytype != thismodel->INPmodType)
#ifdef CIDER
&& (thismodel->INPmodType != INPtypelook("NUMD"))
&& (thismodel->INPmodType != INPtypelook("NUMD2"))
#endif
){
LITERR("incorrect model type");
return;
}
type = thismodel->INPmodType; /*HT 050903*/
mdfast = (thismodel->INPmodfast);
} else {
type = mytype;
if (!tab->defDmod) {
/* create default D model */
IFnewUid(ckt, &uid, NULL, "D", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defDmod), uid));
}
mdfast = tab->defDmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
if (waslead) {
#ifdef CIDER
if( type == INPtypelook("NUMD2") ) {
LITERR(" error: no unlabelled parameter permitted on NUMD2\n");
} else {
#endif
ptemp.rValue = leadval;
GCA(INPpName, ("area", &ptemp, ckt, type, fast));
}
#ifdef CIDER
}
#endif
}
void INP2L(void *ckt, INPtables * tab, card * current)
{
/* parse an inductor card */
/* Lname <node> <node> [<val>] [<mname>] [IC=<val>] */
int mytype; /* the type we determine inductors are */
int type = 0; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *saveline; /* ... just in case we need to go back... */
char *name; /* the resistor's name */
char *model; /* the name of the inductor's model */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
double val; /* temp to held inductance */
int error; /* error code temporary */
int error1; /* secondary error code temporary */
INPmodel *thismodel; /* pointer to model structure describing our model */
void *mdfast = NULL; /* pointer to the actual model */
void *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package inductance into */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid for default cap model */
mytype = INPtypelook("Inductor");
if (mytype < 0) {
LITERR("Device type Inductor not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
val = INPevaluate(&line, &error1, 1);
saveline = line;
INPgetTok(&line, &model, 1);
if (*model) {
/* token isn't null */
if (INPlookMod(model)) {
/* If this is a valid model connect it */
INPinsert(&model, tab);
thismodel = (INPmodel *) NULL;
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (mytype != thismodel->INPmodType) {
LITERR("incorrect model type");
return;
}
mdfast = thismodel->INPmodfast;
type = thismodel->INPmodType;
}
} else {
tfree(model);
/* It is not a model */
line = saveline; /* go back */
type = mytype;
if (!tab->defLmod) { /* create default L model */
IFnewUid(ckt, &uid, (IFuid) NULL, "L", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defLmod), uid));
}
mdfast = tab->defLmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
} else {
tfree(model);
/* The token is null and a default model will be created */
type = mytype;
if (!tab->defLmod) {
/* create default L model */
IFnewUid(ckt, &uid, (IFuid) NULL, "L", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defLmod), uid));
}
IFC(newInstance, (ckt, tab->defLmod, &fast, name));
}
if (error1 == 0) { /* Looks like a number */
ptemp.rValue = val;
GCA(INPpName, ("inductance", &ptemp, ckt, type, fast));
}
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
if (waslead) {
ptemp.rValue = leadval;
GCA(INPpName, ("inductance", &ptemp, ckt, type, fast));
}
return;
}
char *MIFgetMod(
CKTcircuit *ckt, /* The circuit structure */
char *name, /* The name of the model to look for */
INPmodel **model, /* The model found/created */
INPtables *tab /* Table of model info from first pass */
)
{
INPmodel *modtmp;
IFvalue * val;
register int j;
char * line;
char *parm;
char *err = NULL;
int error;
int i;
char *err1;
char *err2;
MIFmodel *mdfast;
/* Mif_Param_Info_t *param_info;*/
/* =========== First locate the named model in the modtab list ================= */
#ifdef TRACE
/* SDB debug statement */
printf("In MIFgetMod, looking for model name = %s . . .\n", name);
#endif
/* maschmann : remove : from name
* char *pos;
* if((pos=strstr(name,":"))!=NULL) *pos=0;
*/
/*------------------------------------
for (i = &modtab; *i != NULL; i = &((*i)->INPnextModel)) {
if (strcmp((*i)->INPmodName, token) == 0) {
return (OK);
}
}
--------------------------*/
/* loop through modtable looking for this model (*name) */
for (modtmp = modtab; modtmp != NULL; modtmp = modtmp->INPnextModel) {
#ifdef TRACE
/* SDB debug statement */
printf("In MIFgetMod, checking model against stored model = %s . . .\n", modtmp->INPmodName);
#endif
if (strcmp(modtmp->INPmodName, name) == 0) {
#ifdef TRACE
/* SDB debug statement */
printf("In MIFgetMod, found model!!!\n");
#endif
/* ========= found the model in question - now instantiate if necessary ========== */
/* ============== and return an appropriate pointer to it ===================== */
/* make sure the type is valid before proceeding */
if(modtmp->INPmodType < 0) {
/* illegal device type, so can't handle */
*model = NULL;
return tprintf("MIF: Unknown device type for model %s\n", name);
}
/* check to see if this model's parameters have been processed */
if(! modtmp->INPmodfast) {
/* not already processed, so create data struct */
error = ft_sim->newModel ( ckt, modtmp->INPmodType,
&(modtmp->INPmodfast), modtmp->INPmodName);
if(error)
return(INPerror(error));
/* gtri modification: allocate and initialize MIF specific model struct items */
mdfast = (MIFmodel*) modtmp->INPmodfast;
mdfast->num_param = DEVices[modtmp->INPmodType]->DEVpublic.num_param;
mdfast->param = TMALLOC(Mif_Param_Data_t *, mdfast->num_param);
for(i = 0; i < mdfast->num_param; i++) {
mdfast->param[i] = TMALLOC(Mif_Param_Data_t, 1);
mdfast->param[i]->is_null = MIF_TRUE;
mdfast->param[i]->size = 0;
mdfast->param[i]->element = NULL;
}
/* remaining initializations will be done by MIFmParam() and MIFsetup() */
/* parameter isolation, identification, binding */
line = modtmp->INPmodLine->line;
INPgetTok(&line,&parm,1); /* throw away '.model' */
tfree(parm);
INPgetTok(&line,&parm,1); /* throw away 'modname' */
tfree(parm);
/* throw away the modtype - we don't treat it as a parameter */
/* like SPICE does */
INPgetTok(&line,&parm,1); /* throw away 'modtype' */
tfree(parm);
while(*line != '\0') {
INPgetTok(&line,&parm,1);
for(j=0 ; j < *(ft_sim->devices[modtmp->INPmodType]->numModelParms); j++) {
if (strcmp(parm, ft_sim->devices[modtmp->INPmodType]->modelParms[j].keyword) == 0) {
/* gtri modification: call MIFgetValue instead of INPgetValue */
err1 = NULL;
val = MIFgetValue(ckt,&line,
ft_sim->devices[modtmp->INPmodType]->modelParms[j].dataType,
tab, &err1);
if(err1) {
err2 = tprintf("MIF-ERROR - model: %s - %s\n", name, err1);
return(err2);
}
error = ft_sim->setModelParm (ckt,
modtmp->INPmodfast,
ft_sim->devices[modtmp->INPmodType]->modelParms[j].id,
val, NULL);
if(error)
return(INPerror(error));
break;
}
}
/* gtri modification: processing of special parameter "level" removed */
if(j >= *(ft_sim->devices[modtmp->INPmodType]->numModelParms)) {
char *temp = tprintf("MIF: unrecognized parameter (%s) - ignored", parm);
err = INPerrCat(err, temp);
}
FREE(parm);
} /* end while end of line not reached */
modtmp->INPmodLine->error = err;
} /* end if model parameters not processed yet */
*model = modtmp;
return(NULL);
} /* end if name matches */
void INP2S(void *ckt, INPtables * tab, card * current)
{
/* Sname <node> <node> <node> <node> [<modname>] [IC] */
/* VOLTAGE CONTROLLED SWITCH */
int mytype; /* the type we determine resistors are */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *model; /* the name of the resistor's model */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
void *node3; /* the third node's node pointer */
void *node4; /* the fourth node's node pointer */
int error; /* error code temporary */
INPmodel *thismodel; /* pointer to model structure describing our model */
void *mdfast; /* pointer to the actual model */
void *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
IFuid uid; /* uid of default model */
mytype = INPtypelook("Switch");
if (mytype < 0) {
LITERR("Device type Switch not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetNetTok(&line, &nname4, 1);
INPtermInsert(ckt, &nname4, tab, &node4);
INPgetTok(&line, &model, 1);
INPinsert(&model, tab);
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (mytype != thismodel->INPmodType) {
LITERR("incorrect model type");
return;
}
type = mytype;
mdfast = (thismodel->INPmodfast);
} else {
type = mytype;
if (!tab->defSmod) {
/* create deafult S model */
IFnewUid(ckt, &uid, (IFuid) NULL, "S", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defSmod), uid));
}
mdfast = tab->defSmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
IFC(bindNode, (ckt, fast, 4, node4));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
if (waslead) {
/* ignore a number */
}
}
int
INP2dot(CKTcircuit *ckt, INPtables *tab, struct card *current, TSKtask *task, CKTnode *gnode)
{
/* .<something> Many possibilities */
char *token; /* a token from the line, tmalloc'ed */
JOB *foo = NULL; /* pointer to analysis */
/* the part of the current line left to parse */
char *line = current->line;
int rtn = 0;
INPgetTok(&line, &token, 1);
if (strcmp(token, ".model") == 0) {
/* don't have to do anything, since models were all done in
* pass 1 */
goto quit;
} else if ((strcmp(token, ".width") == 0) ||
strcmp(token, ".print") == 0 || strcmp(token, ".plot") == 0) {
/* obsolete - ignore */
LITERR(" Warning: obsolete control card - ignored \n");
goto quit;
} else if ((strcmp(token, ".temp") == 0)) {
/* .temp temp1 temp2 temp3 temp4 ..... */
/* not yet implemented - warn & ignore */
/*
LITERR(" Warning: .TEMP card obsolete - use .options TEMP and TNOM\n");
*/
goto quit;
} else if ((strcmp(token, ".op") == 0)) {
rtn = dot_op(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".nodeset") == 0)) {
goto quit;
} else if ((strcmp(token, ".disto") == 0)) {
rtn = dot_disto(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".noise") == 0)) {
rtn = dot_noise(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".four") == 0)
|| (strcmp(token, ".fourier") == 0)) {
/* .four */
/* not implemented - warn & ignore */
LITERR("Use fourier command to obtain fourier analysis\n");
goto quit;
} else if ((strcmp(token, ".ic") == 0)) {
goto quit;
} else if ((strcmp(token, ".ac") == 0)) {
rtn = dot_ac(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".pz") == 0)) {
rtn = dot_pz(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".dc") == 0)) {
rtn = dot_dc(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".tf") == 0)) {
rtn = dot_tf(line, ckt, tab, current, task, gnode, foo);
goto quit;
} else if ((strcmp(token, ".tran") == 0)) {
rtn = dot_tran(line, ckt, tab, current, task, gnode, foo);
goto quit;
#ifdef WITH_PSS
/* SP: Steady State Analysis */
} else if ((strcmp(token, ".pss") == 0)) {
rtn = dot_pss(line, ckt, tab, current, task, gnode, foo);
goto quit;
/* SP */
#endif
} else if ((strcmp(token, ".subckt") == 0) ||
(strcmp(token, ".ends") == 0)) {
/* not yet implemented - warn & ignore */
LITERR(" Warning: Subcircuits not yet implemented - ignored \n");
goto quit;
} else if ((strcmp(token, ".end") == 0)) {
/* .end - end of input */
/* not allowed to pay attention to additional input - return */
rtn = 1;
goto quit;
} else if (strcmp(token, ".sens") == 0) {
rtn = dot_sens(line, ckt, tab, current, task, gnode, foo);
goto quit;
}
#ifdef WANT_SENSE2
else if ((strcmp(token, ".sens2") == 0)) {
rtn = dot_sens2(line, ckt, tab, current, task, gnode, foo);
goto quit;
}
#endif
else if ((strcmp(token, ".probe") == 0)) {
/* Maybe generate a "probe" format file in the future. */
goto quit;
} else if ((strcmp(token, ".options") == 0)||
(strcmp(token,".option")==0) ||
(strcmp(token,".opt")==0)) {
rtn = dot_options(line, ckt, tab, current, task, gnode, foo);
goto quit;
}
/* Added by H.Tanaka to find .global option */
else if (strcmp(token, ".global") == 0) {
rtn = 0;
LITERR(" Warning: .global not yet implemented - ignored \n");
goto quit;
}
/* ignore .meas statements -- these will be handled after analysis */
/* also ignore .param statements */
/* ignore .prot, .unprot */
else if (strcmp(token, ".meas") == 0 || ciprefix(".para", token) || strcmp(token, ".measure") == 0 ||
strcmp(token, ".prot") == 0 || strcmp(token, ".unprot") == 0) {
rtn = 0;
goto quit;
}
LITERR(" unimplemented control card - error \n");
quit:
tfree(token);
return rtn;
}
///<param name = "*ckt"> ircuit being parsed </param>
///<param name = "*anal"> The options analysis to add to </param>
///<param name = "*optCard"> The card image to get data from </param>
///<param name = "*tab"> The parse tables for this circuit </param>
void INPdoOpts(GENERIC *ckt, GENERIC *anal, card *optCard, INPtables *tab)
{
char *line;
char *token;
char *errmsg;
IFvalue *val = NULL;
int error;
int i;
int which;
IFanalysis *prm = NULL;
which = -1;
i = 0;
for (i = 0; i < ft_sim->numAnalyses; i++)
{
prm = ft_sim->analyses[i];
if (strcmp(prm->name, "options") == 0)
{
which = i;
break;
}
i++;
}
if (which == -1)
{
optCard->error = INPerrCat(optCard->error, INPmkTemp("errr: analysis options table not found\n"));
return;
}
line = optCard->line;
INPgetTok(&line, &token, 1); /* throw away '.option' */
while (*line)
{
INPgetTok(&line, &token, 1);
for (i = 0; i < prm->numParms; i++)
{
if (strcmp(token, prm->analysisParms[i].keyword) == 0)
{
if (!(prm->analysisParms[i].dataType & IF_UNIMP_MASK))
{
errmsg = (char *)MALLOC((45 + strlen(token)) * sizeof(char));
(void)sprintf(errmsg, " Warning: %s not yet implemented - ignored \n", token);
optCard->error = INPerrCat(optCard->error, errmsg);
val = INPgetValue(ckt, &line, prm->analysisParms[i].dataType, tab);
break;
}
if (prm->analysisParms[i].dataType & IF_SET)
{
val = INPgetValue(ckt, &line, prm->analysisParms[i].dataType&IF_VARTYPES, tab);
error = (*(ft_sim->setAnalysisParm))(ckt, anal, prm->analysisParms[i].id, val, (IFvalue*)NULL);
if (error)
{
errmsg = (char *)MALLOC((35 + strlen(token))*sizeof(char));
(void)sprintf(errmsg, "Warning: can't set optione %s\n", token);
optCard->error = INPerrCat(optCard->error, errmsg);
}
break;
}
}
}
if (i == prm->numParms)
{
errmsg = (char *)MALLOC(100 * sizeof(char));
(void)strcpy(errmsg, " Error: unknown option - ignored\n");
optCard->error = INPerrCat(optCard->error, errmsg);
}
}
}
void
INPpas3(CKTcircuit *ckt, card *data, INPtables *tab, TSKtask *task,
IFparm *nodeParms, int numNodeParms)
{
card *current;
int error; /* used by the macros defined above */
char *line; /* the part of the current line left
to parse */
char *token=NULL; /* a token from the line */
IFparm *prm; /* pointer to parameter to search
through array */
IFvalue ptemp; /* a value structure to package
resistance into */
int which; /* which analysis we are performing */
CKTnode *node1; /* the first node's node pointer */
NG_IGNORE(task);
#ifdef TRACE
/* SDB debug statement */
printf("In INPpas3 . . . \n");
#endif
for(current = data; current != NULL; current = current->nextcard) {
line = current->line;
FREE(token);
INPgetTok(&line,&token,1);
if (strcmp(token,".nodeset")==0) {
which = -1;
for(prm = nodeParms; prm < nodeParms + numNodeParms; prm++) {
if(strcmp(prm->keyword,"nodeset")==0) {
which = prm->id;
break;
}
}
if(which == -1) {
LITERR("nodeset unknown to simulator. \n");
goto quit;
}
for(;;) {
char *name; /* the node's name */
/* loop until we run out of data */
INPgetTok(&line,&name,1);
if( *name == '\0') {
FREE(name);
break; /* end of line */
}
/* If we have 'all = value' , then set all voltage nodes to 'value',
except for ground node at node->number 0 */
if ( cieq(name, "all")) {
ptemp.rValue = INPevaluate(&line,&error,1);
for (node1 = ckt->CKTnodes; node1 != NULL; node1 = node1->next) {
if ((node1->type == SP_VOLTAGE) && (node1->number > 0))
IFC(setNodeParm, (ckt, node1, which, &ptemp, NULL));
}
FREE(name);
break;
}
/* check to see if in the form V(xxx) and grab the xxx */
if( (*name == 'V' || *name == 'v') && !name[1] ) {
/* looks like V - must be V(xx) - get xx now*/
char *nodename;
INPgetTok(&line,&nodename,1);
if (INPtermInsert(ckt,&nodename,tab,&node1)!=E_EXISTS)
fprintf(stderr,
"Warning : Nodeset on non-existant node - %s\n", nodename);
ptemp.rValue = INPevaluate(&line,&error,1);
IFC(setNodeParm, (ckt, node1, which, &ptemp, NULL));
FREE(name);
continue;
}
LITERR(" Error: .nodeset syntax error.\n");
FREE(name);
break;
}
} else if ((strcmp(token,".ic") == 0)) {
/* .ic */
which = -1;
for(prm = nodeParms; prm < nodeParms + numNodeParms; prm++) {
if(strcmp(prm->keyword,"ic")==0) {
which = prm->id;
break;
}
}
if(which==-1) {
LITERR("ic unknown to simulator. \n");
goto quit;
}
for(;;) {
char *name; /* the node's name */
/* loop until we run out of data */
INPgetTok(&line,&name,1);
/* check to see if in the form V(xxx) and grab the xxx */
if( *name == '\0') {
FREE(name);
break; /* end of line */
}
if( (*name == 'V' || *name == 'v') && !name[1] ) {
/* looks like V - must be V(xx) - get xx now*/
char *nodename;
INPgetTok(&line,&nodename,1);
if (INPtermInsert(ckt,&nodename,tab,&node1)!=E_EXISTS)
fprintf(stderr,
"Warning : IC on non-existant node - %s\n", nodename);
ptemp.rValue = INPevaluate(&line,&error,1);
IFC(setNodeParm, (ckt, node1, which, &ptemp, NULL));
FREE(name);
continue;
}
LITERR(" Error: .ic syntax error.\n");
FREE(name);
break;
}
}
}
quit:
FREE(token);
return;
}
void INPpas2(CKTcircuit *ckt, card * data, INPtables * tab, TSKtask *task)
{
card *current;
char c;
char *groundname = "0";
char *gname;
CKTnode *gnode;
int error; /* used by the macros defined above */
#ifdef HAS_PROGREP
int linecount = 0, actcount = 0;
#endif
#ifdef TRACE
/* SDB debug statement */
printf("Entered INPpas2 . . . .\n");
#endif
#ifdef XSPICE
if (!ckt->CKTadevFlag) ckt->CKTadevFlag = 0;
#endif
error = INPgetTok(&groundname, &gname, 1);
if (error)
data->error =
INPerrCat(data->error,
INPmkTemp
("can't read internal ground node name!\n"));
error = INPgndInsert(ckt, &gname, tab, &gnode);
if (error && error != E_EXISTS)
data->error =
INPerrCat(data->error,
INPmkTemp
("can't insert internal ground node in symbol table!\n"));
#ifdef TRACE
printf("Examining this deck:\n");
for (current = data; current != NULL; current = current->nextcard) {
printf("%s\n", current->line);
}
printf("\n");
#endif
#ifdef HAS_PROGREP
for (current = data; current != NULL; current = current->nextcard)
linecount++;
#endif
for (current = data; current != NULL; current = current->nextcard) {
#ifdef TRACE
/* SDB debug statement */
printf("In INPpas2, examining card %s . . .\n", current->line);
#endif
#ifdef HAS_PROGREP
if (linecount > 0) {
SetAnalyse( "Circuit2", (int) (1000.*actcount/linecount));
actcount++;
}
#endif
c = *(current->line);
if(islower(c))
c = (char) toupper(c);
switch (c) {
case ' ':
/* blank line (space leading) */
case '\t':
/* blank line (tab leading) */
break;
#ifdef XSPICE
/* gtri - add - wbk - 10/23/90 - add case for 'A' devices */
case 'A': /* Aname <cm connections> <mname> */
MIF_INP2A(ckt, tab, current);
ckt->CKTadevFlag = 1; /* an 'A' device is requested */
break;
/* gtri - end - wbk - 10/23/90 */
#endif
case 'R':
/* Rname <node> <node> [<val>][<mname>][w=<val>][l=<val>] */
INP2R(ckt, tab, current);
break;
case 'C':
/* Cname <node> <node> <val> [IC=<val>] */
INP2C(ckt, tab, current);
break;
case 'L':
/* Lname <node> <node> <val> [IC=<val>] */
INP2L(ckt, tab, current);
break;
case 'G':
/* Gname <node> <node> <node> <node> <val> */
INP2G(ckt, tab, current);
break;
case 'E':
/* Ename <node> <node> <node> <node> <val> */
INP2E(ckt, tab, current);
break;
case 'F':
/* Fname <node> <node> <vname> <val> */
INP2F(ckt, tab, current);
break;
case 'H':
/* Hname <node> <node> <vname> <val> */
INP2H(ckt, tab, current);
break;
case 'D':
/* Dname <node> <node> <model> [<val>] [OFF] [IC=<val>] */
INP2D(ckt, tab, current);
break;
case 'J':
/* Jname <node> <node> <node> <model> [<val>] [OFF]
[IC=<val>,<val>] */
INP2J(ckt, tab, current);
break;
case 'Z':
/* Zname <node> <node> <node> <model> [<val>] [OFF]
[IC=<val>,<val>] */
INP2Z(ckt, tab, current);
break;
case 'M':
/* Mname <node> <node> <node> <node> <model> [L=<val>]
[W=<val>] [AD=<val>] [AS=<val>] [PD=<val>]
[PS=<val>] [NRD=<val>] [NRS=<val>] [OFF]
[IC=<val>,<val>,<val>] */
INP2M(ckt, tab, current);
break;
#ifdef NDEV
case 'N':
/* Nname [<node>...] [<mname>] */
INP2N(ckt, tab, current);
break;
#endif
case 'O':
/* Oname <node> <node> <node> <node> <model>
[IC=<val>,<val>,<val>,<val>] */
INP2O(ckt, tab, current);
break;
case 'V':
/* Vname <node> <node> [ [DC] <val>] [AC [<val> [<val> ] ] ]
[<tran function>] */
INP2V(ckt, tab, current);
break;
case 'I':
/* Iname <node> <node> [ [DC] <val>] [AC [<val> [<val> ] ] ]
[<tran function>] */
INP2I(ckt, tab, current);
break;
case 'Q':
/* Qname <node> <node> <node> [<node>] <model> [<val>] [OFF]
[IC=<val>,<val>] */
INP2Q(ckt, tab, current, gnode);
break;
case 'T':
/* Tname <node> <node> <node> <node> [TD=<val>]
[F=<val> [NL=<val>]][IC=<val>,<val>,<val>,<val>] */
INP2T(ckt, tab, current);
break;
case 'S':
/* Sname <node> <node> <node> <node> [<modname>] [IC] */
INP2S(ckt, tab, current);
break;
case 'W':
/* Wname <node> <node> <vctrl> [<modname>] [IC] */
/* CURRENT CONTROLLED SWITCH */
INP2W(ckt, tab, current);
break;
case 'U':
/* Uname <node> <node> <model> [l=<val>] [n=<val>] */
INP2U(ckt, tab, current);
break;
/* Kspice addition - saj */
case 'P':
/* Pname <node> <node> ... <gnd> <node> <node> ... <gnd> [<modname>] */
/* R=<vector> L=<matrix> G=<vector> C=<matrix> len=<val> */
INP2P(ckt, tab, current);
break;
case 'Y':
/* Yname <node> <node> R=<val> L=<val> G=<val> C=<val> len=<val> */
INP2Y(ckt, tab, current);
break;
/* end Kspice */
case 'K':
/* Kname Lname Lname <val> */
INP2K(ckt, tab, current);
break;
case '*': case '$':
/* *<anything> - a comment - ignore */
break;
case 'B':
/* Bname <node> <node> [V=expr] [I=expr] */
/* Arbitrary source. */
INP2B(ckt, tab, current);
break;
case '.': /* .<something> Many possibilities */
if (INP2dot(ckt,tab,current,task,gnode))
return;
break;
case '\0':
break;
default:
/* the un-implemented device */
LITERR(" unknown device type - error \n");
break;
}
}
return;
}
static int
dot_sens2(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
int error; /* error code temporary */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
int which; /* which analysis we are performing */
char *token; /* a token from the line */
NG_IGNORE(gnode);
/* .sens {AC} {DC} {TRAN} [dev=nnn parm=nnn]* */
which = ft_find_analysis("SENS2");
if (which == -1) {
LITERR("Sensitivity-2 analysis unsupported\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Sensitivity-2 Analysis", &foo, task));
while (*line) {
IFparm *if_parm;
/* read the entire line */
INPgetTok(&line, &token, 1);
if_parm = ft_find_analysis_parm(which, token);
if (!if_parm) {
/* didn't find it! */
LITERR(" Error: unknown parameter on .sens-ignored \n");
continue;
}
/* found it, analysis which, parameter i */
if (if_parm->dataType & IF_FLAG) {
/* one of the keywords! */
ptemp.iValue = 1;
error = ft_sim->setAnalysisParm (ckt, foo,
if_parm->id,
&ptemp,
NULL);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
} else {
parm = INPgetValue(ckt, &line, if_parm->dataType, tab);
error = ft_sim->setAnalysisParm (ckt, foo,
if_parm->id,
parm,
NULL);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
}
}
return (0);
}
static int
dot_noise(char *line, CKTcircuit *ckt, INPtables *tab, struct card *current,
TSKtask *task, CKTnode *gnode, JOB *foo)
{
int which; /* which analysis we are performing */
int error; /* error code temporary */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
char *steptype; /* ac analysis, type of stepping function */
int found;
char *point;
/* .noise V(OUTPUT,REF) SRC {DEC OCT LIN} NP FSTART FSTOP <PTSPRSUM> */
which = ft_find_analysis("NOISE");
if (which == -1) {
LITERR("Noise analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Noise Analysis", &foo, task));
INPgetTok(&line, &name, 1);
/* Make sure the ".noise" command is followed by V(xxxx). If it
is, extract 'xxxx'. If not, report an error. */
if (name != NULL) {
if ((*name == 'V' || *name == 'v') && !name[1]) {
INPgetNetTok(&line, &nname1, 0);
INPtermInsert(ckt, &nname1, tab, &node1);
ptemp.nValue = node1;
GCA(INPapName, (ckt, which, foo, "output", &ptemp));
if (*line != ')') {
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
ptemp.nValue = node2;
} else {
ptemp.nValue = gnode;
}
GCA(INPapName, (ckt, which, foo, "outputref", &ptemp));
tfree(name);
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "input", &ptemp));
INPgetTok(&line, &steptype, 1);
ptemp.iValue = 1;
error = INPapName(ckt, which, foo, steptype, &ptemp);
tfree(steptype);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_INTEGER, tab);
error = INPapName(ckt, which, foo, "numsteps", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_REAL, tab);
error = INPapName(ckt, which, foo, "start", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_REAL, tab);
error = INPapName(ckt, which, foo, "stop", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
/* now see if "ptspersum" has been specified by the user */
for (found = 0, point = line; (!found) && (*point != '\0'); found = ((*point != ' ') && (*(point++) != '\t')))
;
if (found) {
parm = INPgetValue(ckt, &line, IF_INTEGER, tab);
error = INPapName(ckt, which, foo, "ptspersum", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
} else {
ptemp.iValue = 0;
error = INPapName(ckt, which, foo, "ptspersum", &ptemp);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
}
} else
LITERR("bad syntax "
"[.noise v(OUT) SRC {DEC OCT LIN} "
"NP FSTART FSTOP <PTSPRSUM>]\n");
} else {
LITERR("bad syntax "
"[.noise v(OUT) SRC {DEC OCT LIN} "
"NP FSTART FSTOP <PTSPRSUM>]\n");
}
return 0;
}
void INP2Z(CKTcircuit *ckt, INPtables * tab, card * current)
{
/* Zname <node> <node> <node> <model> [<val>] [OFF] [IC=<val>,<val>] */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
CKTnode *node3; /* the third node's node pointer */
int error; /* error code temporary */
GENinstance *fast; /* pointer to the actual instance */
IFvalue ptemp; /* a value structure to package resistance into */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* the name of the model */
INPmodel *thismodel; /* pointer to model description for user's model */
GENmodel *mdfast; /* pointer to the actual model */
IFuid uid; /* uid for default model */
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetTok(&line, &model, 1);
INPinsert(&model, tab);
thismodel = NULL;
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if ( thismodel->INPmodType != INPtypelook("MES")
&& thismodel->INPmodType != INPtypelook("MESA")
&& thismodel->INPmodType != INPtypelook("HFET1")
&& thismodel->INPmodType != INPtypelook("HFET2"))
{
LITERR("incorrect model type");
return;
}
type = thismodel->INPmodType;
mdfast = (thismodel->INPmodfast);
} else {
type = INPtypelook("MES");
if (type < 0 ) {
LITERR("Device type MES not supported by this binary\n");
return;
}
if (!tab->defZmod) {
/* create default Z model */
IFnewUid(ckt, &uid, NULL, "Z", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defZmod), uid));
}
mdfast = tab->defZmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
/* use type - not thismodel->INPmodType as it might not exist! */
/* FIXME: Why do we need checking for type here? */
if ( (waslead) && ( type /*thismodel->INPmodType*/ != INPtypelook("MES") ) ) {
ptemp.rValue = leadval;
GCA(INPpName, ("area", &ptemp, ckt, type, fast));
}
}
void INP2O(CKTcircuit *ckt, INPtables * tab, card * current)
{
/* Oname <node> <node> <node> <node> [IC=<val>,<val>,<val>,<val>] */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
CKTnode *node3; /* the third node's node pointer */
CKTnode *node4; /* the fourth node's node pointer */
int error; /* error code temporary */
GENinstance *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* the name of the model */
INPmodel *thismodel; /* pointer to model description for user's model */
GENmodel *mdfast; /* pointer to the actual model */
IFuid uid; /* uid for default model */
type = INPtypelook("LTRA");
if (type < 0) {
LITERR("Device type LossyXmissionLine not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetNetTok(&line, &nname4, 1);
INPtermInsert(ckt, &nname4, tab, &node4);
INPgetTok(&line, &model, 1);
if (INPlookMod(model)) {
/* do nothing for now */
/* no action required */
} else {
/*
nname4 = model;
INPtermInsert(ckt,&nname4,tab,&node4);
INPgetTok(&line,&model,1);
*/
}
INPinsert(&model, tab);
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (type != thismodel->INPmodType) {
LITERR("incorrect model type");
return;
}
mdfast = (thismodel->INPmodfast);
} else {
if (!tab->defOmod) {
/* create default O model */
IFnewUid(ckt, &uid, NULL, "O", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defOmod), uid));
}
mdfast = tab->defOmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
IFC(bindNode, (ckt, fast, 4, node4));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
}
static int
dot_noise(char *line, void *ckt, INPtables *tab, card *current,
void *task, void *gnode, void *foo)
{
int which; /* which analysis we are performing */
int i; /* generic loop variable */
int error; /* error code temporary */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
IFvalue ptemp; /* a value structure to package resistance into */
IFvalue *parm; /* a pointer to a value struct for function returns */
char *steptype; /* ac analysis, type of stepping function */
int found;
char *point;
/* .noise V(OUTPUT,REF) SRC {DEC OCT LIN} NP FSTART FSTOP <PTSPRSUM> */
which = -1;
for (i = 0; i < ft_sim->numAnalyses; i++) {
if (strcmp(ft_sim->analyses[i]->name, "NOISE") == 0) {
which = i;
break;
}
}
if (which == -1) {
LITERR("Noise analysis unsupported.\n");
return (0);
}
IFC(newAnalysis, (ckt, which, "Noise Analysis", &foo, task));
INPgetTok(&line, &name, 1);
/* Make sure the ".noise" command is followed by V(xxxx). If it
is, extract 'xxxx'. If not, report an error. */
if (name != NULL) {
int length;
length = strlen(name);
if (((*name == 'V') || (*name == 'v')) && (length == 1)) {
INPgetNetTok(&line, &nname1, 0);
INPtermInsert(ckt, &nname1, tab, &node1);
ptemp.nValue = (IFnode) node1;
GCA(INPapName, (ckt, which, foo, "output", &ptemp))
if (*line != ')') {
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
ptemp.nValue = (IFnode) node2;
} else {
ptemp.nValue = (IFnode) gnode;
}
GCA(INPapName, (ckt, which, foo, "outputref", &ptemp))
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
ptemp.uValue = name;
GCA(INPapName, (ckt, which, foo, "input", &ptemp))
INPgetTok(&line, &steptype, 1);
ptemp.iValue = 1;
error = INPapName(ckt, which, foo, steptype, &ptemp);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_INTEGER, tab);
error = INPapName(ckt, which, foo, "numsteps", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_REAL, tab);
error = INPapName(ckt, which, foo, "start", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
parm = INPgetValue(ckt, &line, IF_REAL, tab);
error = INPapName(ckt, which, foo, "stop", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
/* now see if "ptspersum" has been specified by the user */
for (found = 0, point = line; (!found) && (*point != '\0');
found = ((*point != ' ') && (*(point++) != '\t')));
if (found) {
parm = INPgetValue(ckt, &line, IF_INTEGER, tab);
error = INPapName(ckt, which, foo, "ptspersum", parm);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
} else {
ptemp.iValue = 0;
error = INPapName(ckt, which, foo, "ptspersum", &ptemp);
if (error)
current->error = INPerrCat(current->error, INPerror(error));
}
} else
void INP2U(void *ckt, INPtables * tab, card * current)
{
/* Uname <node> <node> <model> [l=<val>] [n=<val>] */
int mytype; /* the type my lookup says URC is */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
void *node1; /* the first node's node pointer */
void *node2; /* the second node's node pointer */
void *node3; /* the third node's node pointer */
int error; /* error code temporary */
void *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* name of the model */
INPmodel *thismodel; /* pointer to our model descriptor */
void *mdfast; /* pointer to the actual model */
IFuid uid; /* uid for default model */
mytype = INPtypelook("URC");
if (mytype < 0) {
LITERR("Device type URC not supported by this binary\n");
return;
}
line = current->line;
INPgetTok(&line, &name, 1);
INPinsert(&name, tab);
INPgetNetTok(&line, &nname1, 1);
INPtermInsert(ckt, &nname1, tab, &node1);
INPgetNetTok(&line, &nname2, 1);
INPtermInsert(ckt, &nname2, tab, &node2);
INPgetNetTok(&line, &nname3, 1);
INPtermInsert(ckt, &nname3, tab, &node3);
INPgetTok(&line, &model, 1);
INPinsert(&model, tab);
current->error = INPgetMod(ckt, model, &thismodel, tab);
if (thismodel != NULL) {
if (mytype != thismodel->INPmodType) {
LITERR("incorrect model type");
return;
}
type = mytype;
mdfast = (thismodel->INPmodfast);
} else {
type = mytype;
if (!tab->defUmod) {
/* create deafult U model */
IFnewUid(ckt, &uid, (IFuid) NULL, "U", UID_MODEL,
(void **) NULL);
IFC(newModel, (ckt, type, &(tab->defUmod), uid));
}
mdfast = tab->defUmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
IFC(bindNode, (ckt, fast, 1, node1));
IFC(bindNode, (ckt, fast, 2, node2));
IFC(bindNode, (ckt, fast, 3, node3));
PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab));
}