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)); }
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 */ } }
double cm_netlist_get_c(void) { CKTcircuit *ckt; MIFinstance *cmeter_inst; CAPinstance *cap_inst; VSRCinstance *vsrc_inst; CAPmodel *cap_head; CAPmodel *cap_model; VSRCmodel *vsrc_head; VSRCmodel *vsrc_model; int cap_type; int vsrc_type; int cmeter_node; int vsrc_node; double c; /* Get the circuit data structure and current instance */ ckt = g_mif_info.ckt; cmeter_inst = g_mif_info.instance; /* Get internal node number for positive node of cmeter input */ cmeter_node = cmeter_inst->conn[0]->port[0]->smp_data.pos_node; /* Initialize total capacitance value to zero */ c = 0.0; /* ****************************************************** */ /* Look for capacitors connected directly to cmeter input */ /* ****************************************************** */ /* Get the head of the list of capacitor models in the circuit */ cap_type = INPtypelook("Capacitor"); if(cap_type < 0) { printf("\nERROR - Capacitor type not supported in this binary\n"); return(0); } cap_head = (CAPmodel *) ckt->CKThead[cap_type]; /* Scan through all capacitor instances and add in values */ /* of any capacitors connected to cmeter input */ for(cap_model = cap_head; cap_model; cap_model = CAPnextModel(cap_model)) { for(cap_inst = CAPinstances(cap_model); cap_inst; cap_inst = CAPnextInstance(cap_inst)) { if((cmeter_node == cap_inst->CAPposNode) || (cmeter_node == cap_inst->CAPnegNode)) { c += cap_inst->CAPcapac; } } } /* ***************************************************************** */ /* Look for capacitors connected through zero-valued voltage sources */ /* ***************************************************************** */ /* Get the head of the list of voltage source models in the circuit */ vsrc_type = INPtypelook("Vsource"); if(vsrc_type < 0) { printf("\nERROR - Vsource type not supported in this binary\n"); return(0); } vsrc_head = (VSRCmodel *) ckt->CKThead[vsrc_type]; /* Scan through all voltage source instances and add in values */ /* of any capacitors connected to cmeter input through voltage source */ for(vsrc_model = vsrc_head; vsrc_model; vsrc_model = VSRCnextModel(vsrc_model)) { for(vsrc_inst = VSRCinstances(vsrc_model); vsrc_inst; vsrc_inst = VSRCnextInstance(vsrc_inst)) { /* Skip to next if not DC source with value = 0.0 */ if((vsrc_inst->VSRCfunctionType != 0) || (vsrc_inst->VSRCdcValue != 0.0)) continue; /* See if voltage source is connected to cmeter input */ /* If so, get other node voltage source is connected to */ /* If not, skip to next source */ if(cmeter_node == vsrc_inst->VSRCposNode) vsrc_node = vsrc_inst->VSRCnegNode; else if(cmeter_node == vsrc_inst->VSRCnegNode) vsrc_node = vsrc_inst->VSRCposNode; else continue; /* Scan through all capacitor instances and add in values */ /* of any capacitors connected to the voltage source node */ for(cap_model = cap_head; cap_model; cap_model = CAPnextModel(cap_model)) { for(cap_inst = CAPinstances(cap_model); cap_inst; cap_inst = CAPnextInstance(cap_inst)) { if((vsrc_node == cap_inst->CAPposNode) || (vsrc_node == cap_inst->CAPnegNode)) { c += cap_inst->CAPcapac; } } } } /* end for all vsrc instances */ } /* end for all vsrc models */ /* Return the total capacitance value */ return(c); }
double cm_netlist_get_l(void) { CKTcircuit *ckt; MIFinstance *lmeter_inst; INDinstance *ind_inst; VSRCinstance *vsrc_inst; INDmodel *ind_head; INDmodel *ind_model; VSRCmodel *vsrc_head; VSRCmodel *vsrc_model; int ind_type; int vsrc_type; int lmeter_node; int vsrc_node; double l; /* Get the circuit data structure and current instance */ ckt = g_mif_info.ckt; lmeter_inst = g_mif_info.instance; /* Get internal node number for positive node of lmeter input */ lmeter_node = lmeter_inst->conn[0]->port[0]->smp_data.pos_node; /* Initialize total inductance to infinity */ l = 1.0e12; /* ****************************************************** */ /* Look for inductors connected directly to lmeter input */ /* ****************************************************** */ /* Get the head of the list of inductor models in the circuit */ ind_type = INPtypelook("Inductor"); if(ind_type < 0) { printf("\nERROR - Inductor type not supported in this binary\n"); return(0); } ind_head = (INDmodel *) ckt->CKThead[ind_type]; /* Scan through all inductor instances and add in values */ /* of any inductors connected to lmeter input */ for(ind_model = ind_head; ind_model; ind_model = INDnextModel(ind_model)) { for(ind_inst = INDinstances(ind_model); ind_inst; ind_inst = INDnextInstance(ind_inst)) { if((lmeter_node == ind_inst->INDposNode) || (lmeter_node == ind_inst->INDnegNode)) { l = 1.0 / ( (1.0 / l) + (1.0 / ind_inst->INDinduct) ); } } } /* ***************************************************************** */ /* Look for inductors connected through zero-valued voltage sources */ /* ***************************************************************** */ /* Get the head of the list of voltage source models in the circuit */ vsrc_type = INPtypelook("Vsource"); if(vsrc_type < 0) { printf("\nERROR - Vsource type not supported in this binary\n"); return(0); } vsrc_head = (VSRCmodel *) ckt->CKThead[vsrc_type]; /* Scan through all voltage source instances and add in values */ /* of any inductors connected to lmeter input through voltage source */ for(vsrc_model = vsrc_head; vsrc_model; vsrc_model = VSRCnextModel(vsrc_model)) { for(vsrc_inst = VSRCinstances(vsrc_model); vsrc_inst; vsrc_inst = VSRCnextInstance(vsrc_inst)) { /* Skip to next if not DC source with value = 0.0 */ if((vsrc_inst->VSRCfunctionType != 0) || (vsrc_inst->VSRCdcValue != 0.0)) continue; /* See if voltage source is connected to lmeter input */ /* If so, get other node voltage source is connected to */ /* If not, skip to next source */ if(lmeter_node == vsrc_inst->VSRCposNode) vsrc_node = vsrc_inst->VSRCnegNode; else if(lmeter_node == vsrc_inst->VSRCnegNode) vsrc_node = vsrc_inst->VSRCposNode; else continue; /* Scan through all inductor instances and add in values */ /* of any inductors connected to the voltage source node */ for(ind_model = ind_head; ind_model; ind_model = INDnextModel(ind_model)) { for(ind_inst = INDinstances(ind_model); ind_inst; ind_inst = INDnextInstance(ind_inst)) { if((vsrc_node == ind_inst->INDposNode) || (vsrc_node == ind_inst->INDnegNode)) { l = 1.0 / ( (1.0 / l) + (1.0 / ind_inst->INDinduct) ); } } } } /* end for all vsrc instances */ } /* end for all vsrc models */ /* Return the total capacitance value */ return(l); }
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 }
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 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)); }