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);
}
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));
}
/*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);
}
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);
}
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;
}
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 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 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 */
}
}
static INPparseNode *mkfnode(char *fname, INPparseNode * arg)
{
int i;
INPparseNode *p;
char buf[128], *name, *s;
IFvalue temp;
/* Make sure the case is ok. */
(void) strcpy(buf, fname);
for (s = buf; *s; s++)
if (isupper(*s))
*s = tolower(*s);
p = (INPparseNode *) MALLOC(sizeof(INPparseNode));
if (!strcmp(buf, "v")) {
name = MALLOC(128);
if (arg->type == PT_PLACEHOLDER) {
strcpy(name, arg->funcname);
} else if (arg->type == PT_CONSTANT) {
(void) sprintf(name, "%d", (int) arg->constant);
} else if (arg->type != PT_COMMA) {
fprintf(stderr, "Error: badly formed node voltage\n");
return (NULL);
}
if (arg->type == PT_COMMA) {
/* Change v(a,b) into v(a) - v(b) */
p = mkb(PT_MINUS, mkfnode(fname, arg->left),
mkfnode(fname, arg->right));
} else {
/* printf("getting a node called '%s'\n", name); */
INPtermInsert(circuit, &name, tables, &(temp.nValue));
for (i = 0; i < numvalues; i++)
if ((types[i] == IF_NODE) && (values[i].nValue ==
temp.nValue)) break;
if (i == numvalues) {
if (numvalues) {
values = (IFvalue *)
REALLOC((char *) values,
(numvalues + 1) * sizeof(IFvalue));
types = (int *)
REALLOC((char *) types,
(numvalues + 1) * sizeof(int));
} else {
values = (IFvalue *) MALLOC(sizeof(IFvalue));
types = (int *) MALLOC(sizeof(int));
}
values[i] = temp;
types[i] = IF_NODE;
numvalues++;
}
p->valueIndex = i;
p->type = PT_VAR;
}
} else if (!strcmp(buf, "i")) {
name = MALLOC(128);
if (arg->type == PT_PLACEHOLDER)
strcpy(name, arg->funcname);
else if (arg->type == PT_CONSTANT)
(void) sprintf(name, "%d", (int) arg->constant);
else {
fprintf(stderr, "Error: badly formed branch current\n");
return (NULL);
}
/* printf("getting a device called '%s'\n", name); */
INPinsert(&name, tables);
for (i = 0; i < numvalues; i++)
if ((types[i] == IF_INSTANCE) && (values[i].uValue ==
temp.uValue)) break;
if (i == numvalues) {
if (numvalues) {
values = (IFvalue *)
REALLOC((char *) values,
(numvalues + 1) * sizeof(IFvalue));
types = (int *)
REALLOC((char *) types, (numvalues + 1) * sizeof(int));
} else {
values = (IFvalue *) MALLOC(sizeof(IFvalue));
types = (int *) MALLOC(sizeof(int));
}
values[i].uValue = (IFuid) name;
types[i] = IF_INSTANCE;
numvalues++;
}
p->valueIndex = i;
p->type = PT_VAR;
} else {
for (i = 0; i < NUM_FUNCS; i++)
if (!strcmp(funcs[i].name, buf))
break;
if (i == NUM_FUNCS) {
fprintf(stderr, "Error: no such function '%s'\n", buf);
return (NULL);
}
p->type = PT_FUNCTION;
p->left = arg;
p->funcname = funcs[i].name;
p->funcnum = funcs[i].number;
p->function = funcs[i].funcptr;
}
return (p);
}
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 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));
}
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
}
///<param name = "*fname"> The name of the function </param>
///<param name = "*arg"> The argument it is given </param>
static INPparseNode *mkfnode(char *fname, INPparseNode *arg)
{
int i;
INPparseNode *p = NULL;
char buf[128], *name = NULL, *s = NULL;
IFvalue temp;
temp.nValue = 0;// this line is required by microsoft. Generates a C4700 error if this is not included
/* Make sure the case is ok. */
(void)strcpy(buf, fname);
for (s = buf; *s; s++)
{
if (isupper(*s))
{
*s = tolower(*s);
}
}
p = (INPparseNode *)MALLOC(sizeof(INPparseNode));
if (!strcmp(buf, "v"))
{
name = MALLOC(128);
if (arg->type == PT_PLACEHOLDER)
{
strcpy(name, arg->funcname);
}
else if (arg->type == PT_CONSTANT)
{
(void)sprintf(name, "%d", (int)arg->constant);
}
else if (arg->type != PT_COMMA)
{
fprintf(stderr, "Error: badly formed node voltage\n");
return (NULL);
}
if (arg->type == PT_COMMA)
{
/* Change v(a,b) into v(a) - v(b) */
p = mkb(PT_MINUS, mkfnode(fname, arg->left),
mkfnode(fname, arg->right));
}
else
{
/* printf("getting a node called '%s'\n", name); */
INPtermInsert(circuit, &name, tables, &(temp.nValue));
/* This block is reallocating the value variable. Although defined as a pointer, it is actually being used as a dynamic array*/
for (i = 0; i < numvalues; i++)
{
if ((types[i] == IF_NODE) && (values[i].nValue == temp.nValue))
break;
}
if (i == numvalues)
{
if (numvalues)
{
/*This is a test*/
values = (IFvalue *)REALLOC((char *)values, (numvalues + 1) * sizeof(IFvalue)); /* values is becoming an array where each element is IFvalue. Dynamic Array Allocation */
types = (int *)REALLOC((char *)types, (numvalues + 1) * sizeof(int));
}
else
{
/* If numvalues is 0, then the program will allocate values with 1 cell
The program will only execute this block once */
values = (IFvalue *)MALLOC(sizeof(IFvalue)); /* values is becoming an array where each element is IFvalue */
types = (int *)MALLOC(sizeof(int));
}
values[i] = temp;
types[i] = IF_NODE;
numvalues++;
}
p->valueIndex = i;
p->type = PT_VAR;
}
}
else if (!strcmp(buf, "i"))
{
name = MALLOC(128);
if (arg->type == PT_PLACEHOLDER)
strcpy(name, arg->funcname);
else if (arg->type == PT_CONSTANT)
(void) sprintf(name, "%d", (int)arg->constant);
else
{
fprintf(stderr, "Error: badly formed branch current\n");
return (NULL);
}
/* printf("getting a device called '%s'\n", name); */
INPinsert(&name, tables);
for (i = 0; i < numvalues; i++)
{
if ((types[i] == IF_INSTANCE) && (values[i].uValue == temp.uValue))
break;
}
if (i == numvalues)
{
if (numvalues)
{
values = (IFvalue *)REALLOC((char *)values, (numvalues + 1) * sizeof(IFvalue));
types = (int *)REALLOC((char *)types, (numvalues + 1) * sizeof(int));
}
else
{
values = (IFvalue *)MALLOC(sizeof(IFvalue));
types = (int *)MALLOC(sizeof(int));
}
values[i].uValue = (IFuid)name;
types[i] = IF_INSTANCE;
numvalues++;
}
p->valueIndex = i;
p->type = PT_VAR;
}
else
{
for (i = 0; i < NUM_FUNCS; i++)
{
if (!strcmp(funcs[i].name, buf))
break;
}
if (i == NUM_FUNCS)
{
fprintf(stderr, "Error: no such function '%s'\n", buf);
return (NULL);
}
p->type = PT_FUNCTION;
p->left = arg;
p->funcname = funcs[i].name;
p->funcnum = funcs[i].number;
p->function = funcs[i].funcptr;
}
return (p);
}
void INP2C(CKTcircuit *ckt, INPtables * tab, struct card *current)
{
/* parse a capacitor card */
/* Cname <node> <node> [<val>] [<mname>] [IC=<val>] */
static int mytype = -1; /* the type we determine capacitors 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 capacitor'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 */
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 */
GENmodel *mdfast = NULL; /* pointer to the actual model */
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 */
IFuid uid; /* uid for default cap model */
#ifdef TRACE
printf("In INP2C, Current line: %s\n", current->line);
#endif
if (mytype < 0) {
if ((mytype = INPtypelook("Capacitor")) < 0) {
LITERR("Device type Capacitor not supported by this binary\n");
return;
}
}
line = current->line;
INPgetNetTok(&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;
INPgetNetTok(&line, &model, 1);
if (*model && (strcmp(model, "c") != 0)) {
/* token isn't null */
if (INPlookMod(model)) {
/* If this is a valid model connect it */
INPinsert(&model, tab);
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->defCmod) { /* create default C model */
IFnewUid(ckt, &uid, NULL, "C", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defCmod), uid));
}
mdfast = tab->defCmod;
}
IFC(newInstance, (ckt, mdfast, &fast, name));
} else {
tfree(model);
/* The token is null and a default model will be created */
type = mytype;
if (!tab->defCmod) {
/* create default C model */
IFnewUid(ckt, &uid, NULL, "C", UID_MODEL, NULL);
IFC(newModel, (ckt, type, &(tab->defCmod), uid));
}
IFC(newInstance, (ckt, tab->defCmod, &fast, name));
if (error1 == 1) { /* was a c=val construction */
val = INPevaluate(&line, &error1, 1); /* [<val>] */
#ifdef TRACE
printf ("In INP2C, C=val construction: val=%g\n", val);
#endif
}
}
if (error1 == 0) { /* Looks like a number */
ptemp.rValue = val;
GCA(INPpName, ("capacitance", &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, ("capacitance", &ptemp, ckt, type, fast));
}
return;
}
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))
}
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 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));
}