luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rewrite `TSTALLOC()' macro for auto indentation 

checked for object code invariance
This commit is contained in:
rlar 2013-06-06 22:24:22 +02:00
parent 8f1e92503a
commit 5a4ff7dea5
55 changed files with 1473 additions and 1473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/spicelib/devices/asrc/asrcset.c
View File

@ -54,14 +54,14 @@ ASRCsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
#define MY_TSTALLOC(ptr,first,second) \ #define MY_TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, (second)->number)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, (second)->number)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
/* For each controlling variable set the entries /* For each controlling variable set the entries
in the vector of the positions of the SMP */ in the vector of the positions of the SMP */

50
src/spicelib/devices/bjt/bjtsetup.c
View File

@ -420,28 +420,28 @@ BJTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BJTcolColPrimePtr,BJTcolNode,BJTcolPrimeNode) TSTALLOC(BJTcolColPrimePtr,BJTcolNode,BJTcolPrimeNode);
TSTALLOC(BJTbaseBasePrimePtr,BJTbaseNode,BJTbasePrimeNode) TSTALLOC(BJTbaseBasePrimePtr,BJTbaseNode,BJTbasePrimeNode);
TSTALLOC(BJTemitEmitPrimePtr,BJTemitNode,BJTemitPrimeNode) TSTALLOC(BJTemitEmitPrimePtr,BJTemitNode,BJTemitPrimeNode);
TSTALLOC(BJTcolPrimeColPtr,BJTcolPrimeNode,BJTcolNode) TSTALLOC(BJTcolPrimeColPtr,BJTcolPrimeNode,BJTcolNode);
TSTALLOC(BJTcolPrimeBasePrimePtr,BJTcolPrimeNode,BJTbasePrimeNode) TSTALLOC(BJTcolPrimeBasePrimePtr,BJTcolPrimeNode,BJTbasePrimeNode);
TSTALLOC(BJTcolPrimeEmitPrimePtr,BJTcolPrimeNode,BJTemitPrimeNode) TSTALLOC(BJTcolPrimeEmitPrimePtr,BJTcolPrimeNode,BJTemitPrimeNode);
TSTALLOC(BJTbasePrimeBasePtr,BJTbasePrimeNode,BJTbaseNode) TSTALLOC(BJTbasePrimeBasePtr,BJTbasePrimeNode,BJTbaseNode);
TSTALLOC(BJTbasePrimeColPrimePtr,BJTbasePrimeNode,BJTcolPrimeNode) TSTALLOC(BJTbasePrimeColPrimePtr,BJTbasePrimeNode,BJTcolPrimeNode);
TSTALLOC(BJTbasePrimeEmitPrimePtr,BJTbasePrimeNode,BJTemitPrimeNode) TSTALLOC(BJTbasePrimeEmitPrimePtr,BJTbasePrimeNode,BJTemitPrimeNode);
TSTALLOC(BJTemitPrimeEmitPtr,BJTemitPrimeNode,BJTemitNode) TSTALLOC(BJTemitPrimeEmitPtr,BJTemitPrimeNode,BJTemitNode);
TSTALLOC(BJTemitPrimeColPrimePtr,BJTemitPrimeNode,BJTcolPrimeNode) TSTALLOC(BJTemitPrimeColPrimePtr,BJTemitPrimeNode,BJTcolPrimeNode);
TSTALLOC(BJTemitPrimeBasePrimePtr,BJTemitPrimeNode,BJTbasePrimeNode) TSTALLOC(BJTemitPrimeBasePrimePtr,BJTemitPrimeNode,BJTbasePrimeNode);
TSTALLOC(BJTcolColPtr,BJTcolNode,BJTcolNode) TSTALLOC(BJTcolColPtr,BJTcolNode,BJTcolNode);
TSTALLOC(BJTbaseBasePtr,BJTbaseNode,BJTbaseNode) TSTALLOC(BJTbaseBasePtr,BJTbaseNode,BJTbaseNode);
TSTALLOC(BJTemitEmitPtr,BJTemitNode,BJTemitNode) TSTALLOC(BJTemitEmitPtr,BJTemitNode,BJTemitNode);
TSTALLOC(BJTcolPrimeColPrimePtr,BJTcolPrimeNode,BJTcolPrimeNode) TSTALLOC(BJTcolPrimeColPrimePtr,BJTcolPrimeNode,BJTcolPrimeNode);
TSTALLOC(BJTbasePrimeBasePrimePtr,BJTbasePrimeNode,BJTbasePrimeNode) TSTALLOC(BJTbasePrimeBasePrimePtr,BJTbasePrimeNode,BJTbasePrimeNode);
TSTALLOC(BJTemitPrimeEmitPrimePtr,BJTemitPrimeNode,BJTemitPrimeNode) TSTALLOC(BJTemitPrimeEmitPrimePtr,BJTemitPrimeNode,BJTemitPrimeNode);
TSTALLOC(BJTsubstSubstPtr,BJTsubstNode,BJTsubstNode) TSTALLOC(BJTsubstSubstPtr,BJTsubstNode,BJTsubstNode);
if (model -> BJTsubs == LATERAL) { if (model -> BJTsubs == LATERAL) {
here -> BJTsubstConNode = here -> BJTbasePrimeNode; here -> BJTsubstConNode = here -> BJTbasePrimeNode;
here -> BJTsubstConSubstConPtr = here -> BJTbasePrimeBasePrimePtr; here -> BJTsubstConSubstConPtr = here -> BJTbasePrimeBasePrimePtr;
@ -449,10 +449,10 @@ if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
here -> BJTsubstConNode = here -> BJTcolPrimeNode; here -> BJTsubstConNode = here -> BJTcolPrimeNode;
here -> BJTsubstConSubstConPtr = here -> BJTcolPrimeColPrimePtr; here -> BJTsubstConSubstConPtr = here -> BJTcolPrimeColPrimePtr;
} }
TSTALLOC(BJTsubstConSubstPtr,BJTsubstConNode,BJTsubstNode) TSTALLOC(BJTsubstConSubstPtr,BJTsubstConNode,BJTsubstNode);
TSTALLOC(BJTsubstSubstConPtr,BJTsubstNode,BJTsubstConNode) TSTALLOC(BJTsubstSubstConPtr,BJTsubstNode,BJTsubstConNode);
TSTALLOC(BJTbaseColPrimePtr,BJTbaseNode,BJTcolPrimeNode) TSTALLOC(BJTbaseColPrimePtr,BJTbaseNode,BJTcolPrimeNode);
TSTALLOC(BJTcolPrimeBasePtr,BJTcolPrimeNode,BJTbaseNode) TSTALLOC(BJTcolPrimeBasePtr,BJTcolPrimeNode,BJTbaseNode);
} }
} }
return(OK); return(OK);

48
src/spicelib/devices/bsim1/b1set.c
View File

@ -368,32 +368,32 @@ B1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(B1DdPtr, B1dNode, B1dNode) TSTALLOC(B1DdPtr, B1dNode, B1dNode);
TSTALLOC(B1GgPtr, B1gNode, B1gNode) TSTALLOC(B1GgPtr, B1gNode, B1gNode);
TSTALLOC(B1SsPtr, B1sNode, B1sNode) TSTALLOC(B1SsPtr, B1sNode, B1sNode);
TSTALLOC(B1BbPtr, B1bNode, B1bNode) TSTALLOC(B1BbPtr, B1bNode, B1bNode);
TSTALLOC(B1DPdpPtr, B1dNodePrime, B1dNodePrime) TSTALLOC(B1DPdpPtr, B1dNodePrime, B1dNodePrime);
TSTALLOC(B1SPspPtr, B1sNodePrime, B1sNodePrime) TSTALLOC(B1SPspPtr, B1sNodePrime, B1sNodePrime);
TSTALLOC(B1DdpPtr, B1dNode, B1dNodePrime) TSTALLOC(B1DdpPtr, B1dNode, B1dNodePrime);
TSTALLOC(B1GbPtr, B1gNode, B1bNode) TSTALLOC(B1GbPtr, B1gNode, B1bNode);
TSTALLOC(B1GdpPtr, B1gNode, B1dNodePrime) TSTALLOC(B1GdpPtr, B1gNode, B1dNodePrime);
TSTALLOC(B1GspPtr, B1gNode, B1sNodePrime) TSTALLOC(B1GspPtr, B1gNode, B1sNodePrime);
TSTALLOC(B1SspPtr, B1sNode, B1sNodePrime) TSTALLOC(B1SspPtr, B1sNode, B1sNodePrime);
TSTALLOC(B1BdpPtr, B1bNode, B1dNodePrime) TSTALLOC(B1BdpPtr, B1bNode, B1dNodePrime);
TSTALLOC(B1BspPtr, B1bNode, B1sNodePrime) TSTALLOC(B1BspPtr, B1bNode, B1sNodePrime);
TSTALLOC(B1DPspPtr, B1dNodePrime, B1sNodePrime) TSTALLOC(B1DPspPtr, B1dNodePrime, B1sNodePrime);
TSTALLOC(B1DPdPtr, B1dNodePrime, B1dNode) TSTALLOC(B1DPdPtr, B1dNodePrime, B1dNode);
TSTALLOC(B1BgPtr, B1bNode, B1gNode) TSTALLOC(B1BgPtr, B1bNode, B1gNode);
TSTALLOC(B1DPgPtr, B1dNodePrime, B1gNode) TSTALLOC(B1DPgPtr, B1dNodePrime, B1gNode);
TSTALLOC(B1SPgPtr, B1sNodePrime, B1gNode) TSTALLOC(B1SPgPtr, B1sNodePrime, B1gNode);
TSTALLOC(B1SPsPtr, B1sNodePrime, B1sNode) TSTALLOC(B1SPsPtr, B1sNodePrime, B1sNode);
TSTALLOC(B1DPbPtr, B1dNodePrime, B1bNode) TSTALLOC(B1DPbPtr, B1dNodePrime, B1bNode);
TSTALLOC(B1SPbPtr, B1sNodePrime, B1bNode) TSTALLOC(B1SPbPtr, B1sNodePrime, B1bNode);
TSTALLOC(B1SPdpPtr, B1sNodePrime, B1dNodePrime) TSTALLOC(B1SPdpPtr, B1sNodePrime, B1dNodePrime);
} }
} }

48
src/spicelib/devices/bsim2/b2set.c
View File

@ -535,32 +535,32 @@ B2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(B2DdPtr, B2dNode, B2dNode) TSTALLOC(B2DdPtr, B2dNode, B2dNode);
TSTALLOC(B2GgPtr, B2gNode, B2gNode) TSTALLOC(B2GgPtr, B2gNode, B2gNode);
TSTALLOC(B2SsPtr, B2sNode, B2sNode) TSTALLOC(B2SsPtr, B2sNode, B2sNode);
TSTALLOC(B2BbPtr, B2bNode, B2bNode) TSTALLOC(B2BbPtr, B2bNode, B2bNode);
TSTALLOC(B2DPdpPtr, B2dNodePrime, B2dNodePrime) TSTALLOC(B2DPdpPtr, B2dNodePrime, B2dNodePrime);
TSTALLOC(B2SPspPtr, B2sNodePrime, B2sNodePrime) TSTALLOC(B2SPspPtr, B2sNodePrime, B2sNodePrime);
TSTALLOC(B2DdpPtr, B2dNode, B2dNodePrime) TSTALLOC(B2DdpPtr, B2dNode, B2dNodePrime);
TSTALLOC(B2GbPtr, B2gNode, B2bNode) TSTALLOC(B2GbPtr, B2gNode, B2bNode);
TSTALLOC(B2GdpPtr, B2gNode, B2dNodePrime) TSTALLOC(B2GdpPtr, B2gNode, B2dNodePrime);
TSTALLOC(B2GspPtr, B2gNode, B2sNodePrime) TSTALLOC(B2GspPtr, B2gNode, B2sNodePrime);
TSTALLOC(B2SspPtr, B2sNode, B2sNodePrime) TSTALLOC(B2SspPtr, B2sNode, B2sNodePrime);
TSTALLOC(B2BdpPtr, B2bNode, B2dNodePrime) TSTALLOC(B2BdpPtr, B2bNode, B2dNodePrime);
TSTALLOC(B2BspPtr, B2bNode, B2sNodePrime) TSTALLOC(B2BspPtr, B2bNode, B2sNodePrime);
TSTALLOC(B2DPspPtr, B2dNodePrime, B2sNodePrime) TSTALLOC(B2DPspPtr, B2dNodePrime, B2sNodePrime);
TSTALLOC(B2DPdPtr, B2dNodePrime, B2dNode) TSTALLOC(B2DPdPtr, B2dNodePrime, B2dNode);
TSTALLOC(B2BgPtr, B2bNode, B2gNode) TSTALLOC(B2BgPtr, B2bNode, B2gNode);
TSTALLOC(B2DPgPtr, B2dNodePrime, B2gNode) TSTALLOC(B2DPgPtr, B2dNodePrime, B2gNode);
TSTALLOC(B2SPgPtr, B2sNodePrime, B2gNode) TSTALLOC(B2SPgPtr, B2sNodePrime, B2gNode);
TSTALLOC(B2SPsPtr, B2sNodePrime, B2sNode) TSTALLOC(B2SPsPtr, B2sNodePrime, B2sNode);
TSTALLOC(B2DPbPtr, B2dNodePrime, B2bNode) TSTALLOC(B2DPbPtr, B2dNodePrime, B2bNode);
TSTALLOC(B2SPbPtr, B2sNodePrime, B2bNode) TSTALLOC(B2SPbPtr, B2sNodePrime, B2bNode);
TSTALLOC(B2SPdpPtr, B2sNodePrime, B2dNodePrime) TSTALLOC(B2SPdpPtr, B2sNodePrime, B2dNodePrime);
} }
} }

66
src/spicelib/devices/bsim3/b3set.c
View File

@ -1029,43 +1029,43 @@ BSIM3instance **InstArray;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM3DdPtr, BSIM3dNode, BSIM3dNode) TSTALLOC(BSIM3DdPtr, BSIM3dNode, BSIM3dNode);
TSTALLOC(BSIM3GgPtr, BSIM3gNode, BSIM3gNode) TSTALLOC(BSIM3GgPtr, BSIM3gNode, BSIM3gNode);
TSTALLOC(BSIM3SsPtr, BSIM3sNode, BSIM3sNode) TSTALLOC(BSIM3SsPtr, BSIM3sNode, BSIM3sNode);
TSTALLOC(BSIM3BbPtr, BSIM3bNode, BSIM3bNode) TSTALLOC(BSIM3BbPtr, BSIM3bNode, BSIM3bNode);
TSTALLOC(BSIM3DPdpPtr, BSIM3dNodePrime, BSIM3dNodePrime) TSTALLOC(BSIM3DPdpPtr, BSIM3dNodePrime, BSIM3dNodePrime);
TSTALLOC(BSIM3SPspPtr, BSIM3sNodePrime, BSIM3sNodePrime) TSTALLOC(BSIM3SPspPtr, BSIM3sNodePrime, BSIM3sNodePrime);
TSTALLOC(BSIM3DdpPtr, BSIM3dNode, BSIM3dNodePrime) TSTALLOC(BSIM3DdpPtr, BSIM3dNode, BSIM3dNodePrime);
TSTALLOC(BSIM3GbPtr, BSIM3gNode, BSIM3bNode) TSTALLOC(BSIM3GbPtr, BSIM3gNode, BSIM3bNode);
TSTALLOC(BSIM3GdpPtr, BSIM3gNode, BSIM3dNodePrime) TSTALLOC(BSIM3GdpPtr, BSIM3gNode, BSIM3dNodePrime);
TSTALLOC(BSIM3GspPtr, BSIM3gNode, BSIM3sNodePrime) TSTALLOC(BSIM3GspPtr, BSIM3gNode, BSIM3sNodePrime);
TSTALLOC(BSIM3SspPtr, BSIM3sNode, BSIM3sNodePrime) TSTALLOC(BSIM3SspPtr, BSIM3sNode, BSIM3sNodePrime);
TSTALLOC(BSIM3BdpPtr, BSIM3bNode, BSIM3dNodePrime) TSTALLOC(BSIM3BdpPtr, BSIM3bNode, BSIM3dNodePrime);
TSTALLOC(BSIM3BspPtr, BSIM3bNode, BSIM3sNodePrime) TSTALLOC(BSIM3BspPtr, BSIM3bNode, BSIM3sNodePrime);
TSTALLOC(BSIM3DPspPtr, BSIM3dNodePrime, BSIM3sNodePrime) TSTALLOC(BSIM3DPspPtr, BSIM3dNodePrime, BSIM3sNodePrime);
TSTALLOC(BSIM3DPdPtr, BSIM3dNodePrime, BSIM3dNode) TSTALLOC(BSIM3DPdPtr, BSIM3dNodePrime, BSIM3dNode);
TSTALLOC(BSIM3BgPtr, BSIM3bNode, BSIM3gNode) TSTALLOC(BSIM3BgPtr, BSIM3bNode, BSIM3gNode);
TSTALLOC(BSIM3DPgPtr, BSIM3dNodePrime, BSIM3gNode) TSTALLOC(BSIM3DPgPtr, BSIM3dNodePrime, BSIM3gNode);
TSTALLOC(BSIM3SPgPtr, BSIM3sNodePrime, BSIM3gNode) TSTALLOC(BSIM3SPgPtr, BSIM3sNodePrime, BSIM3gNode);
TSTALLOC(BSIM3SPsPtr, BSIM3sNodePrime, BSIM3sNode) TSTALLOC(BSIM3SPsPtr, BSIM3sNodePrime, BSIM3sNode);
TSTALLOC(BSIM3DPbPtr, BSIM3dNodePrime, BSIM3bNode) TSTALLOC(BSIM3DPbPtr, BSIM3dNodePrime, BSIM3bNode);
TSTALLOC(BSIM3SPbPtr, BSIM3sNodePrime, BSIM3bNode) TSTALLOC(BSIM3SPbPtr, BSIM3sNodePrime, BSIM3bNode);
TSTALLOC(BSIM3SPdpPtr, BSIM3sNodePrime, BSIM3dNodePrime) TSTALLOC(BSIM3SPdpPtr, BSIM3sNodePrime, BSIM3dNodePrime);
TSTALLOC(BSIM3QqPtr, BSIM3qNode, BSIM3qNode) TSTALLOC(BSIM3QqPtr, BSIM3qNode, BSIM3qNode);
TSTALLOC(BSIM3QdpPtr, BSIM3qNode, BSIM3dNodePrime) TSTALLOC(BSIM3QdpPtr, BSIM3qNode, BSIM3dNodePrime);
TSTALLOC(BSIM3QspPtr, BSIM3qNode, BSIM3sNodePrime) TSTALLOC(BSIM3QspPtr, BSIM3qNode, BSIM3sNodePrime);
TSTALLOC(BSIM3QgPtr, BSIM3qNode, BSIM3gNode) TSTALLOC(BSIM3QgPtr, BSIM3qNode, BSIM3gNode);
TSTALLOC(BSIM3QbPtr, BSIM3qNode, BSIM3bNode) TSTALLOC(BSIM3QbPtr, BSIM3qNode, BSIM3bNode);
TSTALLOC(BSIM3DPqPtr, BSIM3dNodePrime, BSIM3qNode) TSTALLOC(BSIM3DPqPtr, BSIM3dNodePrime, BSIM3qNode);
TSTALLOC(BSIM3SPqPtr, BSIM3sNodePrime, BSIM3qNode) TSTALLOC(BSIM3SPqPtr, BSIM3sNodePrime, BSIM3qNode);
TSTALLOC(BSIM3GqPtr, BSIM3gNode, BSIM3qNode) TSTALLOC(BSIM3GqPtr, BSIM3gNode, BSIM3qNode);
TSTALLOC(BSIM3BqPtr, BSIM3bNode, BSIM3qNode) TSTALLOC(BSIM3BqPtr, BSIM3bNode, BSIM3qNode);
} }
} }

190
src/spicelib/devices/bsim3soi_dd/b3soiddset.c
View File

@ -1215,129 +1215,129 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0!=0.0)) { if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0!=0.0)) {
TSTALLOC(B3SOIDDTemptempPtr, B3SOIDDtempNode, B3SOIDDtempNode) TSTALLOC(B3SOIDDTemptempPtr, B3SOIDDtempNode, B3SOIDDtempNode);
TSTALLOC(B3SOIDDTempdpPtr, B3SOIDDtempNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDTempdpPtr, B3SOIDDtempNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDTempspPtr, B3SOIDDtempNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDTempspPtr, B3SOIDDtempNode, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDTempgPtr, B3SOIDDtempNode, B3SOIDDgNode) TSTALLOC(B3SOIDDTempgPtr, B3SOIDDtempNode, B3SOIDDgNode);
TSTALLOC(B3SOIDDTempbPtr, B3SOIDDtempNode, B3SOIDDbNode) TSTALLOC(B3SOIDDTempbPtr, B3SOIDDtempNode, B3SOIDDbNode);
TSTALLOC(B3SOIDDTempePtr, B3SOIDDtempNode, B3SOIDDeNode) TSTALLOC(B3SOIDDTempePtr, B3SOIDDtempNode, B3SOIDDeNode);
TSTALLOC(B3SOIDDGtempPtr, B3SOIDDgNode, B3SOIDDtempNode) TSTALLOC(B3SOIDDGtempPtr, B3SOIDDgNode, B3SOIDDtempNode);
TSTALLOC(B3SOIDDDPtempPtr, B3SOIDDdNodePrime, B3SOIDDtempNode) TSTALLOC(B3SOIDDDPtempPtr, B3SOIDDdNodePrime, B3SOIDDtempNode);
TSTALLOC(B3SOIDDSPtempPtr, B3SOIDDsNodePrime, B3SOIDDtempNode) TSTALLOC(B3SOIDDSPtempPtr, B3SOIDDsNodePrime, B3SOIDDtempNode);
TSTALLOC(B3SOIDDEtempPtr, B3SOIDDeNode, B3SOIDDtempNode) TSTALLOC(B3SOIDDEtempPtr, B3SOIDDeNode, B3SOIDDtempNode);
TSTALLOC(B3SOIDDBtempPtr, B3SOIDDbNode, B3SOIDDtempNode) TSTALLOC(B3SOIDDBtempPtr, B3SOIDDbNode, B3SOIDDtempNode);
if (here->B3SOIDDbodyMod == 1) { if (here->B3SOIDDbodyMod == 1) {
TSTALLOC(B3SOIDDPtempPtr, B3SOIDDpNode, B3SOIDDtempNode) TSTALLOC(B3SOIDDPtempPtr, B3SOIDDpNode, B3SOIDDtempNode);
} }
} }
if (here->B3SOIDDbodyMod == 2) { if (here->B3SOIDDbodyMod == 2) {
/* Don't create any Jacobian entry for pNode */ /* Don't create any Jacobian entry for pNode */
} }
else if (here->B3SOIDDbodyMod == 1) { else if (here->B3SOIDDbodyMod == 1) {
TSTALLOC(B3SOIDDBpPtr, B3SOIDDbNode, B3SOIDDpNode) TSTALLOC(B3SOIDDBpPtr, B3SOIDDbNode, B3SOIDDpNode);
TSTALLOC(B3SOIDDPbPtr, B3SOIDDpNode, B3SOIDDbNode) TSTALLOC(B3SOIDDPbPtr, B3SOIDDpNode, B3SOIDDbNode);
TSTALLOC(B3SOIDDPpPtr, B3SOIDDpNode, B3SOIDDpNode) TSTALLOC(B3SOIDDPpPtr, B3SOIDDpNode, B3SOIDDpNode);
TSTALLOC(B3SOIDDPgPtr, B3SOIDDpNode, B3SOIDDgNode) TSTALLOC(B3SOIDDPgPtr, B3SOIDDpNode, B3SOIDDgNode);
TSTALLOC(B3SOIDDPdpPtr, B3SOIDDpNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDPdpPtr, B3SOIDDpNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDPspPtr, B3SOIDDpNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDPspPtr, B3SOIDDpNode, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDPePtr, B3SOIDDpNode, B3SOIDDeNode) TSTALLOC(B3SOIDDPePtr, B3SOIDDpNode, B3SOIDDeNode);
} }
TSTALLOC(B3SOIDDEgPtr, B3SOIDDeNode, B3SOIDDgNode) TSTALLOC(B3SOIDDEgPtr, B3SOIDDeNode, B3SOIDDgNode);
TSTALLOC(B3SOIDDEdpPtr, B3SOIDDeNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDEdpPtr, B3SOIDDeNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDEspPtr, B3SOIDDeNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDEspPtr, B3SOIDDeNode, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDGePtr, B3SOIDDgNode, B3SOIDDeNode) TSTALLOC(B3SOIDDGePtr, B3SOIDDgNode, B3SOIDDeNode);
TSTALLOC(B3SOIDDDPePtr, B3SOIDDdNodePrime, B3SOIDDeNode) TSTALLOC(B3SOIDDDPePtr, B3SOIDDdNodePrime, B3SOIDDeNode);
TSTALLOC(B3SOIDDSPePtr, B3SOIDDsNodePrime, B3SOIDDeNode) TSTALLOC(B3SOIDDSPePtr, B3SOIDDsNodePrime, B3SOIDDeNode);
TSTALLOC(B3SOIDDEbPtr, B3SOIDDeNode, B3SOIDDbNode) TSTALLOC(B3SOIDDEbPtr, B3SOIDDeNode, B3SOIDDbNode);
TSTALLOC(B3SOIDDGbPtr, B3SOIDDgNode, B3SOIDDbNode) TSTALLOC(B3SOIDDGbPtr, B3SOIDDgNode, B3SOIDDbNode);
TSTALLOC(B3SOIDDDPbPtr, B3SOIDDdNodePrime, B3SOIDDbNode) TSTALLOC(B3SOIDDDPbPtr, B3SOIDDdNodePrime, B3SOIDDbNode);
TSTALLOC(B3SOIDDSPbPtr, B3SOIDDsNodePrime, B3SOIDDbNode) TSTALLOC(B3SOIDDSPbPtr, B3SOIDDsNodePrime, B3SOIDDbNode);
TSTALLOC(B3SOIDDBePtr, B3SOIDDbNode, B3SOIDDeNode) TSTALLOC(B3SOIDDBePtr, B3SOIDDbNode, B3SOIDDeNode);
TSTALLOC(B3SOIDDBgPtr, B3SOIDDbNode, B3SOIDDgNode) TSTALLOC(B3SOIDDBgPtr, B3SOIDDbNode, B3SOIDDgNode);
TSTALLOC(B3SOIDDBdpPtr, B3SOIDDbNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDBdpPtr, B3SOIDDbNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDBspPtr, B3SOIDDbNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDBspPtr, B3SOIDDbNode, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDBbPtr, B3SOIDDbNode, B3SOIDDbNode) TSTALLOC(B3SOIDDBbPtr, B3SOIDDbNode, B3SOIDDbNode);
TSTALLOC(B3SOIDDEePtr, B3SOIDDeNode, B3SOIDDeNode) TSTALLOC(B3SOIDDEePtr, B3SOIDDeNode, B3SOIDDeNode);
TSTALLOC(B3SOIDDGgPtr, B3SOIDDgNode, B3SOIDDgNode) TSTALLOC(B3SOIDDGgPtr, B3SOIDDgNode, B3SOIDDgNode);
TSTALLOC(B3SOIDDGdpPtr, B3SOIDDgNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDGdpPtr, B3SOIDDgNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDGspPtr, B3SOIDDgNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDGspPtr, B3SOIDDgNode, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDDPgPtr, B3SOIDDdNodePrime, B3SOIDDgNode) TSTALLOC(B3SOIDDDPgPtr, B3SOIDDdNodePrime, B3SOIDDgNode);
TSTALLOC(B3SOIDDDPdpPtr, B3SOIDDdNodePrime, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDDPdpPtr, B3SOIDDdNodePrime, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDDPspPtr, B3SOIDDdNodePrime, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDDPspPtr, B3SOIDDdNodePrime, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDDPdPtr, B3SOIDDdNodePrime, B3SOIDDdNode) TSTALLOC(B3SOIDDDPdPtr, B3SOIDDdNodePrime, B3SOIDDdNode);
TSTALLOC(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode) TSTALLOC(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode);
TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode) TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode);
TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode) TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode);
TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime) TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDSsPtr, B3SOIDDsNode, B3SOIDDsNode) TSTALLOC(B3SOIDDSsPtr, B3SOIDDsNode, B3SOIDDsNode);
TSTALLOC(B3SOIDDSspPtr, B3SOIDDsNode, B3SOIDDsNodePrime) TSTALLOC(B3SOIDDSspPtr, B3SOIDDsNode, B3SOIDDsNodePrime);
/* here for debugging purpose only */ /* here for debugging purpose only */
if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1)) if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1))
{ {
TSTALLOC(B3SOIDDVbsPtr, B3SOIDDvbsNode, B3SOIDDvbsNode) TSTALLOC(B3SOIDDVbsPtr, B3SOIDDvbsNode, B3SOIDDvbsNode) ;
TSTALLOC(B3SOIDDIdsPtr, B3SOIDDidsNode, B3SOIDDidsNode) TSTALLOC(B3SOIDDIdsPtr, B3SOIDDidsNode, B3SOIDDidsNode);
TSTALLOC(B3SOIDDIcPtr, B3SOIDDicNode, B3SOIDDicNode) TSTALLOC(B3SOIDDIcPtr, B3SOIDDicNode, B3SOIDDicNode);
TSTALLOC(B3SOIDDIbsPtr, B3SOIDDibsNode, B3SOIDDibsNode) TSTALLOC(B3SOIDDIbsPtr, B3SOIDDibsNode, B3SOIDDibsNode);
TSTALLOC(B3SOIDDIbdPtr, B3SOIDDibdNode, B3SOIDDibdNode) TSTALLOC(B3SOIDDIbdPtr, B3SOIDDibdNode, B3SOIDDibdNode);
TSTALLOC(B3SOIDDIiiPtr, B3SOIDDiiiNode, B3SOIDDiiiNode) TSTALLOC(B3SOIDDIiiPtr, B3SOIDDiiiNode, B3SOIDDiiiNode);
TSTALLOC(B3SOIDDIgidlPtr, B3SOIDDigidlNode, B3SOIDDigidlNode) TSTALLOC(B3SOIDDIgidlPtr, B3SOIDDigidlNode, B3SOIDDigidlNode);
TSTALLOC(B3SOIDDItunPtr, B3SOIDDitunNode, B3SOIDDitunNode) TSTALLOC(B3SOIDDItunPtr, B3SOIDDitunNode, B3SOIDDitunNode);
TSTALLOC(B3SOIDDIbpPtr, B3SOIDDibpNode, B3SOIDDibpNode) TSTALLOC(B3SOIDDIbpPtr, B3SOIDDibpNode, B3SOIDDibpNode);
TSTALLOC(B3SOIDDAbeffPtr, B3SOIDDabeffNode, B3SOIDDabeffNode) TSTALLOC(B3SOIDDAbeffPtr, B3SOIDDabeffNode, B3SOIDDabeffNode);
TSTALLOC(B3SOIDDVbs0effPtr, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode) TSTALLOC(B3SOIDDVbs0effPtr, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode);
TSTALLOC(B3SOIDDVbseffPtr, B3SOIDDvbseffNode, B3SOIDDvbseffNode) TSTALLOC(B3SOIDDVbseffPtr, B3SOIDDvbseffNode, B3SOIDDvbseffNode);
TSTALLOC(B3SOIDDXcPtr, B3SOIDDxcNode, B3SOIDDxcNode) TSTALLOC(B3SOIDDXcPtr, B3SOIDDxcNode, B3SOIDDxcNode);
TSTALLOC(B3SOIDDCbbPtr, B3SOIDDcbbNode, B3SOIDDcbbNode) TSTALLOC(B3SOIDDCbbPtr, B3SOIDDcbbNode, B3SOIDDcbbNode);
TSTALLOC(B3SOIDDCbdPtr, B3SOIDDcbdNode, B3SOIDDcbdNode) TSTALLOC(B3SOIDDCbdPtr, B3SOIDDcbdNode, B3SOIDDcbdNode);
TSTALLOC(B3SOIDDCbgPtr, B3SOIDDcbgNode, B3SOIDDcbgNode) TSTALLOC(B3SOIDDCbgPtr, B3SOIDDcbgNode, B3SOIDDcbgNode);
TSTALLOC(B3SOIDDqbPtr, B3SOIDDqbNode, B3SOIDDqbNode) TSTALLOC(B3SOIDDqbPtr, B3SOIDDqbNode, B3SOIDDqbNode);
TSTALLOC(B3SOIDDQbfPtr, B3SOIDDqbfNode, B3SOIDDqbfNode) TSTALLOC(B3SOIDDQbfPtr, B3SOIDDqbfNode, B3SOIDDqbfNode);
TSTALLOC(B3SOIDDQjsPtr, B3SOIDDqjsNode, B3SOIDDqjsNode) TSTALLOC(B3SOIDDQjsPtr, B3SOIDDqjsNode, B3SOIDDqjsNode);
TSTALLOC(B3SOIDDQjdPtr, B3SOIDDqjdNode, B3SOIDDqjdNode) TSTALLOC(B3SOIDDQjdPtr, B3SOIDDqjdNode, B3SOIDDqjdNode);
/* clean up last */ /* clean up last */
TSTALLOC(B3SOIDDGmPtr, B3SOIDDgmNode, B3SOIDDgmNode) TSTALLOC(B3SOIDDGmPtr, B3SOIDDgmNode, B3SOIDDgmNode);
TSTALLOC(B3SOIDDGmbsPtr, B3SOIDDgmbsNode, B3SOIDDgmbsNode) TSTALLOC(B3SOIDDGmbsPtr, B3SOIDDgmbsNode, B3SOIDDgmbsNode);
TSTALLOC(B3SOIDDGdsPtr, B3SOIDDgdsNode, B3SOIDDgdsNode) TSTALLOC(B3SOIDDGdsPtr, B3SOIDDgdsNode, B3SOIDDgdsNode);
TSTALLOC(B3SOIDDGmePtr, B3SOIDDgmeNode, B3SOIDDgmeNode) TSTALLOC(B3SOIDDGmePtr, B3SOIDDgmeNode, B3SOIDDgmeNode);
TSTALLOC(B3SOIDDVbs0teffPtr, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode) TSTALLOC(B3SOIDDVbs0teffPtr, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode);
TSTALLOC(B3SOIDDVthPtr, B3SOIDDvthNode, B3SOIDDvthNode) TSTALLOC(B3SOIDDVthPtr, B3SOIDDvthNode, B3SOIDDvthNode);
TSTALLOC(B3SOIDDVgsteffPtr, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode) TSTALLOC(B3SOIDDVgsteffPtr, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode);
TSTALLOC(B3SOIDDXcsatPtr, B3SOIDDxcsatNode, B3SOIDDxcsatNode) TSTALLOC(B3SOIDDXcsatPtr, B3SOIDDxcsatNode, B3SOIDDxcsatNode);
TSTALLOC(B3SOIDDVcscvPtr, B3SOIDDvcscvNode, B3SOIDDvcscvNode) TSTALLOC(B3SOIDDVcscvPtr, B3SOIDDvcscvNode, B3SOIDDvcscvNode);
TSTALLOC(B3SOIDDVdscvPtr, B3SOIDDvdscvNode, B3SOIDDvdscvNode) TSTALLOC(B3SOIDDVdscvPtr, B3SOIDDvdscvNode, B3SOIDDvdscvNode);
TSTALLOC(B3SOIDDCbePtr, B3SOIDDcbeNode, B3SOIDDcbeNode) TSTALLOC(B3SOIDDCbePtr, B3SOIDDcbeNode, B3SOIDDcbeNode);
TSTALLOC(B3SOIDDDum1Ptr, B3SOIDDdum1Node, B3SOIDDdum1Node) TSTALLOC(B3SOIDDDum1Ptr, B3SOIDDdum1Node, B3SOIDDdum1Node);
TSTALLOC(B3SOIDDDum2Ptr, B3SOIDDdum2Node, B3SOIDDdum2Node) TSTALLOC(B3SOIDDDum2Ptr, B3SOIDDdum2Node, B3SOIDDdum2Node);
TSTALLOC(B3SOIDDDum3Ptr, B3SOIDDdum3Node, B3SOIDDdum3Node) TSTALLOC(B3SOIDDDum3Ptr, B3SOIDDdum3Node, B3SOIDDdum3Node);
TSTALLOC(B3SOIDDDum4Ptr, B3SOIDDdum4Node, B3SOIDDdum4Node) TSTALLOC(B3SOIDDDum4Ptr, B3SOIDDdum4Node, B3SOIDDdum4Node);
TSTALLOC(B3SOIDDDum5Ptr, B3SOIDDdum5Node, B3SOIDDdum5Node) TSTALLOC(B3SOIDDDum5Ptr, B3SOIDDdum5Node, B3SOIDDdum5Node);
TSTALLOC(B3SOIDDQaccPtr, B3SOIDDqaccNode, B3SOIDDqaccNode) TSTALLOC(B3SOIDDQaccPtr, B3SOIDDqaccNode, B3SOIDDqaccNode);
TSTALLOC(B3SOIDDQsub0Ptr, B3SOIDDqsub0Node, B3SOIDDqsub0Node) TSTALLOC(B3SOIDDQsub0Ptr, B3SOIDDqsub0Node, B3SOIDDqsub0Node);
TSTALLOC(B3SOIDDQsubs1Ptr, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node) TSTALLOC(B3SOIDDQsubs1Ptr, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node);
TSTALLOC(B3SOIDDQsubs2Ptr, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node) TSTALLOC(B3SOIDDQsubs2Ptr, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node);
TSTALLOC(B3SOIDDqePtr, B3SOIDDqeNode, B3SOIDDqeNode) TSTALLOC(B3SOIDDqePtr, B3SOIDDqeNode, B3SOIDDqeNode);
TSTALLOC(B3SOIDDqdPtr, B3SOIDDqdNode, B3SOIDDqdNode) TSTALLOC(B3SOIDDqdPtr, B3SOIDDqdNode, B3SOIDDqdNode);
TSTALLOC(B3SOIDDqgPtr, B3SOIDDqgNode, B3SOIDDqgNode) TSTALLOC(B3SOIDDqgPtr, B3SOIDDqgNode, B3SOIDDqgNode);
} }
} }

174
src/spicelib/devices/bsim3soi_fd/b3soifdset.c
View File

@ -1213,120 +1213,120 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0!=0.0)) { if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0!=0.0)) {
TSTALLOC(B3SOIFDTemptempPtr, B3SOIFDtempNode, B3SOIFDtempNode) TSTALLOC(B3SOIFDTemptempPtr, B3SOIFDtempNode, B3SOIFDtempNode);
TSTALLOC(B3SOIFDTempdpPtr, B3SOIFDtempNode, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDTempdpPtr, B3SOIFDtempNode, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDTempspPtr, B3SOIFDtempNode, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDTempspPtr, B3SOIFDtempNode, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDTempgPtr, B3SOIFDtempNode, B3SOIFDgNode) TSTALLOC(B3SOIFDTempgPtr, B3SOIFDtempNode, B3SOIFDgNode);
TSTALLOC(B3SOIFDTempbPtr, B3SOIFDtempNode, B3SOIFDbNode) TSTALLOC(B3SOIFDTempbPtr, B3SOIFDtempNode, B3SOIFDbNode);
TSTALLOC(B3SOIFDTempePtr, B3SOIFDtempNode, B3SOIFDeNode) TSTALLOC(B3SOIFDTempePtr, B3SOIFDtempNode, B3SOIFDeNode);
TSTALLOC(B3SOIFDGtempPtr, B3SOIFDgNode, B3SOIFDtempNode) TSTALLOC(B3SOIFDGtempPtr, B3SOIFDgNode, B3SOIFDtempNode);
TSTALLOC(B3SOIFDDPtempPtr, B3SOIFDdNodePrime, B3SOIFDtempNode) TSTALLOC(B3SOIFDDPtempPtr, B3SOIFDdNodePrime, B3SOIFDtempNode);
TSTALLOC(B3SOIFDSPtempPtr, B3SOIFDsNodePrime, B3SOIFDtempNode) TSTALLOC(B3SOIFDSPtempPtr, B3SOIFDsNodePrime, B3SOIFDtempNode);
TSTALLOC(B3SOIFDEtempPtr, B3SOIFDeNode, B3SOIFDtempNode) TSTALLOC(B3SOIFDEtempPtr, B3SOIFDeNode, B3SOIFDtempNode);
TSTALLOC(B3SOIFDBtempPtr, B3SOIFDbNode, B3SOIFDtempNode) TSTALLOC(B3SOIFDBtempPtr, B3SOIFDbNode, B3SOIFDtempNode);
if (here->B3SOIFDbodyMod == 1) { if (here->B3SOIFDbodyMod == 1) {
TSTALLOC(B3SOIFDPtempPtr, B3SOIFDpNode, B3SOIFDtempNode) TSTALLOC(B3SOIFDPtempPtr, B3SOIFDpNode, B3SOIFDtempNode);
} }
} }
if (here->B3SOIFDbodyMod == 2) { if (here->B3SOIFDbodyMod == 2) {
/* Don't create any Jacobian entry for pNode */ /* Don't create any Jacobian entry for pNode */
} }
else if (here->B3SOIFDbodyMod == 1) { else if (here->B3SOIFDbodyMod == 1) {
TSTALLOC(B3SOIFDBpPtr, B3SOIFDbNode, B3SOIFDpNode) TSTALLOC(B3SOIFDBpPtr, B3SOIFDbNode, B3SOIFDpNode);
TSTALLOC(B3SOIFDPbPtr, B3SOIFDpNode, B3SOIFDbNode) TSTALLOC(B3SOIFDPbPtr, B3SOIFDpNode, B3SOIFDbNode);
TSTALLOC(B3SOIFDPpPtr, B3SOIFDpNode, B3SOIFDpNode) TSTALLOC(B3SOIFDPpPtr, B3SOIFDpNode, B3SOIFDpNode);
TSTALLOC(B3SOIFDPgPtr, B3SOIFDpNode, B3SOIFDgNode) TSTALLOC(B3SOIFDPgPtr, B3SOIFDpNode, B3SOIFDgNode);
TSTALLOC(B3SOIFDPdpPtr, B3SOIFDpNode, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDPdpPtr, B3SOIFDpNode, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDPspPtr, B3SOIFDpNode, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDPspPtr, B3SOIFDpNode, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDPePtr, B3SOIFDpNode, B3SOIFDeNode) TSTALLOC(B3SOIFDPePtr, B3SOIFDpNode, B3SOIFDeNode);
} }
TSTALLOC(B3SOIFDEgPtr, B3SOIFDeNode, B3SOIFDgNode) TSTALLOC(B3SOIFDEgPtr, B3SOIFDeNode, B3SOIFDgNode);
TSTALLOC(B3SOIFDEdpPtr, B3SOIFDeNode, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDEdpPtr, B3SOIFDeNode, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDEspPtr, B3SOIFDeNode, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDEspPtr, B3SOIFDeNode, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDGePtr, B3SOIFDgNode, B3SOIFDeNode) TSTALLOC(B3SOIFDGePtr, B3SOIFDgNode, B3SOIFDeNode);
TSTALLOC(B3SOIFDDPePtr, B3SOIFDdNodePrime, B3SOIFDeNode) TSTALLOC(B3SOIFDDPePtr, B3SOIFDdNodePrime, B3SOIFDeNode);
TSTALLOC(B3SOIFDSPePtr, B3SOIFDsNodePrime, B3SOIFDeNode) TSTALLOC(B3SOIFDSPePtr, B3SOIFDsNodePrime, B3SOIFDeNode);
TSTALLOC(B3SOIFDEbPtr, B3SOIFDeNode, B3SOIFDbNode) TSTALLOC(B3SOIFDEbPtr, B3SOIFDeNode, B3SOIFDbNode);
TSTALLOC(B3SOIFDEePtr, B3SOIFDeNode, B3SOIFDeNode) TSTALLOC(B3SOIFDEePtr, B3SOIFDeNode, B3SOIFDeNode);
TSTALLOC(B3SOIFDGgPtr, B3SOIFDgNode, B3SOIFDgNode) TSTALLOC(B3SOIFDGgPtr, B3SOIFDgNode, B3SOIFDgNode);
TSTALLOC(B3SOIFDGdpPtr, B3SOIFDgNode, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDGdpPtr, B3SOIFDgNode, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDGspPtr, B3SOIFDgNode, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDGspPtr, B3SOIFDgNode, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDDPgPtr, B3SOIFDdNodePrime, B3SOIFDgNode) TSTALLOC(B3SOIFDDPgPtr, B3SOIFDdNodePrime, B3SOIFDgNode);
TSTALLOC(B3SOIFDDPdpPtr, B3SOIFDdNodePrime, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDDPdpPtr, B3SOIFDdNodePrime, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDDPspPtr, B3SOIFDdNodePrime, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDDPspPtr, B3SOIFDdNodePrime, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDDPdPtr, B3SOIFDdNodePrime, B3SOIFDdNode) TSTALLOC(B3SOIFDDPdPtr, B3SOIFDdNodePrime, B3SOIFDdNode);
TSTALLOC(B3SOIFDSPgPtr, B3SOIFDsNodePrime, B3SOIFDgNode) TSTALLOC(B3SOIFDSPgPtr, B3SOIFDsNodePrime, B3SOIFDgNode);
TSTALLOC(B3SOIFDSPdpPtr, B3SOIFDsNodePrime, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDSPdpPtr, B3SOIFDsNodePrime, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDSPspPtr, B3SOIFDsNodePrime, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDSPspPtr, B3SOIFDsNodePrime, B3SOIFDsNodePrime);
TSTALLOC(B3SOIFDSPsPtr, B3SOIFDsNodePrime, B3SOIFDsNode) TSTALLOC(B3SOIFDSPsPtr, B3SOIFDsNodePrime, B3SOIFDsNode);
TSTALLOC(B3SOIFDDdPtr, B3SOIFDdNode, B3SOIFDdNode) TSTALLOC(B3SOIFDDdPtr, B3SOIFDdNode, B3SOIFDdNode);
TSTALLOC(B3SOIFDDdpPtr, B3SOIFDdNode, B3SOIFDdNodePrime) TSTALLOC(B3SOIFDDdpPtr, B3SOIFDdNode, B3SOIFDdNodePrime);
TSTALLOC(B3SOIFDSsPtr, B3SOIFDsNode, B3SOIFDsNode) TSTALLOC(B3SOIFDSsPtr, B3SOIFDsNode, B3SOIFDsNode);
TSTALLOC(B3SOIFDSspPtr, B3SOIFDsNode, B3SOIFDsNodePrime) TSTALLOC(B3SOIFDSspPtr, B3SOIFDsNode, B3SOIFDsNodePrime);
/* here for debugging purpose only */ /* here for debugging purpose only */
if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1)) if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1))
{ {
TSTALLOC(B3SOIFDVbsPtr, B3SOIFDvbsNode, B3SOIFDvbsNode) TSTALLOC(B3SOIFDVbsPtr, B3SOIFDvbsNode, B3SOIFDvbsNode) ;
TSTALLOC(B3SOIFDIdsPtr, B3SOIFDidsNode, B3SOIFDidsNode) TSTALLOC(B3SOIFDIdsPtr, B3SOIFDidsNode, B3SOIFDidsNode);
TSTALLOC(B3SOIFDIcPtr, B3SOIFDicNode, B3SOIFDicNode) TSTALLOC(B3SOIFDIcPtr, B3SOIFDicNode, B3SOIFDicNode);
TSTALLOC(B3SOIFDIbsPtr, B3SOIFDibsNode, B3SOIFDibsNode) TSTALLOC(B3SOIFDIbsPtr, B3SOIFDibsNode, B3SOIFDibsNode);
TSTALLOC(B3SOIFDIbdPtr, B3SOIFDibdNode, B3SOIFDibdNode) TSTALLOC(B3SOIFDIbdPtr, B3SOIFDibdNode, B3SOIFDibdNode);
TSTALLOC(B3SOIFDIiiPtr, B3SOIFDiiiNode, B3SOIFDiiiNode) TSTALLOC(B3SOIFDIiiPtr, B3SOIFDiiiNode, B3SOIFDiiiNode);
TSTALLOC(B3SOIFDIgidlPtr, B3SOIFDigidlNode, B3SOIFDigidlNode) TSTALLOC(B3SOIFDIgidlPtr, B3SOIFDigidlNode, B3SOIFDigidlNode);
TSTALLOC(B3SOIFDItunPtr, B3SOIFDitunNode, B3SOIFDitunNode) TSTALLOC(B3SOIFDItunPtr, B3SOIFDitunNode, B3SOIFDitunNode);
TSTALLOC(B3SOIFDIbpPtr, B3SOIFDibpNode, B3SOIFDibpNode) TSTALLOC(B3SOIFDIbpPtr, B3SOIFDibpNode, B3SOIFDibpNode);
TSTALLOC(B3SOIFDAbeffPtr, B3SOIFDabeffNode, B3SOIFDabeffNode) TSTALLOC(B3SOIFDAbeffPtr, B3SOIFDabeffNode, B3SOIFDabeffNode);
TSTALLOC(B3SOIFDVbs0effPtr, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode) TSTALLOC(B3SOIFDVbs0effPtr, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode);
TSTALLOC(B3SOIFDVbseffPtr, B3SOIFDvbseffNode, B3SOIFDvbseffNode) TSTALLOC(B3SOIFDVbseffPtr, B3SOIFDvbseffNode, B3SOIFDvbseffNode);
TSTALLOC(B3SOIFDXcPtr, B3SOIFDxcNode, B3SOIFDxcNode) TSTALLOC(B3SOIFDXcPtr, B3SOIFDxcNode, B3SOIFDxcNode);
TSTALLOC(B3SOIFDCbbPtr, B3SOIFDcbbNode, B3SOIFDcbbNode) TSTALLOC(B3SOIFDCbbPtr, B3SOIFDcbbNode, B3SOIFDcbbNode);
TSTALLOC(B3SOIFDCbdPtr, B3SOIFDcbdNode, B3SOIFDcbdNode) TSTALLOC(B3SOIFDCbdPtr, B3SOIFDcbdNode, B3SOIFDcbdNode);
TSTALLOC(B3SOIFDCbgPtr, B3SOIFDcbgNode, B3SOIFDcbgNode) TSTALLOC(B3SOIFDCbgPtr, B3SOIFDcbgNode, B3SOIFDcbgNode);
TSTALLOC(B3SOIFDqbPtr, B3SOIFDqbNode, B3SOIFDqbNode) TSTALLOC(B3SOIFDqbPtr, B3SOIFDqbNode, B3SOIFDqbNode);
TSTALLOC(B3SOIFDQbfPtr, B3SOIFDqbfNode, B3SOIFDqbfNode) TSTALLOC(B3SOIFDQbfPtr, B3SOIFDqbfNode, B3SOIFDqbfNode);
TSTALLOC(B3SOIFDQjsPtr, B3SOIFDqjsNode, B3SOIFDqjsNode) TSTALLOC(B3SOIFDQjsPtr, B3SOIFDqjsNode, B3SOIFDqjsNode);
TSTALLOC(B3SOIFDQjdPtr, B3SOIFDqjdNode, B3SOIFDqjdNode) TSTALLOC(B3SOIFDQjdPtr, B3SOIFDqjdNode, B3SOIFDqjdNode);
/* clean up last */ /* clean up last */
TSTALLOC(B3SOIFDGmPtr, B3SOIFDgmNode, B3SOIFDgmNode) TSTALLOC(B3SOIFDGmPtr, B3SOIFDgmNode, B3SOIFDgmNode);
TSTALLOC(B3SOIFDGmbsPtr, B3SOIFDgmbsNode, B3SOIFDgmbsNode) TSTALLOC(B3SOIFDGmbsPtr, B3SOIFDgmbsNode, B3SOIFDgmbsNode);
TSTALLOC(B3SOIFDGdsPtr, B3SOIFDgdsNode, B3SOIFDgdsNode) TSTALLOC(B3SOIFDGdsPtr, B3SOIFDgdsNode, B3SOIFDgdsNode);
TSTALLOC(B3SOIFDGmePtr, B3SOIFDgmeNode, B3SOIFDgmeNode) TSTALLOC(B3SOIFDGmePtr, B3SOIFDgmeNode, B3SOIFDgmeNode);
TSTALLOC(B3SOIFDVbs0teffPtr, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode) TSTALLOC(B3SOIFDVbs0teffPtr, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode);
TSTALLOC(B3SOIFDVthPtr, B3SOIFDvthNode, B3SOIFDvthNode) TSTALLOC(B3SOIFDVthPtr, B3SOIFDvthNode, B3SOIFDvthNode);
TSTALLOC(B3SOIFDVgsteffPtr, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode) TSTALLOC(B3SOIFDVgsteffPtr, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode);
TSTALLOC(B3SOIFDXcsatPtr, B3SOIFDxcsatNode, B3SOIFDxcsatNode) TSTALLOC(B3SOIFDXcsatPtr, B3SOIFDxcsatNode, B3SOIFDxcsatNode);
TSTALLOC(B3SOIFDVcscvPtr, B3SOIFDvcscvNode, B3SOIFDvcscvNode) TSTALLOC(B3SOIFDVcscvPtr, B3SOIFDvcscvNode, B3SOIFDvcscvNode);
TSTALLOC(B3SOIFDVdscvPtr, B3SOIFDvdscvNode, B3SOIFDvdscvNode) TSTALLOC(B3SOIFDVdscvPtr, B3SOIFDvdscvNode, B3SOIFDvdscvNode);
TSTALLOC(B3SOIFDCbePtr, B3SOIFDcbeNode, B3SOIFDcbeNode) TSTALLOC(B3SOIFDCbePtr, B3SOIFDcbeNode, B3SOIFDcbeNode);
TSTALLOC(B3SOIFDDum1Ptr, B3SOIFDdum1Node, B3SOIFDdum1Node) TSTALLOC(B3SOIFDDum1Ptr, B3SOIFDdum1Node, B3SOIFDdum1Node);
TSTALLOC(B3SOIFDDum2Ptr, B3SOIFDdum2Node, B3SOIFDdum2Node) TSTALLOC(B3SOIFDDum2Ptr, B3SOIFDdum2Node, B3SOIFDdum2Node);
TSTALLOC(B3SOIFDDum3Ptr, B3SOIFDdum3Node, B3SOIFDdum3Node) TSTALLOC(B3SOIFDDum3Ptr, B3SOIFDdum3Node, B3SOIFDdum3Node);
TSTALLOC(B3SOIFDDum4Ptr, B3SOIFDdum4Node, B3SOIFDdum4Node) TSTALLOC(B3SOIFDDum4Ptr, B3SOIFDdum4Node, B3SOIFDdum4Node);
TSTALLOC(B3SOIFDDum5Ptr, B3SOIFDdum5Node, B3SOIFDdum5Node) TSTALLOC(B3SOIFDDum5Ptr, B3SOIFDdum5Node, B3SOIFDdum5Node);
TSTALLOC(B3SOIFDQaccPtr, B3SOIFDqaccNode, B3SOIFDqaccNode) TSTALLOC(B3SOIFDQaccPtr, B3SOIFDqaccNode, B3SOIFDqaccNode);
TSTALLOC(B3SOIFDQsub0Ptr, B3SOIFDqsub0Node, B3SOIFDqsub0Node) TSTALLOC(B3SOIFDQsub0Ptr, B3SOIFDqsub0Node, B3SOIFDqsub0Node);
TSTALLOC(B3SOIFDQsubs1Ptr, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node) TSTALLOC(B3SOIFDQsubs1Ptr, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node);
TSTALLOC(B3SOIFDQsubs2Ptr, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node) TSTALLOC(B3SOIFDQsubs2Ptr, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node);
TSTALLOC(B3SOIFDqePtr, B3SOIFDqeNode, B3SOIFDqeNode) TSTALLOC(B3SOIFDqePtr, B3SOIFDqeNode, B3SOIFDqeNode);
TSTALLOC(B3SOIFDqdPtr, B3SOIFDqdNode, B3SOIFDqdNode) TSTALLOC(B3SOIFDqdPtr, B3SOIFDqdNode, B3SOIFDqdNode);
TSTALLOC(B3SOIFDqgPtr, B3SOIFDqgNode, B3SOIFDqgNode) TSTALLOC(B3SOIFDqgPtr, B3SOIFDqgNode, B3SOIFDqgNode);
} }
} }

132
src/spicelib/devices/bsim3soi_pd/b3soipdset.c
View File

@ -1347,98 +1347,98 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0!=0.0)) { if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0!=0.0)) {
TSTALLOC(B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode) TSTALLOC(B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode);
TSTALLOC(B3SOIPDTempdpPtr, B3SOIPDtempNode, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDTempdpPtr, B3SOIPDtempNode, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDTempspPtr, B3SOIPDtempNode, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDTempspPtr, B3SOIPDtempNode, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDTempgPtr, B3SOIPDtempNode, B3SOIPDgNode) TSTALLOC(B3SOIPDTempgPtr, B3SOIPDtempNode, B3SOIPDgNode);
TSTALLOC(B3SOIPDTempbPtr, B3SOIPDtempNode, B3SOIPDbNode) TSTALLOC(B3SOIPDTempbPtr, B3SOIPDtempNode, B3SOIPDbNode);
TSTALLOC(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode) TSTALLOC(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode);
TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode) TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode);
TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode) TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode);
TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode) TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode);
TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode) TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode);
if (here->B3SOIPDbodyMod == 1) { if (here->B3SOIPDbodyMod == 1) {
TSTALLOC(B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode) TSTALLOC(B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode);
} }
} }
if (here->B3SOIPDbodyMod == 2) { if (here->B3SOIPDbodyMod == 2) {
/* Don't create any Jacobian entry for pNode */ /* Don't create any Jacobian entry for pNode */
} }
else if (here->B3SOIPDbodyMod == 1) { else if (here->B3SOIPDbodyMod == 1) {
TSTALLOC(B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode) TSTALLOC(B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode);
TSTALLOC(B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode) TSTALLOC(B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode);
TSTALLOC(B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode) TSTALLOC(B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode);
} }
TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode) TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode);
TSTALLOC(B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode) TSTALLOC(B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode);
TSTALLOC(B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode) TSTALLOC(B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode);
TSTALLOC(B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode) TSTALLOC(B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode);
TSTALLOC(B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode) TSTALLOC(B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode);
TSTALLOC(B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode) TSTALLOC(B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode);
TSTALLOC(B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode) TSTALLOC(B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode);
TSTALLOC(B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode) TSTALLOC(B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode);
TSTALLOC(B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode) TSTALLOC(B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode);
TSTALLOC(B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode) TSTALLOC(B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode);
TSTALLOC(B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode) TSTALLOC(B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode);
TSTALLOC(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode) TSTALLOC(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode);
TSTALLOC(B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode) TSTALLOC(B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode);
TSTALLOC(B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode) TSTALLOC(B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode);
TSTALLOC(B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode) TSTALLOC(B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode);
TSTALLOC(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode) TSTALLOC(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode);
TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode) TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode);
TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode) TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode);
TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime) TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode) TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode);
TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime) TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime);
/* here for debugging purpose only */ /* here for debugging purpose only */
if (here->B3SOIPDdebugMod != 0) if (here->B3SOIPDdebugMod != 0)
{ {
TSTALLOC(B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode) TSTALLOC(B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode);
TSTALLOC(B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode) TSTALLOC(B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode);
TSTALLOC(B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode) TSTALLOC(B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode);
TSTALLOC(B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode) TSTALLOC(B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode);
TSTALLOC(B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode) TSTALLOC(B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode);
TSTALLOC(B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode) TSTALLOC(B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode);
TSTALLOC(B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode) TSTALLOC(B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode);
TSTALLOC(B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode) TSTALLOC(B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode);
TSTALLOC(B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode) TSTALLOC(B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode);
TSTALLOC(B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode) TSTALLOC(B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode);
TSTALLOC(B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode) TSTALLOC(B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode);
TSTALLOC(B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode) TSTALLOC(B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode);
TSTALLOC(B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode) TSTALLOC(B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode);
TSTALLOC(B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode) TSTALLOC(B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode);
TSTALLOC(B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode) TSTALLOC(B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode);
TSTALLOC(B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode) TSTALLOC(B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode);
TSTALLOC(B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode) TSTALLOC(B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode);
TSTALLOC(B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode) TSTALLOC(B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode);
TSTALLOC(B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode) TSTALLOC(B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode);
} }

66
src/spicelib/devices/bsim3v0/b3v0set.c
View File

@ -848,43 +848,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM3v0DdPtr, BSIM3v0dNode, BSIM3v0dNode) TSTALLOC(BSIM3v0DdPtr, BSIM3v0dNode, BSIM3v0dNode);
TSTALLOC(BSIM3v0GgPtr, BSIM3v0gNode, BSIM3v0gNode) TSTALLOC(BSIM3v0GgPtr, BSIM3v0gNode, BSIM3v0gNode);
TSTALLOC(BSIM3v0SsPtr, BSIM3v0sNode, BSIM3v0sNode) TSTALLOC(BSIM3v0SsPtr, BSIM3v0sNode, BSIM3v0sNode);
TSTALLOC(BSIM3v0BbPtr, BSIM3v0bNode, BSIM3v0bNode) TSTALLOC(BSIM3v0BbPtr, BSIM3v0bNode, BSIM3v0bNode);
TSTALLOC(BSIM3v0DPdpPtr, BSIM3v0dNodePrime, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0DPdpPtr, BSIM3v0dNodePrime, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0SPspPtr, BSIM3v0sNodePrime, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0SPspPtr, BSIM3v0sNodePrime, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0DdpPtr, BSIM3v0dNode, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0DdpPtr, BSIM3v0dNode, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0GbPtr, BSIM3v0gNode, BSIM3v0bNode) TSTALLOC(BSIM3v0GbPtr, BSIM3v0gNode, BSIM3v0bNode);
TSTALLOC(BSIM3v0GdpPtr, BSIM3v0gNode, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0GdpPtr, BSIM3v0gNode, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0GspPtr, BSIM3v0gNode, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0GspPtr, BSIM3v0gNode, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0SspPtr, BSIM3v0sNode, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0SspPtr, BSIM3v0sNode, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0BdpPtr, BSIM3v0bNode, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0BdpPtr, BSIM3v0bNode, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0BspPtr, BSIM3v0bNode, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0BspPtr, BSIM3v0bNode, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0DPspPtr, BSIM3v0dNodePrime, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0DPspPtr, BSIM3v0dNodePrime, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0DPdPtr, BSIM3v0dNodePrime, BSIM3v0dNode) TSTALLOC(BSIM3v0DPdPtr, BSIM3v0dNodePrime, BSIM3v0dNode);
TSTALLOC(BSIM3v0BgPtr, BSIM3v0bNode, BSIM3v0gNode) TSTALLOC(BSIM3v0BgPtr, BSIM3v0bNode, BSIM3v0gNode);
TSTALLOC(BSIM3v0DPgPtr, BSIM3v0dNodePrime, BSIM3v0gNode) TSTALLOC(BSIM3v0DPgPtr, BSIM3v0dNodePrime, BSIM3v0gNode);
TSTALLOC(BSIM3v0SPgPtr, BSIM3v0sNodePrime, BSIM3v0gNode) TSTALLOC(BSIM3v0SPgPtr, BSIM3v0sNodePrime, BSIM3v0gNode);
TSTALLOC(BSIM3v0SPsPtr, BSIM3v0sNodePrime, BSIM3v0sNode) TSTALLOC(BSIM3v0SPsPtr, BSIM3v0sNodePrime, BSIM3v0sNode);
TSTALLOC(BSIM3v0DPbPtr, BSIM3v0dNodePrime, BSIM3v0bNode) TSTALLOC(BSIM3v0DPbPtr, BSIM3v0dNodePrime, BSIM3v0bNode);
TSTALLOC(BSIM3v0SPbPtr, BSIM3v0sNodePrime, BSIM3v0bNode) TSTALLOC(BSIM3v0SPbPtr, BSIM3v0sNodePrime, BSIM3v0bNode);
TSTALLOC(BSIM3v0SPdpPtr, BSIM3v0sNodePrime, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0SPdpPtr, BSIM3v0sNodePrime, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0QqPtr, BSIM3v0qNode, BSIM3v0qNode) TSTALLOC(BSIM3v0QqPtr, BSIM3v0qNode, BSIM3v0qNode);
TSTALLOC(BSIM3v0QdpPtr, BSIM3v0qNode, BSIM3v0dNodePrime) TSTALLOC(BSIM3v0QdpPtr, BSIM3v0qNode, BSIM3v0dNodePrime);
TSTALLOC(BSIM3v0QspPtr, BSIM3v0qNode, BSIM3v0sNodePrime) TSTALLOC(BSIM3v0QspPtr, BSIM3v0qNode, BSIM3v0sNodePrime);
TSTALLOC(BSIM3v0QgPtr, BSIM3v0qNode, BSIM3v0gNode) TSTALLOC(BSIM3v0QgPtr, BSIM3v0qNode, BSIM3v0gNode);
TSTALLOC(BSIM3v0QbPtr, BSIM3v0qNode, BSIM3v0bNode) TSTALLOC(BSIM3v0QbPtr, BSIM3v0qNode, BSIM3v0bNode);
TSTALLOC(BSIM3v0DPqPtr, BSIM3v0dNodePrime, BSIM3v0qNode) TSTALLOC(BSIM3v0DPqPtr, BSIM3v0dNodePrime, BSIM3v0qNode);
TSTALLOC(BSIM3v0SPqPtr, BSIM3v0sNodePrime, BSIM3v0qNode) TSTALLOC(BSIM3v0SPqPtr, BSIM3v0sNodePrime, BSIM3v0qNode);
TSTALLOC(BSIM3v0GqPtr, BSIM3v0gNode, BSIM3v0qNode) TSTALLOC(BSIM3v0GqPtr, BSIM3v0gNode, BSIM3v0qNode);
TSTALLOC(BSIM3v0BqPtr, BSIM3v0bNode, BSIM3v0qNode) TSTALLOC(BSIM3v0BqPtr, BSIM3v0bNode, BSIM3v0qNode);
} }
} }

66
src/spicelib/devices/bsim3v1/b3v1set.c
View File

@ -908,43 +908,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM3v1DdPtr, BSIM3v1dNode, BSIM3v1dNode) TSTALLOC(BSIM3v1DdPtr, BSIM3v1dNode, BSIM3v1dNode);
TSTALLOC(BSIM3v1GgPtr, BSIM3v1gNode, BSIM3v1gNode) TSTALLOC(BSIM3v1GgPtr, BSIM3v1gNode, BSIM3v1gNode);
TSTALLOC(BSIM3v1SsPtr, BSIM3v1sNode, BSIM3v1sNode) TSTALLOC(BSIM3v1SsPtr, BSIM3v1sNode, BSIM3v1sNode);
TSTALLOC(BSIM3v1BbPtr, BSIM3v1bNode, BSIM3v1bNode) TSTALLOC(BSIM3v1BbPtr, BSIM3v1bNode, BSIM3v1bNode);
TSTALLOC(BSIM3v1DPdpPtr, BSIM3v1dNodePrime, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1DPdpPtr, BSIM3v1dNodePrime, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1SPspPtr, BSIM3v1sNodePrime, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1SPspPtr, BSIM3v1sNodePrime, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1DdpPtr, BSIM3v1dNode, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1DdpPtr, BSIM3v1dNode, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1GbPtr, BSIM3v1gNode, BSIM3v1bNode) TSTALLOC(BSIM3v1GbPtr, BSIM3v1gNode, BSIM3v1bNode);
TSTALLOC(BSIM3v1GdpPtr, BSIM3v1gNode, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1GdpPtr, BSIM3v1gNode, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1GspPtr, BSIM3v1gNode, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1GspPtr, BSIM3v1gNode, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1SspPtr, BSIM3v1sNode, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1SspPtr, BSIM3v1sNode, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1BdpPtr, BSIM3v1bNode, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1BdpPtr, BSIM3v1bNode, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1BspPtr, BSIM3v1bNode, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1BspPtr, BSIM3v1bNode, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1DPspPtr, BSIM3v1dNodePrime, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1DPspPtr, BSIM3v1dNodePrime, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1DPdPtr, BSIM3v1dNodePrime, BSIM3v1dNode) TSTALLOC(BSIM3v1DPdPtr, BSIM3v1dNodePrime, BSIM3v1dNode);
TSTALLOC(BSIM3v1BgPtr, BSIM3v1bNode, BSIM3v1gNode) TSTALLOC(BSIM3v1BgPtr, BSIM3v1bNode, BSIM3v1gNode);
TSTALLOC(BSIM3v1DPgPtr, BSIM3v1dNodePrime, BSIM3v1gNode) TSTALLOC(BSIM3v1DPgPtr, BSIM3v1dNodePrime, BSIM3v1gNode);
TSTALLOC(BSIM3v1SPgPtr, BSIM3v1sNodePrime, BSIM3v1gNode) TSTALLOC(BSIM3v1SPgPtr, BSIM3v1sNodePrime, BSIM3v1gNode);
TSTALLOC(BSIM3v1SPsPtr, BSIM3v1sNodePrime, BSIM3v1sNode) TSTALLOC(BSIM3v1SPsPtr, BSIM3v1sNodePrime, BSIM3v1sNode);
TSTALLOC(BSIM3v1DPbPtr, BSIM3v1dNodePrime, BSIM3v1bNode) TSTALLOC(BSIM3v1DPbPtr, BSIM3v1dNodePrime, BSIM3v1bNode);
TSTALLOC(BSIM3v1SPbPtr, BSIM3v1sNodePrime, BSIM3v1bNode) TSTALLOC(BSIM3v1SPbPtr, BSIM3v1sNodePrime, BSIM3v1bNode);
TSTALLOC(BSIM3v1SPdpPtr, BSIM3v1sNodePrime, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1SPdpPtr, BSIM3v1sNodePrime, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1QqPtr, BSIM3v1qNode, BSIM3v1qNode) TSTALLOC(BSIM3v1QqPtr, BSIM3v1qNode, BSIM3v1qNode);
TSTALLOC(BSIM3v1QdpPtr, BSIM3v1qNode, BSIM3v1dNodePrime) TSTALLOC(BSIM3v1QdpPtr, BSIM3v1qNode, BSIM3v1dNodePrime);
TSTALLOC(BSIM3v1QspPtr, BSIM3v1qNode, BSIM3v1sNodePrime) TSTALLOC(BSIM3v1QspPtr, BSIM3v1qNode, BSIM3v1sNodePrime);
TSTALLOC(BSIM3v1QgPtr, BSIM3v1qNode, BSIM3v1gNode) TSTALLOC(BSIM3v1QgPtr, BSIM3v1qNode, BSIM3v1gNode);
TSTALLOC(BSIM3v1QbPtr, BSIM3v1qNode, BSIM3v1bNode) TSTALLOC(BSIM3v1QbPtr, BSIM3v1qNode, BSIM3v1bNode);
TSTALLOC(BSIM3v1DPqPtr, BSIM3v1dNodePrime, BSIM3v1qNode) TSTALLOC(BSIM3v1DPqPtr, BSIM3v1dNodePrime, BSIM3v1qNode);
TSTALLOC(BSIM3v1SPqPtr, BSIM3v1sNodePrime, BSIM3v1qNode) TSTALLOC(BSIM3v1SPqPtr, BSIM3v1sNodePrime, BSIM3v1qNode);
TSTALLOC(BSIM3v1GqPtr, BSIM3v1gNode, BSIM3v1qNode) TSTALLOC(BSIM3v1GqPtr, BSIM3v1gNode, BSIM3v1qNode);
TSTALLOC(BSIM3v1BqPtr, BSIM3v1bNode, BSIM3v1qNode) TSTALLOC(BSIM3v1BqPtr, BSIM3v1bNode, BSIM3v1qNode);
} }
} }

66
src/spicelib/devices/bsim3v32/b3v32set.c
View File

@ -1029,43 +1029,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM3v32DdPtr, BSIM3v32dNode, BSIM3v32dNode) TSTALLOC(BSIM3v32DdPtr, BSIM3v32dNode, BSIM3v32dNode);
TSTALLOC(BSIM3v32GgPtr, BSIM3v32gNode, BSIM3v32gNode) TSTALLOC(BSIM3v32GgPtr, BSIM3v32gNode, BSIM3v32gNode);
TSTALLOC(BSIM3v32SsPtr, BSIM3v32sNode, BSIM3v32sNode) TSTALLOC(BSIM3v32SsPtr, BSIM3v32sNode, BSIM3v32sNode);
TSTALLOC(BSIM3v32BbPtr, BSIM3v32bNode, BSIM3v32bNode) TSTALLOC(BSIM3v32BbPtr, BSIM3v32bNode, BSIM3v32bNode);
TSTALLOC(BSIM3v32DPdpPtr, BSIM3v32dNodePrime, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32DPdpPtr, BSIM3v32dNodePrime, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32SPspPtr, BSIM3v32sNodePrime, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32SPspPtr, BSIM3v32sNodePrime, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32DdpPtr, BSIM3v32dNode, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32DdpPtr, BSIM3v32dNode, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32GbPtr, BSIM3v32gNode, BSIM3v32bNode) TSTALLOC(BSIM3v32GbPtr, BSIM3v32gNode, BSIM3v32bNode);
TSTALLOC(BSIM3v32GdpPtr, BSIM3v32gNode, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32GdpPtr, BSIM3v32gNode, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32GspPtr, BSIM3v32gNode, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32GspPtr, BSIM3v32gNode, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32SspPtr, BSIM3v32sNode, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32SspPtr, BSIM3v32sNode, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32BdpPtr, BSIM3v32bNode, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32BdpPtr, BSIM3v32bNode, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32BspPtr, BSIM3v32bNode, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32BspPtr, BSIM3v32bNode, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32DPspPtr, BSIM3v32dNodePrime, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32DPspPtr, BSIM3v32dNodePrime, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32DPdPtr, BSIM3v32dNodePrime, BSIM3v32dNode) TSTALLOC(BSIM3v32DPdPtr, BSIM3v32dNodePrime, BSIM3v32dNode);
TSTALLOC(BSIM3v32BgPtr, BSIM3v32bNode, BSIM3v32gNode) TSTALLOC(BSIM3v32BgPtr, BSIM3v32bNode, BSIM3v32gNode);
TSTALLOC(BSIM3v32DPgPtr, BSIM3v32dNodePrime, BSIM3v32gNode) TSTALLOC(BSIM3v32DPgPtr, BSIM3v32dNodePrime, BSIM3v32gNode);
TSTALLOC(BSIM3v32SPgPtr, BSIM3v32sNodePrime, BSIM3v32gNode) TSTALLOC(BSIM3v32SPgPtr, BSIM3v32sNodePrime, BSIM3v32gNode);
TSTALLOC(BSIM3v32SPsPtr, BSIM3v32sNodePrime, BSIM3v32sNode) TSTALLOC(BSIM3v32SPsPtr, BSIM3v32sNodePrime, BSIM3v32sNode);
TSTALLOC(BSIM3v32DPbPtr, BSIM3v32dNodePrime, BSIM3v32bNode) TSTALLOC(BSIM3v32DPbPtr, BSIM3v32dNodePrime, BSIM3v32bNode);
TSTALLOC(BSIM3v32SPbPtr, BSIM3v32sNodePrime, BSIM3v32bNode) TSTALLOC(BSIM3v32SPbPtr, BSIM3v32sNodePrime, BSIM3v32bNode);
TSTALLOC(BSIM3v32SPdpPtr, BSIM3v32sNodePrime, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32SPdpPtr, BSIM3v32sNodePrime, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32QqPtr, BSIM3v32qNode, BSIM3v32qNode) TSTALLOC(BSIM3v32QqPtr, BSIM3v32qNode, BSIM3v32qNode);
TSTALLOC(BSIM3v32QdpPtr, BSIM3v32qNode, BSIM3v32dNodePrime) TSTALLOC(BSIM3v32QdpPtr, BSIM3v32qNode, BSIM3v32dNodePrime);
TSTALLOC(BSIM3v32QspPtr, BSIM3v32qNode, BSIM3v32sNodePrime) TSTALLOC(BSIM3v32QspPtr, BSIM3v32qNode, BSIM3v32sNodePrime);
TSTALLOC(BSIM3v32QgPtr, BSIM3v32qNode, BSIM3v32gNode) TSTALLOC(BSIM3v32QgPtr, BSIM3v32qNode, BSIM3v32gNode);
TSTALLOC(BSIM3v32QbPtr, BSIM3v32qNode, BSIM3v32bNode) TSTALLOC(BSIM3v32QbPtr, BSIM3v32qNode, BSIM3v32bNode);
TSTALLOC(BSIM3v32DPqPtr, BSIM3v32dNodePrime, BSIM3v32qNode) TSTALLOC(BSIM3v32DPqPtr, BSIM3v32dNodePrime, BSIM3v32qNode);
TSTALLOC(BSIM3v32SPqPtr, BSIM3v32sNodePrime, BSIM3v32qNode) TSTALLOC(BSIM3v32SPqPtr, BSIM3v32sNodePrime, BSIM3v32qNode);
TSTALLOC(BSIM3v32GqPtr, BSIM3v32gNode, BSIM3v32qNode) TSTALLOC(BSIM3v32GqPtr, BSIM3v32gNode, BSIM3v32qNode);
TSTALLOC(BSIM3v32BqPtr, BSIM3v32bNode, BSIM3v32qNode) TSTALLOC(BSIM3v32BqPtr, BSIM3v32bNode, BSIM3v32qNode);
} }
} }

144
src/spicelib/devices/bsim4/b4set.c
View File

@ -2463,96 +2463,96 @@ BSIM4instance **InstArray;
/* set Sparse Matrix Pointers /* set Sparse Matrix Pointers
* macro to make elements with built-in out-of-memory test */ * macro to make elements with built-in out-of-memory test */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM4DPbpPtr, BSIM4dNodePrime, BSIM4bNodePrime) TSTALLOC(BSIM4DPbpPtr, BSIM4dNodePrime, BSIM4bNodePrime);
TSTALLOC(BSIM4GPbpPtr, BSIM4gNodePrime, BSIM4bNodePrime) TSTALLOC(BSIM4GPbpPtr, BSIM4gNodePrime, BSIM4bNodePrime);
TSTALLOC(BSIM4SPbpPtr, BSIM4sNodePrime, BSIM4bNodePrime) TSTALLOC(BSIM4SPbpPtr, BSIM4sNodePrime, BSIM4bNodePrime);
TSTALLOC(BSIM4BPdpPtr, BSIM4bNodePrime, BSIM4dNodePrime) TSTALLOC(BSIM4BPdpPtr, BSIM4bNodePrime, BSIM4dNodePrime);
TSTALLOC(BSIM4BPgpPtr, BSIM4bNodePrime, BSIM4gNodePrime) TSTALLOC(BSIM4BPgpPtr, BSIM4bNodePrime, BSIM4gNodePrime);
TSTALLOC(BSIM4BPspPtr, BSIM4bNodePrime, BSIM4sNodePrime) TSTALLOC(BSIM4BPspPtr, BSIM4bNodePrime, BSIM4sNodePrime);
TSTALLOC(BSIM4BPbpPtr, BSIM4bNodePrime, BSIM4bNodePrime) TSTALLOC(BSIM4BPbpPtr, BSIM4bNodePrime, BSIM4bNodePrime);
TSTALLOC(BSIM4DdPtr, BSIM4dNode, BSIM4dNode) TSTALLOC(BSIM4DdPtr, BSIM4dNode, BSIM4dNode);
TSTALLOC(BSIM4GPgpPtr, BSIM4gNodePrime, BSIM4gNodePrime) TSTALLOC(BSIM4GPgpPtr, BSIM4gNodePrime, BSIM4gNodePrime);
TSTALLOC(BSIM4SsPtr, BSIM4sNode, BSIM4sNode) TSTALLOC(BSIM4SsPtr, BSIM4sNode, BSIM4sNode);
TSTALLOC(BSIM4DPdpPtr, BSIM4dNodePrime, BSIM4dNodePrime) TSTALLOC(BSIM4DPdpPtr, BSIM4dNodePrime, BSIM4dNodePrime);
TSTALLOC(BSIM4SPspPtr, BSIM4sNodePrime, BSIM4sNodePrime) TSTALLOC(BSIM4SPspPtr, BSIM4sNodePrime, BSIM4sNodePrime);
TSTALLOC(BSIM4DdpPtr, BSIM4dNode, BSIM4dNodePrime) TSTALLOC(BSIM4DdpPtr, BSIM4dNode, BSIM4dNodePrime);
TSTALLOC(BSIM4GPdpPtr, BSIM4gNodePrime, BSIM4dNodePrime) TSTALLOC(BSIM4GPdpPtr, BSIM4gNodePrime, BSIM4dNodePrime);
TSTALLOC(BSIM4GPspPtr, BSIM4gNodePrime, BSIM4sNodePrime) TSTALLOC(BSIM4GPspPtr, BSIM4gNodePrime, BSIM4sNodePrime);
TSTALLOC(BSIM4SspPtr, BSIM4sNode, BSIM4sNodePrime) TSTALLOC(BSIM4SspPtr, BSIM4sNode, BSIM4sNodePrime);
TSTALLOC(BSIM4DPspPtr, BSIM4dNodePrime, BSIM4sNodePrime) TSTALLOC(BSIM4DPspPtr, BSIM4dNodePrime, BSIM4sNodePrime);
TSTALLOC(BSIM4DPdPtr, BSIM4dNodePrime, BSIM4dNode) TSTALLOC(BSIM4DPdPtr, BSIM4dNodePrime, BSIM4dNode);
TSTALLOC(BSIM4DPgpPtr, BSIM4dNodePrime, BSIM4gNodePrime) TSTALLOC(BSIM4DPgpPtr, BSIM4dNodePrime, BSIM4gNodePrime);
TSTALLOC(BSIM4SPgpPtr, BSIM4sNodePrime, BSIM4gNodePrime) TSTALLOC(BSIM4SPgpPtr, BSIM4sNodePrime, BSIM4gNodePrime);
TSTALLOC(BSIM4SPsPtr, BSIM4sNodePrime, BSIM4sNode) TSTALLOC(BSIM4SPsPtr, BSIM4sNodePrime, BSIM4sNode);
TSTALLOC(BSIM4SPdpPtr, BSIM4sNodePrime, BSIM4dNodePrime) TSTALLOC(BSIM4SPdpPtr, BSIM4sNodePrime, BSIM4dNodePrime);
TSTALLOC(BSIM4QqPtr, BSIM4qNode, BSIM4qNode) TSTALLOC(BSIM4QqPtr, BSIM4qNode, BSIM4qNode);
TSTALLOC(BSIM4QbpPtr, BSIM4qNode, BSIM4bNodePrime) TSTALLOC(BSIM4QbpPtr, BSIM4qNode, BSIM4bNodePrime) ;
TSTALLOC(BSIM4QdpPtr, BSIM4qNode, BSIM4dNodePrime) TSTALLOC(BSIM4QdpPtr, BSIM4qNode, BSIM4dNodePrime);
TSTALLOC(BSIM4QspPtr, BSIM4qNode, BSIM4sNodePrime) TSTALLOC(BSIM4QspPtr, BSIM4qNode, BSIM4sNodePrime);
TSTALLOC(BSIM4QgpPtr, BSIM4qNode, BSIM4gNodePrime) TSTALLOC(BSIM4QgpPtr, BSIM4qNode, BSIM4gNodePrime);
TSTALLOC(BSIM4DPqPtr, BSIM4dNodePrime, BSIM4qNode) TSTALLOC(BSIM4DPqPtr, BSIM4dNodePrime, BSIM4qNode);
TSTALLOC(BSIM4SPqPtr, BSIM4sNodePrime, BSIM4qNode) TSTALLOC(BSIM4SPqPtr, BSIM4sNodePrime, BSIM4qNode);
TSTALLOC(BSIM4GPqPtr, BSIM4gNodePrime, BSIM4qNode) TSTALLOC(BSIM4GPqPtr, BSIM4gNodePrime, BSIM4qNode);
if (here->BSIM4rgateMod != 0) if (here->BSIM4rgateMod != 0)
{ TSTALLOC(BSIM4GEgePtr, BSIM4gNodeExt, BSIM4gNodeExt) { TSTALLOC(BSIM4GEgePtr, BSIM4gNodeExt, BSIM4gNodeExt);
TSTALLOC(BSIM4GEgpPtr, BSIM4gNodeExt, BSIM4gNodePrime) TSTALLOC(BSIM4GEgpPtr, BSIM4gNodeExt, BSIM4gNodePrime);
TSTALLOC(BSIM4GPgePtr, BSIM4gNodePrime, BSIM4gNodeExt) TSTALLOC(BSIM4GPgePtr, BSIM4gNodePrime, BSIM4gNodeExt);
TSTALLOC(BSIM4GEdpPtr, BSIM4gNodeExt, BSIM4dNodePrime) TSTALLOC(BSIM4GEdpPtr, BSIM4gNodeExt, BSIM4dNodePrime);
TSTALLOC(BSIM4GEspPtr, BSIM4gNodeExt, BSIM4sNodePrime) TSTALLOC(BSIM4GEspPtr, BSIM4gNodeExt, BSIM4sNodePrime);
TSTALLOC(BSIM4GEbpPtr, BSIM4gNodeExt, BSIM4bNodePrime) TSTALLOC(BSIM4GEbpPtr, BSIM4gNodeExt, BSIM4bNodePrime);
TSTALLOC(BSIM4GMdpPtr, BSIM4gNodeMid, BSIM4dNodePrime) TSTALLOC(BSIM4GMdpPtr, BSIM4gNodeMid, BSIM4dNodePrime);
TSTALLOC(BSIM4GMgpPtr, BSIM4gNodeMid, BSIM4gNodePrime) TSTALLOC(BSIM4GMgpPtr, BSIM4gNodeMid, BSIM4gNodePrime);
TSTALLOC(BSIM4GMgmPtr, BSIM4gNodeMid, BSIM4gNodeMid) TSTALLOC(BSIM4GMgmPtr, BSIM4gNodeMid, BSIM4gNodeMid);
TSTALLOC(BSIM4GMgePtr, BSIM4gNodeMid, BSIM4gNodeExt) TSTALLOC(BSIM4GMgePtr, BSIM4gNodeMid, BSIM4gNodeExt);
TSTALLOC(BSIM4GMspPtr, BSIM4gNodeMid, BSIM4sNodePrime) TSTALLOC(BSIM4GMspPtr, BSIM4gNodeMid, BSIM4sNodePrime);
TSTALLOC(BSIM4GMbpPtr, BSIM4gNodeMid, BSIM4bNodePrime) TSTALLOC(BSIM4GMbpPtr, BSIM4gNodeMid, BSIM4bNodePrime);
TSTALLOC(BSIM4DPgmPtr, BSIM4dNodePrime, BSIM4gNodeMid) TSTALLOC(BSIM4DPgmPtr, BSIM4dNodePrime, BSIM4gNodeMid);
TSTALLOC(BSIM4GPgmPtr, BSIM4gNodePrime, BSIM4gNodeMid) TSTALLOC(BSIM4GPgmPtr, BSIM4gNodePrime, BSIM4gNodeMid);
TSTALLOC(BSIM4GEgmPtr, BSIM4gNodeExt, BSIM4gNodeMid) TSTALLOC(BSIM4GEgmPtr, BSIM4gNodeExt, BSIM4gNodeMid);
TSTALLOC(BSIM4SPgmPtr, BSIM4sNodePrime, BSIM4gNodeMid) TSTALLOC(BSIM4SPgmPtr, BSIM4sNodePrime, BSIM4gNodeMid);
TSTALLOC(BSIM4BPgmPtr, BSIM4bNodePrime, BSIM4gNodeMid) TSTALLOC(BSIM4BPgmPtr, BSIM4bNodePrime, BSIM4gNodeMid);
} }
if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2)) if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2))
{ TSTALLOC(BSIM4DPdbPtr, BSIM4dNodePrime, BSIM4dbNode) { TSTALLOC(BSIM4DPdbPtr, BSIM4dNodePrime, BSIM4dbNode);
TSTALLOC(BSIM4SPsbPtr, BSIM4sNodePrime, BSIM4sbNode) TSTALLOC(BSIM4SPsbPtr, BSIM4sNodePrime, BSIM4sbNode);
TSTALLOC(BSIM4DBdpPtr, BSIM4dbNode, BSIM4dNodePrime) TSTALLOC(BSIM4DBdpPtr, BSIM4dbNode, BSIM4dNodePrime);
TSTALLOC(BSIM4DBdbPtr, BSIM4dbNode, BSIM4dbNode) TSTALLOC(BSIM4DBdbPtr, BSIM4dbNode, BSIM4dbNode);
TSTALLOC(BSIM4DBbpPtr, BSIM4dbNode, BSIM4bNodePrime) TSTALLOC(BSIM4DBbpPtr, BSIM4dbNode, BSIM4bNodePrime);
TSTALLOC(BSIM4DBbPtr, BSIM4dbNode, BSIM4bNode) TSTALLOC(BSIM4DBbPtr, BSIM4dbNode, BSIM4bNode);
TSTALLOC(BSIM4BPdbPtr, BSIM4bNodePrime, BSIM4dbNode) TSTALLOC(BSIM4BPdbPtr, BSIM4bNodePrime, BSIM4dbNode);
TSTALLOC(BSIM4BPbPtr, BSIM4bNodePrime, BSIM4bNode) TSTALLOC(BSIM4BPbPtr, BSIM4bNodePrime, BSIM4bNode);
TSTALLOC(BSIM4BPsbPtr, BSIM4bNodePrime, BSIM4sbNode) TSTALLOC(BSIM4BPsbPtr, BSIM4bNodePrime, BSIM4sbNode);
TSTALLOC(BSIM4SBspPtr, BSIM4sbNode, BSIM4sNodePrime) TSTALLOC(BSIM4SBspPtr, BSIM4sbNode, BSIM4sNodePrime);
TSTALLOC(BSIM4SBbpPtr, BSIM4sbNode, BSIM4bNodePrime) TSTALLOC(BSIM4SBbpPtr, BSIM4sbNode, BSIM4bNodePrime);
TSTALLOC(BSIM4SBbPtr, BSIM4sbNode, BSIM4bNode) TSTALLOC(BSIM4SBbPtr, BSIM4sbNode, BSIM4bNode);
TSTALLOC(BSIM4SBsbPtr, BSIM4sbNode, BSIM4sbNode) TSTALLOC(BSIM4SBsbPtr, BSIM4sbNode, BSIM4sbNode);
TSTALLOC(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode) TSTALLOC(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode);
TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime) TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime);
TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode) TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode);
TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode) TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode);
} }
if (model->BSIM4rdsMod) if (model->BSIM4rdsMod)
{ TSTALLOC(BSIM4DgpPtr, BSIM4dNode, BSIM4gNodePrime) { TSTALLOC(BSIM4DgpPtr, BSIM4dNode, BSIM4gNodePrime);
TSTALLOC(BSIM4DspPtr, BSIM4dNode, BSIM4sNodePrime) TSTALLOC(BSIM4DspPtr, BSIM4dNode, BSIM4sNodePrime);
TSTALLOC(BSIM4DbpPtr, BSIM4dNode, BSIM4bNodePrime) TSTALLOC(BSIM4DbpPtr, BSIM4dNode, BSIM4bNodePrime);
TSTALLOC(BSIM4SdpPtr, BSIM4sNode, BSIM4dNodePrime) TSTALLOC(BSIM4SdpPtr, BSIM4sNode, BSIM4dNodePrime);
TSTALLOC(BSIM4SgpPtr, BSIM4sNode, BSIM4gNodePrime) TSTALLOC(BSIM4SgpPtr, BSIM4sNode, BSIM4gNodePrime);
TSTALLOC(BSIM4SbpPtr, BSIM4sNode, BSIM4bNodePrime) TSTALLOC(BSIM4SbpPtr, BSIM4sNode, BSIM4bNodePrime);
} }
} }
} }

144
src/spicelib/devices/bsim4v4/b4v4set.c
View File

@ -1849,96 +1849,96 @@ JOB *job;
/* set Sparse Matrix Pointers /* set Sparse Matrix Pointers
* macro to make elements with built-in out-of-memory test */ * macro to make elements with built-in out-of-memory test */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM4v4DPbpPtr, BSIM4v4dNodePrime, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4DPbpPtr, BSIM4v4dNodePrime, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4GPbpPtr, BSIM4v4gNodePrime, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4GPbpPtr, BSIM4v4gNodePrime, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4SPbpPtr, BSIM4v4sNodePrime, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4SPbpPtr, BSIM4v4sNodePrime, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4BPdpPtr, BSIM4v4bNodePrime, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4BPdpPtr, BSIM4v4bNodePrime, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4BPgpPtr, BSIM4v4bNodePrime, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4BPgpPtr, BSIM4v4bNodePrime, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4BPspPtr, BSIM4v4bNodePrime, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4BPspPtr, BSIM4v4bNodePrime, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4BPbpPtr, BSIM4v4bNodePrime, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4BPbpPtr, BSIM4v4bNodePrime, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4DdPtr, BSIM4v4dNode, BSIM4v4dNode) TSTALLOC(BSIM4v4DdPtr, BSIM4v4dNode, BSIM4v4dNode);
TSTALLOC(BSIM4v4GPgpPtr, BSIM4v4gNodePrime, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4GPgpPtr, BSIM4v4gNodePrime, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4SsPtr, BSIM4v4sNode, BSIM4v4sNode) TSTALLOC(BSIM4v4SsPtr, BSIM4v4sNode, BSIM4v4sNode);
TSTALLOC(BSIM4v4DPdpPtr, BSIM4v4dNodePrime, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4DPdpPtr, BSIM4v4dNodePrime, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4SPspPtr, BSIM4v4sNodePrime, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4SPspPtr, BSIM4v4sNodePrime, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4DdpPtr, BSIM4v4dNode, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4DdpPtr, BSIM4v4dNode, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4GPdpPtr, BSIM4v4gNodePrime, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4GPdpPtr, BSIM4v4gNodePrime, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4GPspPtr, BSIM4v4gNodePrime, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4GPspPtr, BSIM4v4gNodePrime, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4SspPtr, BSIM4v4sNode, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4SspPtr, BSIM4v4sNode, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4DPspPtr, BSIM4v4dNodePrime, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4DPspPtr, BSIM4v4dNodePrime, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4DPdPtr, BSIM4v4dNodePrime, BSIM4v4dNode) TSTALLOC(BSIM4v4DPdPtr, BSIM4v4dNodePrime, BSIM4v4dNode);
TSTALLOC(BSIM4v4DPgpPtr, BSIM4v4dNodePrime, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4DPgpPtr, BSIM4v4dNodePrime, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4SPgpPtr, BSIM4v4sNodePrime, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4SPgpPtr, BSIM4v4sNodePrime, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4SPsPtr, BSIM4v4sNodePrime, BSIM4v4sNode) TSTALLOC(BSIM4v4SPsPtr, BSIM4v4sNodePrime, BSIM4v4sNode);
TSTALLOC(BSIM4v4SPdpPtr, BSIM4v4sNodePrime, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4SPdpPtr, BSIM4v4sNodePrime, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4QqPtr, BSIM4v4qNode, BSIM4v4qNode) TSTALLOC(BSIM4v4QqPtr, BSIM4v4qNode, BSIM4v4qNode);
TSTALLOC(BSIM4v4QbpPtr, BSIM4v4qNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4QbpPtr, BSIM4v4qNode, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4QdpPtr, BSIM4v4qNode, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4QdpPtr, BSIM4v4qNode, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4QspPtr, BSIM4v4qNode, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4QspPtr, BSIM4v4qNode, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4QgpPtr, BSIM4v4qNode, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4QgpPtr, BSIM4v4qNode, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4DPqPtr, BSIM4v4dNodePrime, BSIM4v4qNode) TSTALLOC(BSIM4v4DPqPtr, BSIM4v4dNodePrime, BSIM4v4qNode);
TSTALLOC(BSIM4v4SPqPtr, BSIM4v4sNodePrime, BSIM4v4qNode) TSTALLOC(BSIM4v4SPqPtr, BSIM4v4sNodePrime, BSIM4v4qNode);
TSTALLOC(BSIM4v4GPqPtr, BSIM4v4gNodePrime, BSIM4v4qNode) TSTALLOC(BSIM4v4GPqPtr, BSIM4v4gNodePrime, BSIM4v4qNode);
if (here->BSIM4v4rgateMod != 0) if (here->BSIM4v4rgateMod != 0)
{ TSTALLOC(BSIM4v4GEgePtr, BSIM4v4gNodeExt, BSIM4v4gNodeExt) { TSTALLOC(BSIM4v4GEgePtr, BSIM4v4gNodeExt, BSIM4v4gNodeExt);
TSTALLOC(BSIM4v4GEgpPtr, BSIM4v4gNodeExt, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4GEgpPtr, BSIM4v4gNodeExt, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4GPgePtr, BSIM4v4gNodePrime, BSIM4v4gNodeExt) TSTALLOC(BSIM4v4GPgePtr, BSIM4v4gNodePrime, BSIM4v4gNodeExt);
TSTALLOC(BSIM4v4GEdpPtr, BSIM4v4gNodeExt, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4GEdpPtr, BSIM4v4gNodeExt, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4GEspPtr, BSIM4v4gNodeExt, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4GEspPtr, BSIM4v4gNodeExt, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4GEbpPtr, BSIM4v4gNodeExt, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4GEbpPtr, BSIM4v4gNodeExt, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4GMdpPtr, BSIM4v4gNodeMid, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4GMdpPtr, BSIM4v4gNodeMid, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4GMgpPtr, BSIM4v4gNodeMid, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4GMgpPtr, BSIM4v4gNodeMid, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4GMgmPtr, BSIM4v4gNodeMid, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4GMgmPtr, BSIM4v4gNodeMid, BSIM4v4gNodeMid);
TSTALLOC(BSIM4v4GMgePtr, BSIM4v4gNodeMid, BSIM4v4gNodeExt) TSTALLOC(BSIM4v4GMgePtr, BSIM4v4gNodeMid, BSIM4v4gNodeExt);
TSTALLOC(BSIM4v4GMspPtr, BSIM4v4gNodeMid, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4GMspPtr, BSIM4v4gNodeMid, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4GMbpPtr, BSIM4v4gNodeMid, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4GMbpPtr, BSIM4v4gNodeMid, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4DPgmPtr, BSIM4v4dNodePrime, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4DPgmPtr, BSIM4v4dNodePrime, BSIM4v4gNodeMid);
TSTALLOC(BSIM4v4GPgmPtr, BSIM4v4gNodePrime, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4GPgmPtr, BSIM4v4gNodePrime, BSIM4v4gNodeMid);
TSTALLOC(BSIM4v4GEgmPtr, BSIM4v4gNodeExt, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4GEgmPtr, BSIM4v4gNodeExt, BSIM4v4gNodeMid);
TSTALLOC(BSIM4v4SPgmPtr, BSIM4v4sNodePrime, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4SPgmPtr, BSIM4v4sNodePrime, BSIM4v4gNodeMid);
TSTALLOC(BSIM4v4BPgmPtr, BSIM4v4bNodePrime, BSIM4v4gNodeMid) TSTALLOC(BSIM4v4BPgmPtr, BSIM4v4bNodePrime, BSIM4v4gNodeMid);
} }
if (here->BSIM4v4rbodyMod) if (here->BSIM4v4rbodyMod)
{ TSTALLOC(BSIM4v4DPdbPtr, BSIM4v4dNodePrime, BSIM4v4dbNode) { TSTALLOC(BSIM4v4DPdbPtr, BSIM4v4dNodePrime, BSIM4v4dbNode);
TSTALLOC(BSIM4v4SPsbPtr, BSIM4v4sNodePrime, BSIM4v4sbNode) TSTALLOC(BSIM4v4SPsbPtr, BSIM4v4sNodePrime, BSIM4v4sbNode);
TSTALLOC(BSIM4v4DBdpPtr, BSIM4v4dbNode, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4DBdpPtr, BSIM4v4dbNode, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4DBdbPtr, BSIM4v4dbNode, BSIM4v4dbNode) TSTALLOC(BSIM4v4DBdbPtr, BSIM4v4dbNode, BSIM4v4dbNode);
TSTALLOC(BSIM4v4DBbpPtr, BSIM4v4dbNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4DBbpPtr, BSIM4v4dbNode, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4DBbPtr, BSIM4v4dbNode, BSIM4v4bNode) TSTALLOC(BSIM4v4DBbPtr, BSIM4v4dbNode, BSIM4v4bNode);
TSTALLOC(BSIM4v4BPdbPtr, BSIM4v4bNodePrime, BSIM4v4dbNode) TSTALLOC(BSIM4v4BPdbPtr, BSIM4v4bNodePrime, BSIM4v4dbNode);
TSTALLOC(BSIM4v4BPbPtr, BSIM4v4bNodePrime, BSIM4v4bNode) TSTALLOC(BSIM4v4BPbPtr, BSIM4v4bNodePrime, BSIM4v4bNode);
TSTALLOC(BSIM4v4BPsbPtr, BSIM4v4bNodePrime, BSIM4v4sbNode) TSTALLOC(BSIM4v4BPsbPtr, BSIM4v4bNodePrime, BSIM4v4sbNode);
TSTALLOC(BSIM4v4SBspPtr, BSIM4v4sbNode, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4SBspPtr, BSIM4v4sbNode, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4SBbpPtr, BSIM4v4sbNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4SBbpPtr, BSIM4v4sbNode, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4SBbPtr, BSIM4v4sbNode, BSIM4v4bNode) TSTALLOC(BSIM4v4SBbPtr, BSIM4v4sbNode, BSIM4v4bNode);
TSTALLOC(BSIM4v4SBsbPtr, BSIM4v4sbNode, BSIM4v4sbNode) TSTALLOC(BSIM4v4SBsbPtr, BSIM4v4sbNode, BSIM4v4sbNode);
TSTALLOC(BSIM4v4BdbPtr, BSIM4v4bNode, BSIM4v4dbNode) TSTALLOC(BSIM4v4BdbPtr, BSIM4v4bNode, BSIM4v4dbNode);
TSTALLOC(BSIM4v4BbpPtr, BSIM4v4bNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4BbpPtr, BSIM4v4bNode, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4BsbPtr, BSIM4v4bNode, BSIM4v4sbNode) TSTALLOC(BSIM4v4BsbPtr, BSIM4v4bNode, BSIM4v4sbNode);
TSTALLOC(BSIM4v4BbPtr, BSIM4v4bNode, BSIM4v4bNode) TSTALLOC(BSIM4v4BbPtr, BSIM4v4bNode, BSIM4v4bNode);
} }
if (model->BSIM4v4rdsMod) if (model->BSIM4v4rdsMod)
{ TSTALLOC(BSIM4v4DgpPtr, BSIM4v4dNode, BSIM4v4gNodePrime) { TSTALLOC(BSIM4v4DgpPtr, BSIM4v4dNode, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4DspPtr, BSIM4v4dNode, BSIM4v4sNodePrime) TSTALLOC(BSIM4v4DspPtr, BSIM4v4dNode, BSIM4v4sNodePrime);
TSTALLOC(BSIM4v4DbpPtr, BSIM4v4dNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4DbpPtr, BSIM4v4dNode, BSIM4v4bNodePrime);
TSTALLOC(BSIM4v4SdpPtr, BSIM4v4sNode, BSIM4v4dNodePrime) TSTALLOC(BSIM4v4SdpPtr, BSIM4v4sNode, BSIM4v4dNodePrime);
TSTALLOC(BSIM4v4SgpPtr, BSIM4v4sNode, BSIM4v4gNodePrime) TSTALLOC(BSIM4v4SgpPtr, BSIM4v4sNode, BSIM4v4gNodePrime);
TSTALLOC(BSIM4v4SbpPtr, BSIM4v4sNode, BSIM4v4bNodePrime) TSTALLOC(BSIM4v4SbpPtr, BSIM4v4sNode, BSIM4v4bNodePrime);
} }
} }
} }

144
src/spicelib/devices/bsim4v5/b4v5set.c
View File

@ -1966,96 +1966,96 @@ JOB *job;
/* set Sparse Matrix Pointers /* set Sparse Matrix Pointers
* macro to make elements with built-in out-of-memory test */ * macro to make elements with built-in out-of-memory test */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM4v5DPbpPtr, BSIM4v5dNodePrime, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5DPbpPtr, BSIM4v5dNodePrime, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5GPbpPtr, BSIM4v5gNodePrime, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5GPbpPtr, BSIM4v5gNodePrime, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5SPbpPtr, BSIM4v5sNodePrime, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5SPbpPtr, BSIM4v5sNodePrime, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5BPdpPtr, BSIM4v5bNodePrime, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5BPdpPtr, BSIM4v5bNodePrime, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5BPgpPtr, BSIM4v5bNodePrime, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5BPgpPtr, BSIM4v5bNodePrime, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5BPspPtr, BSIM4v5bNodePrime, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5BPspPtr, BSIM4v5bNodePrime, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5BPbpPtr, BSIM4v5bNodePrime, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5BPbpPtr, BSIM4v5bNodePrime, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5DdPtr, BSIM4v5dNode, BSIM4v5dNode) TSTALLOC(BSIM4v5DdPtr, BSIM4v5dNode, BSIM4v5dNode);
TSTALLOC(BSIM4v5GPgpPtr, BSIM4v5gNodePrime, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5GPgpPtr, BSIM4v5gNodePrime, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5SsPtr, BSIM4v5sNode, BSIM4v5sNode) TSTALLOC(BSIM4v5SsPtr, BSIM4v5sNode, BSIM4v5sNode);
TSTALLOC(BSIM4v5DPdpPtr, BSIM4v5dNodePrime, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5DPdpPtr, BSIM4v5dNodePrime, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5SPspPtr, BSIM4v5sNodePrime, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5SPspPtr, BSIM4v5sNodePrime, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5DdpPtr, BSIM4v5dNode, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5DdpPtr, BSIM4v5dNode, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5GPdpPtr, BSIM4v5gNodePrime, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5GPdpPtr, BSIM4v5gNodePrime, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5GPspPtr, BSIM4v5gNodePrime, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5GPspPtr, BSIM4v5gNodePrime, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5SspPtr, BSIM4v5sNode, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5SspPtr, BSIM4v5sNode, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5DPspPtr, BSIM4v5dNodePrime, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5DPspPtr, BSIM4v5dNodePrime, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5DPdPtr, BSIM4v5dNodePrime, BSIM4v5dNode) TSTALLOC(BSIM4v5DPdPtr, BSIM4v5dNodePrime, BSIM4v5dNode);
TSTALLOC(BSIM4v5DPgpPtr, BSIM4v5dNodePrime, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5DPgpPtr, BSIM4v5dNodePrime, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5SPgpPtr, BSIM4v5sNodePrime, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5SPgpPtr, BSIM4v5sNodePrime, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5SPsPtr, BSIM4v5sNodePrime, BSIM4v5sNode) TSTALLOC(BSIM4v5SPsPtr, BSIM4v5sNodePrime, BSIM4v5sNode);
TSTALLOC(BSIM4v5SPdpPtr, BSIM4v5sNodePrime, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5SPdpPtr, BSIM4v5sNodePrime, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5QqPtr, BSIM4v5qNode, BSIM4v5qNode) TSTALLOC(BSIM4v5QqPtr, BSIM4v5qNode, BSIM4v5qNode);
TSTALLOC(BSIM4v5QbpPtr, BSIM4v5qNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5QbpPtr, BSIM4v5qNode, BSIM4v5bNodePrime) ;
TSTALLOC(BSIM4v5QdpPtr, BSIM4v5qNode, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5QdpPtr, BSIM4v5qNode, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5QspPtr, BSIM4v5qNode, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5QspPtr, BSIM4v5qNode, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5QgpPtr, BSIM4v5qNode, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5QgpPtr, BSIM4v5qNode, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5DPqPtr, BSIM4v5dNodePrime, BSIM4v5qNode) TSTALLOC(BSIM4v5DPqPtr, BSIM4v5dNodePrime, BSIM4v5qNode);
TSTALLOC(BSIM4v5SPqPtr, BSIM4v5sNodePrime, BSIM4v5qNode) TSTALLOC(BSIM4v5SPqPtr, BSIM4v5sNodePrime, BSIM4v5qNode);
TSTALLOC(BSIM4v5GPqPtr, BSIM4v5gNodePrime, BSIM4v5qNode) TSTALLOC(BSIM4v5GPqPtr, BSIM4v5gNodePrime, BSIM4v5qNode);
if (here->BSIM4v5rgateMod != 0) if (here->BSIM4v5rgateMod != 0)
{ TSTALLOC(BSIM4v5GEgePtr, BSIM4v5gNodeExt, BSIM4v5gNodeExt) { TSTALLOC(BSIM4v5GEgePtr, BSIM4v5gNodeExt, BSIM4v5gNodeExt);
TSTALLOC(BSIM4v5GEgpPtr, BSIM4v5gNodeExt, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5GEgpPtr, BSIM4v5gNodeExt, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5GPgePtr, BSIM4v5gNodePrime, BSIM4v5gNodeExt) TSTALLOC(BSIM4v5GPgePtr, BSIM4v5gNodePrime, BSIM4v5gNodeExt);
TSTALLOC(BSIM4v5GEdpPtr, BSIM4v5gNodeExt, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5GEdpPtr, BSIM4v5gNodeExt, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5GEspPtr, BSIM4v5gNodeExt, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5GEspPtr, BSIM4v5gNodeExt, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5GEbpPtr, BSIM4v5gNodeExt, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5GEbpPtr, BSIM4v5gNodeExt, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5GMdpPtr, BSIM4v5gNodeMid, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5GMdpPtr, BSIM4v5gNodeMid, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5GMgpPtr, BSIM4v5gNodeMid, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5GMgpPtr, BSIM4v5gNodeMid, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5GMgmPtr, BSIM4v5gNodeMid, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5GMgmPtr, BSIM4v5gNodeMid, BSIM4v5gNodeMid);
TSTALLOC(BSIM4v5GMgePtr, BSIM4v5gNodeMid, BSIM4v5gNodeExt) TSTALLOC(BSIM4v5GMgePtr, BSIM4v5gNodeMid, BSIM4v5gNodeExt);
TSTALLOC(BSIM4v5GMspPtr, BSIM4v5gNodeMid, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5GMspPtr, BSIM4v5gNodeMid, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5GMbpPtr, BSIM4v5gNodeMid, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5GMbpPtr, BSIM4v5gNodeMid, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5DPgmPtr, BSIM4v5dNodePrime, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5DPgmPtr, BSIM4v5dNodePrime, BSIM4v5gNodeMid);
TSTALLOC(BSIM4v5GPgmPtr, BSIM4v5gNodePrime, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5GPgmPtr, BSIM4v5gNodePrime, BSIM4v5gNodeMid);
TSTALLOC(BSIM4v5GEgmPtr, BSIM4v5gNodeExt, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5GEgmPtr, BSIM4v5gNodeExt, BSIM4v5gNodeMid);
TSTALLOC(BSIM4v5SPgmPtr, BSIM4v5sNodePrime, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5SPgmPtr, BSIM4v5sNodePrime, BSIM4v5gNodeMid);
TSTALLOC(BSIM4v5BPgmPtr, BSIM4v5bNodePrime, BSIM4v5gNodeMid) TSTALLOC(BSIM4v5BPgmPtr, BSIM4v5bNodePrime, BSIM4v5gNodeMid);
} }
if ((here->BSIM4v5rbodyMod ==1) || (here->BSIM4v5rbodyMod ==2)) if ((here->BSIM4v5rbodyMod ==1) || (here->BSIM4v5rbodyMod ==2))
{ TSTALLOC(BSIM4v5DPdbPtr, BSIM4v5dNodePrime, BSIM4v5dbNode) { TSTALLOC(BSIM4v5DPdbPtr, BSIM4v5dNodePrime, BSIM4v5dbNode);
TSTALLOC(BSIM4v5SPsbPtr, BSIM4v5sNodePrime, BSIM4v5sbNode) TSTALLOC(BSIM4v5SPsbPtr, BSIM4v5sNodePrime, BSIM4v5sbNode);
TSTALLOC(BSIM4v5DBdpPtr, BSIM4v5dbNode, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5DBdpPtr, BSIM4v5dbNode, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5DBdbPtr, BSIM4v5dbNode, BSIM4v5dbNode) TSTALLOC(BSIM4v5DBdbPtr, BSIM4v5dbNode, BSIM4v5dbNode);
TSTALLOC(BSIM4v5DBbpPtr, BSIM4v5dbNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5DBbpPtr, BSIM4v5dbNode, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5DBbPtr, BSIM4v5dbNode, BSIM4v5bNode) TSTALLOC(BSIM4v5DBbPtr, BSIM4v5dbNode, BSIM4v5bNode);
TSTALLOC(BSIM4v5BPdbPtr, BSIM4v5bNodePrime, BSIM4v5dbNode) TSTALLOC(BSIM4v5BPdbPtr, BSIM4v5bNodePrime, BSIM4v5dbNode);
TSTALLOC(BSIM4v5BPbPtr, BSIM4v5bNodePrime, BSIM4v5bNode) TSTALLOC(BSIM4v5BPbPtr, BSIM4v5bNodePrime, BSIM4v5bNode);
TSTALLOC(BSIM4v5BPsbPtr, BSIM4v5bNodePrime, BSIM4v5sbNode) TSTALLOC(BSIM4v5BPsbPtr, BSIM4v5bNodePrime, BSIM4v5sbNode);
TSTALLOC(BSIM4v5SBspPtr, BSIM4v5sbNode, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5SBspPtr, BSIM4v5sbNode, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5SBbpPtr, BSIM4v5sbNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5SBbpPtr, BSIM4v5sbNode, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5SBbPtr, BSIM4v5sbNode, BSIM4v5bNode) TSTALLOC(BSIM4v5SBbPtr, BSIM4v5sbNode, BSIM4v5bNode);
TSTALLOC(BSIM4v5SBsbPtr, BSIM4v5sbNode, BSIM4v5sbNode) TSTALLOC(BSIM4v5SBsbPtr, BSIM4v5sbNode, BSIM4v5sbNode);
TSTALLOC(BSIM4v5BdbPtr, BSIM4v5bNode, BSIM4v5dbNode) TSTALLOC(BSIM4v5BdbPtr, BSIM4v5bNode, BSIM4v5dbNode);
TSTALLOC(BSIM4v5BbpPtr, BSIM4v5bNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5BbpPtr, BSIM4v5bNode, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5BsbPtr, BSIM4v5bNode, BSIM4v5sbNode) TSTALLOC(BSIM4v5BsbPtr, BSIM4v5bNode, BSIM4v5sbNode);
TSTALLOC(BSIM4v5BbPtr, BSIM4v5bNode, BSIM4v5bNode) TSTALLOC(BSIM4v5BbPtr, BSIM4v5bNode, BSIM4v5bNode);
} }
if (model->BSIM4v5rdsMod) if (model->BSIM4v5rdsMod)
{ TSTALLOC(BSIM4v5DgpPtr, BSIM4v5dNode, BSIM4v5gNodePrime) { TSTALLOC(BSIM4v5DgpPtr, BSIM4v5dNode, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5DspPtr, BSIM4v5dNode, BSIM4v5sNodePrime) TSTALLOC(BSIM4v5DspPtr, BSIM4v5dNode, BSIM4v5sNodePrime);
TSTALLOC(BSIM4v5DbpPtr, BSIM4v5dNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5DbpPtr, BSIM4v5dNode, BSIM4v5bNodePrime);
TSTALLOC(BSIM4v5SdpPtr, BSIM4v5sNode, BSIM4v5dNodePrime) TSTALLOC(BSIM4v5SdpPtr, BSIM4v5sNode, BSIM4v5dNodePrime);
TSTALLOC(BSIM4v5SgpPtr, BSIM4v5sNode, BSIM4v5gNodePrime) TSTALLOC(BSIM4v5SgpPtr, BSIM4v5sNode, BSIM4v5gNodePrime);
TSTALLOC(BSIM4v5SbpPtr, BSIM4v5sNode, BSIM4v5bNodePrime) TSTALLOC(BSIM4v5SbpPtr, BSIM4v5sNode, BSIM4v5bNodePrime);
} }
} }
} }

144
src/spicelib/devices/bsim4v6/b4v6set.c
View File

@ -2310,96 +2310,96 @@ BSIM4v6instance **InstArray;
/* set Sparse Matrix Pointers /* set Sparse Matrix Pointers
* macro to make elements with built-in out-of-memory test */ * macro to make elements with built-in out-of-memory test */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(BSIM4v6DPbpPtr, BSIM4v6dNodePrime, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6DPbpPtr, BSIM4v6dNodePrime, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6GPbpPtr, BSIM4v6gNodePrime, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6GPbpPtr, BSIM4v6gNodePrime, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6SPbpPtr, BSIM4v6sNodePrime, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6SPbpPtr, BSIM4v6sNodePrime, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6BPdpPtr, BSIM4v6bNodePrime, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6BPdpPtr, BSIM4v6bNodePrime, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6BPgpPtr, BSIM4v6bNodePrime, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6BPgpPtr, BSIM4v6bNodePrime, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6BPspPtr, BSIM4v6bNodePrime, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6BPspPtr, BSIM4v6bNodePrime, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6BPbpPtr, BSIM4v6bNodePrime, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6BPbpPtr, BSIM4v6bNodePrime, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6DdPtr, BSIM4v6dNode, BSIM4v6dNode) TSTALLOC(BSIM4v6DdPtr, BSIM4v6dNode, BSIM4v6dNode);
TSTALLOC(BSIM4v6GPgpPtr, BSIM4v6gNodePrime, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6GPgpPtr, BSIM4v6gNodePrime, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6SsPtr, BSIM4v6sNode, BSIM4v6sNode) TSTALLOC(BSIM4v6SsPtr, BSIM4v6sNode, BSIM4v6sNode);
TSTALLOC(BSIM4v6DPdpPtr, BSIM4v6dNodePrime, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6DPdpPtr, BSIM4v6dNodePrime, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6SPspPtr, BSIM4v6sNodePrime, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6SPspPtr, BSIM4v6sNodePrime, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6DdpPtr, BSIM4v6dNode, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6DdpPtr, BSIM4v6dNode, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6GPdpPtr, BSIM4v6gNodePrime, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6GPdpPtr, BSIM4v6gNodePrime, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6GPspPtr, BSIM4v6gNodePrime, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6GPspPtr, BSIM4v6gNodePrime, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6SspPtr, BSIM4v6sNode, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6SspPtr, BSIM4v6sNode, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6DPspPtr, BSIM4v6dNodePrime, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6DPspPtr, BSIM4v6dNodePrime, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6DPdPtr, BSIM4v6dNodePrime, BSIM4v6dNode) TSTALLOC(BSIM4v6DPdPtr, BSIM4v6dNodePrime, BSIM4v6dNode);
TSTALLOC(BSIM4v6DPgpPtr, BSIM4v6dNodePrime, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6DPgpPtr, BSIM4v6dNodePrime, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6SPgpPtr, BSIM4v6sNodePrime, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6SPgpPtr, BSIM4v6sNodePrime, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6SPsPtr, BSIM4v6sNodePrime, BSIM4v6sNode) TSTALLOC(BSIM4v6SPsPtr, BSIM4v6sNodePrime, BSIM4v6sNode);
TSTALLOC(BSIM4v6SPdpPtr, BSIM4v6sNodePrime, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6SPdpPtr, BSIM4v6sNodePrime, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6QqPtr, BSIM4v6qNode, BSIM4v6qNode) TSTALLOC(BSIM4v6QqPtr, BSIM4v6qNode, BSIM4v6qNode);
TSTALLOC(BSIM4v6QbpPtr, BSIM4v6qNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6QbpPtr, BSIM4v6qNode, BSIM4v6bNodePrime) ;
TSTALLOC(BSIM4v6QdpPtr, BSIM4v6qNode, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6QdpPtr, BSIM4v6qNode, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6QspPtr, BSIM4v6qNode, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6QspPtr, BSIM4v6qNode, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6QgpPtr, BSIM4v6qNode, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6QgpPtr, BSIM4v6qNode, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6DPqPtr, BSIM4v6dNodePrime, BSIM4v6qNode) TSTALLOC(BSIM4v6DPqPtr, BSIM4v6dNodePrime, BSIM4v6qNode);
TSTALLOC(BSIM4v6SPqPtr, BSIM4v6sNodePrime, BSIM4v6qNode) TSTALLOC(BSIM4v6SPqPtr, BSIM4v6sNodePrime, BSIM4v6qNode);
TSTALLOC(BSIM4v6GPqPtr, BSIM4v6gNodePrime, BSIM4v6qNode) TSTALLOC(BSIM4v6GPqPtr, BSIM4v6gNodePrime, BSIM4v6qNode);
if (here->BSIM4v6rgateMod != 0) if (here->BSIM4v6rgateMod != 0)
{ TSTALLOC(BSIM4v6GEgePtr, BSIM4v6gNodeExt, BSIM4v6gNodeExt) { TSTALLOC(BSIM4v6GEgePtr, BSIM4v6gNodeExt, BSIM4v6gNodeExt);
TSTALLOC(BSIM4v6GEgpPtr, BSIM4v6gNodeExt, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6GEgpPtr, BSIM4v6gNodeExt, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6GPgePtr, BSIM4v6gNodePrime, BSIM4v6gNodeExt) TSTALLOC(BSIM4v6GPgePtr, BSIM4v6gNodePrime, BSIM4v6gNodeExt);
TSTALLOC(BSIM4v6GEdpPtr, BSIM4v6gNodeExt, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6GEdpPtr, BSIM4v6gNodeExt, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6GEspPtr, BSIM4v6gNodeExt, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6GEspPtr, BSIM4v6gNodeExt, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6GEbpPtr, BSIM4v6gNodeExt, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6GEbpPtr, BSIM4v6gNodeExt, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6GMdpPtr, BSIM4v6gNodeMid, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6GMdpPtr, BSIM4v6gNodeMid, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6GMgpPtr, BSIM4v6gNodeMid, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6GMgpPtr, BSIM4v6gNodeMid, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6GMgmPtr, BSIM4v6gNodeMid, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6GMgmPtr, BSIM4v6gNodeMid, BSIM4v6gNodeMid);
TSTALLOC(BSIM4v6GMgePtr, BSIM4v6gNodeMid, BSIM4v6gNodeExt) TSTALLOC(BSIM4v6GMgePtr, BSIM4v6gNodeMid, BSIM4v6gNodeExt);
TSTALLOC(BSIM4v6GMspPtr, BSIM4v6gNodeMid, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6GMspPtr, BSIM4v6gNodeMid, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6GMbpPtr, BSIM4v6gNodeMid, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6GMbpPtr, BSIM4v6gNodeMid, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6DPgmPtr, BSIM4v6dNodePrime, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6DPgmPtr, BSIM4v6dNodePrime, BSIM4v6gNodeMid);
TSTALLOC(BSIM4v6GPgmPtr, BSIM4v6gNodePrime, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6GPgmPtr, BSIM4v6gNodePrime, BSIM4v6gNodeMid);
TSTALLOC(BSIM4v6GEgmPtr, BSIM4v6gNodeExt, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6GEgmPtr, BSIM4v6gNodeExt, BSIM4v6gNodeMid);
TSTALLOC(BSIM4v6SPgmPtr, BSIM4v6sNodePrime, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6SPgmPtr, BSIM4v6sNodePrime, BSIM4v6gNodeMid);
TSTALLOC(BSIM4v6BPgmPtr, BSIM4v6bNodePrime, BSIM4v6gNodeMid) TSTALLOC(BSIM4v6BPgmPtr, BSIM4v6bNodePrime, BSIM4v6gNodeMid);
} }
if ((here->BSIM4v6rbodyMod ==1) || (here->BSIM4v6rbodyMod ==2)) if ((here->BSIM4v6rbodyMod ==1) || (here->BSIM4v6rbodyMod ==2))
{ TSTALLOC(BSIM4v6DPdbPtr, BSIM4v6dNodePrime, BSIM4v6dbNode) { TSTALLOC(BSIM4v6DPdbPtr, BSIM4v6dNodePrime, BSIM4v6dbNode);
TSTALLOC(BSIM4v6SPsbPtr, BSIM4v6sNodePrime, BSIM4v6sbNode) TSTALLOC(BSIM4v6SPsbPtr, BSIM4v6sNodePrime, BSIM4v6sbNode);
TSTALLOC(BSIM4v6DBdpPtr, BSIM4v6dbNode, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6DBdpPtr, BSIM4v6dbNode, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6DBdbPtr, BSIM4v6dbNode, BSIM4v6dbNode) TSTALLOC(BSIM4v6DBdbPtr, BSIM4v6dbNode, BSIM4v6dbNode);
TSTALLOC(BSIM4v6DBbpPtr, BSIM4v6dbNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6DBbpPtr, BSIM4v6dbNode, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6DBbPtr, BSIM4v6dbNode, BSIM4v6bNode) TSTALLOC(BSIM4v6DBbPtr, BSIM4v6dbNode, BSIM4v6bNode);
TSTALLOC(BSIM4v6BPdbPtr, BSIM4v6bNodePrime, BSIM4v6dbNode) TSTALLOC(BSIM4v6BPdbPtr, BSIM4v6bNodePrime, BSIM4v6dbNode);
TSTALLOC(BSIM4v6BPbPtr, BSIM4v6bNodePrime, BSIM4v6bNode) TSTALLOC(BSIM4v6BPbPtr, BSIM4v6bNodePrime, BSIM4v6bNode);
TSTALLOC(BSIM4v6BPsbPtr, BSIM4v6bNodePrime, BSIM4v6sbNode) TSTALLOC(BSIM4v6BPsbPtr, BSIM4v6bNodePrime, BSIM4v6sbNode);
TSTALLOC(BSIM4v6SBspPtr, BSIM4v6sbNode, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6SBspPtr, BSIM4v6sbNode, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6SBbpPtr, BSIM4v6sbNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6SBbpPtr, BSIM4v6sbNode, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6SBbPtr, BSIM4v6sbNode, BSIM4v6bNode) TSTALLOC(BSIM4v6SBbPtr, BSIM4v6sbNode, BSIM4v6bNode);
TSTALLOC(BSIM4v6SBsbPtr, BSIM4v6sbNode, BSIM4v6sbNode) TSTALLOC(BSIM4v6SBsbPtr, BSIM4v6sbNode, BSIM4v6sbNode);
TSTALLOC(BSIM4v6BdbPtr, BSIM4v6bNode, BSIM4v6dbNode) TSTALLOC(BSIM4v6BdbPtr, BSIM4v6bNode, BSIM4v6dbNode);
TSTALLOC(BSIM4v6BbpPtr, BSIM4v6bNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6BbpPtr, BSIM4v6bNode, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6BsbPtr, BSIM4v6bNode, BSIM4v6sbNode) TSTALLOC(BSIM4v6BsbPtr, BSIM4v6bNode, BSIM4v6sbNode);
TSTALLOC(BSIM4v6BbPtr, BSIM4v6bNode, BSIM4v6bNode) TSTALLOC(BSIM4v6BbPtr, BSIM4v6bNode, BSIM4v6bNode);
} }
if (model->BSIM4v6rdsMod) if (model->BSIM4v6rdsMod)
{ TSTALLOC(BSIM4v6DgpPtr, BSIM4v6dNode, BSIM4v6gNodePrime) { TSTALLOC(BSIM4v6DgpPtr, BSIM4v6dNode, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6DspPtr, BSIM4v6dNode, BSIM4v6sNodePrime) TSTALLOC(BSIM4v6DspPtr, BSIM4v6dNode, BSIM4v6sNodePrime);
TSTALLOC(BSIM4v6DbpPtr, BSIM4v6dNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6DbpPtr, BSIM4v6dNode, BSIM4v6bNodePrime);
TSTALLOC(BSIM4v6SdpPtr, BSIM4v6sNode, BSIM4v6dNodePrime) TSTALLOC(BSIM4v6SdpPtr, BSIM4v6sNode, BSIM4v6dNodePrime);
TSTALLOC(BSIM4v6SgpPtr, BSIM4v6sNode, BSIM4v6gNodePrime) TSTALLOC(BSIM4v6SgpPtr, BSIM4v6sNode, BSIM4v6gNodePrime);
TSTALLOC(BSIM4v6SbpPtr, BSIM4v6sNode, BSIM4v6bNodePrime) TSTALLOC(BSIM4v6SbpPtr, BSIM4v6sNode, BSIM4v6bNodePrime);
} }
} }
} /* end of loop through all the BSIM4v6 device models */ } /* end of loop through all the BSIM4v6 device models */

208
src/spicelib/devices/bsimsoi/b4soiset.c
View File

@ -2515,32 +2515,32 @@ B4SOIinstance **InstArray;
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) { if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) {
TSTALLOC(B4SOITemptempPtr, B4SOItempNode, B4SOItempNode) TSTALLOC(B4SOITemptempPtr, B4SOItempNode, B4SOItempNode);
TSTALLOC(B4SOITempdpPtr, B4SOItempNode, B4SOIdNodePrime) TSTALLOC(B4SOITempdpPtr, B4SOItempNode, B4SOIdNodePrime);
TSTALLOC(B4SOITempspPtr, B4SOItempNode, B4SOIsNodePrime) TSTALLOC(B4SOITempspPtr, B4SOItempNode, B4SOIsNodePrime);
TSTALLOC(B4SOITempgPtr, B4SOItempNode, B4SOIgNode) TSTALLOC(B4SOITempgPtr, B4SOItempNode, B4SOIgNode);
TSTALLOC(B4SOITempbPtr, B4SOItempNode, B4SOIbNode) TSTALLOC(B4SOITempbPtr, B4SOItempNode, B4SOIbNode);
TSTALLOC(B4SOIGtempPtr, B4SOIgNode, B4SOItempNode) TSTALLOC(B4SOIGtempPtr, B4SOIgNode, B4SOItempNode);
TSTALLOC(B4SOIDPtempPtr, B4SOIdNodePrime, B4SOItempNode) TSTALLOC(B4SOIDPtempPtr, B4SOIdNodePrime, B4SOItempNode);
TSTALLOC(B4SOISPtempPtr, B4SOIsNodePrime, B4SOItempNode) TSTALLOC(B4SOISPtempPtr, B4SOIsNodePrime, B4SOItempNode);
TSTALLOC(B4SOIEtempPtr, B4SOIeNode, B4SOItempNode) TSTALLOC(B4SOIEtempPtr, B4SOIeNode, B4SOItempNode);
TSTALLOC(B4SOIBtempPtr, B4SOIbNode, B4SOItempNode) TSTALLOC(B4SOIBtempPtr, B4SOIbNode, B4SOItempNode);
if (here->B4SOIbodyMod == 1) { if (here->B4SOIbodyMod == 1) {
TSTALLOC(B4SOIPtempPtr, B4SOIpNode, B4SOItempNode) TSTALLOC(B4SOIPtempPtr, B4SOIpNode, B4SOItempNode);
} }
/* v3.0 */ /* v3.0 */
if (here->B4SOIsoiMod != 0) { /* v3.2 */ if (here->B4SOIsoiMod != 0) { /* v3.2 */
TSTALLOC(B4SOITempePtr, B4SOItempNode, B4SOIeNode) TSTALLOC(B4SOITempePtr, B4SOItempNode, B4SOIeNode);
} }
} }
@ -2548,40 +2548,40 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
/* Don't create any Jacobian entry for pNode */ /* Don't create any Jacobian entry for pNode */
} }
else if (here->B4SOIbodyMod == 1) { else if (here->B4SOIbodyMod == 1) {
TSTALLOC(B4SOIBpPtr, B4SOIbNode, B4SOIpNode) TSTALLOC(B4SOIBpPtr, B4SOIbNode, B4SOIpNode);
TSTALLOC(B4SOIPbPtr, B4SOIpNode, B4SOIbNode) TSTALLOC(B4SOIPbPtr, B4SOIpNode, B4SOIbNode);
TSTALLOC(B4SOIPpPtr, B4SOIpNode, B4SOIpNode) TSTALLOC(B4SOIPpPtr, B4SOIpNode, B4SOIpNode);
/* 4.1 for Igb2_agbcp2 */ /* 4.1 for Igb2_agbcp2 */
TSTALLOC(B4SOIPgPtr , B4SOIpNode, B4SOIgNode) TSTALLOC(B4SOIPgPtr , B4SOIpNode, B4SOIgNode);
TSTALLOC(B4SOIGpPtr , B4SOIgNode, B4SOIpNode) TSTALLOC(B4SOIGpPtr , B4SOIgNode, B4SOIpNode);
} }
/* v3.1 added for RF */ /* v3.1 added for RF */
if (here->B4SOIrgateMod != 0) if (here->B4SOIrgateMod != 0)
{ TSTALLOC(B4SOIGEgePtr, B4SOIgNodeExt, B4SOIgNodeExt) { TSTALLOC(B4SOIGEgePtr, B4SOIgNodeExt, B4SOIgNodeExt);
TSTALLOC(B4SOIGEgPtr, B4SOIgNodeExt, B4SOIgNode) TSTALLOC(B4SOIGEgPtr, B4SOIgNodeExt, B4SOIgNode);
TSTALLOC(B4SOIGgePtr, B4SOIgNode, B4SOIgNodeExt) TSTALLOC(B4SOIGgePtr, B4SOIgNode, B4SOIgNodeExt);
TSTALLOC(B4SOIGEdpPtr, B4SOIgNodeExt, B4SOIdNodePrime) TSTALLOC(B4SOIGEdpPtr, B4SOIgNodeExt, B4SOIdNodePrime);
TSTALLOC(B4SOIGEspPtr, B4SOIgNodeExt, B4SOIsNodePrime) TSTALLOC(B4SOIGEspPtr, B4SOIgNodeExt, B4SOIsNodePrime);
if (here->B4SOIsoiMod !=2) /* v3.2 */ if (here->B4SOIsoiMod !=2) /* v3.2 */
TSTALLOC(B4SOIGEbPtr, B4SOIgNodeExt, B4SOIbNode) TSTALLOC(B4SOIGEbPtr, B4SOIgNodeExt, B4SOIbNode);
TSTALLOC(B4SOIGMdpPtr, B4SOIgNodeMid, B4SOIdNodePrime) TSTALLOC(B4SOIGMdpPtr, B4SOIgNodeMid, B4SOIdNodePrime);
TSTALLOC(B4SOIGMgPtr, B4SOIgNodeMid, B4SOIgNode) TSTALLOC(B4SOIGMgPtr, B4SOIgNodeMid, B4SOIgNode);
TSTALLOC(B4SOIGMgmPtr, B4SOIgNodeMid, B4SOIgNodeMid) TSTALLOC(B4SOIGMgmPtr, B4SOIgNodeMid, B4SOIgNodeMid);
TSTALLOC(B4SOIGMgePtr, B4SOIgNodeMid, B4SOIgNodeExt) TSTALLOC(B4SOIGMgePtr, B4SOIgNodeMid, B4SOIgNodeExt);
TSTALLOC(B4SOIGMspPtr, B4SOIgNodeMid, B4SOIsNodePrime) TSTALLOC(B4SOIGMspPtr, B4SOIgNodeMid, B4SOIsNodePrime);
if (here->B4SOIsoiMod !=2) /* v3.2 */ if (here->B4SOIsoiMod !=2) /* v3.2 */
TSTALLOC(B4SOIGMbPtr, B4SOIgNodeMid, B4SOIbNode) TSTALLOC(B4SOIGMbPtr, B4SOIgNodeMid, B4SOIbNode);
TSTALLOC(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode) TSTALLOC(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode);
TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid) TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid);
TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid) TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid);
TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid) TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid);
TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid) TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid);
TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid) TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid);
} }
/* v3.1 added for RF end */ /* v3.1 added for RF end */
@ -2589,74 +2589,74 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
/* v3.1 */ /* v3.1 */
if (here->B4SOIsoiMod != 2) /* v3.2 */ if (here->B4SOIsoiMod != 2) /* v3.2 */
{ {
TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode);
TSTALLOC(B4SOIGbPtr, B4SOIgNode, B4SOIbNode) TSTALLOC(B4SOIGbPtr, B4SOIgNode, B4SOIbNode);
TSTALLOC(B4SOIDPbPtr, B4SOIdNodePrime, B4SOIbNode) TSTALLOC(B4SOIDPbPtr, B4SOIdNodePrime, B4SOIbNode);
TSTALLOC(B4SOISPbPtr, B4SOIsNodePrime, B4SOIbNode) TSTALLOC(B4SOISPbPtr, B4SOIsNodePrime, B4SOIbNode);
TSTALLOC(B4SOIBePtr, B4SOIbNode, B4SOIeNode) TSTALLOC(B4SOIBePtr, B4SOIbNode, B4SOIeNode);
TSTALLOC(B4SOIBgPtr, B4SOIbNode, B4SOIgNode) TSTALLOC(B4SOIBgPtr, B4SOIbNode, B4SOIgNode);
TSTALLOC(B4SOIBdpPtr, B4SOIbNode, B4SOIdNodePrime) TSTALLOC(B4SOIBdpPtr, B4SOIbNode, B4SOIdNodePrime);
TSTALLOC(B4SOIBspPtr, B4SOIbNode, B4SOIsNodePrime) TSTALLOC(B4SOIBspPtr, B4SOIbNode, B4SOIsNodePrime);
TSTALLOC(B4SOIBbPtr, B4SOIbNode, B4SOIbNode) TSTALLOC(B4SOIBbPtr, B4SOIbNode, B4SOIbNode);
} }
/* v3.1 */ /* v3.1 */
TSTALLOC(B4SOIEgPtr, B4SOIeNode, B4SOIgNode) TSTALLOC(B4SOIEgPtr, B4SOIeNode, B4SOIgNode);
TSTALLOC(B4SOIEdpPtr, B4SOIeNode, B4SOIdNodePrime) TSTALLOC(B4SOIEdpPtr, B4SOIeNode, B4SOIdNodePrime);
TSTALLOC(B4SOIEspPtr, B4SOIeNode, B4SOIsNodePrime) TSTALLOC(B4SOIEspPtr, B4SOIeNode, B4SOIsNodePrime);
TSTALLOC(B4SOIGePtr, B4SOIgNode, B4SOIeNode) TSTALLOC(B4SOIGePtr, B4SOIgNode, B4SOIeNode);
TSTALLOC(B4SOIDPePtr, B4SOIdNodePrime, B4SOIeNode) TSTALLOC(B4SOIDPePtr, B4SOIdNodePrime, B4SOIeNode);
TSTALLOC(B4SOISPePtr, B4SOIsNodePrime, B4SOIeNode) TSTALLOC(B4SOISPePtr, B4SOIsNodePrime, B4SOIeNode);
TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode);
TSTALLOC(B4SOIEePtr, B4SOIeNode, B4SOIeNode) TSTALLOC(B4SOIEePtr, B4SOIeNode, B4SOIeNode);
TSTALLOC(B4SOIGgPtr, B4SOIgNode, B4SOIgNode) TSTALLOC(B4SOIGgPtr, B4SOIgNode, B4SOIgNode);
TSTALLOC(B4SOIGdpPtr, B4SOIgNode, B4SOIdNodePrime) TSTALLOC(B4SOIGdpPtr, B4SOIgNode, B4SOIdNodePrime);
TSTALLOC(B4SOIGspPtr, B4SOIgNode, B4SOIsNodePrime) TSTALLOC(B4SOIGspPtr, B4SOIgNode, B4SOIsNodePrime);
TSTALLOC(B4SOIDPgPtr, B4SOIdNodePrime, B4SOIgNode) TSTALLOC(B4SOIDPgPtr, B4SOIdNodePrime, B4SOIgNode);
TSTALLOC(B4SOIDPdpPtr, B4SOIdNodePrime, B4SOIdNodePrime) TSTALLOC(B4SOIDPdpPtr, B4SOIdNodePrime, B4SOIdNodePrime);
TSTALLOC(B4SOIDPspPtr, B4SOIdNodePrime, B4SOIsNodePrime) TSTALLOC(B4SOIDPspPtr, B4SOIdNodePrime, B4SOIsNodePrime);
TSTALLOC(B4SOIDPdPtr, B4SOIdNodePrime, B4SOIdNode) TSTALLOC(B4SOIDPdPtr, B4SOIdNodePrime, B4SOIdNode);
TSTALLOC(B4SOISPgPtr, B4SOIsNodePrime, B4SOIgNode) TSTALLOC(B4SOISPgPtr, B4SOIsNodePrime, B4SOIgNode);
TSTALLOC(B4SOISPdpPtr, B4SOIsNodePrime, B4SOIdNodePrime) TSTALLOC(B4SOISPdpPtr, B4SOIsNodePrime, B4SOIdNodePrime);
TSTALLOC(B4SOISPspPtr, B4SOIsNodePrime, B4SOIsNodePrime) TSTALLOC(B4SOISPspPtr, B4SOIsNodePrime, B4SOIsNodePrime);
TSTALLOC(B4SOISPsPtr, B4SOIsNodePrime, B4SOIsNode) TSTALLOC(B4SOISPsPtr, B4SOIsNodePrime, B4SOIsNode);
TSTALLOC(B4SOIDdPtr, B4SOIdNode, B4SOIdNode) TSTALLOC(B4SOIDdPtr, B4SOIdNode, B4SOIdNode);
TSTALLOC(B4SOIDdpPtr, B4SOIdNode, B4SOIdNodePrime) TSTALLOC(B4SOIDdpPtr, B4SOIdNode, B4SOIdNodePrime);
TSTALLOC(B4SOISsPtr, B4SOIsNode, B4SOIsNode) TSTALLOC(B4SOISsPtr, B4SOIsNode, B4SOIsNode);
TSTALLOC(B4SOISspPtr, B4SOIsNode, B4SOIsNodePrime) TSTALLOC(B4SOISspPtr, B4SOIsNode, B4SOIsNodePrime);
/* v4.0 */ /* v4.0 */
if (here->B4SOIrbodyMod == 1) if (here->B4SOIrbodyMod == 1)
{ TSTALLOC(B4SOIDPdbPtr, B4SOIdNodePrime, B4SOIdbNode) { TSTALLOC(B4SOIDPdbPtr, B4SOIdNodePrime, B4SOIdbNode);
TSTALLOC(B4SOISPsbPtr, B4SOIsNodePrime, B4SOIsbNode) TSTALLOC(B4SOISPsbPtr, B4SOIsNodePrime, B4SOIsbNode);
TSTALLOC(B4SOIDBdpPtr, B4SOIdbNode, B4SOIdNodePrime) TSTALLOC(B4SOIDBdpPtr, B4SOIdbNode, B4SOIdNodePrime);
TSTALLOC(B4SOIDBdbPtr, B4SOIdbNode, B4SOIdbNode) TSTALLOC(B4SOIDBdbPtr, B4SOIdbNode, B4SOIdbNode);
TSTALLOC(B4SOIDBbPtr, B4SOIdbNode, B4SOIbNode) TSTALLOC(B4SOIDBbPtr, B4SOIdbNode, B4SOIbNode);
TSTALLOC(B4SOISBspPtr, B4SOIsbNode, B4SOIsNodePrime) TSTALLOC(B4SOISBspPtr, B4SOIsbNode, B4SOIsNodePrime);
TSTALLOC(B4SOISBsbPtr, B4SOIsbNode, B4SOIsbNode) TSTALLOC(B4SOISBsbPtr, B4SOIsbNode, B4SOIsbNode);
TSTALLOC(B4SOISBbPtr, B4SOIsbNode, B4SOIbNode) TSTALLOC(B4SOISBbPtr, B4SOIsbNode, B4SOIbNode);
TSTALLOC(B4SOIBdbPtr, B4SOIbNode, B4SOIdbNode) TSTALLOC(B4SOIBdbPtr, B4SOIbNode, B4SOIdbNode);
TSTALLOC(B4SOIBsbPtr, B4SOIbNode, B4SOIsbNode) TSTALLOC(B4SOIBsbPtr, B4SOIbNode, B4SOIsbNode);
} }
if (model->B4SOIrdsMod) if (model->B4SOIrdsMod)
{ TSTALLOC(B4SOIDgPtr, B4SOIdNode, B4SOIgNode) { TSTALLOC(B4SOIDgPtr, B4SOIdNode, B4SOIgNode);
TSTALLOC(B4SOIDspPtr, B4SOIdNode, B4SOIsNodePrime) TSTALLOC(B4SOIDspPtr, B4SOIdNode, B4SOIsNodePrime);
TSTALLOC(B4SOISdpPtr, B4SOIsNode, B4SOIdNodePrime) TSTALLOC(B4SOISdpPtr, B4SOIsNode, B4SOIdNodePrime);
TSTALLOC(B4SOISgPtr, B4SOIsNode, B4SOIgNode) TSTALLOC(B4SOISgPtr, B4SOIsNode, B4SOIgNode);
if (model->B4SOIsoiMod != 2) { if (model->B4SOIsoiMod != 2) {
TSTALLOC(B4SOIDbPtr, B4SOIdNode, B4SOIbNode) TSTALLOC(B4SOIDbPtr, B4SOIdNode, B4SOIbNode);
TSTALLOC(B4SOISbPtr, B4SOIsNode, B4SOIbNode) TSTALLOC(B4SOISbPtr, B4SOIsNode, B4SOIbNode);
} }
} }
@ -2666,25 +2666,25 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
/* here for debugging purpose only */ /* here for debugging purpose only */
if (here->B4SOIdebugMod != 0) if (here->B4SOIdebugMod != 0)
{ {
TSTALLOC(B4SOIVbsPtr, B4SOIvbsNode, B4SOIvbsNode) TSTALLOC(B4SOIVbsPtr, B4SOIvbsNode, B4SOIvbsNode);
TSTALLOC(B4SOIIdsPtr, B4SOIidsNode, B4SOIidsNode) TSTALLOC(B4SOIIdsPtr, B4SOIidsNode, B4SOIidsNode);
TSTALLOC(B4SOIIcPtr, B4SOIicNode, B4SOIicNode) TSTALLOC(B4SOIIcPtr, B4SOIicNode, B4SOIicNode);
TSTALLOC(B4SOIIbsPtr, B4SOIibsNode, B4SOIibsNode) TSTALLOC(B4SOIIbsPtr, B4SOIibsNode, B4SOIibsNode);
TSTALLOC(B4SOIIbdPtr, B4SOIibdNode, B4SOIibdNode) TSTALLOC(B4SOIIbdPtr, B4SOIibdNode, B4SOIibdNode);
TSTALLOC(B4SOIIiiPtr, B4SOIiiiNode, B4SOIiiiNode) TSTALLOC(B4SOIIiiPtr, B4SOIiiiNode, B4SOIiiiNode);
TSTALLOC(B4SOIIgPtr, B4SOIigNode, B4SOIigNode) TSTALLOC(B4SOIIgPtr, B4SOIigNode, B4SOIigNode);
TSTALLOC(B4SOIGiggPtr, B4SOIgiggNode, B4SOIgiggNode) TSTALLOC(B4SOIGiggPtr, B4SOIgiggNode, B4SOIgiggNode);
TSTALLOC(B4SOIGigdPtr, B4SOIgigdNode, B4SOIgigdNode) TSTALLOC(B4SOIGigdPtr, B4SOIgigdNode, B4SOIgigdNode);
TSTALLOC(B4SOIGigbPtr, B4SOIgigbNode, B4SOIgigbNode) TSTALLOC(B4SOIGigbPtr, B4SOIgigbNode, B4SOIgigbNode);
TSTALLOC(B4SOIIgidlPtr, B4SOIigidlNode, B4SOIigidlNode) TSTALLOC(B4SOIIgidlPtr, B4SOIigidlNode, B4SOIigidlNode);
TSTALLOC(B4SOIItunPtr, B4SOIitunNode, B4SOIitunNode) TSTALLOC(B4SOIItunPtr, B4SOIitunNode, B4SOIitunNode);
TSTALLOC(B4SOIIbpPtr, B4SOIibpNode, B4SOIibpNode) TSTALLOC(B4SOIIbpPtr, B4SOIibpNode, B4SOIibpNode);
TSTALLOC(B4SOICbbPtr, B4SOIcbbNode, B4SOIcbbNode) TSTALLOC(B4SOICbbPtr, B4SOIcbbNode, B4SOIcbbNode);
TSTALLOC(B4SOICbdPtr, B4SOIcbdNode, B4SOIcbdNode) TSTALLOC(B4SOICbdPtr, B4SOIcbdNode, B4SOIcbdNode);
TSTALLOC(B4SOICbgPtr, B4SOIcbgNode, B4SOIcbgNode) TSTALLOC(B4SOICbgPtr, B4SOIcbgNode, B4SOIcbgNode);
TSTALLOC(B4SOIQbfPtr, B4SOIqbfNode, B4SOIqbfNode) TSTALLOC(B4SOIQbfPtr, B4SOIqbfNode, B4SOIqbfNode);
TSTALLOC(B4SOIQjsPtr, B4SOIqjsNode, B4SOIqjsNode) TSTALLOC(B4SOIQjsPtr, B4SOIqjsNode, B4SOIqjsNode);
TSTALLOC(B4SOIQjdPtr, B4SOIqjdNode, B4SOIqjdNode) TSTALLOC(B4SOIQjdPtr, B4SOIqjdNode, B4SOIqjdNode);
} }

12
src/spicelib/devices/cap/capsetup.c
View File

@ -101,14 +101,14 @@ CAPsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(CAPposPosptr,CAPposNode,CAPposNode) TSTALLOC(CAPposPosptr,CAPposNode,CAPposNode);
TSTALLOC(CAPnegNegptr,CAPnegNode,CAPnegNode) TSTALLOC(CAPnegNegptr,CAPnegNode,CAPnegNode);
TSTALLOC(CAPposNegptr,CAPposNode,CAPnegNode) TSTALLOC(CAPposNegptr,CAPposNode,CAPnegNode);
TSTALLOC(CAPnegPosptr,CAPnegNode,CAPposNode) TSTALLOC(CAPnegPosptr,CAPnegNode,CAPposNode);
} }
} }
return(OK); return(OK);

8
src/spicelib/devices/cccs/cccsset.c
View File

@ -45,12 +45,12 @@ CCCSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(CCCSposContBrptr,CCCSposNode,CCCScontBranch) TSTALLOC(CCCSposContBrptr,CCCSposNode,CCCScontBranch);
TSTALLOC(CCCSnegContBrptr,CCCSnegNode,CCCScontBranch) TSTALLOC(CCCSnegContBrptr,CCCSnegNode,CCCScontBranch);
} }
} }
return(OK); return(OK);

14
src/spicelib/devices/ccvs/ccvsset.c
View File

@ -54,15 +54,15 @@ CCVSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(CCVSposIbrptr, CCVSposNode, CCVSbranch) TSTALLOC(CCVSposIbrptr, CCVSposNode, CCVSbranch);
TSTALLOC(CCVSnegIbrptr, CCVSnegNode, CCVSbranch) TSTALLOC(CCVSnegIbrptr, CCVSnegNode, CCVSbranch);
TSTALLOC(CCVSibrNegptr, CCVSbranch, CCVSnegNode) TSTALLOC(CCVSibrNegptr, CCVSbranch, CCVSnegNode);
TSTALLOC(CCVSibrPosptr, CCVSbranch, CCVSposNode) TSTALLOC(CCVSibrPosptr, CCVSbranch, CCVSposNode);
TSTALLOC(CCVSibrContBrptr, CCVSbranch, CCVScontBranch) TSTALLOC(CCVSibrContBrptr, CCVSbranch, CCVScontBranch);
} }
} }
return(OK); return(OK);

4
src/spicelib/devices/cpl/cplsetup.c
View File

@ -185,9 +185,9 @@ CPLsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
noL = here->dimension; noL = here->dimension;

12
src/spicelib/devices/csw/cswsetup.c
View File

@ -60,14 +60,14 @@ CSWsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(CSWposPosptr, CSWposNode, CSWposNode) TSTALLOC(CSWposPosptr, CSWposNode, CSWposNode);
TSTALLOC(CSWposNegptr, CSWposNode, CSWnegNode) TSTALLOC(CSWposNegptr, CSWposNode, CSWnegNode);
TSTALLOC(CSWnegPosptr, CSWnegNode, CSWposNode) TSTALLOC(CSWnegPosptr, CSWnegNode, CSWposNode);
TSTALLOC(CSWnegNegptr, CSWnegNode, CSWnegNode) TSTALLOC(CSWnegNegptr, CSWnegNode, CSWnegNode);
} }
} }
return(OK); return(OK);

18
src/spicelib/devices/dio/diosetup.c
View File

@ -219,17 +219,17 @@ DIOsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(DIOposPosPrimePtr,DIOposNode,DIOposPrimeNode) TSTALLOC(DIOposPosPrimePtr,DIOposNode,DIOposPrimeNode);
TSTALLOC(DIOnegPosPrimePtr,DIOnegNode,DIOposPrimeNode) TSTALLOC(DIOnegPosPrimePtr,DIOnegNode,DIOposPrimeNode);
TSTALLOC(DIOposPrimePosPtr,DIOposPrimeNode,DIOposNode) TSTALLOC(DIOposPrimePosPtr,DIOposPrimeNode,DIOposNode);
TSTALLOC(DIOposPrimeNegPtr,DIOposPrimeNode,DIOnegNode) TSTALLOC(DIOposPrimeNegPtr,DIOposPrimeNode,DIOnegNode);
TSTALLOC(DIOposPosPtr,DIOposNode,DIOposNode) TSTALLOC(DIOposPosPtr,DIOposNode,DIOposNode);
TSTALLOC(DIOnegNegPtr,DIOnegNode,DIOnegNode) TSTALLOC(DIOnegNegPtr,DIOnegNode,DIOnegNode);
TSTALLOC(DIOposPrimePosPrimePtr,DIOposPrimeNode,DIOposPrimeNode) TSTALLOC(DIOposPrimePosPrimePtr,DIOposPrimeNode,DIOposPrimeNode);
} }
} }
return(OK); return(OK);

60
src/spicelib/devices/hfet1/hfetsetup.c
View File

@ -363,38 +363,38 @@ HFETAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(HFETAdrainDrainPrimePtr,HFETAdrainNode,HFETAdrainPrimeNode) TSTALLOC(HFETAdrainDrainPrimePtr,HFETAdrainNode,HFETAdrainPrimeNode);
TSTALLOC(HFETAgatePrimeDrainPrimePtr,HFETAgatePrimeNode,HFETAdrainPrimeNode) TSTALLOC(HFETAgatePrimeDrainPrimePtr,HFETAgatePrimeNode,HFETAdrainPrimeNode);
TSTALLOC(HFETAgatePrimeSourcePrimePtr,HFETAgatePrimeNode,HFETAsourcePrimeNode) TSTALLOC(HFETAgatePrimeSourcePrimePtr,HFETAgatePrimeNode,HFETAsourcePrimeNode);
TSTALLOC(HFETAsourceSourcePrimePtr,HFETAsourceNode,HFETAsourcePrimeNode) TSTALLOC(HFETAsourceSourcePrimePtr,HFETAsourceNode,HFETAsourcePrimeNode);
TSTALLOC(HFETAdrainPrimeDrainPtr,HFETAdrainPrimeNode,HFETAdrainNode) TSTALLOC(HFETAdrainPrimeDrainPtr,HFETAdrainPrimeNode,HFETAdrainNode);
TSTALLOC(HFETAdrainPrimeGatePrimePtr,HFETAdrainPrimeNode,HFETAgatePrimeNode) TSTALLOC(HFETAdrainPrimeGatePrimePtr,HFETAdrainPrimeNode,HFETAgatePrimeNode);
TSTALLOC(HFETAdrainPrimeSourcePrimePtr,HFETAdrainPrimeNode,HFETAsourcePrimeNode) TSTALLOC(HFETAdrainPrimeSourcePrimePtr,HFETAdrainPrimeNode,HFETAsourcePrimeNode);
TSTALLOC(HFETAsourcePrimeGatePrimePtr,HFETAsourcePrimeNode,HFETAgatePrimeNode) TSTALLOC(HFETAsourcePrimeGatePrimePtr,HFETAsourcePrimeNode,HFETAgatePrimeNode);
TSTALLOC(HFETAsourcePrimeSourcePtr,HFETAsourcePrimeNode,HFETAsourceNode) TSTALLOC(HFETAsourcePrimeSourcePtr,HFETAsourcePrimeNode,HFETAsourceNode);
TSTALLOC(HFETAsourcePrimeDrainPrimePtr,HFETAsourcePrimeNode,HFETAdrainPrimeNode) TSTALLOC(HFETAsourcePrimeDrainPrimePtr,HFETAsourcePrimeNode,HFETAdrainPrimeNode);
TSTALLOC(HFETAdrainDrainPtr,HFETAdrainNode,HFETAdrainNode) TSTALLOC(HFETAdrainDrainPtr,HFETAdrainNode,HFETAdrainNode);
TSTALLOC(HFETAgatePrimeGatePrimePtr,HFETAgatePrimeNode,HFETAgatePrimeNode) TSTALLOC(HFETAgatePrimeGatePrimePtr,HFETAgatePrimeNode,HFETAgatePrimeNode);
TSTALLOC(HFETAsourceSourcePtr,HFETAsourceNode,HFETAsourceNode) TSTALLOC(HFETAsourceSourcePtr,HFETAsourceNode,HFETAsourceNode);
TSTALLOC(HFETAdrainPrimeDrainPrimePtr,HFETAdrainPrimeNode,HFETAdrainPrimeNode) TSTALLOC(HFETAdrainPrimeDrainPrimePtr,HFETAdrainPrimeNode,HFETAdrainPrimeNode);
TSTALLOC(HFETAsourcePrimeSourcePrimePtr,HFETAsourcePrimeNode,HFETAsourcePrimeNode) TSTALLOC(HFETAsourcePrimeSourcePrimePtr,HFETAsourcePrimeNode,HFETAsourcePrimeNode);
TSTALLOC(HFETAdrainPrimeDrainPrmPrmPtr,HFETAdrainPrimeNode,HFETAdrainPrmPrmNode) TSTALLOC(HFETAdrainPrimeDrainPrmPrmPtr,HFETAdrainPrimeNode,HFETAdrainPrmPrmNode);
TSTALLOC(HFETAdrainPrmPrmDrainPrimePtr,HFETAdrainPrmPrmNode,HFETAdrainPrimeNode) TSTALLOC(HFETAdrainPrmPrmDrainPrimePtr,HFETAdrainPrmPrmNode,HFETAdrainPrimeNode);
TSTALLOC(HFETAdrainPrmPrmGatePrimePtr,HFETAdrainPrmPrmNode,HFETAgatePrimeNode) TSTALLOC(HFETAdrainPrmPrmGatePrimePtr,HFETAdrainPrmPrmNode,HFETAgatePrimeNode);
TSTALLOC(HFETAgatePrimeDrainPrmPrmPtr,HFETAgatePrimeNode,HFETAdrainPrmPrmNode) TSTALLOC(HFETAgatePrimeDrainPrmPrmPtr,HFETAgatePrimeNode,HFETAdrainPrmPrmNode);
TSTALLOC(HFETAdrainPrmPrmDrainPrmPrmPtr,HFETAdrainPrmPrmNode,HFETAdrainPrmPrmNode) TSTALLOC(HFETAdrainPrmPrmDrainPrmPrmPtr,HFETAdrainPrmPrmNode,HFETAdrainPrmPrmNode);
TSTALLOC(HFETAsourcePrimeSourcePrmPrmPtr,HFETAsourcePrimeNode,HFETAsourcePrmPrmNode) TSTALLOC(HFETAsourcePrimeSourcePrmPrmPtr,HFETAsourcePrimeNode,HFETAsourcePrmPrmNode);
TSTALLOC(HFETAsourcePrmPrmSourcePrimePtr,HFETAsourcePrmPrmNode,HFETAsourcePrimeNode) TSTALLOC(HFETAsourcePrmPrmSourcePrimePtr,HFETAsourcePrmPrmNode,HFETAsourcePrimeNode);
TSTALLOC(HFETAsourcePrmPrmGatePrimePtr,HFETAsourcePrmPrmNode,HFETAgatePrimeNode) TSTALLOC(HFETAsourcePrmPrmGatePrimePtr,HFETAsourcePrmPrmNode,HFETAgatePrimeNode);
TSTALLOC(HFETAgatePrimeSourcePrmPrmPtr,HFETAgatePrimeNode,HFETAsourcePrmPrmNode) TSTALLOC(HFETAgatePrimeSourcePrmPrmPtr,HFETAgatePrimeNode,HFETAsourcePrmPrmNode);
TSTALLOC(HFETAsourcePrmPrmSourcePrmPrmPtr,HFETAsourcePrmPrmNode,HFETAsourcePrmPrmNode) TSTALLOC(HFETAsourcePrmPrmSourcePrmPrmPtr,HFETAsourcePrmPrmNode,HFETAsourcePrmPrmNode);
TSTALLOC(HFETAgateGatePtr,HFETAgateNode,HFETAgateNode) TSTALLOC(HFETAgateGatePtr,HFETAgateNode,HFETAgateNode);
TSTALLOC(HFETAgateGatePrimePtr,HFETAgateNode,HFETAgatePrimeNode) TSTALLOC(HFETAgateGatePrimePtr,HFETAgateNode,HFETAgatePrimeNode);
TSTALLOC(HFETAgatePrimeGatePtr,HFETAgatePrimeNode,HFETAgateNode) TSTALLOC(HFETAgatePrimeGatePtr,HFETAgatePrimeNode,HFETAgateNode);
} }
} }
return(OK); return(OK);

34
src/spicelib/devices/hfet2/hfet2setup.c
View File

@ -177,25 +177,25 @@ int HFET2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(HFET2drainDrainPrimePtr,HFET2drainNode,HFET2drainPrimeNode) TSTALLOC(HFET2drainDrainPrimePtr,HFET2drainNode,HFET2drainPrimeNode);
TSTALLOC(HFET2gateDrainPrimePtr,HFET2gateNode,HFET2drainPrimeNode) TSTALLOC(HFET2gateDrainPrimePtr,HFET2gateNode,HFET2drainPrimeNode);
TSTALLOC(HFET2gateSourcePrimePtr,HFET2gateNode,HFET2sourcePrimeNode) TSTALLOC(HFET2gateSourcePrimePtr,HFET2gateNode,HFET2sourcePrimeNode);
TSTALLOC(HFET2sourceSourcePrimePtr,HFET2sourceNode,HFET2sourcePrimeNode) TSTALLOC(HFET2sourceSourcePrimePtr,HFET2sourceNode,HFET2sourcePrimeNode);
TSTALLOC(HFET2drainPrimeDrainPtr,HFET2drainPrimeNode,HFET2drainNode) TSTALLOC(HFET2drainPrimeDrainPtr,HFET2drainPrimeNode,HFET2drainNode);
TSTALLOC(HFET2drainPrimeGatePtr,HFET2drainPrimeNode,HFET2gateNode) TSTALLOC(HFET2drainPrimeGatePtr,HFET2drainPrimeNode,HFET2gateNode);
TSTALLOC(HFET2drainPriHFET2ourcePrimePtr,HFET2drainPrimeNode,HFET2sourcePrimeNode) TSTALLOC(HFET2drainPriHFET2ourcePrimePtr,HFET2drainPrimeNode,HFET2sourcePrimeNode);
TSTALLOC(HFET2sourcePrimeGatePtr,HFET2sourcePrimeNode,HFET2gateNode) TSTALLOC(HFET2sourcePrimeGatePtr,HFET2sourcePrimeNode,HFET2gateNode);
TSTALLOC(HFET2sourcePriHFET2ourcePtr,HFET2sourcePrimeNode,HFET2sourceNode) TSTALLOC(HFET2sourcePriHFET2ourcePtr,HFET2sourcePrimeNode,HFET2sourceNode);
TSTALLOC(HFET2sourcePrimeDrainPrimePtr,HFET2sourcePrimeNode,HFET2drainPrimeNode) TSTALLOC(HFET2sourcePrimeDrainPrimePtr,HFET2sourcePrimeNode,HFET2drainPrimeNode);
TSTALLOC(HFET2drainDrainPtr,HFET2drainNode,HFET2drainNode) TSTALLOC(HFET2drainDrainPtr,HFET2drainNode,HFET2drainNode);
TSTALLOC(HFET2gateGatePtr,HFET2gateNode,HFET2gateNode) TSTALLOC(HFET2gateGatePtr,HFET2gateNode,HFET2gateNode);
TSTALLOC(HFET2sourceSourcePtr,HFET2sourceNode,HFET2sourceNode) TSTALLOC(HFET2sourceSourcePtr,HFET2sourceNode,HFET2sourceNode);
TSTALLOC(HFET2drainPrimeDrainPrimePtr,HFET2drainPrimeNode,HFET2drainPrimeNode) TSTALLOC(HFET2drainPrimeDrainPrimePtr,HFET2drainPrimeNode,HFET2drainPrimeNode);
TSTALLOC(HFET2sourcePriHFET2ourcePrimePtr,HFET2sourcePrimeNode,HFET2sourcePrimeNode) TSTALLOC(HFET2sourcePriHFET2ourcePrimePtr,HFET2sourcePrimeNode,HFET2sourcePrimeNode);
} }
} }

46
src/spicelib/devices/hisim2/hsm2set.c
View File

@ -774,33 +774,33 @@ int HSM2setup(
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(HSM2DPbpPtr, HSM2dNodePrime, HSM2bNodePrime) TSTALLOC(HSM2DPbpPtr, HSM2dNodePrime, HSM2bNodePrime);
TSTALLOC(HSM2SPbpPtr, HSM2sNodePrime, HSM2bNodePrime) TSTALLOC(HSM2SPbpPtr, HSM2sNodePrime, HSM2bNodePrime);
TSTALLOC(HSM2GPbpPtr, HSM2gNodePrime, HSM2bNodePrime) TSTALLOC(HSM2GPbpPtr, HSM2gNodePrime, HSM2bNodePrime);
TSTALLOC(HSM2BPdpPtr, HSM2bNodePrime, HSM2dNodePrime) TSTALLOC(HSM2BPdpPtr, HSM2bNodePrime, HSM2dNodePrime);
TSTALLOC(HSM2BPspPtr, HSM2bNodePrime, HSM2sNodePrime) TSTALLOC(HSM2BPspPtr, HSM2bNodePrime, HSM2sNodePrime);
TSTALLOC(HSM2BPgpPtr, HSM2bNodePrime, HSM2gNodePrime) TSTALLOC(HSM2BPgpPtr, HSM2bNodePrime, HSM2gNodePrime);
TSTALLOC(HSM2BPbpPtr, HSM2bNodePrime, HSM2bNodePrime) TSTALLOC(HSM2BPbpPtr, HSM2bNodePrime, HSM2bNodePrime);
TSTALLOC(HSM2DdPtr, HSM2dNode, HSM2dNode) TSTALLOC(HSM2DdPtr, HSM2dNode, HSM2dNode);
TSTALLOC(HSM2GPgpPtr, HSM2gNodePrime, HSM2gNodePrime) TSTALLOC(HSM2GPgpPtr, HSM2gNodePrime, HSM2gNodePrime);
TSTALLOC(HSM2SsPtr, HSM2sNode, HSM2sNode) TSTALLOC(HSM2SsPtr, HSM2sNode, HSM2sNode);
TSTALLOC(HSM2DPdpPtr, HSM2dNodePrime, HSM2dNodePrime) TSTALLOC(HSM2DPdpPtr, HSM2dNodePrime, HSM2dNodePrime);
TSTALLOC(HSM2SPspPtr, HSM2sNodePrime, HSM2sNodePrime) TSTALLOC(HSM2SPspPtr, HSM2sNodePrime, HSM2sNodePrime);
TSTALLOC(HSM2DdpPtr, HSM2dNode, HSM2dNodePrime) TSTALLOC(HSM2DdpPtr, HSM2dNode, HSM2dNodePrime);
TSTALLOC(HSM2GPdpPtr, HSM2gNodePrime, HSM2dNodePrime) TSTALLOC(HSM2GPdpPtr, HSM2gNodePrime, HSM2dNodePrime);
TSTALLOC(HSM2GPspPtr, HSM2gNodePrime, HSM2sNodePrime) TSTALLOC(HSM2GPspPtr, HSM2gNodePrime, HSM2sNodePrime);
TSTALLOC(HSM2SspPtr, HSM2sNode, HSM2sNodePrime) TSTALLOC(HSM2SspPtr, HSM2sNode, HSM2sNodePrime);
TSTALLOC(HSM2DPspPtr, HSM2dNodePrime, HSM2sNodePrime) TSTALLOC(HSM2DPspPtr, HSM2dNodePrime, HSM2sNodePrime);
TSTALLOC(HSM2DPdPtr, HSM2dNodePrime, HSM2dNode) TSTALLOC(HSM2DPdPtr, HSM2dNodePrime, HSM2dNode);
TSTALLOC(HSM2DPgpPtr, HSM2dNodePrime, HSM2gNodePrime) TSTALLOC(HSM2DPgpPtr, HSM2dNodePrime, HSM2gNodePrime);
TSTALLOC(HSM2SPgpPtr, HSM2sNodePrime, HSM2gNodePrime) TSTALLOC(HSM2SPgpPtr, HSM2sNodePrime, HSM2gNodePrime);
TSTALLOC(HSM2SPsPtr, HSM2sNodePrime, HSM2sNode) TSTALLOC(HSM2SPsPtr, HSM2sNodePrime, HSM2sNode);
TSTALLOC(HSM2SPdpPtr, HSM2sNodePrime, HSM2dNodePrime); TSTALLOC(HSM2SPdpPtr, HSM2sNodePrime, HSM2dNodePrime);
if ( here->HSM2_corg == 1 ) { if ( here->HSM2_corg == 1 ) {

110
src/spicelib/devices/hisimhv1/hsmhvset.c
View File

@ -938,35 +938,35 @@ int HSMHVsetup(
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(HSMHVDPbpPtr, HSMHVdNodePrime, HSMHVbNodePrime) TSTALLOC(HSMHVDPbpPtr, HSMHVdNodePrime, HSMHVbNodePrime);
TSTALLOC(HSMHVSPbpPtr, HSMHVsNodePrime, HSMHVbNodePrime) TSTALLOC(HSMHVSPbpPtr, HSMHVsNodePrime, HSMHVbNodePrime);
TSTALLOC(HSMHVGPbpPtr, HSMHVgNodePrime, HSMHVbNodePrime) TSTALLOC(HSMHVGPbpPtr, HSMHVgNodePrime, HSMHVbNodePrime);
TSTALLOC(HSMHVBPdPtr, HSMHVbNodePrime, HSMHVdNode) TSTALLOC(HSMHVBPdPtr, HSMHVbNodePrime, HSMHVdNode);
TSTALLOC(HSMHVBPsPtr, HSMHVbNodePrime, HSMHVsNode) TSTALLOC(HSMHVBPsPtr, HSMHVbNodePrime, HSMHVsNode);
TSTALLOC(HSMHVBPdpPtr, HSMHVbNodePrime, HSMHVdNodePrime) TSTALLOC(HSMHVBPdpPtr, HSMHVbNodePrime, HSMHVdNodePrime);
TSTALLOC(HSMHVBPspPtr, HSMHVbNodePrime, HSMHVsNodePrime) TSTALLOC(HSMHVBPspPtr, HSMHVbNodePrime, HSMHVsNodePrime);
TSTALLOC(HSMHVBPgpPtr, HSMHVbNodePrime, HSMHVgNodePrime) TSTALLOC(HSMHVBPgpPtr, HSMHVbNodePrime, HSMHVgNodePrime);
TSTALLOC(HSMHVBPbpPtr, HSMHVbNodePrime, HSMHVbNodePrime) TSTALLOC(HSMHVBPbpPtr, HSMHVbNodePrime, HSMHVbNodePrime);
TSTALLOC(HSMHVDdPtr, HSMHVdNode, HSMHVdNode) TSTALLOC(HSMHVDdPtr, HSMHVdNode, HSMHVdNode);
TSTALLOC(HSMHVGPgpPtr, HSMHVgNodePrime, HSMHVgNodePrime) TSTALLOC(HSMHVGPgpPtr, HSMHVgNodePrime, HSMHVgNodePrime);
TSTALLOC(HSMHVSsPtr, HSMHVsNode, HSMHVsNode) TSTALLOC(HSMHVSsPtr, HSMHVsNode, HSMHVsNode);
TSTALLOC(HSMHVDPdpPtr, HSMHVdNodePrime, HSMHVdNodePrime) TSTALLOC(HSMHVDPdpPtr, HSMHVdNodePrime, HSMHVdNodePrime);
TSTALLOC(HSMHVSPspPtr, HSMHVsNodePrime, HSMHVsNodePrime) TSTALLOC(HSMHVSPspPtr, HSMHVsNodePrime, HSMHVsNodePrime);
TSTALLOC(HSMHVDdpPtr, HSMHVdNode, HSMHVdNodePrime) TSTALLOC(HSMHVDdpPtr, HSMHVdNode, HSMHVdNodePrime);
TSTALLOC(HSMHVGPdpPtr, HSMHVgNodePrime, HSMHVdNodePrime) TSTALLOC(HSMHVGPdpPtr, HSMHVgNodePrime, HSMHVdNodePrime);
TSTALLOC(HSMHVGPspPtr, HSMHVgNodePrime, HSMHVsNodePrime) TSTALLOC(HSMHVGPspPtr, HSMHVgNodePrime, HSMHVsNodePrime);
TSTALLOC(HSMHVSspPtr, HSMHVsNode, HSMHVsNodePrime) TSTALLOC(HSMHVSspPtr, HSMHVsNode, HSMHVsNodePrime);
TSTALLOC(HSMHVDPspPtr, HSMHVdNodePrime, HSMHVsNodePrime) TSTALLOC(HSMHVDPspPtr, HSMHVdNodePrime, HSMHVsNodePrime);
TSTALLOC(HSMHVDPdPtr, HSMHVdNodePrime, HSMHVdNode) TSTALLOC(HSMHVDPdPtr, HSMHVdNodePrime, HSMHVdNode);
TSTALLOC(HSMHVDPgpPtr, HSMHVdNodePrime, HSMHVgNodePrime) TSTALLOC(HSMHVDPgpPtr, HSMHVdNodePrime, HSMHVgNodePrime);
TSTALLOC(HSMHVSPgpPtr, HSMHVsNodePrime, HSMHVgNodePrime) TSTALLOC(HSMHVSPgpPtr, HSMHVsNodePrime, HSMHVgNodePrime);
TSTALLOC(HSMHVSPsPtr, HSMHVsNodePrime, HSMHVsNode) TSTALLOC(HSMHVSPsPtr, HSMHVsNodePrime, HSMHVsNode);
TSTALLOC(HSMHVSPdpPtr, HSMHVsNodePrime, HSMHVdNodePrime); TSTALLOC(HSMHVSPdpPtr, HSMHVsNodePrime, HSMHVdNodePrime);
TSTALLOC(HSMHVGgPtr, HSMHVgNode, HSMHVgNode); TSTALLOC(HSMHVGgPtr, HSMHVgNode, HSMHVgNode);
@ -1019,44 +1019,44 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
TSTALLOC(HSMHVSPsubPtr, HSMHVsNodePrime, HSMHVsubNode); TSTALLOC(HSMHVSPsubPtr, HSMHVsNodePrime, HSMHVsubNode);
} }
if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ if ( here->HSMHV_coselfheat > 0 ) { /* self heating */
TSTALLOC(HSMHVTemptempPtr, HSMHVtempNode, HSMHVtempNode) TSTALLOC(HSMHVTemptempPtr, HSMHVtempNode, HSMHVtempNode);
TSTALLOC(HSMHVTempdPtr, HSMHVtempNode, HSMHVdNode) TSTALLOC(HSMHVTempdPtr, HSMHVtempNode, HSMHVdNode);
TSTALLOC(HSMHVTempdpPtr, HSMHVtempNode, HSMHVdNodePrime) TSTALLOC(HSMHVTempdpPtr, HSMHVtempNode, HSMHVdNodePrime);
TSTALLOC(HSMHVTempsPtr, HSMHVtempNode, HSMHVsNode) TSTALLOC(HSMHVTempsPtr, HSMHVtempNode, HSMHVsNode);
TSTALLOC(HSMHVTempspPtr, HSMHVtempNode, HSMHVsNodePrime) TSTALLOC(HSMHVTempspPtr, HSMHVtempNode, HSMHVsNodePrime);
TSTALLOC(HSMHVDPtempPtr, HSMHVdNodePrime, HSMHVtempNode) TSTALLOC(HSMHVDPtempPtr, HSMHVdNodePrime, HSMHVtempNode);
TSTALLOC(HSMHVSPtempPtr, HSMHVsNodePrime, HSMHVtempNode) TSTALLOC(HSMHVSPtempPtr, HSMHVsNodePrime, HSMHVtempNode);
TSTALLOC(HSMHVTempgpPtr, HSMHVtempNode, HSMHVgNodePrime) TSTALLOC(HSMHVTempgpPtr, HSMHVtempNode, HSMHVgNodePrime);
TSTALLOC(HSMHVTempbpPtr, HSMHVtempNode, HSMHVbNodePrime) TSTALLOC(HSMHVTempbpPtr, HSMHVtempNode, HSMHVbNodePrime);
TSTALLOC(HSMHVGPtempPtr, HSMHVgNodePrime, HSMHVtempNode) TSTALLOC(HSMHVGPtempPtr, HSMHVgNodePrime, HSMHVtempNode);
TSTALLOC(HSMHVBPtempPtr, HSMHVbNodePrime, HSMHVtempNode) TSTALLOC(HSMHVBPtempPtr, HSMHVbNodePrime, HSMHVtempNode);
TSTALLOC(HSMHVDBtempPtr, HSMHVdbNode, HSMHVtempNode) TSTALLOC(HSMHVDBtempPtr, HSMHVdbNode, HSMHVtempNode);
TSTALLOC(HSMHVSBtempPtr, HSMHVsbNode, HSMHVtempNode) TSTALLOC(HSMHVSBtempPtr, HSMHVsbNode, HSMHVtempNode);
TSTALLOC(HSMHVDtempPtr, HSMHVdNode, HSMHVtempNode); TSTALLOC(HSMHVDtempPtr, HSMHVdNode, HSMHVtempNode);
TSTALLOC(HSMHVStempPtr, HSMHVsNode, HSMHVtempNode); TSTALLOC(HSMHVStempPtr, HSMHVsNode, HSMHVtempNode);
} }
if ( model->HSMHV_conqs ) { /* flat handling of NQS */ if ( model->HSMHV_conqs ) { /* flat handling of NQS */
TSTALLOC(HSMHVDPqiPtr, HSMHVdNodePrime, HSMHVqiNode) TSTALLOC(HSMHVDPqiPtr, HSMHVdNodePrime, HSMHVqiNode);
TSTALLOC(HSMHVGPqiPtr, HSMHVgNodePrime, HSMHVqiNode) TSTALLOC(HSMHVGPqiPtr, HSMHVgNodePrime, HSMHVqiNode);
TSTALLOC(HSMHVGPqbPtr, HSMHVgNodePrime, HSMHVqbNode) TSTALLOC(HSMHVGPqbPtr, HSMHVgNodePrime, HSMHVqbNode);
TSTALLOC(HSMHVSPqiPtr, HSMHVsNodePrime, HSMHVqiNode) TSTALLOC(HSMHVSPqiPtr, HSMHVsNodePrime, HSMHVqiNode);
TSTALLOC(HSMHVBPqbPtr, HSMHVbNodePrime, HSMHVqbNode) TSTALLOC(HSMHVBPqbPtr, HSMHVbNodePrime, HSMHVqbNode);
TSTALLOC(HSMHVQIdpPtr, HSMHVqiNode, HSMHVdNodePrime) TSTALLOC(HSMHVQIdpPtr, HSMHVqiNode, HSMHVdNodePrime);
TSTALLOC(HSMHVQIgpPtr, HSMHVqiNode, HSMHVgNodePrime) TSTALLOC(HSMHVQIgpPtr, HSMHVqiNode, HSMHVgNodePrime);
TSTALLOC(HSMHVQIspPtr, HSMHVqiNode, HSMHVsNodePrime) TSTALLOC(HSMHVQIspPtr, HSMHVqiNode, HSMHVsNodePrime);
TSTALLOC(HSMHVQIbpPtr, HSMHVqiNode, HSMHVbNodePrime) TSTALLOC(HSMHVQIbpPtr, HSMHVqiNode, HSMHVbNodePrime);
TSTALLOC(HSMHVQIqiPtr, HSMHVqiNode, HSMHVqiNode) TSTALLOC(HSMHVQIqiPtr, HSMHVqiNode, HSMHVqiNode);
TSTALLOC(HSMHVQBdpPtr, HSMHVqbNode, HSMHVdNodePrime) TSTALLOC(HSMHVQBdpPtr, HSMHVqbNode, HSMHVdNodePrime);
TSTALLOC(HSMHVQBgpPtr, HSMHVqbNode, HSMHVgNodePrime) TSTALLOC(HSMHVQBgpPtr, HSMHVqbNode, HSMHVgNodePrime);
TSTALLOC(HSMHVQBspPtr, HSMHVqbNode, HSMHVsNodePrime) TSTALLOC(HSMHVQBspPtr, HSMHVqbNode, HSMHVsNodePrime);
TSTALLOC(HSMHVQBbpPtr, HSMHVqbNode, HSMHVbNodePrime) TSTALLOC(HSMHVQBbpPtr, HSMHVqbNode, HSMHVbNodePrime);
TSTALLOC(HSMHVQBqbPtr, HSMHVqbNode, HSMHVqbNode) TSTALLOC(HSMHVQBqbPtr, HSMHVqbNode, HSMHVqbNode);
if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ if ( here->HSMHV_coselfheat > 0 ) { /* self heating */
TSTALLOC(HSMHVQItempPtr, HSMHVqiNode, HSMHVtempNode) TSTALLOC(HSMHVQItempPtr, HSMHVqiNode, HSMHVtempNode);
TSTALLOC(HSMHVQBtempPtr, HSMHVqbNode, HSMHVtempNode) TSTALLOC(HSMHVQBtempPtr, HSMHVqbNode, HSMHVtempNode);
} }
} }

14
src/spicelib/devices/ind/indsetup.c
View File

@ -89,15 +89,15 @@ INDsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(INDposIbrptr,INDposNode,INDbrEq) TSTALLOC(INDposIbrptr,INDposNode,INDbrEq);
TSTALLOC(INDnegIbrptr,INDnegNode,INDbrEq) TSTALLOC(INDnegIbrptr,INDnegNode,INDbrEq);
TSTALLOC(INDibrNegptr,INDbrEq,INDnegNode) TSTALLOC(INDibrNegptr,INDbrEq,INDnegNode);
TSTALLOC(INDibrPosptr,INDbrEq,INDposNode) TSTALLOC(INDibrPosptr,INDbrEq,INDposNode);
TSTALLOC(INDibrIbrptr,INDbrEq,INDbrEq) TSTALLOC(INDibrIbrptr,INDbrEq,INDbrEq);
} }
} }
return(OK); return(OK);

8
src/spicelib/devices/ind/mutsetup.c
View File

@ -69,12 +69,12 @@ MUTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MUTbr1br2,MUTind1->INDbrEq,MUTind2->INDbrEq) TSTALLOC(MUTbr1br2,MUTind1->INDbrEq,MUTind2->INDbrEq);
TSTALLOC(MUTbr2br1,MUTind2->INDbrEq,MUTind1->INDbrEq) TSTALLOC(MUTbr2br1,MUTind2->INDbrEq,MUTind1->INDbrEq);
} }
} }
return(OK); return(OK);

34
src/spicelib/devices/jfet/jfetset.c
View File

@ -159,25 +159,25 @@ JFETsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(JFETdrainDrainPrimePtr,JFETdrainNode,JFETdrainPrimeNode) TSTALLOC(JFETdrainDrainPrimePtr,JFETdrainNode,JFETdrainPrimeNode);
TSTALLOC(JFETgateDrainPrimePtr,JFETgateNode,JFETdrainPrimeNode) TSTALLOC(JFETgateDrainPrimePtr,JFETgateNode,JFETdrainPrimeNode);
TSTALLOC(JFETgateSourcePrimePtr,JFETgateNode,JFETsourcePrimeNode) TSTALLOC(JFETgateSourcePrimePtr,JFETgateNode,JFETsourcePrimeNode);
TSTALLOC(JFETsourceSourcePrimePtr,JFETsourceNode,JFETsourcePrimeNode) TSTALLOC(JFETsourceSourcePrimePtr,JFETsourceNode,JFETsourcePrimeNode);
TSTALLOC(JFETdrainPrimeDrainPtr,JFETdrainPrimeNode,JFETdrainNode) TSTALLOC(JFETdrainPrimeDrainPtr,JFETdrainPrimeNode,JFETdrainNode);
TSTALLOC(JFETdrainPrimeGatePtr,JFETdrainPrimeNode,JFETgateNode) TSTALLOC(JFETdrainPrimeGatePtr,JFETdrainPrimeNode,JFETgateNode);
TSTALLOC(JFETdrainPrimeSourcePrimePtr,JFETdrainPrimeNode,JFETsourcePrimeNode) TSTALLOC(JFETdrainPrimeSourcePrimePtr,JFETdrainPrimeNode,JFETsourcePrimeNode);
TSTALLOC(JFETsourcePrimeGatePtr,JFETsourcePrimeNode,JFETgateNode) TSTALLOC(JFETsourcePrimeGatePtr,JFETsourcePrimeNode,JFETgateNode);
TSTALLOC(JFETsourcePrimeSourcePtr,JFETsourcePrimeNode,JFETsourceNode) TSTALLOC(JFETsourcePrimeSourcePtr,JFETsourcePrimeNode,JFETsourceNode);
TSTALLOC(JFETsourcePrimeDrainPrimePtr,JFETsourcePrimeNode,JFETdrainPrimeNode) TSTALLOC(JFETsourcePrimeDrainPrimePtr,JFETsourcePrimeNode,JFETdrainPrimeNode);
TSTALLOC(JFETdrainDrainPtr,JFETdrainNode,JFETdrainNode) TSTALLOC(JFETdrainDrainPtr,JFETdrainNode,JFETdrainNode);
TSTALLOC(JFETgateGatePtr,JFETgateNode,JFETgateNode) TSTALLOC(JFETgateGatePtr,JFETgateNode,JFETgateNode);
TSTALLOC(JFETsourceSourcePtr,JFETsourceNode,JFETsourceNode) TSTALLOC(JFETsourceSourcePtr,JFETsourceNode,JFETsourceNode);
TSTALLOC(JFETdrainPrimeDrainPrimePtr,JFETdrainPrimeNode,JFETdrainPrimeNode) TSTALLOC(JFETdrainPrimeDrainPrimePtr,JFETdrainPrimeNode,JFETdrainPrimeNode);
TSTALLOC(JFETsourcePrimeSourcePrimePtr,JFETsourcePrimeNode,JFETsourcePrimeNode) TSTALLOC(JFETsourcePrimeSourcePrimePtr,JFETsourcePrimeNode,JFETsourcePrimeNode);
} }
} }
return(OK); return(OK);

34
src/spicelib/devices/jfet2/jfet2set.c
View File

@ -99,25 +99,25 @@ JFET2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(JFET2drainDrainPrimePtr,JFET2drainNode,JFET2drainPrimeNode) TSTALLOC(JFET2drainDrainPrimePtr,JFET2drainNode,JFET2drainPrimeNode);
TSTALLOC(JFET2gateDrainPrimePtr,JFET2gateNode,JFET2drainPrimeNode) TSTALLOC(JFET2gateDrainPrimePtr,JFET2gateNode,JFET2drainPrimeNode);
TSTALLOC(JFET2gateSourcePrimePtr,JFET2gateNode,JFET2sourcePrimeNode) TSTALLOC(JFET2gateSourcePrimePtr,JFET2gateNode,JFET2sourcePrimeNode);
TSTALLOC(JFET2sourceSourcePrimePtr,JFET2sourceNode,JFET2sourcePrimeNode) TSTALLOC(JFET2sourceSourcePrimePtr,JFET2sourceNode,JFET2sourcePrimeNode);
TSTALLOC(JFET2drainPrimeDrainPtr,JFET2drainPrimeNode,JFET2drainNode) TSTALLOC(JFET2drainPrimeDrainPtr,JFET2drainPrimeNode,JFET2drainNode);
TSTALLOC(JFET2drainPrimeGatePtr,JFET2drainPrimeNode,JFET2gateNode) TSTALLOC(JFET2drainPrimeGatePtr,JFET2drainPrimeNode,JFET2gateNode);
TSTALLOC(JFET2drainPrimeSourcePrimePtr,JFET2drainPrimeNode,JFET2sourcePrimeNode) TSTALLOC(JFET2drainPrimeSourcePrimePtr,JFET2drainPrimeNode,JFET2sourcePrimeNode);
TSTALLOC(JFET2sourcePrimeGatePtr,JFET2sourcePrimeNode,JFET2gateNode) TSTALLOC(JFET2sourcePrimeGatePtr,JFET2sourcePrimeNode,JFET2gateNode);
TSTALLOC(JFET2sourcePrimeSourcePtr,JFET2sourcePrimeNode,JFET2sourceNode) TSTALLOC(JFET2sourcePrimeSourcePtr,JFET2sourcePrimeNode,JFET2sourceNode);
TSTALLOC(JFET2sourcePrimeDrainPrimePtr,JFET2sourcePrimeNode,JFET2drainPrimeNode) TSTALLOC(JFET2sourcePrimeDrainPrimePtr,JFET2sourcePrimeNode,JFET2drainPrimeNode);
TSTALLOC(JFET2drainDrainPtr,JFET2drainNode,JFET2drainNode) TSTALLOC(JFET2drainDrainPtr,JFET2drainNode,JFET2drainNode);
TSTALLOC(JFET2gateGatePtr,JFET2gateNode,JFET2gateNode) TSTALLOC(JFET2gateGatePtr,JFET2gateNode,JFET2gateNode);
TSTALLOC(JFET2sourceSourcePtr,JFET2sourceNode,JFET2sourceNode) TSTALLOC(JFET2sourceSourcePtr,JFET2sourceNode,JFET2sourceNode);
TSTALLOC(JFET2drainPrimeDrainPrimePtr,JFET2drainPrimeNode,JFET2drainPrimeNode) TSTALLOC(JFET2drainPrimeDrainPrimePtr,JFET2drainPrimeNode,JFET2drainPrimeNode);
TSTALLOC(JFET2sourcePrimeSourcePrimePtr,JFET2sourcePrimeNode,JFET2sourcePrimeNode) TSTALLOC(JFET2sourcePrimeSourcePrimePtr,JFET2sourcePrimeNode,JFET2sourcePrimeNode);
} }
} }
return(OK); return(OK);

44
src/spicelib/devices/ltra/ltraset.c
View File

@ -186,34 +186,34 @@ LTRAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
} }
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(LTRAibr1Pos1Ptr, LTRAbrEq1, LTRAposNode1) TSTALLOC(LTRAibr1Pos1Ptr, LTRAbrEq1, LTRAposNode1);
TSTALLOC(LTRAibr1Neg1Ptr, LTRAbrEq1, LTRAnegNode1) TSTALLOC(LTRAibr1Neg1Ptr, LTRAbrEq1, LTRAnegNode1);
TSTALLOC(LTRAibr1Pos2Ptr, LTRAbrEq1, LTRAposNode2) TSTALLOC(LTRAibr1Pos2Ptr, LTRAbrEq1, LTRAposNode2);
TSTALLOC(LTRAibr1Neg2Ptr, LTRAbrEq1, LTRAnegNode2) TSTALLOC(LTRAibr1Neg2Ptr, LTRAbrEq1, LTRAnegNode2);
TSTALLOC(LTRAibr1Ibr1Ptr, LTRAbrEq1, LTRAbrEq1) TSTALLOC(LTRAibr1Ibr1Ptr, LTRAbrEq1, LTRAbrEq1);
TSTALLOC(LTRAibr1Ibr2Ptr, LTRAbrEq1, LTRAbrEq2) TSTALLOC(LTRAibr1Ibr2Ptr, LTRAbrEq1, LTRAbrEq2);
TSTALLOC(LTRAibr2Pos1Ptr, LTRAbrEq2, LTRAposNode1) TSTALLOC(LTRAibr2Pos1Ptr, LTRAbrEq2, LTRAposNode1);
TSTALLOC(LTRAibr2Neg1Ptr, LTRAbrEq2, LTRAnegNode1) TSTALLOC(LTRAibr2Neg1Ptr, LTRAbrEq2, LTRAnegNode1);
TSTALLOC(LTRAibr2Pos2Ptr, LTRAbrEq2, LTRAposNode2) TSTALLOC(LTRAibr2Pos2Ptr, LTRAbrEq2, LTRAposNode2);
TSTALLOC(LTRAibr2Neg2Ptr, LTRAbrEq2, LTRAnegNode2) TSTALLOC(LTRAibr2Neg2Ptr, LTRAbrEq2, LTRAnegNode2);
TSTALLOC(LTRAibr2Ibr1Ptr, LTRAbrEq2, LTRAbrEq1) TSTALLOC(LTRAibr2Ibr1Ptr, LTRAbrEq2, LTRAbrEq1);
TSTALLOC(LTRAibr2Ibr2Ptr, LTRAbrEq2, LTRAbrEq2) TSTALLOC(LTRAibr2Ibr2Ptr, LTRAbrEq2, LTRAbrEq2);
TSTALLOC(LTRApos1Ibr1Ptr, LTRAposNode1, LTRAbrEq1) TSTALLOC(LTRApos1Ibr1Ptr, LTRAposNode1, LTRAbrEq1);
TSTALLOC(LTRAneg1Ibr1Ptr, LTRAnegNode1, LTRAbrEq1) TSTALLOC(LTRAneg1Ibr1Ptr, LTRAnegNode1, LTRAbrEq1);
TSTALLOC(LTRApos2Ibr2Ptr, LTRAposNode2, LTRAbrEq2) TSTALLOC(LTRApos2Ibr2Ptr, LTRAposNode2, LTRAbrEq2);
TSTALLOC(LTRAneg2Ibr2Ptr, LTRAnegNode2, LTRAbrEq2) TSTALLOC(LTRAneg2Ibr2Ptr, LTRAnegNode2, LTRAbrEq2);
/* /*
* the following are done so that SMPpreOrder does not screw up on * the following are done so that SMPpreOrder does not screw up on
* occasion - for example, when one end of the lossy line is hanging * occasion - for example, when one end of the lossy line is hanging
*/ */
TSTALLOC(LTRApos1Pos1Ptr, LTRAposNode1, LTRAposNode1) TSTALLOC(LTRApos1Pos1Ptr, LTRAposNode1, LTRAposNode1);
TSTALLOC(LTRAneg1Neg1Ptr, LTRAnegNode1, LTRAnegNode1) TSTALLOC(LTRAneg1Neg1Ptr, LTRAnegNode1, LTRAnegNode1);
TSTALLOC(LTRApos2Pos2Ptr, LTRAposNode2, LTRAposNode2) TSTALLOC(LTRApos2Pos2Ptr, LTRAposNode2, LTRAposNode2);
TSTALLOC(LTRAneg2Neg2Ptr, LTRAnegNode2, LTRAnegNode2) TSTALLOC(LTRAneg2Neg2Ptr, LTRAnegNode2, LTRAnegNode2);
} }
} }
return (OK); return (OK);

34
src/spicelib/devices/mes/messetup.c
View File

@ -132,25 +132,25 @@ MESsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MESdrainDrainPrimePtr,MESdrainNode,MESdrainPrimeNode) TSTALLOC(MESdrainDrainPrimePtr,MESdrainNode,MESdrainPrimeNode);
TSTALLOC(MESgateDrainPrimePtr,MESgateNode,MESdrainPrimeNode) TSTALLOC(MESgateDrainPrimePtr,MESgateNode,MESdrainPrimeNode);
TSTALLOC(MESgateSourcePrimePtr,MESgateNode,MESsourcePrimeNode) TSTALLOC(MESgateSourcePrimePtr,MESgateNode,MESsourcePrimeNode);
TSTALLOC(MESsourceSourcePrimePtr,MESsourceNode,MESsourcePrimeNode) TSTALLOC(MESsourceSourcePrimePtr,MESsourceNode,MESsourcePrimeNode);
TSTALLOC(MESdrainPrimeDrainPtr,MESdrainPrimeNode,MESdrainNode) TSTALLOC(MESdrainPrimeDrainPtr,MESdrainPrimeNode,MESdrainNode);
TSTALLOC(MESdrainPrimeGatePtr,MESdrainPrimeNode,MESgateNode) TSTALLOC(MESdrainPrimeGatePtr,MESdrainPrimeNode,MESgateNode);
TSTALLOC(MESdrainPrimeSourcePrimePtr,MESdrainPrimeNode,MESsourcePrimeNode) TSTALLOC(MESdrainPrimeSourcePrimePtr,MESdrainPrimeNode,MESsourcePrimeNode);
TSTALLOC(MESsourcePrimeGatePtr,MESsourcePrimeNode,MESgateNode) TSTALLOC(MESsourcePrimeGatePtr,MESsourcePrimeNode,MESgateNode);
TSTALLOC(MESsourcePrimeSourcePtr,MESsourcePrimeNode,MESsourceNode) TSTALLOC(MESsourcePrimeSourcePtr,MESsourcePrimeNode,MESsourceNode);
TSTALLOC(MESsourcePrimeDrainPrimePtr,MESsourcePrimeNode,MESdrainPrimeNode) TSTALLOC(MESsourcePrimeDrainPrimePtr,MESsourcePrimeNode,MESdrainPrimeNode);
TSTALLOC(MESdrainDrainPtr,MESdrainNode,MESdrainNode) TSTALLOC(MESdrainDrainPtr,MESdrainNode,MESdrainNode);
TSTALLOC(MESgateGatePtr,MESgateNode,MESgateNode) TSTALLOC(MESgateGatePtr,MESgateNode,MESgateNode);
TSTALLOC(MESsourceSourcePtr,MESsourceNode,MESsourceNode) TSTALLOC(MESsourceSourcePtr,MESsourceNode,MESsourceNode);
TSTALLOC(MESdrainPrimeDrainPrimePtr,MESdrainPrimeNode,MESdrainPrimeNode) TSTALLOC(MESdrainPrimeDrainPrimePtr,MESdrainPrimeNode,MESdrainPrimeNode);
TSTALLOC(MESsourcePrimeSourcePrimePtr,MESsourcePrimeNode,MESsourcePrimeNode) TSTALLOC(MESsourcePrimeSourcePrimePtr,MESsourcePrimeNode,MESsourcePrimeNode);
} }
} }
return(OK); return(OK);

60
src/spicelib/devices/mesa/mesasetup.c
View File

@ -369,38 +369,38 @@ MESAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
} }
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MESAdrainDrainPtr,MESAdrainNode,MESAdrainNode) TSTALLOC(MESAdrainDrainPtr,MESAdrainNode,MESAdrainNode);
TSTALLOC(MESAdrainPrimeDrainPrimePtr,MESAdrainPrimeNode,MESAdrainPrimeNode) TSTALLOC(MESAdrainPrimeDrainPrimePtr,MESAdrainPrimeNode,MESAdrainPrimeNode);
TSTALLOC(MESAdrainPrmPrmDrainPrmPrmPtr,MESAdrainPrmPrmNode,MESAdrainPrmPrmNode) TSTALLOC(MESAdrainPrmPrmDrainPrmPrmPtr,MESAdrainPrmPrmNode,MESAdrainPrmPrmNode);
TSTALLOC(MESAgateGatePtr,MESAgateNode,MESAgateNode) TSTALLOC(MESAgateGatePtr,MESAgateNode,MESAgateNode);
TSTALLOC(MESAgatePrimeGatePrimePtr,MESAgatePrimeNode,MESAgatePrimeNode) TSTALLOC(MESAgatePrimeGatePrimePtr,MESAgatePrimeNode,MESAgatePrimeNode);
TSTALLOC(MESAsourceSourcePtr,MESAsourceNode,MESAsourceNode) TSTALLOC(MESAsourceSourcePtr,MESAsourceNode,MESAsourceNode);
TSTALLOC(MESAsourcePrimeSourcePrimePtr,MESAsourcePrimeNode,MESAsourcePrimeNode) TSTALLOC(MESAsourcePrimeSourcePrimePtr,MESAsourcePrimeNode,MESAsourcePrimeNode);
TSTALLOC(MESAsourcePrmPrmSourcePrmPrmPtr,MESAsourcePrmPrmNode,MESAsourcePrmPrmNode) TSTALLOC(MESAsourcePrmPrmSourcePrmPrmPtr,MESAsourcePrmPrmNode,MESAsourcePrmPrmNode);
TSTALLOC(MESAdrainDrainPrimePtr,MESAdrainNode,MESAdrainPrimeNode) TSTALLOC(MESAdrainDrainPrimePtr,MESAdrainNode,MESAdrainPrimeNode);
TSTALLOC(MESAdrainPrimeDrainPtr,MESAdrainPrimeNode,MESAdrainNode) TSTALLOC(MESAdrainPrimeDrainPtr,MESAdrainPrimeNode,MESAdrainNode);
TSTALLOC(MESAgatePrimeDrainPrimePtr,MESAgatePrimeNode,MESAdrainPrimeNode) TSTALLOC(MESAgatePrimeDrainPrimePtr,MESAgatePrimeNode,MESAdrainPrimeNode);
TSTALLOC(MESAdrainPrimeGatePrimePtr,MESAdrainPrimeNode,MESAgatePrimeNode) TSTALLOC(MESAdrainPrimeGatePrimePtr,MESAdrainPrimeNode,MESAgatePrimeNode);
TSTALLOC(MESAgatePrimeSourcePrimePtr,MESAgatePrimeNode,MESAsourcePrimeNode) TSTALLOC(MESAgatePrimeSourcePrimePtr,MESAgatePrimeNode,MESAsourcePrimeNode);
TSTALLOC(MESAsourcePrimeGatePrimePtr,MESAsourcePrimeNode,MESAgatePrimeNode) TSTALLOC(MESAsourcePrimeGatePrimePtr,MESAsourcePrimeNode,MESAgatePrimeNode) ;
TSTALLOC(MESAsourceSourcePrimePtr,MESAsourceNode,MESAsourcePrimeNode) TSTALLOC(MESAsourceSourcePrimePtr,MESAsourceNode,MESAsourcePrimeNode);
TSTALLOC(MESAsourcePrimeSourcePtr,MESAsourcePrimeNode,MESAsourceNode) TSTALLOC(MESAsourcePrimeSourcePtr,MESAsourcePrimeNode,MESAsourceNode);
TSTALLOC(MESAdrainPrimeSourcePrimePtr,MESAdrainPrimeNode,MESAsourcePrimeNode) TSTALLOC(MESAdrainPrimeSourcePrimePtr,MESAdrainPrimeNode,MESAsourcePrimeNode);
TSTALLOC(MESAsourcePrimeDrainPrimePtr,MESAsourcePrimeNode,MESAdrainPrimeNode) TSTALLOC(MESAsourcePrimeDrainPrimePtr,MESAsourcePrimeNode,MESAdrainPrimeNode);
TSTALLOC(MESAgatePrimeGatePtr,MESAgatePrimeNode,MESAgateNode) TSTALLOC(MESAgatePrimeGatePtr,MESAgatePrimeNode,MESAgateNode);
TSTALLOC(MESAgateGatePrimePtr,MESAgateNode,MESAgatePrimeNode) TSTALLOC(MESAgateGatePrimePtr,MESAgateNode,MESAgatePrimeNode);
TSTALLOC(MESAsourcePrmPrmSourcePrimePtr,MESAsourcePrmPrmNode,MESAsourcePrimeNode) TSTALLOC(MESAsourcePrmPrmSourcePrimePtr,MESAsourcePrmPrmNode,MESAsourcePrimeNode);
TSTALLOC(MESAsourcePrimeSourcePrmPrmPtr,MESAsourcePrimeNode,MESAsourcePrmPrmNode) TSTALLOC(MESAsourcePrimeSourcePrmPrmPtr,MESAsourcePrimeNode,MESAsourcePrmPrmNode);
TSTALLOC(MESAsourcePrmPrmGatePrimePtr,MESAsourcePrmPrmNode,MESAgatePrimeNode) TSTALLOC(MESAsourcePrmPrmGatePrimePtr,MESAsourcePrmPrmNode,MESAgatePrimeNode);
TSTALLOC(MESAgatePrimeSourcePrmPrmPtr,MESAgatePrimeNode,MESAsourcePrmPrmNode) TSTALLOC(MESAgatePrimeSourcePrmPrmPtr,MESAgatePrimeNode,MESAsourcePrmPrmNode);
TSTALLOC(MESAdrainPrmPrmDrainPrimePtr,MESAdrainPrmPrmNode,MESAdrainPrimeNode) TSTALLOC(MESAdrainPrmPrmDrainPrimePtr,MESAdrainPrmPrmNode,MESAdrainPrimeNode);
TSTALLOC(MESAdrainPrimeDrainPrmPrmPtr,MESAdrainPrimeNode,MESAdrainPrmPrmNode) TSTALLOC(MESAdrainPrimeDrainPrmPrmPtr,MESAdrainPrimeNode,MESAdrainPrmPrmNode);
TSTALLOC(MESAdrainPrmPrmGatePrimePtr,MESAdrainPrmPrmNode,MESAgatePrimeNode) TSTALLOC(MESAdrainPrmPrmGatePrimePtr,MESAdrainPrmPrmNode,MESAgatePrimeNode);
TSTALLOC(MESAgatePrimeDrainPrmPrmPtr,MESAgatePrimeNode,MESAdrainPrmPrmNode) TSTALLOC(MESAgatePrimeDrainPrmPrmPtr,MESAgatePrimeNode,MESAdrainPrmPrmNode);
} }
} }
return(OK); return(OK);

48
src/spicelib/devices/mos1/mos1set.c
View File

@ -180,31 +180,31 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MOS1DdPtr,MOS1dNode,MOS1dNode) TSTALLOC(MOS1DdPtr,MOS1dNode,MOS1dNode);
TSTALLOC(MOS1GgPtr,MOS1gNode,MOS1gNode) TSTALLOC(MOS1GgPtr,MOS1gNode,MOS1gNode);
TSTALLOC(MOS1SsPtr,MOS1sNode,MOS1sNode) TSTALLOC(MOS1SsPtr,MOS1sNode,MOS1sNode);
TSTALLOC(MOS1BbPtr,MOS1bNode,MOS1bNode) TSTALLOC(MOS1BbPtr,MOS1bNode,MOS1bNode);
TSTALLOC(MOS1DPdpPtr,MOS1dNodePrime,MOS1dNodePrime) TSTALLOC(MOS1DPdpPtr,MOS1dNodePrime,MOS1dNodePrime);
TSTALLOC(MOS1SPspPtr,MOS1sNodePrime,MOS1sNodePrime) TSTALLOC(MOS1SPspPtr,MOS1sNodePrime,MOS1sNodePrime);
TSTALLOC(MOS1DdpPtr,MOS1dNode,MOS1dNodePrime) TSTALLOC(MOS1DdpPtr,MOS1dNode,MOS1dNodePrime);
TSTALLOC(MOS1GbPtr,MOS1gNode,MOS1bNode) TSTALLOC(MOS1GbPtr,MOS1gNode,MOS1bNode);
TSTALLOC(MOS1GdpPtr,MOS1gNode,MOS1dNodePrime) TSTALLOC(MOS1GdpPtr,MOS1gNode,MOS1dNodePrime);
TSTALLOC(MOS1GspPtr,MOS1gNode,MOS1sNodePrime) TSTALLOC(MOS1GspPtr,MOS1gNode,MOS1sNodePrime);
TSTALLOC(MOS1SspPtr,MOS1sNode,MOS1sNodePrime) TSTALLOC(MOS1SspPtr,MOS1sNode,MOS1sNodePrime);
TSTALLOC(MOS1BdpPtr,MOS1bNode,MOS1dNodePrime) TSTALLOC(MOS1BdpPtr,MOS1bNode,MOS1dNodePrime);
TSTALLOC(MOS1BspPtr,MOS1bNode,MOS1sNodePrime) TSTALLOC(MOS1BspPtr,MOS1bNode,MOS1sNodePrime);
TSTALLOC(MOS1DPspPtr,MOS1dNodePrime,MOS1sNodePrime) TSTALLOC(MOS1DPspPtr,MOS1dNodePrime,MOS1sNodePrime);
TSTALLOC(MOS1DPdPtr,MOS1dNodePrime,MOS1dNode) TSTALLOC(MOS1DPdPtr,MOS1dNodePrime,MOS1dNode);
TSTALLOC(MOS1BgPtr,MOS1bNode,MOS1gNode) TSTALLOC(MOS1BgPtr,MOS1bNode,MOS1gNode);
TSTALLOC(MOS1DPgPtr,MOS1dNodePrime,MOS1gNode) TSTALLOC(MOS1DPgPtr,MOS1dNodePrime,MOS1gNode);
TSTALLOC(MOS1SPgPtr,MOS1sNodePrime,MOS1gNode) TSTALLOC(MOS1SPgPtr,MOS1sNodePrime,MOS1gNode);
TSTALLOC(MOS1SPsPtr,MOS1sNodePrime,MOS1sNode) TSTALLOC(MOS1SPsPtr,MOS1sNodePrime,MOS1sNode);
TSTALLOC(MOS1DPbPtr,MOS1dNodePrime,MOS1bNode) TSTALLOC(MOS1DPbPtr,MOS1dNodePrime,MOS1bNode);
TSTALLOC(MOS1SPbPtr,MOS1sNodePrime,MOS1bNode) TSTALLOC(MOS1SPbPtr,MOS1sNodePrime,MOS1bNode);
TSTALLOC(MOS1SPdpPtr,MOS1sNodePrime,MOS1dNodePrime) TSTALLOC(MOS1SPdpPtr,MOS1sNodePrime,MOS1dNodePrime);
} }
} }

48
src/spicelib/devices/mos2/mos2set.c
View File

@ -202,32 +202,32 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MOS2DdPtr, MOS2dNode, MOS2dNode) TSTALLOC(MOS2DdPtr, MOS2dNode, MOS2dNode);
TSTALLOC(MOS2GgPtr, MOS2gNode, MOS2gNode) TSTALLOC(MOS2GgPtr, MOS2gNode, MOS2gNode);
TSTALLOC(MOS2SsPtr, MOS2sNode, MOS2sNode) TSTALLOC(MOS2SsPtr, MOS2sNode, MOS2sNode);
TSTALLOC(MOS2BbPtr, MOS2bNode, MOS2bNode) TSTALLOC(MOS2BbPtr, MOS2bNode, MOS2bNode);
TSTALLOC(MOS2DPdpPtr, MOS2dNodePrime, MOS2dNodePrime) TSTALLOC(MOS2DPdpPtr, MOS2dNodePrime, MOS2dNodePrime);
TSTALLOC(MOS2SPspPtr, MOS2sNodePrime, MOS2sNodePrime) TSTALLOC(MOS2SPspPtr, MOS2sNodePrime, MOS2sNodePrime);
TSTALLOC(MOS2DdpPtr, MOS2dNode, MOS2dNodePrime) TSTALLOC(MOS2DdpPtr, MOS2dNode, MOS2dNodePrime);
TSTALLOC(MOS2GbPtr, MOS2gNode, MOS2bNode) TSTALLOC(MOS2GbPtr, MOS2gNode, MOS2bNode);
TSTALLOC(MOS2GdpPtr, MOS2gNode, MOS2dNodePrime) TSTALLOC(MOS2GdpPtr, MOS2gNode, MOS2dNodePrime);
TSTALLOC(MOS2GspPtr, MOS2gNode, MOS2sNodePrime) TSTALLOC(MOS2GspPtr, MOS2gNode, MOS2sNodePrime);
TSTALLOC(MOS2SspPtr, MOS2sNode, MOS2sNodePrime) TSTALLOC(MOS2SspPtr, MOS2sNode, MOS2sNodePrime);
TSTALLOC(MOS2BdpPtr, MOS2bNode, MOS2dNodePrime) TSTALLOC(MOS2BdpPtr, MOS2bNode, MOS2dNodePrime);
TSTALLOC(MOS2BspPtr, MOS2bNode, MOS2sNodePrime) TSTALLOC(MOS2BspPtr, MOS2bNode, MOS2sNodePrime);
TSTALLOC(MOS2DPspPtr, MOS2dNodePrime, MOS2sNodePrime) TSTALLOC(MOS2DPspPtr, MOS2dNodePrime, MOS2sNodePrime);
TSTALLOC(MOS2DPdPtr, MOS2dNodePrime, MOS2dNode) TSTALLOC(MOS2DPdPtr, MOS2dNodePrime, MOS2dNode);
TSTALLOC(MOS2BgPtr, MOS2bNode, MOS2gNode) TSTALLOC(MOS2BgPtr, MOS2bNode, MOS2gNode);
TSTALLOC(MOS2DPgPtr, MOS2dNodePrime, MOS2gNode) TSTALLOC(MOS2DPgPtr, MOS2dNodePrime, MOS2gNode);
TSTALLOC(MOS2SPgPtr, MOS2sNodePrime, MOS2gNode) TSTALLOC(MOS2SPgPtr, MOS2sNodePrime, MOS2gNode);
TSTALLOC(MOS2SPsPtr, MOS2sNodePrime, MOS2sNode) TSTALLOC(MOS2SPsPtr, MOS2sNodePrime, MOS2sNode);
TSTALLOC(MOS2DPbPtr, MOS2dNodePrime, MOS2bNode) TSTALLOC(MOS2DPbPtr, MOS2dNodePrime, MOS2bNode);
TSTALLOC(MOS2SPbPtr, MOS2sNodePrime, MOS2bNode) TSTALLOC(MOS2SPbPtr, MOS2sNodePrime, MOS2bNode);
TSTALLOC(MOS2SPdpPtr, MOS2sNodePrime, MOS2dNodePrime) TSTALLOC(MOS2SPdpPtr, MOS2sNodePrime, MOS2dNodePrime);
} }
} }

48
src/spicelib/devices/mos3/mos3set.c
View File

@ -227,32 +227,32 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MOS3DdPtr, MOS3dNode, MOS3dNode) TSTALLOC(MOS3DdPtr, MOS3dNode, MOS3dNode);
TSTALLOC(MOS3GgPtr, MOS3gNode, MOS3gNode) TSTALLOC(MOS3GgPtr, MOS3gNode, MOS3gNode);
TSTALLOC(MOS3SsPtr, MOS3sNode, MOS3sNode) TSTALLOC(MOS3SsPtr, MOS3sNode, MOS3sNode);
TSTALLOC(MOS3BbPtr, MOS3bNode, MOS3bNode) TSTALLOC(MOS3BbPtr, MOS3bNode, MOS3bNode);
TSTALLOC(MOS3DPdpPtr, MOS3dNodePrime, MOS3dNodePrime) TSTALLOC(MOS3DPdpPtr, MOS3dNodePrime, MOS3dNodePrime);
TSTALLOC(MOS3SPspPtr, MOS3sNodePrime, MOS3sNodePrime) TSTALLOC(MOS3SPspPtr, MOS3sNodePrime, MOS3sNodePrime);
TSTALLOC(MOS3DdpPtr, MOS3dNode, MOS3dNodePrime) TSTALLOC(MOS3DdpPtr, MOS3dNode, MOS3dNodePrime);
TSTALLOC(MOS3GbPtr, MOS3gNode, MOS3bNode) TSTALLOC(MOS3GbPtr, MOS3gNode, MOS3bNode);
TSTALLOC(MOS3GdpPtr, MOS3gNode, MOS3dNodePrime) TSTALLOC(MOS3GdpPtr, MOS3gNode, MOS3dNodePrime);
TSTALLOC(MOS3GspPtr, MOS3gNode, MOS3sNodePrime) TSTALLOC(MOS3GspPtr, MOS3gNode, MOS3sNodePrime);
TSTALLOC(MOS3SspPtr, MOS3sNode, MOS3sNodePrime) TSTALLOC(MOS3SspPtr, MOS3sNode, MOS3sNodePrime);
TSTALLOC(MOS3BdpPtr, MOS3bNode, MOS3dNodePrime) TSTALLOC(MOS3BdpPtr, MOS3bNode, MOS3dNodePrime);
TSTALLOC(MOS3BspPtr, MOS3bNode, MOS3sNodePrime) TSTALLOC(MOS3BspPtr, MOS3bNode, MOS3sNodePrime);
TSTALLOC(MOS3DPspPtr, MOS3dNodePrime, MOS3sNodePrime) TSTALLOC(MOS3DPspPtr, MOS3dNodePrime, MOS3sNodePrime);
TSTALLOC(MOS3DPdPtr, MOS3dNodePrime, MOS3dNode) TSTALLOC(MOS3DPdPtr, MOS3dNodePrime, MOS3dNode);
TSTALLOC(MOS3BgPtr, MOS3bNode, MOS3gNode) TSTALLOC(MOS3BgPtr, MOS3bNode, MOS3gNode);
TSTALLOC(MOS3DPgPtr, MOS3dNodePrime, MOS3gNode) TSTALLOC(MOS3DPgPtr, MOS3dNodePrime, MOS3gNode);
TSTALLOC(MOS3SPgPtr, MOS3sNodePrime, MOS3gNode) TSTALLOC(MOS3SPgPtr, MOS3sNodePrime, MOS3gNode);
TSTALLOC(MOS3SPsPtr, MOS3sNodePrime, MOS3sNode) TSTALLOC(MOS3SPsPtr, MOS3sNodePrime, MOS3sNode);
TSTALLOC(MOS3DPbPtr, MOS3dNodePrime, MOS3bNode) TSTALLOC(MOS3DPbPtr, MOS3dNodePrime, MOS3bNode);
TSTALLOC(MOS3SPbPtr, MOS3sNodePrime, MOS3bNode) TSTALLOC(MOS3SPbPtr, MOS3sNodePrime, MOS3bNode);
TSTALLOC(MOS3SPdpPtr, MOS3sNodePrime, MOS3dNodePrime) TSTALLOC(MOS3SPdpPtr, MOS3sNodePrime, MOS3dNodePrime);
} }
} }

48
src/spicelib/devices/mos6/mos6set.c
View File

@ -189,32 +189,32 @@ MOS6setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
} }
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MOS6DdPtr,MOS6dNode,MOS6dNode) TSTALLOC(MOS6DdPtr,MOS6dNode,MOS6dNode);
TSTALLOC(MOS6GgPtr,MOS6gNode,MOS6gNode) TSTALLOC(MOS6GgPtr,MOS6gNode,MOS6gNode);
TSTALLOC(MOS6SsPtr,MOS6sNode,MOS6sNode) TSTALLOC(MOS6SsPtr,MOS6sNode,MOS6sNode);
TSTALLOC(MOS6BbPtr,MOS6bNode,MOS6bNode) TSTALLOC(MOS6BbPtr,MOS6bNode,MOS6bNode);
TSTALLOC(MOS6DPdpPtr,MOS6dNodePrime,MOS6dNodePrime) TSTALLOC(MOS6DPdpPtr,MOS6dNodePrime,MOS6dNodePrime);
TSTALLOC(MOS6SPspPtr,MOS6sNodePrime,MOS6sNodePrime) TSTALLOC(MOS6SPspPtr,MOS6sNodePrime,MOS6sNodePrime);
TSTALLOC(MOS6DdpPtr,MOS6dNode,MOS6dNodePrime) TSTALLOC(MOS6DdpPtr,MOS6dNode,MOS6dNodePrime);
TSTALLOC(MOS6GbPtr,MOS6gNode,MOS6bNode) TSTALLOC(MOS6GbPtr,MOS6gNode,MOS6bNode);
TSTALLOC(MOS6GdpPtr,MOS6gNode,MOS6dNodePrime) TSTALLOC(MOS6GdpPtr,MOS6gNode,MOS6dNodePrime);
TSTALLOC(MOS6GspPtr,MOS6gNode,MOS6sNodePrime) TSTALLOC(MOS6GspPtr,MOS6gNode,MOS6sNodePrime);
TSTALLOC(MOS6SspPtr,MOS6sNode,MOS6sNodePrime) TSTALLOC(MOS6SspPtr,MOS6sNode,MOS6sNodePrime);
TSTALLOC(MOS6BdpPtr,MOS6bNode,MOS6dNodePrime) TSTALLOC(MOS6BdpPtr,MOS6bNode,MOS6dNodePrime);
TSTALLOC(MOS6BspPtr,MOS6bNode,MOS6sNodePrime) TSTALLOC(MOS6BspPtr,MOS6bNode,MOS6sNodePrime);
TSTALLOC(MOS6DPspPtr,MOS6dNodePrime,MOS6sNodePrime) TSTALLOC(MOS6DPspPtr,MOS6dNodePrime,MOS6sNodePrime);
TSTALLOC(MOS6DPdPtr,MOS6dNodePrime,MOS6dNode) TSTALLOC(MOS6DPdPtr,MOS6dNodePrime,MOS6dNode);
TSTALLOC(MOS6BgPtr,MOS6bNode,MOS6gNode) TSTALLOC(MOS6BgPtr,MOS6bNode,MOS6gNode);
TSTALLOC(MOS6DPgPtr,MOS6dNodePrime,MOS6gNode) TSTALLOC(MOS6DPgPtr,MOS6dNodePrime,MOS6gNode);
TSTALLOC(MOS6SPgPtr,MOS6sNodePrime,MOS6gNode) TSTALLOC(MOS6SPgPtr,MOS6sNodePrime,MOS6gNode);
TSTALLOC(MOS6SPsPtr,MOS6sNodePrime,MOS6sNode) TSTALLOC(MOS6SPsPtr,MOS6sNodePrime,MOS6sNode);
TSTALLOC(MOS6DPbPtr,MOS6dNodePrime,MOS6bNode) TSTALLOC(MOS6DPbPtr,MOS6dNodePrime,MOS6bNode);
TSTALLOC(MOS6SPbPtr,MOS6sNodePrime,MOS6bNode) TSTALLOC(MOS6SPbPtr,MOS6sNodePrime,MOS6bNode);
TSTALLOC(MOS6SPdpPtr,MOS6sNodePrime,MOS6dNodePrime) TSTALLOC(MOS6SPdpPtr,MOS6sNodePrime,MOS6dNodePrime);
} }
} }

48
src/spicelib/devices/mos9/mos9set.c
View File

@ -227,32 +227,32 @@ MOS9setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(MOS9DdPtr, MOS9dNode, MOS9dNode) TSTALLOC(MOS9DdPtr, MOS9dNode, MOS9dNode);
TSTALLOC(MOS9GgPtr, MOS9gNode, MOS9gNode) TSTALLOC(MOS9GgPtr, MOS9gNode, MOS9gNode);
TSTALLOC(MOS9SsPtr, MOS9sNode, MOS9sNode) TSTALLOC(MOS9SsPtr, MOS9sNode, MOS9sNode);
TSTALLOC(MOS9BbPtr, MOS9bNode, MOS9bNode) TSTALLOC(MOS9BbPtr, MOS9bNode, MOS9bNode);
TSTALLOC(MOS9DPdpPtr, MOS9dNodePrime, MOS9dNodePrime) TSTALLOC(MOS9DPdpPtr, MOS9dNodePrime, MOS9dNodePrime);
TSTALLOC(MOS9SPspPtr, MOS9sNodePrime, MOS9sNodePrime) TSTALLOC(MOS9SPspPtr, MOS9sNodePrime, MOS9sNodePrime);
TSTALLOC(MOS9DdpPtr, MOS9dNode, MOS9dNodePrime) TSTALLOC(MOS9DdpPtr, MOS9dNode, MOS9dNodePrime);
TSTALLOC(MOS9GbPtr, MOS9gNode, MOS9bNode) TSTALLOC(MOS9GbPtr, MOS9gNode, MOS9bNode);
TSTALLOC(MOS9GdpPtr, MOS9gNode, MOS9dNodePrime) TSTALLOC(MOS9GdpPtr, MOS9gNode, MOS9dNodePrime);
TSTALLOC(MOS9GspPtr, MOS9gNode, MOS9sNodePrime) TSTALLOC(MOS9GspPtr, MOS9gNode, MOS9sNodePrime);
TSTALLOC(MOS9SspPtr, MOS9sNode, MOS9sNodePrime) TSTALLOC(MOS9SspPtr, MOS9sNode, MOS9sNodePrime);
TSTALLOC(MOS9BdpPtr, MOS9bNode, MOS9dNodePrime) TSTALLOC(MOS9BdpPtr, MOS9bNode, MOS9dNodePrime);
TSTALLOC(MOS9BspPtr, MOS9bNode, MOS9sNodePrime) TSTALLOC(MOS9BspPtr, MOS9bNode, MOS9sNodePrime);
TSTALLOC(MOS9DPspPtr, MOS9dNodePrime, MOS9sNodePrime) TSTALLOC(MOS9DPspPtr, MOS9dNodePrime, MOS9sNodePrime);
TSTALLOC(MOS9DPdPtr, MOS9dNodePrime, MOS9dNode) TSTALLOC(MOS9DPdPtr, MOS9dNodePrime, MOS9dNode);
TSTALLOC(MOS9BgPtr, MOS9bNode, MOS9gNode) TSTALLOC(MOS9BgPtr, MOS9bNode, MOS9gNode);
TSTALLOC(MOS9DPgPtr, MOS9dNodePrime, MOS9gNode) TSTALLOC(MOS9DPgPtr, MOS9dNodePrime, MOS9gNode);
TSTALLOC(MOS9SPgPtr, MOS9sNodePrime, MOS9gNode) TSTALLOC(MOS9SPgPtr, MOS9sNodePrime, MOS9gNode);
TSTALLOC(MOS9SPsPtr, MOS9sNodePrime, MOS9sNode) TSTALLOC(MOS9SPsPtr, MOS9sNodePrime, MOS9sNode);
TSTALLOC(MOS9DPbPtr, MOS9dNodePrime, MOS9bNode) TSTALLOC(MOS9DPbPtr, MOS9dNodePrime, MOS9bNode);
TSTALLOC(MOS9SPbPtr, MOS9sNodePrime, MOS9bNode) TSTALLOC(MOS9SPbPtr, MOS9sNodePrime, MOS9bNode);
TSTALLOC(MOS9SPdpPtr, MOS9sNodePrime, MOS9dNodePrime) TSTALLOC(MOS9SPdpPtr, MOS9sNodePrime, MOS9dNodePrime);
} }
} }

22
src/spicelib/devices/nbjt/nbjtset.c
View File

@ -228,19 +228,19 @@ NBJTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\ do { if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(NBJTcolColPtr, NBJTcolNode, NBJTcolNode) TSTALLOC(NBJTcolColPtr, NBJTcolNode, NBJTcolNode);
TSTALLOC(NBJTbaseBasePtr, NBJTbaseNode, NBJTbaseNode) TSTALLOC(NBJTbaseBasePtr, NBJTbaseNode, NBJTbaseNode);
TSTALLOC(NBJTemitEmitPtr, NBJTemitNode, NBJTemitNode) TSTALLOC(NBJTemitEmitPtr, NBJTemitNode, NBJTemitNode);
TSTALLOC(NBJTcolBasePtr, NBJTcolNode, NBJTbaseNode) TSTALLOC(NBJTcolBasePtr, NBJTcolNode, NBJTbaseNode);
TSTALLOC(NBJTcolEmitPtr, NBJTcolNode, NBJTemitNode) TSTALLOC(NBJTcolEmitPtr, NBJTcolNode, NBJTemitNode);
TSTALLOC(NBJTbaseColPtr, NBJTbaseNode, NBJTcolNode) TSTALLOC(NBJTbaseColPtr, NBJTbaseNode, NBJTcolNode);
TSTALLOC(NBJTbaseEmitPtr, NBJTbaseNode, NBJTemitNode) TSTALLOC(NBJTbaseEmitPtr, NBJTbaseNode, NBJTemitNode);
TSTALLOC(NBJTemitColPtr, NBJTemitNode, NBJTcolNode) TSTALLOC(NBJTemitColPtr, NBJTemitNode, NBJTcolNode);
TSTALLOC(NBJTemitBasePtr, NBJTemitNode, NBJTbaseNode) TSTALLOC(NBJTemitBasePtr, NBJTemitNode, NBJTbaseNode);
} }
/* Clean up lists */ /* Clean up lists */
killCoordInfo(xCoordList); killCoordInfo(xCoordList);

22
src/spicelib/devices/nbjt2/nbt2set.c
View File

@ -244,19 +244,19 @@ NBJT2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\ do { if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(NBJT2colColPtr, NBJT2colNode, NBJT2colNode) TSTALLOC(NBJT2colColPtr, NBJT2colNode, NBJT2colNode);
TSTALLOC(NBJT2colBasePtr, NBJT2colNode, NBJT2baseNode) TSTALLOC(NBJT2colBasePtr, NBJT2colNode, NBJT2baseNode);
TSTALLOC(NBJT2colEmitPtr, NBJT2colNode, NBJT2emitNode) TSTALLOC(NBJT2colEmitPtr, NBJT2colNode, NBJT2emitNode);
TSTALLOC(NBJT2baseColPtr, NBJT2baseNode, NBJT2colNode) TSTALLOC(NBJT2baseColPtr, NBJT2baseNode, NBJT2colNode);
TSTALLOC(NBJT2baseBasePtr, NBJT2baseNode, NBJT2baseNode) TSTALLOC(NBJT2baseBasePtr, NBJT2baseNode, NBJT2baseNode);
TSTALLOC(NBJT2baseEmitPtr, NBJT2baseNode, NBJT2emitNode) TSTALLOC(NBJT2baseEmitPtr, NBJT2baseNode, NBJT2emitNode);
TSTALLOC(NBJT2emitColPtr, NBJT2emitNode, NBJT2colNode) TSTALLOC(NBJT2emitColPtr, NBJT2emitNode, NBJT2colNode);
TSTALLOC(NBJT2emitBasePtr, NBJT2emitNode, NBJT2baseNode) TSTALLOC(NBJT2emitBasePtr, NBJT2emitNode, NBJT2baseNode);
TSTALLOC(NBJT2emitEmitPtr, NBJT2emitNode, NBJT2emitNode) TSTALLOC(NBJT2emitEmitPtr, NBJT2emitNode, NBJT2emitNode);
} }
/* Clean up lists */ /* Clean up lists */
killCoordInfo(xCoordList); killCoordInfo(xCoordList);

4
src/spicelib/devices/ndev/ndevset.c
View File

@ -51,9 +51,9 @@ int NDEVsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states
send(model->sock,&(here->Ndevinfo),sizeof(here->Ndevinfo),0); send(model->sock,&(here->Ndevinfo),sizeof(here->Ndevinfo),0);
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
for(i=0;i<here->term;i++) for(i=0;i<here->term;i++)
for(j=0;j<here->term;j++) for(j=0;j<here->term;j++)

12
src/spicelib/devices/numd/numdset.c
View File

@ -217,14 +217,14 @@ NUMDsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\ do { if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(NUMDposPosPtr, NUMDposNode, NUMDposNode) TSTALLOC(NUMDposPosPtr, NUMDposNode, NUMDposNode);
TSTALLOC(NUMDnegNegPtr, NUMDnegNode, NUMDnegNode) TSTALLOC(NUMDnegNegPtr, NUMDnegNode, NUMDnegNode);
TSTALLOC(NUMDnegPosPtr, NUMDnegNode, NUMDposNode) TSTALLOC(NUMDnegPosPtr, NUMDnegNode, NUMDposNode);
TSTALLOC(NUMDposNegPtr, NUMDposNode, NUMDnegNode) TSTALLOC(NUMDposNegPtr, NUMDposNode, NUMDnegNode);
} }
/* Clean up lists */ /* Clean up lists */
killCoordInfo(xCoordList); killCoordInfo(xCoordList);

12
src/spicelib/devices/numd2/nud2set.c
View File

@ -242,14 +242,14 @@ NUMD2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\ do { if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(NUMD2posPosPtr, NUMD2posNode, NUMD2posNode) TSTALLOC(NUMD2posPosPtr, NUMD2posNode, NUMD2posNode);
TSTALLOC(NUMD2negNegPtr, NUMD2negNode, NUMD2negNode) TSTALLOC(NUMD2negNegPtr, NUMD2negNode, NUMD2negNode);
TSTALLOC(NUMD2negPosPtr, NUMD2negNode, NUMD2posNode) TSTALLOC(NUMD2negPosPtr, NUMD2negNode, NUMD2posNode);
TSTALLOC(NUMD2posNegPtr, NUMD2posNode, NUMD2negNode) TSTALLOC(NUMD2posNegPtr, NUMD2posNode, NUMD2negNode);
} }
/* Clean up lists */ /* Clean up lists */
killCoordInfo(xCoordList); killCoordInfo(xCoordList);

36
src/spicelib/devices/numos/nummset.c
View File

@ -241,26 +241,26 @@ NUMOSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\ do { if ((inst->ptr = SMPmakeElt(matrix, inst->first, inst->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(NUMOSdrainDrainPtr, NUMOSdrainNode, NUMOSdrainNode) TSTALLOC(NUMOSdrainDrainPtr, NUMOSdrainNode, NUMOSdrainNode);
TSTALLOC(NUMOSdrainSourcePtr, NUMOSdrainNode, NUMOSsourceNode) TSTALLOC(NUMOSdrainSourcePtr, NUMOSdrainNode, NUMOSsourceNode);
TSTALLOC(NUMOSdrainGatePtr, NUMOSdrainNode, NUMOSgateNode) TSTALLOC(NUMOSdrainGatePtr, NUMOSdrainNode, NUMOSgateNode);
TSTALLOC(NUMOSdrainBulkPtr, NUMOSdrainNode, NUMOSbulkNode) TSTALLOC(NUMOSdrainBulkPtr, NUMOSdrainNode, NUMOSbulkNode);
TSTALLOC(NUMOSsourceDrainPtr, NUMOSsourceNode, NUMOSdrainNode) TSTALLOC(NUMOSsourceDrainPtr, NUMOSsourceNode, NUMOSdrainNode);
TSTALLOC(NUMOSsourceSourcePtr, NUMOSsourceNode, NUMOSsourceNode) TSTALLOC(NUMOSsourceSourcePtr, NUMOSsourceNode, NUMOSsourceNode);
TSTALLOC(NUMOSsourceGatePtr, NUMOSsourceNode, NUMOSgateNode) TSTALLOC(NUMOSsourceGatePtr, NUMOSsourceNode, NUMOSgateNode);
TSTALLOC(NUMOSsourceBulkPtr, NUMOSsourceNode, NUMOSbulkNode) TSTALLOC(NUMOSsourceBulkPtr, NUMOSsourceNode, NUMOSbulkNode);
TSTALLOC(NUMOSgateDrainPtr, NUMOSgateNode, NUMOSdrainNode) TSTALLOC(NUMOSgateDrainPtr, NUMOSgateNode, NUMOSdrainNode);
TSTALLOC(NUMOSgateSourcePtr, NUMOSgateNode, NUMOSsourceNode) TSTALLOC(NUMOSgateSourcePtr, NUMOSgateNode, NUMOSsourceNode);
TSTALLOC(NUMOSgateGatePtr, NUMOSgateNode, NUMOSgateNode) TSTALLOC(NUMOSgateGatePtr, NUMOSgateNode, NUMOSgateNode);
TSTALLOC(NUMOSgateBulkPtr, NUMOSgateNode, NUMOSbulkNode) TSTALLOC(NUMOSgateBulkPtr, NUMOSgateNode, NUMOSbulkNode);
TSTALLOC(NUMOSbulkDrainPtr, NUMOSbulkNode, NUMOSdrainNode) TSTALLOC(NUMOSbulkDrainPtr, NUMOSbulkNode, NUMOSdrainNode);
TSTALLOC(NUMOSbulkSourcePtr, NUMOSbulkNode, NUMOSsourceNode) TSTALLOC(NUMOSbulkSourcePtr, NUMOSbulkNode, NUMOSsourceNode);
TSTALLOC(NUMOSbulkGatePtr, NUMOSbulkNode, NUMOSgateNode) TSTALLOC(NUMOSbulkGatePtr, NUMOSbulkNode, NUMOSgateNode);
TSTALLOC(NUMOSbulkBulkPtr, NUMOSbulkNode, NUMOSbulkNode) TSTALLOC(NUMOSbulkBulkPtr, NUMOSbulkNode, NUMOSbulkNode);
} }
/* Clean up lists */ /* Clean up lists */
killCoordInfo(xCoordList); killCoordInfo(xCoordList);

4
src/spicelib/devices/res/ressetup.c
View File

@ -34,9 +34,9 @@ RESsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit*ckt, int *state)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(RESposPosptr, RESposNode, RESposNode); TSTALLOC(RESposPosptr, RESposNode, RESposNode);
TSTALLOC(RESnegNegptr, RESnegNode, RESnegNode); TSTALLOC(RESnegNegptr, RESnegNode, RESnegNode);

118
src/spicelib/devices/soi3/soi3set.c
View File

@ -566,94 +566,94 @@ SOI3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(SOI3D_dPtr,SOI3dNode,SOI3dNode) TSTALLOC(SOI3D_dPtr,SOI3dNode,SOI3dNode);
TSTALLOC(SOI3D_dpPtr,SOI3dNode,SOI3dNodePrime) TSTALLOC(SOI3D_dpPtr,SOI3dNode,SOI3dNodePrime);
TSTALLOC(SOI3DP_dPtr,SOI3dNodePrime,SOI3dNode) TSTALLOC(SOI3DP_dPtr,SOI3dNodePrime,SOI3dNode);
TSTALLOC(SOI3S_sPtr,SOI3sNode,SOI3sNode) TSTALLOC(SOI3S_sPtr,SOI3sNode,SOI3sNode);
TSTALLOC(SOI3S_spPtr,SOI3sNode,SOI3sNodePrime) TSTALLOC(SOI3S_spPtr,SOI3sNode,SOI3sNodePrime);
TSTALLOC(SOI3SP_sPtr,SOI3sNodePrime,SOI3sNode) TSTALLOC(SOI3SP_sPtr,SOI3sNodePrime,SOI3sNode);
TSTALLOC(SOI3GF_gfPtr,SOI3gfNode,SOI3gfNode) TSTALLOC(SOI3GF_gfPtr,SOI3gfNode,SOI3gfNode);
TSTALLOC(SOI3GF_gbPtr,SOI3gfNode,SOI3gbNode) TSTALLOC(SOI3GF_gbPtr,SOI3gfNode,SOI3gbNode);
TSTALLOC(SOI3GF_dpPtr,SOI3gfNode,SOI3dNodePrime) TSTALLOC(SOI3GF_dpPtr,SOI3gfNode,SOI3dNodePrime);
TSTALLOC(SOI3GF_spPtr,SOI3gfNode,SOI3sNodePrime) TSTALLOC(SOI3GF_spPtr,SOI3gfNode,SOI3sNodePrime);
TSTALLOC(SOI3GF_bPtr,SOI3gfNode,SOI3bNode) TSTALLOC(SOI3GF_bPtr,SOI3gfNode,SOI3bNode);
TSTALLOC(SOI3GB_gfPtr,SOI3gbNode,SOI3gfNode) TSTALLOC(SOI3GB_gfPtr,SOI3gbNode,SOI3gfNode);
TSTALLOC(SOI3GB_gbPtr,SOI3gbNode,SOI3gbNode) TSTALLOC(SOI3GB_gbPtr,SOI3gbNode,SOI3gbNode);
TSTALLOC(SOI3GB_dpPtr,SOI3gbNode,SOI3dNodePrime) TSTALLOC(SOI3GB_dpPtr,SOI3gbNode,SOI3dNodePrime);
TSTALLOC(SOI3GB_spPtr,SOI3gbNode,SOI3sNodePrime) TSTALLOC(SOI3GB_spPtr,SOI3gbNode,SOI3sNodePrime);
TSTALLOC(SOI3GB_bPtr,SOI3gbNode,SOI3bNode) TSTALLOC(SOI3GB_bPtr,SOI3gbNode,SOI3bNode);
TSTALLOC(SOI3B_gfPtr,SOI3bNode,SOI3gfNode) TSTALLOC(SOI3B_gfPtr,SOI3bNode,SOI3gfNode);
TSTALLOC(SOI3B_gbPtr,SOI3bNode,SOI3gbNode) TSTALLOC(SOI3B_gbPtr,SOI3bNode,SOI3gbNode);
TSTALLOC(SOI3B_dpPtr,SOI3bNode,SOI3dNodePrime) TSTALLOC(SOI3B_dpPtr,SOI3bNode,SOI3dNodePrime);
TSTALLOC(SOI3B_spPtr,SOI3bNode,SOI3sNodePrime) TSTALLOC(SOI3B_spPtr,SOI3bNode,SOI3sNodePrime);
TSTALLOC(SOI3B_bPtr,SOI3bNode,SOI3bNode) TSTALLOC(SOI3B_bPtr,SOI3bNode,SOI3bNode);
TSTALLOC(SOI3DP_gfPtr,SOI3dNodePrime,SOI3gfNode) TSTALLOC(SOI3DP_gfPtr,SOI3dNodePrime,SOI3gfNode);
TSTALLOC(SOI3DP_gbPtr,SOI3dNodePrime,SOI3gbNode) TSTALLOC(SOI3DP_gbPtr,SOI3dNodePrime,SOI3gbNode);
TSTALLOC(SOI3DP_dpPtr,SOI3dNodePrime,SOI3dNodePrime) TSTALLOC(SOI3DP_dpPtr,SOI3dNodePrime,SOI3dNodePrime);
TSTALLOC(SOI3DP_spPtr,SOI3dNodePrime,SOI3sNodePrime) TSTALLOC(SOI3DP_spPtr,SOI3dNodePrime,SOI3sNodePrime);
TSTALLOC(SOI3DP_bPtr,SOI3dNodePrime,SOI3bNode) TSTALLOC(SOI3DP_bPtr,SOI3dNodePrime,SOI3bNode);
TSTALLOC(SOI3SP_gfPtr,SOI3sNodePrime,SOI3gfNode) TSTALLOC(SOI3SP_gfPtr,SOI3sNodePrime,SOI3gfNode);
TSTALLOC(SOI3SP_gbPtr,SOI3sNodePrime,SOI3gbNode) TSTALLOC(SOI3SP_gbPtr,SOI3sNodePrime,SOI3gbNode);
TSTALLOC(SOI3SP_dpPtr,SOI3sNodePrime,SOI3dNodePrime) TSTALLOC(SOI3SP_dpPtr,SOI3sNodePrime,SOI3dNodePrime);
TSTALLOC(SOI3SP_spPtr,SOI3sNodePrime,SOI3sNodePrime) TSTALLOC(SOI3SP_spPtr,SOI3sNodePrime,SOI3sNodePrime);
TSTALLOC(SOI3SP_bPtr,SOI3sNodePrime,SOI3bNode) TSTALLOC(SOI3SP_bPtr,SOI3sNodePrime,SOI3bNode);
if (here->SOI3rt == 0) if (here->SOI3rt == 0)
{ {
TSTALLOC(SOI3TOUT_ibrPtr,SOI3toutNode,SOI3branch) TSTALLOC(SOI3TOUT_ibrPtr,SOI3toutNode,SOI3branch);
TSTALLOC(SOI3IBR_toutPtr,SOI3branch,SOI3toutNode) TSTALLOC(SOI3IBR_toutPtr,SOI3branch,SOI3toutNode);
} }
else else
{ {
TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode) TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode);
if (here->SOI3numThermalNodes > 1) if (here->SOI3numThermalNodes > 1)
{ {
TSTALLOC(SOI3TOUT_tout1Ptr,SOI3toutNode,SOI3tout1Node) TSTALLOC(SOI3TOUT_tout1Ptr,SOI3toutNode,SOI3tout1Node);
TSTALLOC(SOI3TOUT1_toutPtr,SOI3tout1Node,SOI3toutNode) TSTALLOC(SOI3TOUT1_toutPtr,SOI3tout1Node,SOI3toutNode);
TSTALLOC(SOI3TOUT1_tout1Ptr,SOI3tout1Node,SOI3tout1Node) TSTALLOC(SOI3TOUT1_tout1Ptr,SOI3tout1Node,SOI3tout1Node);
} }
if (here->SOI3numThermalNodes > 2) if (here->SOI3numThermalNodes > 2)
{ {
TSTALLOC(SOI3TOUT1_tout2Ptr,SOI3tout1Node,SOI3tout2Node) TSTALLOC(SOI3TOUT1_tout2Ptr,SOI3tout1Node,SOI3tout2Node);
TSTALLOC(SOI3TOUT2_tout1Ptr,SOI3tout2Node,SOI3tout1Node) TSTALLOC(SOI3TOUT2_tout1Ptr,SOI3tout2Node,SOI3tout1Node);
TSTALLOC(SOI3TOUT2_tout2Ptr,SOI3tout2Node,SOI3tout2Node) TSTALLOC(SOI3TOUT2_tout2Ptr,SOI3tout2Node,SOI3tout2Node);
} }
if (here->SOI3numThermalNodes > 3) if (here->SOI3numThermalNodes > 3)
{ {
TSTALLOC(SOI3TOUT2_tout3Ptr,SOI3tout2Node,SOI3tout3Node) TSTALLOC(SOI3TOUT2_tout3Ptr,SOI3tout2Node,SOI3tout3Node);
TSTALLOC(SOI3TOUT3_tout2Ptr,SOI3tout3Node,SOI3tout2Node) TSTALLOC(SOI3TOUT3_tout2Ptr,SOI3tout3Node,SOI3tout2Node);
TSTALLOC(SOI3TOUT3_tout3Ptr,SOI3tout3Node,SOI3tout3Node) TSTALLOC(SOI3TOUT3_tout3Ptr,SOI3tout3Node,SOI3tout3Node);
} }
if (here->SOI3numThermalNodes > 4) if (here->SOI3numThermalNodes > 4)
{ {
TSTALLOC(SOI3TOUT3_tout4Ptr,SOI3tout3Node,SOI3tout4Node) TSTALLOC(SOI3TOUT3_tout4Ptr,SOI3tout3Node,SOI3tout4Node);
TSTALLOC(SOI3TOUT4_tout3Ptr,SOI3tout4Node,SOI3tout3Node) TSTALLOC(SOI3TOUT4_tout3Ptr,SOI3tout4Node,SOI3tout3Node);
TSTALLOC(SOI3TOUT4_tout4Ptr,SOI3tout4Node,SOI3tout4Node) TSTALLOC(SOI3TOUT4_tout4Ptr,SOI3tout4Node,SOI3tout4Node);
} }
TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode) TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode);
TSTALLOC(SOI3TOUT_gfPtr,SOI3toutNode,SOI3gfNode) TSTALLOC(SOI3TOUT_gfPtr,SOI3toutNode,SOI3gfNode);
TSTALLOC(SOI3TOUT_gbPtr,SOI3toutNode,SOI3gbNode) TSTALLOC(SOI3TOUT_gbPtr,SOI3toutNode,SOI3gbNode);
TSTALLOC(SOI3TOUT_dpPtr,SOI3toutNode,SOI3dNodePrime) TSTALLOC(SOI3TOUT_dpPtr,SOI3toutNode,SOI3dNodePrime);
TSTALLOC(SOI3TOUT_spPtr,SOI3toutNode,SOI3sNodePrime) TSTALLOC(SOI3TOUT_spPtr,SOI3toutNode,SOI3sNodePrime);
TSTALLOC(SOI3TOUT_bPtr,SOI3toutNode,SOI3bNode) TSTALLOC(SOI3TOUT_bPtr,SOI3toutNode,SOI3bNode);
TSTALLOC(SOI3GF_toutPtr,SOI3gfNode,SOI3toutNode) TSTALLOC(SOI3GF_toutPtr,SOI3gfNode,SOI3toutNode);
TSTALLOC(SOI3GB_toutPtr,SOI3gbNode,SOI3toutNode) TSTALLOC(SOI3GB_toutPtr,SOI3gbNode,SOI3toutNode);
TSTALLOC(SOI3DP_toutPtr,SOI3dNodePrime,SOI3toutNode) TSTALLOC(SOI3DP_toutPtr,SOI3dNodePrime,SOI3toutNode);
TSTALLOC(SOI3SP_toutPtr,SOI3sNodePrime,SOI3toutNode) TSTALLOC(SOI3SP_toutPtr,SOI3sNodePrime,SOI3toutNode);
TSTALLOC(SOI3B_toutPtr,SOI3bNode,SOI3toutNode) TSTALLOC(SOI3B_toutPtr,SOI3bNode,SOI3toutNode);
} }
} }
} }

12
src/spicelib/devices/sw/swsetup.c
View File

@ -52,14 +52,14 @@ SWsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(SWposPosptr, SWposNode, SWposNode) TSTALLOC(SWposPosptr, SWposNode, SWposNode);
TSTALLOC(SWposNegptr, SWposNode, SWnegNode) TSTALLOC(SWposNegptr, SWposNode, SWnegNode);
TSTALLOC(SWnegPosptr, SWnegNode, SWposNode) TSTALLOC(SWnegPosptr, SWnegNode, SWposNode);
TSTALLOC(SWnegNegptr, SWnegNode, SWnegNode) TSTALLOC(SWnegNegptr, SWnegNode, SWnegNode);
} }
} }
return(OK); return(OK);

48
src/spicelib/devices/tra/trasetup.c
View File

@ -64,32 +64,32 @@ TRAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(TRAibr1Ibr2Ptr, TRAbrEq1, TRAbrEq2) TSTALLOC(TRAibr1Ibr2Ptr, TRAbrEq1, TRAbrEq2);
TSTALLOC(TRAibr1Int1Ptr, TRAbrEq1, TRAintNode1) TSTALLOC(TRAibr1Int1Ptr, TRAbrEq1, TRAintNode1);
TSTALLOC(TRAibr1Neg1Ptr, TRAbrEq1, TRAnegNode1) TSTALLOC(TRAibr1Neg1Ptr, TRAbrEq1, TRAnegNode1);
TSTALLOC(TRAibr1Neg2Ptr, TRAbrEq1, TRAnegNode2) TSTALLOC(TRAibr1Neg2Ptr, TRAbrEq1, TRAnegNode2);
TSTALLOC(TRAibr1Pos2Ptr, TRAbrEq1, TRAposNode2) TSTALLOC(TRAibr1Pos2Ptr, TRAbrEq1, TRAposNode2);
TSTALLOC(TRAibr2Ibr1Ptr, TRAbrEq2, TRAbrEq1) TSTALLOC(TRAibr2Ibr1Ptr, TRAbrEq2, TRAbrEq1);
TSTALLOC(TRAibr2Int2Ptr, TRAbrEq2, TRAintNode2) TSTALLOC(TRAibr2Int2Ptr, TRAbrEq2, TRAintNode2);
TSTALLOC(TRAibr2Neg1Ptr, TRAbrEq2, TRAnegNode1) TSTALLOC(TRAibr2Neg1Ptr, TRAbrEq2, TRAnegNode1);
TSTALLOC(TRAibr2Neg2Ptr, TRAbrEq2, TRAnegNode2) TSTALLOC(TRAibr2Neg2Ptr, TRAbrEq2, TRAnegNode2);
TSTALLOC(TRAibr2Pos1Ptr, TRAbrEq2, TRAposNode1) TSTALLOC(TRAibr2Pos1Ptr, TRAbrEq2, TRAposNode1);
TSTALLOC(TRAint1Ibr1Ptr, TRAintNode1, TRAbrEq1) TSTALLOC(TRAint1Ibr1Ptr, TRAintNode1, TRAbrEq1);
TSTALLOC(TRAint1Int1Ptr, TRAintNode1, TRAintNode1) TSTALLOC(TRAint1Int1Ptr, TRAintNode1, TRAintNode1);
TSTALLOC(TRAint1Pos1Ptr, TRAintNode1, TRAposNode1) TSTALLOC(TRAint1Pos1Ptr, TRAintNode1, TRAposNode1);
TSTALLOC(TRAint2Ibr2Ptr, TRAintNode2, TRAbrEq2) TSTALLOC(TRAint2Ibr2Ptr, TRAintNode2, TRAbrEq2);
TSTALLOC(TRAint2Int2Ptr, TRAintNode2, TRAintNode2) TSTALLOC(TRAint2Int2Ptr, TRAintNode2, TRAintNode2);
TSTALLOC(TRAint2Pos2Ptr, TRAintNode2, TRAposNode2) TSTALLOC(TRAint2Pos2Ptr, TRAintNode2, TRAposNode2);
TSTALLOC(TRAneg1Ibr1Ptr, TRAnegNode1, TRAbrEq1) TSTALLOC(TRAneg1Ibr1Ptr, TRAnegNode1, TRAbrEq1);
TSTALLOC(TRAneg2Ibr2Ptr, TRAnegNode2, TRAbrEq2) TSTALLOC(TRAneg2Ibr2Ptr, TRAnegNode2, TRAbrEq2);
TSTALLOC(TRApos1Int1Ptr, TRAposNode1, TRAintNode1) TSTALLOC(TRApos1Int1Ptr, TRAposNode1, TRAintNode1);
TSTALLOC(TRApos1Pos1Ptr, TRAposNode1, TRAposNode1) TSTALLOC(TRApos1Pos1Ptr, TRAposNode1, TRAposNode1);
TSTALLOC(TRApos2Int2Ptr, TRAposNode2, TRAintNode2) TSTALLOC(TRApos2Int2Ptr, TRAposNode2, TRAintNode2);
TSTALLOC(TRApos2Pos2Ptr, TRAposNode2, TRAposNode2) TSTALLOC(TRApos2Pos2Ptr, TRAposNode2, TRAposNode2);
if(!here->TRAnlGiven) { if(!here->TRAnlGiven) {
here->TRAnl = .25; here->TRAnl = .25;

4
src/spicelib/devices/txl/txlsetup.c
View File

@ -120,9 +120,9 @@ TXLsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit*ckt, int *state)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
if (! here->TXLibr1Given) { if (! here->TXLibr1Given) {
error = CKTmkCur(ckt, &tmp, here->TXLname, "branch1"); error = CKTmkCur(ckt, &tmp, here->TXLname, "branch1");

106
src/spicelib/devices/vbic/vbicsetup.c
View File

@ -472,62 +472,62 @@ VBICsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(VBICcollCollPtr,VBICcollNode,VBICcollNode) TSTALLOC(VBICcollCollPtr,VBICcollNode,VBICcollNode);
TSTALLOC(VBICbaseBasePtr,VBICbaseNode,VBICbaseNode) TSTALLOC(VBICbaseBasePtr,VBICbaseNode,VBICbaseNode);
TSTALLOC(VBICemitEmitPtr,VBICemitNode,VBICemitNode) TSTALLOC(VBICemitEmitPtr,VBICemitNode,VBICemitNode);
TSTALLOC(VBICsubsSubsPtr,VBICsubsNode,VBICsubsNode) TSTALLOC(VBICsubsSubsPtr,VBICsubsNode,VBICsubsNode);
TSTALLOC(VBICcollCXCollCXPtr,VBICcollCXNode,VBICcollCXNode) TSTALLOC(VBICcollCXCollCXPtr,VBICcollCXNode,VBICcollCXNode);
TSTALLOC(VBICcollCICollCIPtr,VBICcollCINode,VBICcollCINode) TSTALLOC(VBICcollCICollCIPtr,VBICcollCINode,VBICcollCINode);
TSTALLOC(VBICbaseBXBaseBXPtr,VBICbaseBXNode,VBICbaseBXNode) TSTALLOC(VBICbaseBXBaseBXPtr,VBICbaseBXNode,VBICbaseBXNode);
TSTALLOC(VBICbaseBIBaseBIPtr,VBICbaseBINode,VBICbaseBINode) TSTALLOC(VBICbaseBIBaseBIPtr,VBICbaseBINode,VBICbaseBINode);
TSTALLOC(VBICemitEIEmitEIPtr,VBICemitEINode,VBICemitEINode) TSTALLOC(VBICemitEIEmitEIPtr,VBICemitEINode,VBICemitEINode);
TSTALLOC(VBICbaseBPBaseBPPtr,VBICbaseBPNode,VBICbaseBPNode) TSTALLOC(VBICbaseBPBaseBPPtr,VBICbaseBPNode,VBICbaseBPNode);
TSTALLOC(VBICsubsSISubsSIPtr,VBICsubsSINode,VBICsubsSINode) TSTALLOC(VBICsubsSISubsSIPtr,VBICsubsSINode,VBICsubsSINode);
TSTALLOC(VBICbaseEmitPtr,VBICbaseNode,VBICemitNode) TSTALLOC(VBICbaseEmitPtr,VBICbaseNode,VBICemitNode);
TSTALLOC(VBICemitBasePtr,VBICemitNode,VBICbaseNode) TSTALLOC(VBICemitBasePtr,VBICemitNode,VBICbaseNode);
TSTALLOC(VBICbaseCollPtr,VBICbaseNode,VBICcollNode) TSTALLOC(VBICbaseCollPtr,VBICbaseNode,VBICcollNode);
TSTALLOC(VBICcollBasePtr,VBICcollNode,VBICbaseNode) TSTALLOC(VBICcollBasePtr,VBICcollNode,VBICbaseNode);
TSTALLOC(VBICcollCollCXPtr,VBICcollNode,VBICcollCXNode) TSTALLOC(VBICcollCollCXPtr,VBICcollNode,VBICcollCXNode);
TSTALLOC(VBICbaseBaseBXPtr,VBICbaseNode,VBICbaseBXNode) TSTALLOC(VBICbaseBaseBXPtr,VBICbaseNode,VBICbaseBXNode);
TSTALLOC(VBICemitEmitEIPtr,VBICemitNode,VBICemitEINode) TSTALLOC(VBICemitEmitEIPtr,VBICemitNode,VBICemitEINode);
TSTALLOC(VBICsubsSubsSIPtr,VBICsubsNode,VBICsubsSINode) TSTALLOC(VBICsubsSubsSIPtr,VBICsubsNode,VBICsubsSINode);
TSTALLOC(VBICcollCXCollCIPtr,VBICcollCXNode,VBICcollCINode) TSTALLOC(VBICcollCXCollCIPtr,VBICcollCXNode,VBICcollCINode);
TSTALLOC(VBICcollCXBaseBXPtr,VBICcollCXNode,VBICbaseBXNode) TSTALLOC(VBICcollCXBaseBXPtr,VBICcollCXNode,VBICbaseBXNode);
TSTALLOC(VBICcollCXBaseBIPtr,VBICcollCXNode,VBICbaseBINode) TSTALLOC(VBICcollCXBaseBIPtr,VBICcollCXNode,VBICbaseBINode);
TSTALLOC(VBICcollCXBaseBPPtr,VBICcollCXNode,VBICbaseBPNode) TSTALLOC(VBICcollCXBaseBPPtr,VBICcollCXNode,VBICbaseBPNode);
TSTALLOC(VBICcollCIBaseBIPtr,VBICcollCINode,VBICbaseBINode) TSTALLOC(VBICcollCIBaseBIPtr,VBICcollCINode,VBICbaseBINode);
TSTALLOC(VBICcollCIEmitEIPtr,VBICcollCINode,VBICemitEINode) TSTALLOC(VBICcollCIEmitEIPtr,VBICcollCINode,VBICemitEINode);
TSTALLOC(VBICbaseBXBaseBIPtr,VBICbaseBXNode,VBICbaseBINode) TSTALLOC(VBICbaseBXBaseBIPtr,VBICbaseBXNode,VBICbaseBINode);
TSTALLOC(VBICbaseBXEmitEIPtr,VBICbaseBXNode,VBICemitEINode) TSTALLOC(VBICbaseBXEmitEIPtr,VBICbaseBXNode,VBICemitEINode);
TSTALLOC(VBICbaseBXBaseBPPtr,VBICbaseBXNode,VBICbaseBPNode) TSTALLOC(VBICbaseBXBaseBPPtr,VBICbaseBXNode,VBICbaseBPNode);
TSTALLOC(VBICbaseBXSubsSIPtr,VBICbaseBXNode,VBICsubsSINode) TSTALLOC(VBICbaseBXSubsSIPtr,VBICbaseBXNode,VBICsubsSINode);
TSTALLOC(VBICbaseBIEmitEIPtr,VBICbaseBINode,VBICemitEINode) TSTALLOC(VBICbaseBIEmitEIPtr,VBICbaseBINode,VBICemitEINode);
TSTALLOC(VBICbaseBPSubsSIPtr,VBICbaseBPNode,VBICsubsSINode) TSTALLOC(VBICbaseBPSubsSIPtr,VBICbaseBPNode,VBICsubsSINode);
TSTALLOC(VBICcollCXCollPtr,VBICcollCXNode,VBICcollNode) TSTALLOC(VBICcollCXCollPtr,VBICcollCXNode,VBICcollNode);
TSTALLOC(VBICbaseBXBasePtr,VBICbaseBXNode,VBICbaseNode) TSTALLOC(VBICbaseBXBasePtr,VBICbaseBXNode,VBICbaseNode);
TSTALLOC(VBICemitEIEmitPtr,VBICemitEINode,VBICemitNode) TSTALLOC(VBICemitEIEmitPtr,VBICemitEINode,VBICemitNode);
TSTALLOC(VBICsubsSISubsPtr,VBICsubsSINode,VBICsubsNode) TSTALLOC(VBICsubsSISubsPtr,VBICsubsSINode,VBICsubsNode);
TSTALLOC(VBICcollCICollCXPtr,VBICcollCINode,VBICcollCXNode) TSTALLOC(VBICcollCICollCXPtr,VBICcollCINode,VBICcollCXNode);
TSTALLOC(VBICbaseBICollCXPtr,VBICbaseBINode,VBICcollCXNode) TSTALLOC(VBICbaseBICollCXPtr,VBICbaseBINode,VBICcollCXNode);
TSTALLOC(VBICbaseBPCollCXPtr,VBICbaseBPNode,VBICcollCXNode) TSTALLOC(VBICbaseBPCollCXPtr,VBICbaseBPNode,VBICcollCXNode);
TSTALLOC(VBICbaseBXCollCIPtr,VBICbaseBXNode,VBICcollCINode) TSTALLOC(VBICbaseBXCollCIPtr,VBICbaseBXNode,VBICcollCINode);
TSTALLOC(VBICbaseBICollCIPtr,VBICbaseBINode,VBICcollCINode) TSTALLOC(VBICbaseBICollCIPtr,VBICbaseBINode,VBICcollCINode);
TSTALLOC(VBICemitEICollCIPtr,VBICemitEINode,VBICcollCINode) TSTALLOC(VBICemitEICollCIPtr,VBICemitEINode,VBICcollCINode);
TSTALLOC(VBICbaseBPCollCIPtr,VBICbaseBPNode,VBICcollCINode) TSTALLOC(VBICbaseBPCollCIPtr,VBICbaseBPNode,VBICcollCINode);
TSTALLOC(VBICbaseBIBaseBXPtr,VBICbaseBINode,VBICbaseBXNode) TSTALLOC(VBICbaseBIBaseBXPtr,VBICbaseBINode,VBICbaseBXNode);
TSTALLOC(VBICemitEIBaseBXPtr,VBICemitEINode,VBICbaseBXNode) TSTALLOC(VBICemitEIBaseBXPtr,VBICemitEINode,VBICbaseBXNode);
TSTALLOC(VBICbaseBPBaseBXPtr,VBICbaseBPNode,VBICbaseBXNode) TSTALLOC(VBICbaseBPBaseBXPtr,VBICbaseBPNode,VBICbaseBXNode);
TSTALLOC(VBICsubsSIBaseBXPtr,VBICsubsSINode,VBICbaseBXNode) TSTALLOC(VBICsubsSIBaseBXPtr,VBICsubsSINode,VBICbaseBXNode);
TSTALLOC(VBICemitEIBaseBIPtr,VBICemitEINode,VBICbaseBINode) TSTALLOC(VBICemitEIBaseBIPtr,VBICemitEINode,VBICbaseBINode);
TSTALLOC(VBICbaseBPBaseBIPtr,VBICbaseBPNode,VBICbaseBINode) TSTALLOC(VBICbaseBPBaseBIPtr,VBICbaseBPNode,VBICbaseBINode);
TSTALLOC(VBICsubsSICollCIPtr,VBICsubsSINode,VBICcollCINode) TSTALLOC(VBICsubsSICollCIPtr,VBICsubsSINode,VBICcollCINode);
TSTALLOC(VBICsubsSIBaseBIPtr,VBICsubsSINode,VBICbaseBINode) TSTALLOC(VBICsubsSIBaseBIPtr,VBICsubsSINode,VBICbaseBINode);
TSTALLOC(VBICsubsSIBaseBPPtr,VBICsubsSINode,VBICbaseBPNode) TSTALLOC(VBICsubsSIBaseBPPtr,VBICsubsSINode,VBICbaseBPNode);
} }
} }

12
src/spicelib/devices/vccs/vccsset.c
View File

@ -36,14 +36,14 @@ VCCSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(VCCSposContPosptr, VCCSposNode, VCCScontPosNode) TSTALLOC(VCCSposContPosptr, VCCSposNode, VCCScontPosNode);
TSTALLOC(VCCSposContNegptr, VCCSposNode, VCCScontNegNode) TSTALLOC(VCCSposContNegptr, VCCSposNode, VCCScontNegNode);
TSTALLOC(VCCSnegContPosptr, VCCSnegNode, VCCScontPosNode) TSTALLOC(VCCSnegContPosptr, VCCSnegNode, VCCScontPosNode);
TSTALLOC(VCCSnegContNegptr, VCCSnegNode, VCCScontNegNode) TSTALLOC(VCCSnegContNegptr, VCCSnegNode, VCCScontNegNode);
} }
} }
return(OK); return(OK);

16
src/spicelib/devices/vcvs/vcvsset.c
View File

@ -46,16 +46,16 @@ VCVSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(VCVSposIbrptr, VCVSposNode, VCVSbranch) TSTALLOC(VCVSposIbrptr, VCVSposNode, VCVSbranch);
TSTALLOC(VCVSnegIbrptr, VCVSnegNode, VCVSbranch) TSTALLOC(VCVSnegIbrptr, VCVSnegNode, VCVSbranch);
TSTALLOC(VCVSibrPosptr, VCVSbranch, VCVSposNode) TSTALLOC(VCVSibrPosptr, VCVSbranch, VCVSposNode);
TSTALLOC(VCVSibrNegptr, VCVSbranch, VCVSnegNode) TSTALLOC(VCVSibrNegptr, VCVSbranch, VCVSnegNode);
TSTALLOC(VCVSibrContPosptr, VCVSbranch, VCVScontPosNode) TSTALLOC(VCVSibrContPosptr, VCVSbranch, VCVScontPosNode);
TSTALLOC(VCVSibrContNegptr, VCVSbranch, VCVScontNegNode) TSTALLOC(VCVSibrContNegptr, VCVSbranch, VCVScontNegNode);
} }
} }
return(OK); return(OK);

14
src/spicelib/devices/vsrc/vsrcpzs.c
View File

@ -38,15 +38,15 @@ VSRCpzSetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch) TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch);
TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch) TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch);
TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode) TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode);
TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode) TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode);
TSTALLOC(VSRCibrIbrptr, VSRCbranch, VSRCbranch) TSTALLOC(VSRCibrIbrptr, VSRCbranch, VSRCbranch);
} }
} }
return(OK); return(OK);

12
src/spicelib/devices/vsrc/vsrcset.c
View File

@ -45,14 +45,14 @@ VSRCsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */ /* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ do { if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\
return(E_NOMEM);\ return(E_NOMEM);\
} } } while(0)
TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch) TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch);
TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch) TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch);
TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode) TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode);
TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode) TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode);
} }
} }
return(OK); return(OK);

8
src/xspice/mif/mifsetup.c
View File

@ -56,17 +56,17 @@ NON-STANDARD FEATURES
/* define macro for easy creation of matrix entries/pointers for outputs */ /* define macro for easy creation of matrix entries/pointers for outputs */
#define TSTALLOC(ptr,first,second) \ #define TSTALLOC(ptr,first,second) \
if((smp_data_out->ptr = \ do { if((smp_data_out->ptr = \
SMPmakeElt(matrix, smp_data_out->first, smp_data_out->second)) == NULL) { \ SMPmakeElt(matrix, smp_data_out->first, smp_data_out->second)) == NULL) { \
return(E_NOMEM); \ return(E_NOMEM); \
} } } while(0)
/* define macro for easy creation of matrix entries/pointers for inputs */ /* define macro for easy creation of matrix entries/pointers for inputs */
#define CTSTALLOC(ptr,first,second) \ #define CTSTALLOC(ptr,first,second) \
if((smp_data_out->input[k].port[l].ptr = \ do { if((smp_data_out->input[k].port[l].ptr = \
SMPmakeElt(matrix, smp_data_out->first, smp_data_cntl->second)) == NULL) { \ SMPmakeElt(matrix, smp_data_out->first, smp_data_cntl->second)) == NULL) { \
return(E_NOMEM); \ return(E_NOMEM); \
} } } while(0)