diff --git a/src/spicelib/devices/asrc/asrcset.c b/src/spicelib/devices/asrc/asrcset.c index 8f4fb22a0..84ab66f69 100644 --- a/src/spicelib/devices/asrc/asrcset.c +++ b/src/spicelib/devices/asrc/asrcset.c @@ -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 */ #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);\ -} +} } while(0) #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);\ -} +} } while(0) /* For each controlling variable set the entries in the vector of the positions of the SMP */ diff --git a/src/spicelib/devices/bjt/bjtsetup.c b/src/spicelib/devices/bjt/bjtsetup.c index 5c94f2edf..0ca183775 100644 --- a/src/spicelib/devices/bjt/bjtsetup.c +++ b/src/spicelib/devices/bjt/bjtsetup.c @@ -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 */ #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);\ -} - TSTALLOC(BJTcolColPrimePtr,BJTcolNode,BJTcolPrimeNode) - TSTALLOC(BJTbaseBasePrimePtr,BJTbaseNode,BJTbasePrimeNode) - TSTALLOC(BJTemitEmitPrimePtr,BJTemitNode,BJTemitPrimeNode) - TSTALLOC(BJTcolPrimeColPtr,BJTcolPrimeNode,BJTcolNode) - TSTALLOC(BJTcolPrimeBasePrimePtr,BJTcolPrimeNode,BJTbasePrimeNode) - TSTALLOC(BJTcolPrimeEmitPrimePtr,BJTcolPrimeNode,BJTemitPrimeNode) - TSTALLOC(BJTbasePrimeBasePtr,BJTbasePrimeNode,BJTbaseNode) - TSTALLOC(BJTbasePrimeColPrimePtr,BJTbasePrimeNode,BJTcolPrimeNode) - TSTALLOC(BJTbasePrimeEmitPrimePtr,BJTbasePrimeNode,BJTemitPrimeNode) - TSTALLOC(BJTemitPrimeEmitPtr,BJTemitPrimeNode,BJTemitNode) - TSTALLOC(BJTemitPrimeColPrimePtr,BJTemitPrimeNode,BJTcolPrimeNode) - TSTALLOC(BJTemitPrimeBasePrimePtr,BJTemitPrimeNode,BJTbasePrimeNode) - TSTALLOC(BJTcolColPtr,BJTcolNode,BJTcolNode) - TSTALLOC(BJTbaseBasePtr,BJTbaseNode,BJTbaseNode) - TSTALLOC(BJTemitEmitPtr,BJTemitNode,BJTemitNode) - TSTALLOC(BJTcolPrimeColPrimePtr,BJTcolPrimeNode,BJTcolPrimeNode) - TSTALLOC(BJTbasePrimeBasePrimePtr,BJTbasePrimeNode,BJTbasePrimeNode) - TSTALLOC(BJTemitPrimeEmitPrimePtr,BJTemitPrimeNode,BJTemitPrimeNode) - TSTALLOC(BJTsubstSubstPtr,BJTsubstNode,BJTsubstNode) +} } while(0) + TSTALLOC(BJTcolColPrimePtr,BJTcolNode,BJTcolPrimeNode); + TSTALLOC(BJTbaseBasePrimePtr,BJTbaseNode,BJTbasePrimeNode); + TSTALLOC(BJTemitEmitPrimePtr,BJTemitNode,BJTemitPrimeNode); + TSTALLOC(BJTcolPrimeColPtr,BJTcolPrimeNode,BJTcolNode); + TSTALLOC(BJTcolPrimeBasePrimePtr,BJTcolPrimeNode,BJTbasePrimeNode); + TSTALLOC(BJTcolPrimeEmitPrimePtr,BJTcolPrimeNode,BJTemitPrimeNode); + TSTALLOC(BJTbasePrimeBasePtr,BJTbasePrimeNode,BJTbaseNode); + TSTALLOC(BJTbasePrimeColPrimePtr,BJTbasePrimeNode,BJTcolPrimeNode); + TSTALLOC(BJTbasePrimeEmitPrimePtr,BJTbasePrimeNode,BJTemitPrimeNode); + TSTALLOC(BJTemitPrimeEmitPtr,BJTemitPrimeNode,BJTemitNode); + TSTALLOC(BJTemitPrimeColPrimePtr,BJTemitPrimeNode,BJTcolPrimeNode); + TSTALLOC(BJTemitPrimeBasePrimePtr,BJTemitPrimeNode,BJTbasePrimeNode); + TSTALLOC(BJTcolColPtr,BJTcolNode,BJTcolNode); + TSTALLOC(BJTbaseBasePtr,BJTbaseNode,BJTbaseNode); + TSTALLOC(BJTemitEmitPtr,BJTemitNode,BJTemitNode); + TSTALLOC(BJTcolPrimeColPrimePtr,BJTcolPrimeNode,BJTcolPrimeNode); + TSTALLOC(BJTbasePrimeBasePrimePtr,BJTbasePrimeNode,BJTbasePrimeNode); + TSTALLOC(BJTemitPrimeEmitPrimePtr,BJTemitPrimeNode,BJTemitPrimeNode); + TSTALLOC(BJTsubstSubstPtr,BJTsubstNode,BJTsubstNode); if (model -> BJTsubs == LATERAL) { here -> BJTsubstConNode = here -> BJTbasePrimeNode; here -> BJTsubstConSubstConPtr = here -> BJTbasePrimeBasePrimePtr; @@ -449,10 +449,10 @@ if((here->ptr = SMPmakeElt(matrix, here->first, here->second)) == NULL){\ here -> BJTsubstConNode = here -> BJTcolPrimeNode; here -> BJTsubstConSubstConPtr = here -> BJTcolPrimeColPrimePtr; } - TSTALLOC(BJTsubstConSubstPtr,BJTsubstConNode,BJTsubstNode) - TSTALLOC(BJTsubstSubstConPtr,BJTsubstNode,BJTsubstConNode) - TSTALLOC(BJTbaseColPrimePtr,BJTbaseNode,BJTcolPrimeNode) - TSTALLOC(BJTcolPrimeBasePtr,BJTcolPrimeNode,BJTbaseNode) + TSTALLOC(BJTsubstConSubstPtr,BJTsubstConNode,BJTsubstNode); + TSTALLOC(BJTsubstSubstConPtr,BJTsubstNode,BJTsubstConNode); + TSTALLOC(BJTbaseColPrimePtr,BJTbaseNode,BJTcolPrimeNode); + TSTALLOC(BJTcolPrimeBasePtr,BJTcolPrimeNode,BJTbaseNode); } } return(OK); diff --git a/src/spicelib/devices/bsim1/b1set.c b/src/spicelib/devices/bsim1/b1set.c index ab29964ee..46ae6d5b2 100644 --- a/src/spicelib/devices/bsim1/b1set.c +++ b/src/spicelib/devices/bsim1/b1set.c @@ -368,32 +368,32 @@ B1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(B1DdPtr, B1dNode, B1dNode) - TSTALLOC(B1GgPtr, B1gNode, B1gNode) - TSTALLOC(B1SsPtr, B1sNode, B1sNode) - TSTALLOC(B1BbPtr, B1bNode, B1bNode) - TSTALLOC(B1DPdpPtr, B1dNodePrime, B1dNodePrime) - TSTALLOC(B1SPspPtr, B1sNodePrime, B1sNodePrime) - TSTALLOC(B1DdpPtr, B1dNode, B1dNodePrime) - TSTALLOC(B1GbPtr, B1gNode, B1bNode) - TSTALLOC(B1GdpPtr, B1gNode, B1dNodePrime) - TSTALLOC(B1GspPtr, B1gNode, B1sNodePrime) - TSTALLOC(B1SspPtr, B1sNode, B1sNodePrime) - TSTALLOC(B1BdpPtr, B1bNode, B1dNodePrime) - TSTALLOC(B1BspPtr, B1bNode, B1sNodePrime) - TSTALLOC(B1DPspPtr, B1dNodePrime, B1sNodePrime) - TSTALLOC(B1DPdPtr, B1dNodePrime, B1dNode) - TSTALLOC(B1BgPtr, B1bNode, B1gNode) - TSTALLOC(B1DPgPtr, B1dNodePrime, B1gNode) - TSTALLOC(B1SPgPtr, B1sNodePrime, B1gNode) - TSTALLOC(B1SPsPtr, B1sNodePrime, B1sNode) - TSTALLOC(B1DPbPtr, B1dNodePrime, B1bNode) - TSTALLOC(B1SPbPtr, B1sNodePrime, B1bNode) - TSTALLOC(B1SPdpPtr, B1sNodePrime, B1dNodePrime) + TSTALLOC(B1DdPtr, B1dNode, B1dNode); + TSTALLOC(B1GgPtr, B1gNode, B1gNode); + TSTALLOC(B1SsPtr, B1sNode, B1sNode); + TSTALLOC(B1BbPtr, B1bNode, B1bNode); + TSTALLOC(B1DPdpPtr, B1dNodePrime, B1dNodePrime); + TSTALLOC(B1SPspPtr, B1sNodePrime, B1sNodePrime); + TSTALLOC(B1DdpPtr, B1dNode, B1dNodePrime); + TSTALLOC(B1GbPtr, B1gNode, B1bNode); + TSTALLOC(B1GdpPtr, B1gNode, B1dNodePrime); + TSTALLOC(B1GspPtr, B1gNode, B1sNodePrime); + TSTALLOC(B1SspPtr, B1sNode, B1sNodePrime); + TSTALLOC(B1BdpPtr, B1bNode, B1dNodePrime); + TSTALLOC(B1BspPtr, B1bNode, B1sNodePrime); + TSTALLOC(B1DPspPtr, B1dNodePrime, B1sNodePrime); + TSTALLOC(B1DPdPtr, B1dNodePrime, B1dNode); + TSTALLOC(B1BgPtr, B1bNode, B1gNode); + TSTALLOC(B1DPgPtr, B1dNodePrime, B1gNode); + TSTALLOC(B1SPgPtr, B1sNodePrime, B1gNode); + TSTALLOC(B1SPsPtr, B1sNodePrime, B1sNode); + TSTALLOC(B1DPbPtr, B1dNodePrime, B1bNode); + TSTALLOC(B1SPbPtr, B1sNodePrime, B1bNode); + TSTALLOC(B1SPdpPtr, B1sNodePrime, B1dNodePrime); } } diff --git a/src/spicelib/devices/bsim2/b2set.c b/src/spicelib/devices/bsim2/b2set.c index 9721885d7..3c9dec9a3 100644 --- a/src/spicelib/devices/bsim2/b2set.c +++ b/src/spicelib/devices/bsim2/b2set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(B2DdPtr, B2dNode, B2dNode) - TSTALLOC(B2GgPtr, B2gNode, B2gNode) - TSTALLOC(B2SsPtr, B2sNode, B2sNode) - TSTALLOC(B2BbPtr, B2bNode, B2bNode) - TSTALLOC(B2DPdpPtr, B2dNodePrime, B2dNodePrime) - TSTALLOC(B2SPspPtr, B2sNodePrime, B2sNodePrime) - TSTALLOC(B2DdpPtr, B2dNode, B2dNodePrime) - TSTALLOC(B2GbPtr, B2gNode, B2bNode) - TSTALLOC(B2GdpPtr, B2gNode, B2dNodePrime) - TSTALLOC(B2GspPtr, B2gNode, B2sNodePrime) - TSTALLOC(B2SspPtr, B2sNode, B2sNodePrime) - TSTALLOC(B2BdpPtr, B2bNode, B2dNodePrime) - TSTALLOC(B2BspPtr, B2bNode, B2sNodePrime) - TSTALLOC(B2DPspPtr, B2dNodePrime, B2sNodePrime) - TSTALLOC(B2DPdPtr, B2dNodePrime, B2dNode) - TSTALLOC(B2BgPtr, B2bNode, B2gNode) - TSTALLOC(B2DPgPtr, B2dNodePrime, B2gNode) - TSTALLOC(B2SPgPtr, B2sNodePrime, B2gNode) - TSTALLOC(B2SPsPtr, B2sNodePrime, B2sNode) - TSTALLOC(B2DPbPtr, B2dNodePrime, B2bNode) - TSTALLOC(B2SPbPtr, B2sNodePrime, B2bNode) - TSTALLOC(B2SPdpPtr, B2sNodePrime, B2dNodePrime) + TSTALLOC(B2DdPtr, B2dNode, B2dNode); + TSTALLOC(B2GgPtr, B2gNode, B2gNode); + TSTALLOC(B2SsPtr, B2sNode, B2sNode); + TSTALLOC(B2BbPtr, B2bNode, B2bNode); + TSTALLOC(B2DPdpPtr, B2dNodePrime, B2dNodePrime); + TSTALLOC(B2SPspPtr, B2sNodePrime, B2sNodePrime); + TSTALLOC(B2DdpPtr, B2dNode, B2dNodePrime); + TSTALLOC(B2GbPtr, B2gNode, B2bNode); + TSTALLOC(B2GdpPtr, B2gNode, B2dNodePrime); + TSTALLOC(B2GspPtr, B2gNode, B2sNodePrime); + TSTALLOC(B2SspPtr, B2sNode, B2sNodePrime); + TSTALLOC(B2BdpPtr, B2bNode, B2dNodePrime); + TSTALLOC(B2BspPtr, B2bNode, B2sNodePrime); + TSTALLOC(B2DPspPtr, B2dNodePrime, B2sNodePrime); + TSTALLOC(B2DPdPtr, B2dNodePrime, B2dNode); + TSTALLOC(B2BgPtr, B2bNode, B2gNode); + TSTALLOC(B2DPgPtr, B2dNodePrime, B2gNode); + TSTALLOC(B2SPgPtr, B2sNodePrime, B2gNode); + TSTALLOC(B2SPsPtr, B2sNodePrime, B2sNode); + TSTALLOC(B2DPbPtr, B2dNodePrime, B2bNode); + TSTALLOC(B2SPbPtr, B2sNodePrime, B2bNode); + TSTALLOC(B2SPdpPtr, B2sNodePrime, B2dNodePrime); } } diff --git a/src/spicelib/devices/bsim3/b3set.c b/src/spicelib/devices/bsim3/b3set.c index 7a59dc334..f85c73e04 100644 --- a/src/spicelib/devices/bsim3/b3set.c +++ b/src/spicelib/devices/bsim3/b3set.c @@ -1029,43 +1029,43 @@ BSIM3instance **InstArray; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(BSIM3DdPtr, BSIM3dNode, BSIM3dNode) - TSTALLOC(BSIM3GgPtr, BSIM3gNode, BSIM3gNode) - TSTALLOC(BSIM3SsPtr, BSIM3sNode, BSIM3sNode) - TSTALLOC(BSIM3BbPtr, BSIM3bNode, BSIM3bNode) - TSTALLOC(BSIM3DPdpPtr, BSIM3dNodePrime, BSIM3dNodePrime) - TSTALLOC(BSIM3SPspPtr, BSIM3sNodePrime, BSIM3sNodePrime) - TSTALLOC(BSIM3DdpPtr, BSIM3dNode, BSIM3dNodePrime) - TSTALLOC(BSIM3GbPtr, BSIM3gNode, BSIM3bNode) - TSTALLOC(BSIM3GdpPtr, BSIM3gNode, BSIM3dNodePrime) - TSTALLOC(BSIM3GspPtr, BSIM3gNode, BSIM3sNodePrime) - TSTALLOC(BSIM3SspPtr, BSIM3sNode, BSIM3sNodePrime) - TSTALLOC(BSIM3BdpPtr, BSIM3bNode, BSIM3dNodePrime) - TSTALLOC(BSIM3BspPtr, BSIM3bNode, BSIM3sNodePrime) - TSTALLOC(BSIM3DPspPtr, BSIM3dNodePrime, BSIM3sNodePrime) - TSTALLOC(BSIM3DPdPtr, BSIM3dNodePrime, BSIM3dNode) - TSTALLOC(BSIM3BgPtr, BSIM3bNode, BSIM3gNode) - TSTALLOC(BSIM3DPgPtr, BSIM3dNodePrime, BSIM3gNode) - TSTALLOC(BSIM3SPgPtr, BSIM3sNodePrime, BSIM3gNode) - TSTALLOC(BSIM3SPsPtr, BSIM3sNodePrime, BSIM3sNode) - TSTALLOC(BSIM3DPbPtr, BSIM3dNodePrime, BSIM3bNode) - TSTALLOC(BSIM3SPbPtr, BSIM3sNodePrime, BSIM3bNode) - TSTALLOC(BSIM3SPdpPtr, BSIM3sNodePrime, BSIM3dNodePrime) + TSTALLOC(BSIM3DdPtr, BSIM3dNode, BSIM3dNode); + TSTALLOC(BSIM3GgPtr, BSIM3gNode, BSIM3gNode); + TSTALLOC(BSIM3SsPtr, BSIM3sNode, BSIM3sNode); + TSTALLOC(BSIM3BbPtr, BSIM3bNode, BSIM3bNode); + TSTALLOC(BSIM3DPdpPtr, BSIM3dNodePrime, BSIM3dNodePrime); + TSTALLOC(BSIM3SPspPtr, BSIM3sNodePrime, BSIM3sNodePrime); + TSTALLOC(BSIM3DdpPtr, BSIM3dNode, BSIM3dNodePrime); + TSTALLOC(BSIM3GbPtr, BSIM3gNode, BSIM3bNode); + TSTALLOC(BSIM3GdpPtr, BSIM3gNode, BSIM3dNodePrime); + TSTALLOC(BSIM3GspPtr, BSIM3gNode, BSIM3sNodePrime); + TSTALLOC(BSIM3SspPtr, BSIM3sNode, BSIM3sNodePrime); + TSTALLOC(BSIM3BdpPtr, BSIM3bNode, BSIM3dNodePrime); + TSTALLOC(BSIM3BspPtr, BSIM3bNode, BSIM3sNodePrime); + TSTALLOC(BSIM3DPspPtr, BSIM3dNodePrime, BSIM3sNodePrime); + TSTALLOC(BSIM3DPdPtr, BSIM3dNodePrime, BSIM3dNode); + TSTALLOC(BSIM3BgPtr, BSIM3bNode, BSIM3gNode); + TSTALLOC(BSIM3DPgPtr, BSIM3dNodePrime, BSIM3gNode); + TSTALLOC(BSIM3SPgPtr, BSIM3sNodePrime, BSIM3gNode); + TSTALLOC(BSIM3SPsPtr, BSIM3sNodePrime, BSIM3sNode); + TSTALLOC(BSIM3DPbPtr, BSIM3dNodePrime, BSIM3bNode); + TSTALLOC(BSIM3SPbPtr, BSIM3sNodePrime, BSIM3bNode); + TSTALLOC(BSIM3SPdpPtr, BSIM3sNodePrime, BSIM3dNodePrime); - TSTALLOC(BSIM3QqPtr, BSIM3qNode, BSIM3qNode) + TSTALLOC(BSIM3QqPtr, BSIM3qNode, BSIM3qNode); - TSTALLOC(BSIM3QdpPtr, BSIM3qNode, BSIM3dNodePrime) - TSTALLOC(BSIM3QspPtr, BSIM3qNode, BSIM3sNodePrime) - TSTALLOC(BSIM3QgPtr, BSIM3qNode, BSIM3gNode) - TSTALLOC(BSIM3QbPtr, BSIM3qNode, BSIM3bNode) - TSTALLOC(BSIM3DPqPtr, BSIM3dNodePrime, BSIM3qNode) - TSTALLOC(BSIM3SPqPtr, BSIM3sNodePrime, BSIM3qNode) - TSTALLOC(BSIM3GqPtr, BSIM3gNode, BSIM3qNode) - TSTALLOC(BSIM3BqPtr, BSIM3bNode, BSIM3qNode) + TSTALLOC(BSIM3QdpPtr, BSIM3qNode, BSIM3dNodePrime); + TSTALLOC(BSIM3QspPtr, BSIM3qNode, BSIM3sNodePrime); + TSTALLOC(BSIM3QgPtr, BSIM3qNode, BSIM3gNode); + TSTALLOC(BSIM3QbPtr, BSIM3qNode, BSIM3bNode); + TSTALLOC(BSIM3DPqPtr, BSIM3dNodePrime, BSIM3qNode); + TSTALLOC(BSIM3SPqPtr, BSIM3sNodePrime, BSIM3qNode); + TSTALLOC(BSIM3GqPtr, BSIM3gNode, BSIM3qNode); + TSTALLOC(BSIM3BqPtr, BSIM3bNode, BSIM3qNode); } } diff --git a/src/spicelib/devices/bsim3soi_dd/b3soiddset.c b/src/spicelib/devices/bsim3soi_dd/b3soiddset.c index f103ddff1..3fed81aae 100644 --- a/src/spicelib/devices/bsim3soi_dd/b3soiddset.c +++ b/src/spicelib/devices/bsim3soi_dd/b3soiddset.c @@ -1215,129 +1215,129 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0!=0.0)) { - TSTALLOC(B3SOIDDTemptempPtr, B3SOIDDtempNode, B3SOIDDtempNode) - TSTALLOC(B3SOIDDTempdpPtr, B3SOIDDtempNode, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDTempspPtr, B3SOIDDtempNode, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDTempgPtr, B3SOIDDtempNode, B3SOIDDgNode) - TSTALLOC(B3SOIDDTempbPtr, B3SOIDDtempNode, B3SOIDDbNode) - TSTALLOC(B3SOIDDTempePtr, B3SOIDDtempNode, B3SOIDDeNode) + TSTALLOC(B3SOIDDTemptempPtr, B3SOIDDtempNode, B3SOIDDtempNode); + TSTALLOC(B3SOIDDTempdpPtr, B3SOIDDtempNode, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDTempspPtr, B3SOIDDtempNode, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDTempgPtr, B3SOIDDtempNode, B3SOIDDgNode); + TSTALLOC(B3SOIDDTempbPtr, B3SOIDDtempNode, B3SOIDDbNode); + TSTALLOC(B3SOIDDTempePtr, B3SOIDDtempNode, B3SOIDDeNode); - TSTALLOC(B3SOIDDGtempPtr, B3SOIDDgNode, B3SOIDDtempNode) - TSTALLOC(B3SOIDDDPtempPtr, B3SOIDDdNodePrime, B3SOIDDtempNode) - TSTALLOC(B3SOIDDSPtempPtr, B3SOIDDsNodePrime, B3SOIDDtempNode) - TSTALLOC(B3SOIDDEtempPtr, B3SOIDDeNode, B3SOIDDtempNode) - TSTALLOC(B3SOIDDBtempPtr, B3SOIDDbNode, B3SOIDDtempNode) + TSTALLOC(B3SOIDDGtempPtr, B3SOIDDgNode, B3SOIDDtempNode); + TSTALLOC(B3SOIDDDPtempPtr, B3SOIDDdNodePrime, B3SOIDDtempNode); + TSTALLOC(B3SOIDDSPtempPtr, B3SOIDDsNodePrime, B3SOIDDtempNode); + TSTALLOC(B3SOIDDEtempPtr, B3SOIDDeNode, B3SOIDDtempNode); + TSTALLOC(B3SOIDDBtempPtr, B3SOIDDbNode, B3SOIDDtempNode); if (here->B3SOIDDbodyMod == 1) { - TSTALLOC(B3SOIDDPtempPtr, B3SOIDDpNode, B3SOIDDtempNode) + TSTALLOC(B3SOIDDPtempPtr, B3SOIDDpNode, B3SOIDDtempNode); } } if (here->B3SOIDDbodyMod == 2) { /* Don't create any Jacobian entry for pNode */ } else if (here->B3SOIDDbodyMod == 1) { - TSTALLOC(B3SOIDDBpPtr, B3SOIDDbNode, B3SOIDDpNode) - TSTALLOC(B3SOIDDPbPtr, B3SOIDDpNode, B3SOIDDbNode) - TSTALLOC(B3SOIDDPpPtr, B3SOIDDpNode, B3SOIDDpNode) - TSTALLOC(B3SOIDDPgPtr, B3SOIDDpNode, B3SOIDDgNode) - TSTALLOC(B3SOIDDPdpPtr, B3SOIDDpNode, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDPspPtr, B3SOIDDpNode, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDPePtr, B3SOIDDpNode, B3SOIDDeNode) + TSTALLOC(B3SOIDDBpPtr, B3SOIDDbNode, B3SOIDDpNode); + TSTALLOC(B3SOIDDPbPtr, B3SOIDDpNode, B3SOIDDbNode); + TSTALLOC(B3SOIDDPpPtr, B3SOIDDpNode, B3SOIDDpNode); + TSTALLOC(B3SOIDDPgPtr, B3SOIDDpNode, B3SOIDDgNode); + TSTALLOC(B3SOIDDPdpPtr, B3SOIDDpNode, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDPspPtr, B3SOIDDpNode, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDPePtr, B3SOIDDpNode, B3SOIDDeNode); } - TSTALLOC(B3SOIDDEgPtr, B3SOIDDeNode, B3SOIDDgNode) - TSTALLOC(B3SOIDDEdpPtr, B3SOIDDeNode, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDEspPtr, B3SOIDDeNode, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDGePtr, B3SOIDDgNode, B3SOIDDeNode) - TSTALLOC(B3SOIDDDPePtr, B3SOIDDdNodePrime, B3SOIDDeNode) - TSTALLOC(B3SOIDDSPePtr, B3SOIDDsNodePrime, B3SOIDDeNode) + TSTALLOC(B3SOIDDEgPtr, B3SOIDDeNode, B3SOIDDgNode); + TSTALLOC(B3SOIDDEdpPtr, B3SOIDDeNode, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDEspPtr, B3SOIDDeNode, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDGePtr, B3SOIDDgNode, B3SOIDDeNode); + TSTALLOC(B3SOIDDDPePtr, B3SOIDDdNodePrime, B3SOIDDeNode); + TSTALLOC(B3SOIDDSPePtr, B3SOIDDsNodePrime, B3SOIDDeNode); - TSTALLOC(B3SOIDDEbPtr, B3SOIDDeNode, B3SOIDDbNode) - TSTALLOC(B3SOIDDGbPtr, B3SOIDDgNode, B3SOIDDbNode) - TSTALLOC(B3SOIDDDPbPtr, B3SOIDDdNodePrime, B3SOIDDbNode) - TSTALLOC(B3SOIDDSPbPtr, B3SOIDDsNodePrime, B3SOIDDbNode) - TSTALLOC(B3SOIDDBePtr, B3SOIDDbNode, B3SOIDDeNode) - TSTALLOC(B3SOIDDBgPtr, B3SOIDDbNode, B3SOIDDgNode) - TSTALLOC(B3SOIDDBdpPtr, B3SOIDDbNode, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDBspPtr, B3SOIDDbNode, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDBbPtr, B3SOIDDbNode, B3SOIDDbNode) + TSTALLOC(B3SOIDDEbPtr, B3SOIDDeNode, B3SOIDDbNode); + TSTALLOC(B3SOIDDGbPtr, B3SOIDDgNode, B3SOIDDbNode); + TSTALLOC(B3SOIDDDPbPtr, B3SOIDDdNodePrime, B3SOIDDbNode); + TSTALLOC(B3SOIDDSPbPtr, B3SOIDDsNodePrime, B3SOIDDbNode); + TSTALLOC(B3SOIDDBePtr, B3SOIDDbNode, B3SOIDDeNode); + TSTALLOC(B3SOIDDBgPtr, B3SOIDDbNode, B3SOIDDgNode); + TSTALLOC(B3SOIDDBdpPtr, B3SOIDDbNode, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDBspPtr, B3SOIDDbNode, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDBbPtr, B3SOIDDbNode, B3SOIDDbNode); - TSTALLOC(B3SOIDDEePtr, B3SOIDDeNode, B3SOIDDeNode) + TSTALLOC(B3SOIDDEePtr, B3SOIDDeNode, B3SOIDDeNode); - TSTALLOC(B3SOIDDGgPtr, B3SOIDDgNode, B3SOIDDgNode) - TSTALLOC(B3SOIDDGdpPtr, B3SOIDDgNode, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDGspPtr, B3SOIDDgNode, B3SOIDDsNodePrime) + TSTALLOC(B3SOIDDGgPtr, B3SOIDDgNode, B3SOIDDgNode); + TSTALLOC(B3SOIDDGdpPtr, B3SOIDDgNode, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDGspPtr, B3SOIDDgNode, B3SOIDDsNodePrime); - TSTALLOC(B3SOIDDDPgPtr, B3SOIDDdNodePrime, B3SOIDDgNode) - TSTALLOC(B3SOIDDDPdpPtr, B3SOIDDdNodePrime, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDDPspPtr, B3SOIDDdNodePrime, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDDPdPtr, B3SOIDDdNodePrime, B3SOIDDdNode) + TSTALLOC(B3SOIDDDPgPtr, B3SOIDDdNodePrime, B3SOIDDgNode); + TSTALLOC(B3SOIDDDPdpPtr, B3SOIDDdNodePrime, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDDPspPtr, B3SOIDDdNodePrime, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDDPdPtr, B3SOIDDdNodePrime, B3SOIDDdNode); - TSTALLOC(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode) - TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime) - TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime) - TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode) + TSTALLOC(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode); + TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime); + TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime); + TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode); - TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode) - TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime) + TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode); + TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime); - TSTALLOC(B3SOIDDSsPtr, B3SOIDDsNode, B3SOIDDsNode) - TSTALLOC(B3SOIDDSspPtr, B3SOIDDsNode, B3SOIDDsNodePrime) + TSTALLOC(B3SOIDDSsPtr, B3SOIDDsNode, B3SOIDDsNode); + TSTALLOC(B3SOIDDSspPtr, B3SOIDDsNode, B3SOIDDsNodePrime); /* here for debugging purpose only */ if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1)) { - TSTALLOC(B3SOIDDVbsPtr, B3SOIDDvbsNode, B3SOIDDvbsNode) - TSTALLOC(B3SOIDDIdsPtr, B3SOIDDidsNode, B3SOIDDidsNode) - TSTALLOC(B3SOIDDIcPtr, B3SOIDDicNode, B3SOIDDicNode) - TSTALLOC(B3SOIDDIbsPtr, B3SOIDDibsNode, B3SOIDDibsNode) - TSTALLOC(B3SOIDDIbdPtr, B3SOIDDibdNode, B3SOIDDibdNode) - TSTALLOC(B3SOIDDIiiPtr, B3SOIDDiiiNode, B3SOIDDiiiNode) - TSTALLOC(B3SOIDDIgidlPtr, B3SOIDDigidlNode, B3SOIDDigidlNode) - TSTALLOC(B3SOIDDItunPtr, B3SOIDDitunNode, B3SOIDDitunNode) - TSTALLOC(B3SOIDDIbpPtr, B3SOIDDibpNode, B3SOIDDibpNode) - TSTALLOC(B3SOIDDAbeffPtr, B3SOIDDabeffNode, B3SOIDDabeffNode) - TSTALLOC(B3SOIDDVbs0effPtr, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode) - TSTALLOC(B3SOIDDVbseffPtr, B3SOIDDvbseffNode, B3SOIDDvbseffNode) - TSTALLOC(B3SOIDDXcPtr, B3SOIDDxcNode, B3SOIDDxcNode) - TSTALLOC(B3SOIDDCbbPtr, B3SOIDDcbbNode, B3SOIDDcbbNode) - TSTALLOC(B3SOIDDCbdPtr, B3SOIDDcbdNode, B3SOIDDcbdNode) - TSTALLOC(B3SOIDDCbgPtr, B3SOIDDcbgNode, B3SOIDDcbgNode) - TSTALLOC(B3SOIDDqbPtr, B3SOIDDqbNode, B3SOIDDqbNode) - TSTALLOC(B3SOIDDQbfPtr, B3SOIDDqbfNode, B3SOIDDqbfNode) - TSTALLOC(B3SOIDDQjsPtr, B3SOIDDqjsNode, B3SOIDDqjsNode) - TSTALLOC(B3SOIDDQjdPtr, B3SOIDDqjdNode, B3SOIDDqjdNode) + TSTALLOC(B3SOIDDVbsPtr, B3SOIDDvbsNode, B3SOIDDvbsNode) ; + TSTALLOC(B3SOIDDIdsPtr, B3SOIDDidsNode, B3SOIDDidsNode); + TSTALLOC(B3SOIDDIcPtr, B3SOIDDicNode, B3SOIDDicNode); + TSTALLOC(B3SOIDDIbsPtr, B3SOIDDibsNode, B3SOIDDibsNode); + TSTALLOC(B3SOIDDIbdPtr, B3SOIDDibdNode, B3SOIDDibdNode); + TSTALLOC(B3SOIDDIiiPtr, B3SOIDDiiiNode, B3SOIDDiiiNode); + TSTALLOC(B3SOIDDIgidlPtr, B3SOIDDigidlNode, B3SOIDDigidlNode); + TSTALLOC(B3SOIDDItunPtr, B3SOIDDitunNode, B3SOIDDitunNode); + TSTALLOC(B3SOIDDIbpPtr, B3SOIDDibpNode, B3SOIDDibpNode); + TSTALLOC(B3SOIDDAbeffPtr, B3SOIDDabeffNode, B3SOIDDabeffNode); + TSTALLOC(B3SOIDDVbs0effPtr, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode); + TSTALLOC(B3SOIDDVbseffPtr, B3SOIDDvbseffNode, B3SOIDDvbseffNode); + TSTALLOC(B3SOIDDXcPtr, B3SOIDDxcNode, B3SOIDDxcNode); + TSTALLOC(B3SOIDDCbbPtr, B3SOIDDcbbNode, B3SOIDDcbbNode); + TSTALLOC(B3SOIDDCbdPtr, B3SOIDDcbdNode, B3SOIDDcbdNode); + TSTALLOC(B3SOIDDCbgPtr, B3SOIDDcbgNode, B3SOIDDcbgNode); + TSTALLOC(B3SOIDDqbPtr, B3SOIDDqbNode, B3SOIDDqbNode); + TSTALLOC(B3SOIDDQbfPtr, B3SOIDDqbfNode, B3SOIDDqbfNode); + TSTALLOC(B3SOIDDQjsPtr, B3SOIDDqjsNode, B3SOIDDqjsNode); + TSTALLOC(B3SOIDDQjdPtr, B3SOIDDqjdNode, B3SOIDDqjdNode); /* clean up last */ - TSTALLOC(B3SOIDDGmPtr, B3SOIDDgmNode, B3SOIDDgmNode) - TSTALLOC(B3SOIDDGmbsPtr, B3SOIDDgmbsNode, B3SOIDDgmbsNode) - TSTALLOC(B3SOIDDGdsPtr, B3SOIDDgdsNode, B3SOIDDgdsNode) - TSTALLOC(B3SOIDDGmePtr, B3SOIDDgmeNode, B3SOIDDgmeNode) - TSTALLOC(B3SOIDDVbs0teffPtr, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode) - TSTALLOC(B3SOIDDVthPtr, B3SOIDDvthNode, B3SOIDDvthNode) - TSTALLOC(B3SOIDDVgsteffPtr, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode) - TSTALLOC(B3SOIDDXcsatPtr, B3SOIDDxcsatNode, B3SOIDDxcsatNode) - TSTALLOC(B3SOIDDVcscvPtr, B3SOIDDvcscvNode, B3SOIDDvcscvNode) - TSTALLOC(B3SOIDDVdscvPtr, B3SOIDDvdscvNode, B3SOIDDvdscvNode) - TSTALLOC(B3SOIDDCbePtr, B3SOIDDcbeNode, B3SOIDDcbeNode) - TSTALLOC(B3SOIDDDum1Ptr, B3SOIDDdum1Node, B3SOIDDdum1Node) - TSTALLOC(B3SOIDDDum2Ptr, B3SOIDDdum2Node, B3SOIDDdum2Node) - TSTALLOC(B3SOIDDDum3Ptr, B3SOIDDdum3Node, B3SOIDDdum3Node) - TSTALLOC(B3SOIDDDum4Ptr, B3SOIDDdum4Node, B3SOIDDdum4Node) - TSTALLOC(B3SOIDDDum5Ptr, B3SOIDDdum5Node, B3SOIDDdum5Node) - TSTALLOC(B3SOIDDQaccPtr, B3SOIDDqaccNode, B3SOIDDqaccNode) - TSTALLOC(B3SOIDDQsub0Ptr, B3SOIDDqsub0Node, B3SOIDDqsub0Node) - TSTALLOC(B3SOIDDQsubs1Ptr, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node) - TSTALLOC(B3SOIDDQsubs2Ptr, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node) - TSTALLOC(B3SOIDDqePtr, B3SOIDDqeNode, B3SOIDDqeNode) - TSTALLOC(B3SOIDDqdPtr, B3SOIDDqdNode, B3SOIDDqdNode) - TSTALLOC(B3SOIDDqgPtr, B3SOIDDqgNode, B3SOIDDqgNode) + TSTALLOC(B3SOIDDGmPtr, B3SOIDDgmNode, B3SOIDDgmNode); + TSTALLOC(B3SOIDDGmbsPtr, B3SOIDDgmbsNode, B3SOIDDgmbsNode); + TSTALLOC(B3SOIDDGdsPtr, B3SOIDDgdsNode, B3SOIDDgdsNode); + TSTALLOC(B3SOIDDGmePtr, B3SOIDDgmeNode, B3SOIDDgmeNode); + TSTALLOC(B3SOIDDVbs0teffPtr, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode); + TSTALLOC(B3SOIDDVthPtr, B3SOIDDvthNode, B3SOIDDvthNode); + TSTALLOC(B3SOIDDVgsteffPtr, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode); + TSTALLOC(B3SOIDDXcsatPtr, B3SOIDDxcsatNode, B3SOIDDxcsatNode); + TSTALLOC(B3SOIDDVcscvPtr, B3SOIDDvcscvNode, B3SOIDDvcscvNode); + TSTALLOC(B3SOIDDVdscvPtr, B3SOIDDvdscvNode, B3SOIDDvdscvNode); + TSTALLOC(B3SOIDDCbePtr, B3SOIDDcbeNode, B3SOIDDcbeNode); + TSTALLOC(B3SOIDDDum1Ptr, B3SOIDDdum1Node, B3SOIDDdum1Node); + TSTALLOC(B3SOIDDDum2Ptr, B3SOIDDdum2Node, B3SOIDDdum2Node); + TSTALLOC(B3SOIDDDum3Ptr, B3SOIDDdum3Node, B3SOIDDdum3Node); + TSTALLOC(B3SOIDDDum4Ptr, B3SOIDDdum4Node, B3SOIDDdum4Node); + TSTALLOC(B3SOIDDDum5Ptr, B3SOIDDdum5Node, B3SOIDDdum5Node); + TSTALLOC(B3SOIDDQaccPtr, B3SOIDDqaccNode, B3SOIDDqaccNode); + TSTALLOC(B3SOIDDQsub0Ptr, B3SOIDDqsub0Node, B3SOIDDqsub0Node); + TSTALLOC(B3SOIDDQsubs1Ptr, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node); + TSTALLOC(B3SOIDDQsubs2Ptr, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node); + TSTALLOC(B3SOIDDqePtr, B3SOIDDqeNode, B3SOIDDqeNode); + TSTALLOC(B3SOIDDqdPtr, B3SOIDDqdNode, B3SOIDDqdNode); + TSTALLOC(B3SOIDDqgPtr, B3SOIDDqgNode, B3SOIDDqgNode); } } diff --git a/src/spicelib/devices/bsim3soi_fd/b3soifdset.c b/src/spicelib/devices/bsim3soi_fd/b3soifdset.c index 6e6c8ebdb..242aa1517 100644 --- a/src/spicelib/devices/bsim3soi_fd/b3soifdset.c +++ b/src/spicelib/devices/bsim3soi_fd/b3soifdset.c @@ -1213,120 +1213,120 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0!=0.0)) { - TSTALLOC(B3SOIFDTemptempPtr, B3SOIFDtempNode, B3SOIFDtempNode) - TSTALLOC(B3SOIFDTempdpPtr, B3SOIFDtempNode, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDTempspPtr, B3SOIFDtempNode, B3SOIFDsNodePrime) - TSTALLOC(B3SOIFDTempgPtr, B3SOIFDtempNode, B3SOIFDgNode) - TSTALLOC(B3SOIFDTempbPtr, B3SOIFDtempNode, B3SOIFDbNode) - TSTALLOC(B3SOIFDTempePtr, B3SOIFDtempNode, B3SOIFDeNode) + TSTALLOC(B3SOIFDTemptempPtr, B3SOIFDtempNode, B3SOIFDtempNode); + TSTALLOC(B3SOIFDTempdpPtr, B3SOIFDtempNode, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDTempspPtr, B3SOIFDtempNode, B3SOIFDsNodePrime); + TSTALLOC(B3SOIFDTempgPtr, B3SOIFDtempNode, B3SOIFDgNode); + TSTALLOC(B3SOIFDTempbPtr, B3SOIFDtempNode, B3SOIFDbNode); + TSTALLOC(B3SOIFDTempePtr, B3SOIFDtempNode, B3SOIFDeNode); - TSTALLOC(B3SOIFDGtempPtr, B3SOIFDgNode, B3SOIFDtempNode) - TSTALLOC(B3SOIFDDPtempPtr, B3SOIFDdNodePrime, B3SOIFDtempNode) - TSTALLOC(B3SOIFDSPtempPtr, B3SOIFDsNodePrime, B3SOIFDtempNode) - TSTALLOC(B3SOIFDEtempPtr, B3SOIFDeNode, B3SOIFDtempNode) - TSTALLOC(B3SOIFDBtempPtr, B3SOIFDbNode, B3SOIFDtempNode) + TSTALLOC(B3SOIFDGtempPtr, B3SOIFDgNode, B3SOIFDtempNode); + TSTALLOC(B3SOIFDDPtempPtr, B3SOIFDdNodePrime, B3SOIFDtempNode); + TSTALLOC(B3SOIFDSPtempPtr, B3SOIFDsNodePrime, B3SOIFDtempNode); + TSTALLOC(B3SOIFDEtempPtr, B3SOIFDeNode, B3SOIFDtempNode); + TSTALLOC(B3SOIFDBtempPtr, B3SOIFDbNode, B3SOIFDtempNode); if (here->B3SOIFDbodyMod == 1) { - TSTALLOC(B3SOIFDPtempPtr, B3SOIFDpNode, B3SOIFDtempNode) + TSTALLOC(B3SOIFDPtempPtr, B3SOIFDpNode, B3SOIFDtempNode); } } if (here->B3SOIFDbodyMod == 2) { /* Don't create any Jacobian entry for pNode */ } else if (here->B3SOIFDbodyMod == 1) { - TSTALLOC(B3SOIFDBpPtr, B3SOIFDbNode, B3SOIFDpNode) - TSTALLOC(B3SOIFDPbPtr, B3SOIFDpNode, B3SOIFDbNode) - TSTALLOC(B3SOIFDPpPtr, B3SOIFDpNode, B3SOIFDpNode) - TSTALLOC(B3SOIFDPgPtr, B3SOIFDpNode, B3SOIFDgNode) - TSTALLOC(B3SOIFDPdpPtr, B3SOIFDpNode, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDPspPtr, B3SOIFDpNode, B3SOIFDsNodePrime) - TSTALLOC(B3SOIFDPePtr, B3SOIFDpNode, B3SOIFDeNode) + TSTALLOC(B3SOIFDBpPtr, B3SOIFDbNode, B3SOIFDpNode); + TSTALLOC(B3SOIFDPbPtr, B3SOIFDpNode, B3SOIFDbNode); + TSTALLOC(B3SOIFDPpPtr, B3SOIFDpNode, B3SOIFDpNode); + TSTALLOC(B3SOIFDPgPtr, B3SOIFDpNode, B3SOIFDgNode); + TSTALLOC(B3SOIFDPdpPtr, B3SOIFDpNode, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDPspPtr, B3SOIFDpNode, B3SOIFDsNodePrime); + TSTALLOC(B3SOIFDPePtr, B3SOIFDpNode, B3SOIFDeNode); } - TSTALLOC(B3SOIFDEgPtr, B3SOIFDeNode, B3SOIFDgNode) - TSTALLOC(B3SOIFDEdpPtr, B3SOIFDeNode, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDEspPtr, B3SOIFDeNode, B3SOIFDsNodePrime) - TSTALLOC(B3SOIFDGePtr, B3SOIFDgNode, B3SOIFDeNode) - TSTALLOC(B3SOIFDDPePtr, B3SOIFDdNodePrime, B3SOIFDeNode) - TSTALLOC(B3SOIFDSPePtr, B3SOIFDsNodePrime, B3SOIFDeNode) + TSTALLOC(B3SOIFDEgPtr, B3SOIFDeNode, B3SOIFDgNode); + TSTALLOC(B3SOIFDEdpPtr, B3SOIFDeNode, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDEspPtr, B3SOIFDeNode, B3SOIFDsNodePrime); + TSTALLOC(B3SOIFDGePtr, B3SOIFDgNode, B3SOIFDeNode); + TSTALLOC(B3SOIFDDPePtr, B3SOIFDdNodePrime, B3SOIFDeNode); + TSTALLOC(B3SOIFDSPePtr, B3SOIFDsNodePrime, B3SOIFDeNode); - TSTALLOC(B3SOIFDEbPtr, B3SOIFDeNode, B3SOIFDbNode) - TSTALLOC(B3SOIFDEePtr, B3SOIFDeNode, B3SOIFDeNode) + TSTALLOC(B3SOIFDEbPtr, B3SOIFDeNode, B3SOIFDbNode); + TSTALLOC(B3SOIFDEePtr, B3SOIFDeNode, B3SOIFDeNode); - TSTALLOC(B3SOIFDGgPtr, B3SOIFDgNode, B3SOIFDgNode) - TSTALLOC(B3SOIFDGdpPtr, B3SOIFDgNode, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDGspPtr, B3SOIFDgNode, B3SOIFDsNodePrime) + TSTALLOC(B3SOIFDGgPtr, B3SOIFDgNode, B3SOIFDgNode); + TSTALLOC(B3SOIFDGdpPtr, B3SOIFDgNode, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDGspPtr, B3SOIFDgNode, B3SOIFDsNodePrime); - TSTALLOC(B3SOIFDDPgPtr, B3SOIFDdNodePrime, B3SOIFDgNode) - TSTALLOC(B3SOIFDDPdpPtr, B3SOIFDdNodePrime, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDDPspPtr, B3SOIFDdNodePrime, B3SOIFDsNodePrime) - TSTALLOC(B3SOIFDDPdPtr, B3SOIFDdNodePrime, B3SOIFDdNode) + TSTALLOC(B3SOIFDDPgPtr, B3SOIFDdNodePrime, B3SOIFDgNode); + TSTALLOC(B3SOIFDDPdpPtr, B3SOIFDdNodePrime, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDDPspPtr, B3SOIFDdNodePrime, B3SOIFDsNodePrime); + TSTALLOC(B3SOIFDDPdPtr, B3SOIFDdNodePrime, B3SOIFDdNode); - TSTALLOC(B3SOIFDSPgPtr, B3SOIFDsNodePrime, B3SOIFDgNode) - TSTALLOC(B3SOIFDSPdpPtr, B3SOIFDsNodePrime, B3SOIFDdNodePrime) - TSTALLOC(B3SOIFDSPspPtr, B3SOIFDsNodePrime, B3SOIFDsNodePrime) - TSTALLOC(B3SOIFDSPsPtr, B3SOIFDsNodePrime, B3SOIFDsNode) + TSTALLOC(B3SOIFDSPgPtr, B3SOIFDsNodePrime, B3SOIFDgNode); + TSTALLOC(B3SOIFDSPdpPtr, B3SOIFDsNodePrime, B3SOIFDdNodePrime); + TSTALLOC(B3SOIFDSPspPtr, B3SOIFDsNodePrime, B3SOIFDsNodePrime); + TSTALLOC(B3SOIFDSPsPtr, B3SOIFDsNodePrime, B3SOIFDsNode); - TSTALLOC(B3SOIFDDdPtr, B3SOIFDdNode, B3SOIFDdNode) - TSTALLOC(B3SOIFDDdpPtr, B3SOIFDdNode, B3SOIFDdNodePrime) + TSTALLOC(B3SOIFDDdPtr, B3SOIFDdNode, B3SOIFDdNode); + TSTALLOC(B3SOIFDDdpPtr, B3SOIFDdNode, B3SOIFDdNodePrime); - TSTALLOC(B3SOIFDSsPtr, B3SOIFDsNode, B3SOIFDsNode) - TSTALLOC(B3SOIFDSspPtr, B3SOIFDsNode, B3SOIFDsNodePrime) + TSTALLOC(B3SOIFDSsPtr, B3SOIFDsNode, B3SOIFDsNode); + TSTALLOC(B3SOIFDSspPtr, B3SOIFDsNode, B3SOIFDsNodePrime); /* here for debugging purpose only */ if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1)) { - TSTALLOC(B3SOIFDVbsPtr, B3SOIFDvbsNode, B3SOIFDvbsNode) - TSTALLOC(B3SOIFDIdsPtr, B3SOIFDidsNode, B3SOIFDidsNode) - TSTALLOC(B3SOIFDIcPtr, B3SOIFDicNode, B3SOIFDicNode) - TSTALLOC(B3SOIFDIbsPtr, B3SOIFDibsNode, B3SOIFDibsNode) - TSTALLOC(B3SOIFDIbdPtr, B3SOIFDibdNode, B3SOIFDibdNode) - TSTALLOC(B3SOIFDIiiPtr, B3SOIFDiiiNode, B3SOIFDiiiNode) - TSTALLOC(B3SOIFDIgidlPtr, B3SOIFDigidlNode, B3SOIFDigidlNode) - TSTALLOC(B3SOIFDItunPtr, B3SOIFDitunNode, B3SOIFDitunNode) - TSTALLOC(B3SOIFDIbpPtr, B3SOIFDibpNode, B3SOIFDibpNode) - TSTALLOC(B3SOIFDAbeffPtr, B3SOIFDabeffNode, B3SOIFDabeffNode) - TSTALLOC(B3SOIFDVbs0effPtr, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode) - TSTALLOC(B3SOIFDVbseffPtr, B3SOIFDvbseffNode, B3SOIFDvbseffNode) - TSTALLOC(B3SOIFDXcPtr, B3SOIFDxcNode, B3SOIFDxcNode) - TSTALLOC(B3SOIFDCbbPtr, B3SOIFDcbbNode, B3SOIFDcbbNode) - TSTALLOC(B3SOIFDCbdPtr, B3SOIFDcbdNode, B3SOIFDcbdNode) - TSTALLOC(B3SOIFDCbgPtr, B3SOIFDcbgNode, B3SOIFDcbgNode) - TSTALLOC(B3SOIFDqbPtr, B3SOIFDqbNode, B3SOIFDqbNode) - TSTALLOC(B3SOIFDQbfPtr, B3SOIFDqbfNode, B3SOIFDqbfNode) - TSTALLOC(B3SOIFDQjsPtr, B3SOIFDqjsNode, B3SOIFDqjsNode) - TSTALLOC(B3SOIFDQjdPtr, B3SOIFDqjdNode, B3SOIFDqjdNode) + TSTALLOC(B3SOIFDVbsPtr, B3SOIFDvbsNode, B3SOIFDvbsNode) ; + TSTALLOC(B3SOIFDIdsPtr, B3SOIFDidsNode, B3SOIFDidsNode); + TSTALLOC(B3SOIFDIcPtr, B3SOIFDicNode, B3SOIFDicNode); + TSTALLOC(B3SOIFDIbsPtr, B3SOIFDibsNode, B3SOIFDibsNode); + TSTALLOC(B3SOIFDIbdPtr, B3SOIFDibdNode, B3SOIFDibdNode); + TSTALLOC(B3SOIFDIiiPtr, B3SOIFDiiiNode, B3SOIFDiiiNode); + TSTALLOC(B3SOIFDIgidlPtr, B3SOIFDigidlNode, B3SOIFDigidlNode); + TSTALLOC(B3SOIFDItunPtr, B3SOIFDitunNode, B3SOIFDitunNode); + TSTALLOC(B3SOIFDIbpPtr, B3SOIFDibpNode, B3SOIFDibpNode); + TSTALLOC(B3SOIFDAbeffPtr, B3SOIFDabeffNode, B3SOIFDabeffNode); + TSTALLOC(B3SOIFDVbs0effPtr, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode); + TSTALLOC(B3SOIFDVbseffPtr, B3SOIFDvbseffNode, B3SOIFDvbseffNode); + TSTALLOC(B3SOIFDXcPtr, B3SOIFDxcNode, B3SOIFDxcNode); + TSTALLOC(B3SOIFDCbbPtr, B3SOIFDcbbNode, B3SOIFDcbbNode); + TSTALLOC(B3SOIFDCbdPtr, B3SOIFDcbdNode, B3SOIFDcbdNode); + TSTALLOC(B3SOIFDCbgPtr, B3SOIFDcbgNode, B3SOIFDcbgNode); + TSTALLOC(B3SOIFDqbPtr, B3SOIFDqbNode, B3SOIFDqbNode); + TSTALLOC(B3SOIFDQbfPtr, B3SOIFDqbfNode, B3SOIFDqbfNode); + TSTALLOC(B3SOIFDQjsPtr, B3SOIFDqjsNode, B3SOIFDqjsNode); + TSTALLOC(B3SOIFDQjdPtr, B3SOIFDqjdNode, B3SOIFDqjdNode); /* clean up last */ - TSTALLOC(B3SOIFDGmPtr, B3SOIFDgmNode, B3SOIFDgmNode) - TSTALLOC(B3SOIFDGmbsPtr, B3SOIFDgmbsNode, B3SOIFDgmbsNode) - TSTALLOC(B3SOIFDGdsPtr, B3SOIFDgdsNode, B3SOIFDgdsNode) - TSTALLOC(B3SOIFDGmePtr, B3SOIFDgmeNode, B3SOIFDgmeNode) - TSTALLOC(B3SOIFDVbs0teffPtr, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode) - TSTALLOC(B3SOIFDVthPtr, B3SOIFDvthNode, B3SOIFDvthNode) - TSTALLOC(B3SOIFDVgsteffPtr, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode) - TSTALLOC(B3SOIFDXcsatPtr, B3SOIFDxcsatNode, B3SOIFDxcsatNode) - TSTALLOC(B3SOIFDVcscvPtr, B3SOIFDvcscvNode, B3SOIFDvcscvNode) - TSTALLOC(B3SOIFDVdscvPtr, B3SOIFDvdscvNode, B3SOIFDvdscvNode) - TSTALLOC(B3SOIFDCbePtr, B3SOIFDcbeNode, B3SOIFDcbeNode) - TSTALLOC(B3SOIFDDum1Ptr, B3SOIFDdum1Node, B3SOIFDdum1Node) - TSTALLOC(B3SOIFDDum2Ptr, B3SOIFDdum2Node, B3SOIFDdum2Node) - TSTALLOC(B3SOIFDDum3Ptr, B3SOIFDdum3Node, B3SOIFDdum3Node) - TSTALLOC(B3SOIFDDum4Ptr, B3SOIFDdum4Node, B3SOIFDdum4Node) - TSTALLOC(B3SOIFDDum5Ptr, B3SOIFDdum5Node, B3SOIFDdum5Node) - TSTALLOC(B3SOIFDQaccPtr, B3SOIFDqaccNode, B3SOIFDqaccNode) - TSTALLOC(B3SOIFDQsub0Ptr, B3SOIFDqsub0Node, B3SOIFDqsub0Node) - TSTALLOC(B3SOIFDQsubs1Ptr, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node) - TSTALLOC(B3SOIFDQsubs2Ptr, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node) - TSTALLOC(B3SOIFDqePtr, B3SOIFDqeNode, B3SOIFDqeNode) - TSTALLOC(B3SOIFDqdPtr, B3SOIFDqdNode, B3SOIFDqdNode) - TSTALLOC(B3SOIFDqgPtr, B3SOIFDqgNode, B3SOIFDqgNode) + TSTALLOC(B3SOIFDGmPtr, B3SOIFDgmNode, B3SOIFDgmNode); + TSTALLOC(B3SOIFDGmbsPtr, B3SOIFDgmbsNode, B3SOIFDgmbsNode); + TSTALLOC(B3SOIFDGdsPtr, B3SOIFDgdsNode, B3SOIFDgdsNode); + TSTALLOC(B3SOIFDGmePtr, B3SOIFDgmeNode, B3SOIFDgmeNode); + TSTALLOC(B3SOIFDVbs0teffPtr, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode); + TSTALLOC(B3SOIFDVthPtr, B3SOIFDvthNode, B3SOIFDvthNode); + TSTALLOC(B3SOIFDVgsteffPtr, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode); + TSTALLOC(B3SOIFDXcsatPtr, B3SOIFDxcsatNode, B3SOIFDxcsatNode); + TSTALLOC(B3SOIFDVcscvPtr, B3SOIFDvcscvNode, B3SOIFDvcscvNode); + TSTALLOC(B3SOIFDVdscvPtr, B3SOIFDvdscvNode, B3SOIFDvdscvNode); + TSTALLOC(B3SOIFDCbePtr, B3SOIFDcbeNode, B3SOIFDcbeNode); + TSTALLOC(B3SOIFDDum1Ptr, B3SOIFDdum1Node, B3SOIFDdum1Node); + TSTALLOC(B3SOIFDDum2Ptr, B3SOIFDdum2Node, B3SOIFDdum2Node); + TSTALLOC(B3SOIFDDum3Ptr, B3SOIFDdum3Node, B3SOIFDdum3Node); + TSTALLOC(B3SOIFDDum4Ptr, B3SOIFDdum4Node, B3SOIFDdum4Node); + TSTALLOC(B3SOIFDDum5Ptr, B3SOIFDdum5Node, B3SOIFDdum5Node); + TSTALLOC(B3SOIFDQaccPtr, B3SOIFDqaccNode, B3SOIFDqaccNode); + TSTALLOC(B3SOIFDQsub0Ptr, B3SOIFDqsub0Node, B3SOIFDqsub0Node); + TSTALLOC(B3SOIFDQsubs1Ptr, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node); + TSTALLOC(B3SOIFDQsubs2Ptr, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node); + TSTALLOC(B3SOIFDqePtr, B3SOIFDqeNode, B3SOIFDqeNode); + TSTALLOC(B3SOIFDqdPtr, B3SOIFDqdNode, B3SOIFDqdNode); + TSTALLOC(B3SOIFDqgPtr, B3SOIFDqgNode, B3SOIFDqgNode); } } diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdset.c b/src/spicelib/devices/bsim3soi_pd/b3soipdset.c index eeb731037..8a4e3b047 100644 --- a/src/spicelib/devices/bsim3soi_pd/b3soipdset.c +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdset.c @@ -1347,98 +1347,98 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0!=0.0)) { - TSTALLOC(B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode) - TSTALLOC(B3SOIPDTempdpPtr, B3SOIPDtempNode, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDTempspPtr, B3SOIPDtempNode, B3SOIPDsNodePrime) - TSTALLOC(B3SOIPDTempgPtr, B3SOIPDtempNode, B3SOIPDgNode) - TSTALLOC(B3SOIPDTempbPtr, B3SOIPDtempNode, B3SOIPDbNode) + TSTALLOC(B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode); + TSTALLOC(B3SOIPDTempdpPtr, B3SOIPDtempNode, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDTempspPtr, B3SOIPDtempNode, B3SOIPDsNodePrime); + TSTALLOC(B3SOIPDTempgPtr, B3SOIPDtempNode, B3SOIPDgNode); + TSTALLOC(B3SOIPDTempbPtr, B3SOIPDtempNode, B3SOIPDbNode); - TSTALLOC(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode) - TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode) - TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode) - TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode) - TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode) + TSTALLOC(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode); + TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode); + TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode); + TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode); + TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode); if (here->B3SOIPDbodyMod == 1) { - TSTALLOC(B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode) + TSTALLOC(B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode); } } if (here->B3SOIPDbodyMod == 2) { /* Don't create any Jacobian entry for pNode */ } else if (here->B3SOIPDbodyMod == 1) { - TSTALLOC(B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode) - TSTALLOC(B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode) - TSTALLOC(B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode) + TSTALLOC(B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode); + TSTALLOC(B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode); + TSTALLOC(B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode); } - TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode) - TSTALLOC(B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode) - TSTALLOC(B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode) - TSTALLOC(B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode) - TSTALLOC(B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode) - TSTALLOC(B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode) - TSTALLOC(B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime) - TSTALLOC(B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode) + TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode); + TSTALLOC(B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode); + TSTALLOC(B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode); + TSTALLOC(B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode); + TSTALLOC(B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode); + TSTALLOC(B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode); + TSTALLOC(B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime); + TSTALLOC(B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode); - TSTALLOC(B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode) - TSTALLOC(B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime) - TSTALLOC(B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode) - TSTALLOC(B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode) - TSTALLOC(B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode) + TSTALLOC(B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode); + TSTALLOC(B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime); + TSTALLOC(B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode); + TSTALLOC(B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode); + TSTALLOC(B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode); - TSTALLOC(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode) + TSTALLOC(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode); - TSTALLOC(B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode) - TSTALLOC(B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime) + TSTALLOC(B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode); + TSTALLOC(B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime); - TSTALLOC(B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode) - TSTALLOC(B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime) - TSTALLOC(B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode) + TSTALLOC(B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode); + TSTALLOC(B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime); + TSTALLOC(B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode); - TSTALLOC(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode) - TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime) - TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime) - TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode) + TSTALLOC(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode); + TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime); + TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime); + TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode); - TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode) - TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime) + TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode); + TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime); - TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode) - TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime) + TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode); + TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime); /* here for debugging purpose only */ if (here->B3SOIPDdebugMod != 0) { - TSTALLOC(B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode) - TSTALLOC(B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode) - TSTALLOC(B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode) - TSTALLOC(B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode) - TSTALLOC(B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode) - TSTALLOC(B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode) - TSTALLOC(B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode) - TSTALLOC(B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode) - TSTALLOC(B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode) - TSTALLOC(B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode) - TSTALLOC(B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode) - TSTALLOC(B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode) - TSTALLOC(B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode) - TSTALLOC(B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode) - TSTALLOC(B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode) - TSTALLOC(B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode) - TSTALLOC(B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode) - TSTALLOC(B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode) - TSTALLOC(B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode) + TSTALLOC(B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode); + TSTALLOC(B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode); + TSTALLOC(B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode); + TSTALLOC(B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode); + TSTALLOC(B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode); + TSTALLOC(B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode); + TSTALLOC(B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode); + TSTALLOC(B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode); + TSTALLOC(B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode); + TSTALLOC(B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode); + TSTALLOC(B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode); + TSTALLOC(B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode); + TSTALLOC(B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode); + TSTALLOC(B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode); + TSTALLOC(B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode); + TSTALLOC(B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode); + TSTALLOC(B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode); + TSTALLOC(B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode); + TSTALLOC(B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode); } diff --git a/src/spicelib/devices/bsim3v0/b3v0set.c b/src/spicelib/devices/bsim3v0/b3v0set.c index 8016aa937..4243b7456 100644 --- a/src/spicelib/devices/bsim3v0/b3v0set.c +++ b/src/spicelib/devices/bsim3v0/b3v0set.c @@ -848,43 +848,43 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(BSIM3v0DdPtr, BSIM3v0dNode, BSIM3v0dNode) - TSTALLOC(BSIM3v0GgPtr, BSIM3v0gNode, BSIM3v0gNode) - TSTALLOC(BSIM3v0SsPtr, BSIM3v0sNode, BSIM3v0sNode) - TSTALLOC(BSIM3v0BbPtr, BSIM3v0bNode, BSIM3v0bNode) - TSTALLOC(BSIM3v0DPdpPtr, BSIM3v0dNodePrime, BSIM3v0dNodePrime) - TSTALLOC(BSIM3v0SPspPtr, BSIM3v0sNodePrime, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0DdpPtr, BSIM3v0dNode, BSIM3v0dNodePrime) - TSTALLOC(BSIM3v0GbPtr, BSIM3v0gNode, BSIM3v0bNode) - TSTALLOC(BSIM3v0GdpPtr, BSIM3v0gNode, BSIM3v0dNodePrime) - TSTALLOC(BSIM3v0GspPtr, BSIM3v0gNode, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0SspPtr, BSIM3v0sNode, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0BdpPtr, BSIM3v0bNode, BSIM3v0dNodePrime) - TSTALLOC(BSIM3v0BspPtr, BSIM3v0bNode, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0DPspPtr, BSIM3v0dNodePrime, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0DPdPtr, BSIM3v0dNodePrime, BSIM3v0dNode) - TSTALLOC(BSIM3v0BgPtr, BSIM3v0bNode, BSIM3v0gNode) - TSTALLOC(BSIM3v0DPgPtr, BSIM3v0dNodePrime, BSIM3v0gNode) - TSTALLOC(BSIM3v0SPgPtr, BSIM3v0sNodePrime, BSIM3v0gNode) - TSTALLOC(BSIM3v0SPsPtr, BSIM3v0sNodePrime, BSIM3v0sNode) - TSTALLOC(BSIM3v0DPbPtr, BSIM3v0dNodePrime, BSIM3v0bNode) - TSTALLOC(BSIM3v0SPbPtr, BSIM3v0sNodePrime, BSIM3v0bNode) - TSTALLOC(BSIM3v0SPdpPtr, BSIM3v0sNodePrime, BSIM3v0dNodePrime) + TSTALLOC(BSIM3v0DdPtr, BSIM3v0dNode, BSIM3v0dNode); + TSTALLOC(BSIM3v0GgPtr, BSIM3v0gNode, BSIM3v0gNode); + TSTALLOC(BSIM3v0SsPtr, BSIM3v0sNode, BSIM3v0sNode); + TSTALLOC(BSIM3v0BbPtr, BSIM3v0bNode, BSIM3v0bNode); + TSTALLOC(BSIM3v0DPdpPtr, BSIM3v0dNodePrime, BSIM3v0dNodePrime); + TSTALLOC(BSIM3v0SPspPtr, BSIM3v0sNodePrime, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0DdpPtr, BSIM3v0dNode, BSIM3v0dNodePrime); + TSTALLOC(BSIM3v0GbPtr, BSIM3v0gNode, BSIM3v0bNode); + TSTALLOC(BSIM3v0GdpPtr, BSIM3v0gNode, BSIM3v0dNodePrime); + TSTALLOC(BSIM3v0GspPtr, BSIM3v0gNode, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0SspPtr, BSIM3v0sNode, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0BdpPtr, BSIM3v0bNode, BSIM3v0dNodePrime); + TSTALLOC(BSIM3v0BspPtr, BSIM3v0bNode, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0DPspPtr, BSIM3v0dNodePrime, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0DPdPtr, BSIM3v0dNodePrime, BSIM3v0dNode); + TSTALLOC(BSIM3v0BgPtr, BSIM3v0bNode, BSIM3v0gNode); + TSTALLOC(BSIM3v0DPgPtr, BSIM3v0dNodePrime, BSIM3v0gNode); + TSTALLOC(BSIM3v0SPgPtr, BSIM3v0sNodePrime, BSIM3v0gNode); + TSTALLOC(BSIM3v0SPsPtr, BSIM3v0sNodePrime, BSIM3v0sNode); + TSTALLOC(BSIM3v0DPbPtr, BSIM3v0dNodePrime, BSIM3v0bNode); + TSTALLOC(BSIM3v0SPbPtr, BSIM3v0sNodePrime, BSIM3v0bNode); + TSTALLOC(BSIM3v0SPdpPtr, BSIM3v0sNodePrime, BSIM3v0dNodePrime); - TSTALLOC(BSIM3v0QqPtr, BSIM3v0qNode, BSIM3v0qNode) + TSTALLOC(BSIM3v0QqPtr, BSIM3v0qNode, BSIM3v0qNode); - TSTALLOC(BSIM3v0QdpPtr, BSIM3v0qNode, BSIM3v0dNodePrime) - TSTALLOC(BSIM3v0QspPtr, BSIM3v0qNode, BSIM3v0sNodePrime) - TSTALLOC(BSIM3v0QgPtr, BSIM3v0qNode, BSIM3v0gNode) - TSTALLOC(BSIM3v0QbPtr, BSIM3v0qNode, BSIM3v0bNode) - TSTALLOC(BSIM3v0DPqPtr, BSIM3v0dNodePrime, BSIM3v0qNode) - TSTALLOC(BSIM3v0SPqPtr, BSIM3v0sNodePrime, BSIM3v0qNode) - TSTALLOC(BSIM3v0GqPtr, BSIM3v0gNode, BSIM3v0qNode) - TSTALLOC(BSIM3v0BqPtr, BSIM3v0bNode, BSIM3v0qNode) + TSTALLOC(BSIM3v0QdpPtr, BSIM3v0qNode, BSIM3v0dNodePrime); + TSTALLOC(BSIM3v0QspPtr, BSIM3v0qNode, BSIM3v0sNodePrime); + TSTALLOC(BSIM3v0QgPtr, BSIM3v0qNode, BSIM3v0gNode); + TSTALLOC(BSIM3v0QbPtr, BSIM3v0qNode, BSIM3v0bNode); + TSTALLOC(BSIM3v0DPqPtr, BSIM3v0dNodePrime, BSIM3v0qNode); + TSTALLOC(BSIM3v0SPqPtr, BSIM3v0sNodePrime, BSIM3v0qNode); + TSTALLOC(BSIM3v0GqPtr, BSIM3v0gNode, BSIM3v0qNode); + TSTALLOC(BSIM3v0BqPtr, BSIM3v0bNode, BSIM3v0qNode); } } diff --git a/src/spicelib/devices/bsim3v1/b3v1set.c b/src/spicelib/devices/bsim3v1/b3v1set.c index e87a372a1..e3bedcbb9 100644 --- a/src/spicelib/devices/bsim3v1/b3v1set.c +++ b/src/spicelib/devices/bsim3v1/b3v1set.c @@ -908,43 +908,43 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(BSIM3v1DdPtr, BSIM3v1dNode, BSIM3v1dNode) - TSTALLOC(BSIM3v1GgPtr, BSIM3v1gNode, BSIM3v1gNode) - TSTALLOC(BSIM3v1SsPtr, BSIM3v1sNode, BSIM3v1sNode) - TSTALLOC(BSIM3v1BbPtr, BSIM3v1bNode, BSIM3v1bNode) - TSTALLOC(BSIM3v1DPdpPtr, BSIM3v1dNodePrime, BSIM3v1dNodePrime) - TSTALLOC(BSIM3v1SPspPtr, BSIM3v1sNodePrime, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1DdpPtr, BSIM3v1dNode, BSIM3v1dNodePrime) - TSTALLOC(BSIM3v1GbPtr, BSIM3v1gNode, BSIM3v1bNode) - TSTALLOC(BSIM3v1GdpPtr, BSIM3v1gNode, BSIM3v1dNodePrime) - TSTALLOC(BSIM3v1GspPtr, BSIM3v1gNode, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1SspPtr, BSIM3v1sNode, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1BdpPtr, BSIM3v1bNode, BSIM3v1dNodePrime) - TSTALLOC(BSIM3v1BspPtr, BSIM3v1bNode, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1DPspPtr, BSIM3v1dNodePrime, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1DPdPtr, BSIM3v1dNodePrime, BSIM3v1dNode) - TSTALLOC(BSIM3v1BgPtr, BSIM3v1bNode, BSIM3v1gNode) - TSTALLOC(BSIM3v1DPgPtr, BSIM3v1dNodePrime, BSIM3v1gNode) - TSTALLOC(BSIM3v1SPgPtr, BSIM3v1sNodePrime, BSIM3v1gNode) - TSTALLOC(BSIM3v1SPsPtr, BSIM3v1sNodePrime, BSIM3v1sNode) - TSTALLOC(BSIM3v1DPbPtr, BSIM3v1dNodePrime, BSIM3v1bNode) - TSTALLOC(BSIM3v1SPbPtr, BSIM3v1sNodePrime, BSIM3v1bNode) - TSTALLOC(BSIM3v1SPdpPtr, BSIM3v1sNodePrime, BSIM3v1dNodePrime) + TSTALLOC(BSIM3v1DdPtr, BSIM3v1dNode, BSIM3v1dNode); + TSTALLOC(BSIM3v1GgPtr, BSIM3v1gNode, BSIM3v1gNode); + TSTALLOC(BSIM3v1SsPtr, BSIM3v1sNode, BSIM3v1sNode); + TSTALLOC(BSIM3v1BbPtr, BSIM3v1bNode, BSIM3v1bNode); + TSTALLOC(BSIM3v1DPdpPtr, BSIM3v1dNodePrime, BSIM3v1dNodePrime); + TSTALLOC(BSIM3v1SPspPtr, BSIM3v1sNodePrime, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1DdpPtr, BSIM3v1dNode, BSIM3v1dNodePrime); + TSTALLOC(BSIM3v1GbPtr, BSIM3v1gNode, BSIM3v1bNode); + TSTALLOC(BSIM3v1GdpPtr, BSIM3v1gNode, BSIM3v1dNodePrime); + TSTALLOC(BSIM3v1GspPtr, BSIM3v1gNode, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1SspPtr, BSIM3v1sNode, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1BdpPtr, BSIM3v1bNode, BSIM3v1dNodePrime); + TSTALLOC(BSIM3v1BspPtr, BSIM3v1bNode, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1DPspPtr, BSIM3v1dNodePrime, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1DPdPtr, BSIM3v1dNodePrime, BSIM3v1dNode); + TSTALLOC(BSIM3v1BgPtr, BSIM3v1bNode, BSIM3v1gNode); + TSTALLOC(BSIM3v1DPgPtr, BSIM3v1dNodePrime, BSIM3v1gNode); + TSTALLOC(BSIM3v1SPgPtr, BSIM3v1sNodePrime, BSIM3v1gNode); + TSTALLOC(BSIM3v1SPsPtr, BSIM3v1sNodePrime, BSIM3v1sNode); + TSTALLOC(BSIM3v1DPbPtr, BSIM3v1dNodePrime, BSIM3v1bNode); + TSTALLOC(BSIM3v1SPbPtr, BSIM3v1sNodePrime, BSIM3v1bNode); + TSTALLOC(BSIM3v1SPdpPtr, BSIM3v1sNodePrime, BSIM3v1dNodePrime); - TSTALLOC(BSIM3v1QqPtr, BSIM3v1qNode, BSIM3v1qNode) + TSTALLOC(BSIM3v1QqPtr, BSIM3v1qNode, BSIM3v1qNode); - TSTALLOC(BSIM3v1QdpPtr, BSIM3v1qNode, BSIM3v1dNodePrime) - TSTALLOC(BSIM3v1QspPtr, BSIM3v1qNode, BSIM3v1sNodePrime) - TSTALLOC(BSIM3v1QgPtr, BSIM3v1qNode, BSIM3v1gNode) - TSTALLOC(BSIM3v1QbPtr, BSIM3v1qNode, BSIM3v1bNode) - TSTALLOC(BSIM3v1DPqPtr, BSIM3v1dNodePrime, BSIM3v1qNode) - TSTALLOC(BSIM3v1SPqPtr, BSIM3v1sNodePrime, BSIM3v1qNode) - TSTALLOC(BSIM3v1GqPtr, BSIM3v1gNode, BSIM3v1qNode) - TSTALLOC(BSIM3v1BqPtr, BSIM3v1bNode, BSIM3v1qNode) + TSTALLOC(BSIM3v1QdpPtr, BSIM3v1qNode, BSIM3v1dNodePrime); + TSTALLOC(BSIM3v1QspPtr, BSIM3v1qNode, BSIM3v1sNodePrime); + TSTALLOC(BSIM3v1QgPtr, BSIM3v1qNode, BSIM3v1gNode); + TSTALLOC(BSIM3v1QbPtr, BSIM3v1qNode, BSIM3v1bNode); + TSTALLOC(BSIM3v1DPqPtr, BSIM3v1dNodePrime, BSIM3v1qNode); + TSTALLOC(BSIM3v1SPqPtr, BSIM3v1sNodePrime, BSIM3v1qNode); + TSTALLOC(BSIM3v1GqPtr, BSIM3v1gNode, BSIM3v1qNode); + TSTALLOC(BSIM3v1BqPtr, BSIM3v1bNode, BSIM3v1qNode); } } diff --git a/src/spicelib/devices/bsim3v32/b3v32set.c b/src/spicelib/devices/bsim3v32/b3v32set.c index 185681c77..e558536e3 100644 --- a/src/spicelib/devices/bsim3v32/b3v32set.c +++ b/src/spicelib/devices/bsim3v32/b3v32set.c @@ -1029,43 +1029,43 @@ IFuid tmpName; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(BSIM3v32DdPtr, BSIM3v32dNode, BSIM3v32dNode) - TSTALLOC(BSIM3v32GgPtr, BSIM3v32gNode, BSIM3v32gNode) - TSTALLOC(BSIM3v32SsPtr, BSIM3v32sNode, BSIM3v32sNode) - TSTALLOC(BSIM3v32BbPtr, BSIM3v32bNode, BSIM3v32bNode) - TSTALLOC(BSIM3v32DPdpPtr, BSIM3v32dNodePrime, BSIM3v32dNodePrime) - TSTALLOC(BSIM3v32SPspPtr, BSIM3v32sNodePrime, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32DdpPtr, BSIM3v32dNode, BSIM3v32dNodePrime) - TSTALLOC(BSIM3v32GbPtr, BSIM3v32gNode, BSIM3v32bNode) - TSTALLOC(BSIM3v32GdpPtr, BSIM3v32gNode, BSIM3v32dNodePrime) - TSTALLOC(BSIM3v32GspPtr, BSIM3v32gNode, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32SspPtr, BSIM3v32sNode, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32BdpPtr, BSIM3v32bNode, BSIM3v32dNodePrime) - TSTALLOC(BSIM3v32BspPtr, BSIM3v32bNode, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32DPspPtr, BSIM3v32dNodePrime, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32DPdPtr, BSIM3v32dNodePrime, BSIM3v32dNode) - TSTALLOC(BSIM3v32BgPtr, BSIM3v32bNode, BSIM3v32gNode) - TSTALLOC(BSIM3v32DPgPtr, BSIM3v32dNodePrime, BSIM3v32gNode) - TSTALLOC(BSIM3v32SPgPtr, BSIM3v32sNodePrime, BSIM3v32gNode) - TSTALLOC(BSIM3v32SPsPtr, BSIM3v32sNodePrime, BSIM3v32sNode) - TSTALLOC(BSIM3v32DPbPtr, BSIM3v32dNodePrime, BSIM3v32bNode) - TSTALLOC(BSIM3v32SPbPtr, BSIM3v32sNodePrime, BSIM3v32bNode) - TSTALLOC(BSIM3v32SPdpPtr, BSIM3v32sNodePrime, BSIM3v32dNodePrime) + TSTALLOC(BSIM3v32DdPtr, BSIM3v32dNode, BSIM3v32dNode); + TSTALLOC(BSIM3v32GgPtr, BSIM3v32gNode, BSIM3v32gNode); + TSTALLOC(BSIM3v32SsPtr, BSIM3v32sNode, BSIM3v32sNode); + TSTALLOC(BSIM3v32BbPtr, BSIM3v32bNode, BSIM3v32bNode); + TSTALLOC(BSIM3v32DPdpPtr, BSIM3v32dNodePrime, BSIM3v32dNodePrime); + TSTALLOC(BSIM3v32SPspPtr, BSIM3v32sNodePrime, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32DdpPtr, BSIM3v32dNode, BSIM3v32dNodePrime); + TSTALLOC(BSIM3v32GbPtr, BSIM3v32gNode, BSIM3v32bNode); + TSTALLOC(BSIM3v32GdpPtr, BSIM3v32gNode, BSIM3v32dNodePrime); + TSTALLOC(BSIM3v32GspPtr, BSIM3v32gNode, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32SspPtr, BSIM3v32sNode, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32BdpPtr, BSIM3v32bNode, BSIM3v32dNodePrime); + TSTALLOC(BSIM3v32BspPtr, BSIM3v32bNode, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32DPspPtr, BSIM3v32dNodePrime, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32DPdPtr, BSIM3v32dNodePrime, BSIM3v32dNode); + TSTALLOC(BSIM3v32BgPtr, BSIM3v32bNode, BSIM3v32gNode); + TSTALLOC(BSIM3v32DPgPtr, BSIM3v32dNodePrime, BSIM3v32gNode); + TSTALLOC(BSIM3v32SPgPtr, BSIM3v32sNodePrime, BSIM3v32gNode); + TSTALLOC(BSIM3v32SPsPtr, BSIM3v32sNodePrime, BSIM3v32sNode); + TSTALLOC(BSIM3v32DPbPtr, BSIM3v32dNodePrime, BSIM3v32bNode); + TSTALLOC(BSIM3v32SPbPtr, BSIM3v32sNodePrime, BSIM3v32bNode); + TSTALLOC(BSIM3v32SPdpPtr, BSIM3v32sNodePrime, BSIM3v32dNodePrime); - TSTALLOC(BSIM3v32QqPtr, BSIM3v32qNode, BSIM3v32qNode) + TSTALLOC(BSIM3v32QqPtr, BSIM3v32qNode, BSIM3v32qNode); - TSTALLOC(BSIM3v32QdpPtr, BSIM3v32qNode, BSIM3v32dNodePrime) - TSTALLOC(BSIM3v32QspPtr, BSIM3v32qNode, BSIM3v32sNodePrime) - TSTALLOC(BSIM3v32QgPtr, BSIM3v32qNode, BSIM3v32gNode) - TSTALLOC(BSIM3v32QbPtr, BSIM3v32qNode, BSIM3v32bNode) - TSTALLOC(BSIM3v32DPqPtr, BSIM3v32dNodePrime, BSIM3v32qNode) - TSTALLOC(BSIM3v32SPqPtr, BSIM3v32sNodePrime, BSIM3v32qNode) - TSTALLOC(BSIM3v32GqPtr, BSIM3v32gNode, BSIM3v32qNode) - TSTALLOC(BSIM3v32BqPtr, BSIM3v32bNode, BSIM3v32qNode) + TSTALLOC(BSIM3v32QdpPtr, BSIM3v32qNode, BSIM3v32dNodePrime); + TSTALLOC(BSIM3v32QspPtr, BSIM3v32qNode, BSIM3v32sNodePrime); + TSTALLOC(BSIM3v32QgPtr, BSIM3v32qNode, BSIM3v32gNode); + TSTALLOC(BSIM3v32QbPtr, BSIM3v32qNode, BSIM3v32bNode); + TSTALLOC(BSIM3v32DPqPtr, BSIM3v32dNodePrime, BSIM3v32qNode); + TSTALLOC(BSIM3v32SPqPtr, BSIM3v32sNodePrime, BSIM3v32qNode); + TSTALLOC(BSIM3v32GqPtr, BSIM3v32gNode, BSIM3v32qNode); + TSTALLOC(BSIM3v32BqPtr, BSIM3v32bNode, BSIM3v32qNode); } } diff --git a/src/spicelib/devices/bsim4/b4set.c b/src/spicelib/devices/bsim4/b4set.c index dd7ce8948..20e935efb 100644 --- a/src/spicelib/devices/bsim4/b4set.c +++ b/src/spicelib/devices/bsim4/b4set.c @@ -2463,96 +2463,96 @@ BSIM4instance **InstArray; /* set Sparse Matrix Pointers * macro to make elements with built-in out-of-memory test */ #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);\ -} +} } while(0) - TSTALLOC(BSIM4DPbpPtr, BSIM4dNodePrime, BSIM4bNodePrime) - TSTALLOC(BSIM4GPbpPtr, BSIM4gNodePrime, BSIM4bNodePrime) - TSTALLOC(BSIM4SPbpPtr, BSIM4sNodePrime, BSIM4bNodePrime) + TSTALLOC(BSIM4DPbpPtr, BSIM4dNodePrime, BSIM4bNodePrime); + TSTALLOC(BSIM4GPbpPtr, BSIM4gNodePrime, BSIM4bNodePrime); + TSTALLOC(BSIM4SPbpPtr, BSIM4sNodePrime, BSIM4bNodePrime); - TSTALLOC(BSIM4BPdpPtr, BSIM4bNodePrime, BSIM4dNodePrime) - TSTALLOC(BSIM4BPgpPtr, BSIM4bNodePrime, BSIM4gNodePrime) - TSTALLOC(BSIM4BPspPtr, BSIM4bNodePrime, BSIM4sNodePrime) - TSTALLOC(BSIM4BPbpPtr, BSIM4bNodePrime, BSIM4bNodePrime) + TSTALLOC(BSIM4BPdpPtr, BSIM4bNodePrime, BSIM4dNodePrime); + TSTALLOC(BSIM4BPgpPtr, BSIM4bNodePrime, BSIM4gNodePrime); + TSTALLOC(BSIM4BPspPtr, BSIM4bNodePrime, BSIM4sNodePrime); + TSTALLOC(BSIM4BPbpPtr, BSIM4bNodePrime, BSIM4bNodePrime); - TSTALLOC(BSIM4DdPtr, BSIM4dNode, BSIM4dNode) - TSTALLOC(BSIM4GPgpPtr, BSIM4gNodePrime, BSIM4gNodePrime) - TSTALLOC(BSIM4SsPtr, BSIM4sNode, BSIM4sNode) - TSTALLOC(BSIM4DPdpPtr, BSIM4dNodePrime, BSIM4dNodePrime) - TSTALLOC(BSIM4SPspPtr, BSIM4sNodePrime, BSIM4sNodePrime) - TSTALLOC(BSIM4DdpPtr, BSIM4dNode, BSIM4dNodePrime) - TSTALLOC(BSIM4GPdpPtr, BSIM4gNodePrime, BSIM4dNodePrime) - TSTALLOC(BSIM4GPspPtr, BSIM4gNodePrime, BSIM4sNodePrime) - TSTALLOC(BSIM4SspPtr, BSIM4sNode, BSIM4sNodePrime) - TSTALLOC(BSIM4DPspPtr, BSIM4dNodePrime, BSIM4sNodePrime) - TSTALLOC(BSIM4DPdPtr, BSIM4dNodePrime, BSIM4dNode) - TSTALLOC(BSIM4DPgpPtr, BSIM4dNodePrime, BSIM4gNodePrime) - TSTALLOC(BSIM4SPgpPtr, BSIM4sNodePrime, BSIM4gNodePrime) - TSTALLOC(BSIM4SPsPtr, BSIM4sNodePrime, BSIM4sNode) - TSTALLOC(BSIM4SPdpPtr, BSIM4sNodePrime, BSIM4dNodePrime) + TSTALLOC(BSIM4DdPtr, BSIM4dNode, BSIM4dNode); + TSTALLOC(BSIM4GPgpPtr, BSIM4gNodePrime, BSIM4gNodePrime); + TSTALLOC(BSIM4SsPtr, BSIM4sNode, BSIM4sNode); + TSTALLOC(BSIM4DPdpPtr, BSIM4dNodePrime, BSIM4dNodePrime); + TSTALLOC(BSIM4SPspPtr, BSIM4sNodePrime, BSIM4sNodePrime); + TSTALLOC(BSIM4DdpPtr, BSIM4dNode, BSIM4dNodePrime); + TSTALLOC(BSIM4GPdpPtr, BSIM4gNodePrime, BSIM4dNodePrime); + TSTALLOC(BSIM4GPspPtr, BSIM4gNodePrime, BSIM4sNodePrime); + TSTALLOC(BSIM4SspPtr, BSIM4sNode, BSIM4sNodePrime); + TSTALLOC(BSIM4DPspPtr, BSIM4dNodePrime, BSIM4sNodePrime); + TSTALLOC(BSIM4DPdPtr, BSIM4dNodePrime, BSIM4dNode); + TSTALLOC(BSIM4DPgpPtr, BSIM4dNodePrime, BSIM4gNodePrime); + TSTALLOC(BSIM4SPgpPtr, BSIM4sNodePrime, BSIM4gNodePrime); + TSTALLOC(BSIM4SPsPtr, BSIM4sNodePrime, BSIM4sNode); + TSTALLOC(BSIM4SPdpPtr, BSIM4sNodePrime, BSIM4dNodePrime); - TSTALLOC(BSIM4QqPtr, BSIM4qNode, BSIM4qNode) - TSTALLOC(BSIM4QbpPtr, BSIM4qNode, BSIM4bNodePrime) - TSTALLOC(BSIM4QdpPtr, BSIM4qNode, BSIM4dNodePrime) - TSTALLOC(BSIM4QspPtr, BSIM4qNode, BSIM4sNodePrime) - TSTALLOC(BSIM4QgpPtr, BSIM4qNode, BSIM4gNodePrime) - TSTALLOC(BSIM4DPqPtr, BSIM4dNodePrime, BSIM4qNode) - TSTALLOC(BSIM4SPqPtr, BSIM4sNodePrime, BSIM4qNode) - TSTALLOC(BSIM4GPqPtr, BSIM4gNodePrime, BSIM4qNode) + TSTALLOC(BSIM4QqPtr, BSIM4qNode, BSIM4qNode); + TSTALLOC(BSIM4QbpPtr, BSIM4qNode, BSIM4bNodePrime) ; + TSTALLOC(BSIM4QdpPtr, BSIM4qNode, BSIM4dNodePrime); + TSTALLOC(BSIM4QspPtr, BSIM4qNode, BSIM4sNodePrime); + TSTALLOC(BSIM4QgpPtr, BSIM4qNode, BSIM4gNodePrime); + TSTALLOC(BSIM4DPqPtr, BSIM4dNodePrime, BSIM4qNode); + TSTALLOC(BSIM4SPqPtr, BSIM4sNodePrime, BSIM4qNode); + TSTALLOC(BSIM4GPqPtr, BSIM4gNodePrime, BSIM4qNode); if (here->BSIM4rgateMod != 0) - { TSTALLOC(BSIM4GEgePtr, BSIM4gNodeExt, BSIM4gNodeExt) - TSTALLOC(BSIM4GEgpPtr, BSIM4gNodeExt, BSIM4gNodePrime) - TSTALLOC(BSIM4GPgePtr, BSIM4gNodePrime, BSIM4gNodeExt) - TSTALLOC(BSIM4GEdpPtr, BSIM4gNodeExt, BSIM4dNodePrime) - TSTALLOC(BSIM4GEspPtr, BSIM4gNodeExt, BSIM4sNodePrime) - TSTALLOC(BSIM4GEbpPtr, BSIM4gNodeExt, BSIM4bNodePrime) + { TSTALLOC(BSIM4GEgePtr, BSIM4gNodeExt, BSIM4gNodeExt); + TSTALLOC(BSIM4GEgpPtr, BSIM4gNodeExt, BSIM4gNodePrime); + TSTALLOC(BSIM4GPgePtr, BSIM4gNodePrime, BSIM4gNodeExt); + TSTALLOC(BSIM4GEdpPtr, BSIM4gNodeExt, BSIM4dNodePrime); + TSTALLOC(BSIM4GEspPtr, BSIM4gNodeExt, BSIM4sNodePrime); + TSTALLOC(BSIM4GEbpPtr, BSIM4gNodeExt, BSIM4bNodePrime); - TSTALLOC(BSIM4GMdpPtr, BSIM4gNodeMid, BSIM4dNodePrime) - TSTALLOC(BSIM4GMgpPtr, BSIM4gNodeMid, BSIM4gNodePrime) - TSTALLOC(BSIM4GMgmPtr, BSIM4gNodeMid, BSIM4gNodeMid) - TSTALLOC(BSIM4GMgePtr, BSIM4gNodeMid, BSIM4gNodeExt) - TSTALLOC(BSIM4GMspPtr, BSIM4gNodeMid, BSIM4sNodePrime) - TSTALLOC(BSIM4GMbpPtr, BSIM4gNodeMid, BSIM4bNodePrime) - TSTALLOC(BSIM4DPgmPtr, BSIM4dNodePrime, BSIM4gNodeMid) - TSTALLOC(BSIM4GPgmPtr, BSIM4gNodePrime, BSIM4gNodeMid) - TSTALLOC(BSIM4GEgmPtr, BSIM4gNodeExt, BSIM4gNodeMid) - TSTALLOC(BSIM4SPgmPtr, BSIM4sNodePrime, BSIM4gNodeMid) - TSTALLOC(BSIM4BPgmPtr, BSIM4bNodePrime, BSIM4gNodeMid) + TSTALLOC(BSIM4GMdpPtr, BSIM4gNodeMid, BSIM4dNodePrime); + TSTALLOC(BSIM4GMgpPtr, BSIM4gNodeMid, BSIM4gNodePrime); + TSTALLOC(BSIM4GMgmPtr, BSIM4gNodeMid, BSIM4gNodeMid); + TSTALLOC(BSIM4GMgePtr, BSIM4gNodeMid, BSIM4gNodeExt); + TSTALLOC(BSIM4GMspPtr, BSIM4gNodeMid, BSIM4sNodePrime); + TSTALLOC(BSIM4GMbpPtr, BSIM4gNodeMid, BSIM4bNodePrime); + TSTALLOC(BSIM4DPgmPtr, BSIM4dNodePrime, BSIM4gNodeMid); + TSTALLOC(BSIM4GPgmPtr, BSIM4gNodePrime, BSIM4gNodeMid); + TSTALLOC(BSIM4GEgmPtr, BSIM4gNodeExt, BSIM4gNodeMid); + TSTALLOC(BSIM4SPgmPtr, BSIM4sNodePrime, BSIM4gNodeMid); + TSTALLOC(BSIM4BPgmPtr, BSIM4bNodePrime, BSIM4gNodeMid); } if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2)) - { TSTALLOC(BSIM4DPdbPtr, BSIM4dNodePrime, BSIM4dbNode) - TSTALLOC(BSIM4SPsbPtr, BSIM4sNodePrime, BSIM4sbNode) + { TSTALLOC(BSIM4DPdbPtr, BSIM4dNodePrime, BSIM4dbNode); + TSTALLOC(BSIM4SPsbPtr, BSIM4sNodePrime, BSIM4sbNode); - TSTALLOC(BSIM4DBdpPtr, BSIM4dbNode, BSIM4dNodePrime) - TSTALLOC(BSIM4DBdbPtr, BSIM4dbNode, BSIM4dbNode) - TSTALLOC(BSIM4DBbpPtr, BSIM4dbNode, BSIM4bNodePrime) - TSTALLOC(BSIM4DBbPtr, BSIM4dbNode, BSIM4bNode) + TSTALLOC(BSIM4DBdpPtr, BSIM4dbNode, BSIM4dNodePrime); + TSTALLOC(BSIM4DBdbPtr, BSIM4dbNode, BSIM4dbNode); + TSTALLOC(BSIM4DBbpPtr, BSIM4dbNode, BSIM4bNodePrime); + TSTALLOC(BSIM4DBbPtr, BSIM4dbNode, BSIM4bNode); - TSTALLOC(BSIM4BPdbPtr, BSIM4bNodePrime, BSIM4dbNode) - TSTALLOC(BSIM4BPbPtr, BSIM4bNodePrime, BSIM4bNode) - TSTALLOC(BSIM4BPsbPtr, BSIM4bNodePrime, BSIM4sbNode) + TSTALLOC(BSIM4BPdbPtr, BSIM4bNodePrime, BSIM4dbNode); + TSTALLOC(BSIM4BPbPtr, BSIM4bNodePrime, BSIM4bNode); + TSTALLOC(BSIM4BPsbPtr, BSIM4bNodePrime, BSIM4sbNode); - TSTALLOC(BSIM4SBspPtr, BSIM4sbNode, BSIM4sNodePrime) - TSTALLOC(BSIM4SBbpPtr, BSIM4sbNode, BSIM4bNodePrime) - TSTALLOC(BSIM4SBbPtr, BSIM4sbNode, BSIM4bNode) - TSTALLOC(BSIM4SBsbPtr, BSIM4sbNode, BSIM4sbNode) + TSTALLOC(BSIM4SBspPtr, BSIM4sbNode, BSIM4sNodePrime); + TSTALLOC(BSIM4SBbpPtr, BSIM4sbNode, BSIM4bNodePrime); + TSTALLOC(BSIM4SBbPtr, BSIM4sbNode, BSIM4bNode); + TSTALLOC(BSIM4SBsbPtr, BSIM4sbNode, BSIM4sbNode); - TSTALLOC(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode) - TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime) - TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode) - TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode) + TSTALLOC(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode); + TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime); + TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode); + TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode); } if (model->BSIM4rdsMod) - { TSTALLOC(BSIM4DgpPtr, BSIM4dNode, BSIM4gNodePrime) - TSTALLOC(BSIM4DspPtr, BSIM4dNode, BSIM4sNodePrime) - TSTALLOC(BSIM4DbpPtr, BSIM4dNode, BSIM4bNodePrime) - TSTALLOC(BSIM4SdpPtr, BSIM4sNode, BSIM4dNodePrime) - TSTALLOC(BSIM4SgpPtr, BSIM4sNode, BSIM4gNodePrime) - TSTALLOC(BSIM4SbpPtr, BSIM4sNode, BSIM4bNodePrime) + { TSTALLOC(BSIM4DgpPtr, BSIM4dNode, BSIM4gNodePrime); + TSTALLOC(BSIM4DspPtr, BSIM4dNode, BSIM4sNodePrime); + TSTALLOC(BSIM4DbpPtr, BSIM4dNode, BSIM4bNodePrime); + TSTALLOC(BSIM4SdpPtr, BSIM4sNode, BSIM4dNodePrime); + TSTALLOC(BSIM4SgpPtr, BSIM4sNode, BSIM4gNodePrime); + TSTALLOC(BSIM4SbpPtr, BSIM4sNode, BSIM4bNodePrime); } } } diff --git a/src/spicelib/devices/bsim4v4/b4v4set.c b/src/spicelib/devices/bsim4v4/b4v4set.c index a1f483973..cf01a4a80 100644 --- a/src/spicelib/devices/bsim4v4/b4v4set.c +++ b/src/spicelib/devices/bsim4v4/b4v4set.c @@ -1849,96 +1849,96 @@ JOB *job; /* set Sparse Matrix Pointers * macro to make elements with built-in out-of-memory test */ #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);\ -} +} } while(0) - TSTALLOC(BSIM4v4DPbpPtr, BSIM4v4dNodePrime, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4GPbpPtr, BSIM4v4gNodePrime, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4SPbpPtr, BSIM4v4sNodePrime, BSIM4v4bNodePrime) + TSTALLOC(BSIM4v4DPbpPtr, BSIM4v4dNodePrime, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4GPbpPtr, BSIM4v4gNodePrime, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4SPbpPtr, BSIM4v4sNodePrime, BSIM4v4bNodePrime); - TSTALLOC(BSIM4v4BPdpPtr, BSIM4v4bNodePrime, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4BPgpPtr, BSIM4v4bNodePrime, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4BPspPtr, BSIM4v4bNodePrime, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4BPbpPtr, BSIM4v4bNodePrime, BSIM4v4bNodePrime) + TSTALLOC(BSIM4v4BPdpPtr, BSIM4v4bNodePrime, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4BPgpPtr, BSIM4v4bNodePrime, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4BPspPtr, BSIM4v4bNodePrime, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4BPbpPtr, BSIM4v4bNodePrime, BSIM4v4bNodePrime); - TSTALLOC(BSIM4v4DdPtr, BSIM4v4dNode, BSIM4v4dNode) - TSTALLOC(BSIM4v4GPgpPtr, BSIM4v4gNodePrime, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4SsPtr, BSIM4v4sNode, BSIM4v4sNode) - TSTALLOC(BSIM4v4DPdpPtr, BSIM4v4dNodePrime, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4SPspPtr, BSIM4v4sNodePrime, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4DdpPtr, BSIM4v4dNode, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4GPdpPtr, BSIM4v4gNodePrime, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4GPspPtr, BSIM4v4gNodePrime, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4SspPtr, BSIM4v4sNode, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4DPspPtr, BSIM4v4dNodePrime, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4DPdPtr, BSIM4v4dNodePrime, BSIM4v4dNode) - TSTALLOC(BSIM4v4DPgpPtr, BSIM4v4dNodePrime, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4SPgpPtr, BSIM4v4sNodePrime, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4SPsPtr, BSIM4v4sNodePrime, BSIM4v4sNode) - TSTALLOC(BSIM4v4SPdpPtr, BSIM4v4sNodePrime, BSIM4v4dNodePrime) + TSTALLOC(BSIM4v4DdPtr, BSIM4v4dNode, BSIM4v4dNode); + TSTALLOC(BSIM4v4GPgpPtr, BSIM4v4gNodePrime, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4SsPtr, BSIM4v4sNode, BSIM4v4sNode); + TSTALLOC(BSIM4v4DPdpPtr, BSIM4v4dNodePrime, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4SPspPtr, BSIM4v4sNodePrime, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4DdpPtr, BSIM4v4dNode, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4GPdpPtr, BSIM4v4gNodePrime, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4GPspPtr, BSIM4v4gNodePrime, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4SspPtr, BSIM4v4sNode, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4DPspPtr, BSIM4v4dNodePrime, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4DPdPtr, BSIM4v4dNodePrime, BSIM4v4dNode); + TSTALLOC(BSIM4v4DPgpPtr, BSIM4v4dNodePrime, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4SPgpPtr, BSIM4v4sNodePrime, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4SPsPtr, BSIM4v4sNodePrime, BSIM4v4sNode); + TSTALLOC(BSIM4v4SPdpPtr, BSIM4v4sNodePrime, BSIM4v4dNodePrime); - TSTALLOC(BSIM4v4QqPtr, BSIM4v4qNode, BSIM4v4qNode) - TSTALLOC(BSIM4v4QbpPtr, BSIM4v4qNode, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4QdpPtr, BSIM4v4qNode, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4QspPtr, BSIM4v4qNode, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4QgpPtr, BSIM4v4qNode, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4DPqPtr, BSIM4v4dNodePrime, BSIM4v4qNode) - TSTALLOC(BSIM4v4SPqPtr, BSIM4v4sNodePrime, BSIM4v4qNode) - TSTALLOC(BSIM4v4GPqPtr, BSIM4v4gNodePrime, BSIM4v4qNode) + TSTALLOC(BSIM4v4QqPtr, BSIM4v4qNode, BSIM4v4qNode); + TSTALLOC(BSIM4v4QbpPtr, BSIM4v4qNode, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4QdpPtr, BSIM4v4qNode, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4QspPtr, BSIM4v4qNode, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4QgpPtr, BSIM4v4qNode, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4DPqPtr, BSIM4v4dNodePrime, BSIM4v4qNode); + TSTALLOC(BSIM4v4SPqPtr, BSIM4v4sNodePrime, BSIM4v4qNode); + TSTALLOC(BSIM4v4GPqPtr, BSIM4v4gNodePrime, BSIM4v4qNode); if (here->BSIM4v4rgateMod != 0) - { TSTALLOC(BSIM4v4GEgePtr, BSIM4v4gNodeExt, BSIM4v4gNodeExt) - TSTALLOC(BSIM4v4GEgpPtr, BSIM4v4gNodeExt, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4GPgePtr, BSIM4v4gNodePrime, BSIM4v4gNodeExt) - TSTALLOC(BSIM4v4GEdpPtr, BSIM4v4gNodeExt, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4GEspPtr, BSIM4v4gNodeExt, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4GEbpPtr, BSIM4v4gNodeExt, BSIM4v4bNodePrime) + { TSTALLOC(BSIM4v4GEgePtr, BSIM4v4gNodeExt, BSIM4v4gNodeExt); + TSTALLOC(BSIM4v4GEgpPtr, BSIM4v4gNodeExt, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4GPgePtr, BSIM4v4gNodePrime, BSIM4v4gNodeExt); + TSTALLOC(BSIM4v4GEdpPtr, BSIM4v4gNodeExt, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4GEspPtr, BSIM4v4gNodeExt, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4GEbpPtr, BSIM4v4gNodeExt, BSIM4v4bNodePrime); - TSTALLOC(BSIM4v4GMdpPtr, BSIM4v4gNodeMid, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4GMgpPtr, BSIM4v4gNodeMid, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4GMgmPtr, BSIM4v4gNodeMid, BSIM4v4gNodeMid) - TSTALLOC(BSIM4v4GMgePtr, BSIM4v4gNodeMid, BSIM4v4gNodeExt) - TSTALLOC(BSIM4v4GMspPtr, BSIM4v4gNodeMid, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4GMbpPtr, BSIM4v4gNodeMid, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4DPgmPtr, BSIM4v4dNodePrime, BSIM4v4gNodeMid) - TSTALLOC(BSIM4v4GPgmPtr, BSIM4v4gNodePrime, BSIM4v4gNodeMid) - TSTALLOC(BSIM4v4GEgmPtr, BSIM4v4gNodeExt, BSIM4v4gNodeMid) - TSTALLOC(BSIM4v4SPgmPtr, BSIM4v4sNodePrime, BSIM4v4gNodeMid) - TSTALLOC(BSIM4v4BPgmPtr, BSIM4v4bNodePrime, BSIM4v4gNodeMid) + TSTALLOC(BSIM4v4GMdpPtr, BSIM4v4gNodeMid, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4GMgpPtr, BSIM4v4gNodeMid, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4GMgmPtr, BSIM4v4gNodeMid, BSIM4v4gNodeMid); + TSTALLOC(BSIM4v4GMgePtr, BSIM4v4gNodeMid, BSIM4v4gNodeExt); + TSTALLOC(BSIM4v4GMspPtr, BSIM4v4gNodeMid, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4GMbpPtr, BSIM4v4gNodeMid, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4DPgmPtr, BSIM4v4dNodePrime, BSIM4v4gNodeMid); + TSTALLOC(BSIM4v4GPgmPtr, BSIM4v4gNodePrime, BSIM4v4gNodeMid); + TSTALLOC(BSIM4v4GEgmPtr, BSIM4v4gNodeExt, BSIM4v4gNodeMid); + TSTALLOC(BSIM4v4SPgmPtr, BSIM4v4sNodePrime, BSIM4v4gNodeMid); + TSTALLOC(BSIM4v4BPgmPtr, BSIM4v4bNodePrime, BSIM4v4gNodeMid); } if (here->BSIM4v4rbodyMod) - { TSTALLOC(BSIM4v4DPdbPtr, BSIM4v4dNodePrime, BSIM4v4dbNode) - TSTALLOC(BSIM4v4SPsbPtr, BSIM4v4sNodePrime, BSIM4v4sbNode) + { TSTALLOC(BSIM4v4DPdbPtr, BSIM4v4dNodePrime, BSIM4v4dbNode); + TSTALLOC(BSIM4v4SPsbPtr, BSIM4v4sNodePrime, BSIM4v4sbNode); - TSTALLOC(BSIM4v4DBdpPtr, BSIM4v4dbNode, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4DBdbPtr, BSIM4v4dbNode, BSIM4v4dbNode) - TSTALLOC(BSIM4v4DBbpPtr, BSIM4v4dbNode, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4DBbPtr, BSIM4v4dbNode, BSIM4v4bNode) + TSTALLOC(BSIM4v4DBdpPtr, BSIM4v4dbNode, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4DBdbPtr, BSIM4v4dbNode, BSIM4v4dbNode); + TSTALLOC(BSIM4v4DBbpPtr, BSIM4v4dbNode, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4DBbPtr, BSIM4v4dbNode, BSIM4v4bNode); - TSTALLOC(BSIM4v4BPdbPtr, BSIM4v4bNodePrime, BSIM4v4dbNode) - TSTALLOC(BSIM4v4BPbPtr, BSIM4v4bNodePrime, BSIM4v4bNode) - TSTALLOC(BSIM4v4BPsbPtr, BSIM4v4bNodePrime, BSIM4v4sbNode) + TSTALLOC(BSIM4v4BPdbPtr, BSIM4v4bNodePrime, BSIM4v4dbNode); + TSTALLOC(BSIM4v4BPbPtr, BSIM4v4bNodePrime, BSIM4v4bNode); + TSTALLOC(BSIM4v4BPsbPtr, BSIM4v4bNodePrime, BSIM4v4sbNode); - TSTALLOC(BSIM4v4SBspPtr, BSIM4v4sbNode, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4SBbpPtr, BSIM4v4sbNode, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4SBbPtr, BSIM4v4sbNode, BSIM4v4bNode) - TSTALLOC(BSIM4v4SBsbPtr, BSIM4v4sbNode, BSIM4v4sbNode) + TSTALLOC(BSIM4v4SBspPtr, BSIM4v4sbNode, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4SBbpPtr, BSIM4v4sbNode, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4SBbPtr, BSIM4v4sbNode, BSIM4v4bNode); + TSTALLOC(BSIM4v4SBsbPtr, BSIM4v4sbNode, BSIM4v4sbNode); - TSTALLOC(BSIM4v4BdbPtr, BSIM4v4bNode, BSIM4v4dbNode) - TSTALLOC(BSIM4v4BbpPtr, BSIM4v4bNode, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4BsbPtr, BSIM4v4bNode, BSIM4v4sbNode) - TSTALLOC(BSIM4v4BbPtr, BSIM4v4bNode, BSIM4v4bNode) + TSTALLOC(BSIM4v4BdbPtr, BSIM4v4bNode, BSIM4v4dbNode); + TSTALLOC(BSIM4v4BbpPtr, BSIM4v4bNode, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4BsbPtr, BSIM4v4bNode, BSIM4v4sbNode); + TSTALLOC(BSIM4v4BbPtr, BSIM4v4bNode, BSIM4v4bNode); } if (model->BSIM4v4rdsMod) - { TSTALLOC(BSIM4v4DgpPtr, BSIM4v4dNode, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4DspPtr, BSIM4v4dNode, BSIM4v4sNodePrime) - TSTALLOC(BSIM4v4DbpPtr, BSIM4v4dNode, BSIM4v4bNodePrime) - TSTALLOC(BSIM4v4SdpPtr, BSIM4v4sNode, BSIM4v4dNodePrime) - TSTALLOC(BSIM4v4SgpPtr, BSIM4v4sNode, BSIM4v4gNodePrime) - TSTALLOC(BSIM4v4SbpPtr, BSIM4v4sNode, BSIM4v4bNodePrime) + { TSTALLOC(BSIM4v4DgpPtr, BSIM4v4dNode, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4DspPtr, BSIM4v4dNode, BSIM4v4sNodePrime); + TSTALLOC(BSIM4v4DbpPtr, BSIM4v4dNode, BSIM4v4bNodePrime); + TSTALLOC(BSIM4v4SdpPtr, BSIM4v4sNode, BSIM4v4dNodePrime); + TSTALLOC(BSIM4v4SgpPtr, BSIM4v4sNode, BSIM4v4gNodePrime); + TSTALLOC(BSIM4v4SbpPtr, BSIM4v4sNode, BSIM4v4bNodePrime); } } } diff --git a/src/spicelib/devices/bsim4v5/b4v5set.c b/src/spicelib/devices/bsim4v5/b4v5set.c index f3909ae14..667a86c7c 100644 --- a/src/spicelib/devices/bsim4v5/b4v5set.c +++ b/src/spicelib/devices/bsim4v5/b4v5set.c @@ -1966,96 +1966,96 @@ JOB *job; /* set Sparse Matrix Pointers * macro to make elements with built-in out-of-memory test */ #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);\ -} +} } while(0) - TSTALLOC(BSIM4v5DPbpPtr, BSIM4v5dNodePrime, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5GPbpPtr, BSIM4v5gNodePrime, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5SPbpPtr, BSIM4v5sNodePrime, BSIM4v5bNodePrime) + TSTALLOC(BSIM4v5DPbpPtr, BSIM4v5dNodePrime, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5GPbpPtr, BSIM4v5gNodePrime, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5SPbpPtr, BSIM4v5sNodePrime, BSIM4v5bNodePrime); - TSTALLOC(BSIM4v5BPdpPtr, BSIM4v5bNodePrime, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5BPgpPtr, BSIM4v5bNodePrime, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5BPspPtr, BSIM4v5bNodePrime, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5BPbpPtr, BSIM4v5bNodePrime, BSIM4v5bNodePrime) + TSTALLOC(BSIM4v5BPdpPtr, BSIM4v5bNodePrime, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5BPgpPtr, BSIM4v5bNodePrime, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5BPspPtr, BSIM4v5bNodePrime, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5BPbpPtr, BSIM4v5bNodePrime, BSIM4v5bNodePrime); - TSTALLOC(BSIM4v5DdPtr, BSIM4v5dNode, BSIM4v5dNode) - TSTALLOC(BSIM4v5GPgpPtr, BSIM4v5gNodePrime, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5SsPtr, BSIM4v5sNode, BSIM4v5sNode) - TSTALLOC(BSIM4v5DPdpPtr, BSIM4v5dNodePrime, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5SPspPtr, BSIM4v5sNodePrime, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5DdpPtr, BSIM4v5dNode, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5GPdpPtr, BSIM4v5gNodePrime, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5GPspPtr, BSIM4v5gNodePrime, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5SspPtr, BSIM4v5sNode, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5DPspPtr, BSIM4v5dNodePrime, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5DPdPtr, BSIM4v5dNodePrime, BSIM4v5dNode) - TSTALLOC(BSIM4v5DPgpPtr, BSIM4v5dNodePrime, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5SPgpPtr, BSIM4v5sNodePrime, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5SPsPtr, BSIM4v5sNodePrime, BSIM4v5sNode) - TSTALLOC(BSIM4v5SPdpPtr, BSIM4v5sNodePrime, BSIM4v5dNodePrime) + TSTALLOC(BSIM4v5DdPtr, BSIM4v5dNode, BSIM4v5dNode); + TSTALLOC(BSIM4v5GPgpPtr, BSIM4v5gNodePrime, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5SsPtr, BSIM4v5sNode, BSIM4v5sNode); + TSTALLOC(BSIM4v5DPdpPtr, BSIM4v5dNodePrime, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5SPspPtr, BSIM4v5sNodePrime, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5DdpPtr, BSIM4v5dNode, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5GPdpPtr, BSIM4v5gNodePrime, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5GPspPtr, BSIM4v5gNodePrime, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5SspPtr, BSIM4v5sNode, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5DPspPtr, BSIM4v5dNodePrime, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5DPdPtr, BSIM4v5dNodePrime, BSIM4v5dNode); + TSTALLOC(BSIM4v5DPgpPtr, BSIM4v5dNodePrime, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5SPgpPtr, BSIM4v5sNodePrime, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5SPsPtr, BSIM4v5sNodePrime, BSIM4v5sNode); + TSTALLOC(BSIM4v5SPdpPtr, BSIM4v5sNodePrime, BSIM4v5dNodePrime); - TSTALLOC(BSIM4v5QqPtr, BSIM4v5qNode, BSIM4v5qNode) - TSTALLOC(BSIM4v5QbpPtr, BSIM4v5qNode, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5QdpPtr, BSIM4v5qNode, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5QspPtr, BSIM4v5qNode, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5QgpPtr, BSIM4v5qNode, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5DPqPtr, BSIM4v5dNodePrime, BSIM4v5qNode) - TSTALLOC(BSIM4v5SPqPtr, BSIM4v5sNodePrime, BSIM4v5qNode) - TSTALLOC(BSIM4v5GPqPtr, BSIM4v5gNodePrime, BSIM4v5qNode) + TSTALLOC(BSIM4v5QqPtr, BSIM4v5qNode, BSIM4v5qNode); + TSTALLOC(BSIM4v5QbpPtr, BSIM4v5qNode, BSIM4v5bNodePrime) ; + TSTALLOC(BSIM4v5QdpPtr, BSIM4v5qNode, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5QspPtr, BSIM4v5qNode, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5QgpPtr, BSIM4v5qNode, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5DPqPtr, BSIM4v5dNodePrime, BSIM4v5qNode); + TSTALLOC(BSIM4v5SPqPtr, BSIM4v5sNodePrime, BSIM4v5qNode); + TSTALLOC(BSIM4v5GPqPtr, BSIM4v5gNodePrime, BSIM4v5qNode); if (here->BSIM4v5rgateMod != 0) - { TSTALLOC(BSIM4v5GEgePtr, BSIM4v5gNodeExt, BSIM4v5gNodeExt) - TSTALLOC(BSIM4v5GEgpPtr, BSIM4v5gNodeExt, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5GPgePtr, BSIM4v5gNodePrime, BSIM4v5gNodeExt) - TSTALLOC(BSIM4v5GEdpPtr, BSIM4v5gNodeExt, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5GEspPtr, BSIM4v5gNodeExt, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5GEbpPtr, BSIM4v5gNodeExt, BSIM4v5bNodePrime) + { TSTALLOC(BSIM4v5GEgePtr, BSIM4v5gNodeExt, BSIM4v5gNodeExt); + TSTALLOC(BSIM4v5GEgpPtr, BSIM4v5gNodeExt, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5GPgePtr, BSIM4v5gNodePrime, BSIM4v5gNodeExt); + TSTALLOC(BSIM4v5GEdpPtr, BSIM4v5gNodeExt, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5GEspPtr, BSIM4v5gNodeExt, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5GEbpPtr, BSIM4v5gNodeExt, BSIM4v5bNodePrime); - TSTALLOC(BSIM4v5GMdpPtr, BSIM4v5gNodeMid, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5GMgpPtr, BSIM4v5gNodeMid, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5GMgmPtr, BSIM4v5gNodeMid, BSIM4v5gNodeMid) - TSTALLOC(BSIM4v5GMgePtr, BSIM4v5gNodeMid, BSIM4v5gNodeExt) - TSTALLOC(BSIM4v5GMspPtr, BSIM4v5gNodeMid, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5GMbpPtr, BSIM4v5gNodeMid, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5DPgmPtr, BSIM4v5dNodePrime, BSIM4v5gNodeMid) - TSTALLOC(BSIM4v5GPgmPtr, BSIM4v5gNodePrime, BSIM4v5gNodeMid) - TSTALLOC(BSIM4v5GEgmPtr, BSIM4v5gNodeExt, BSIM4v5gNodeMid) - TSTALLOC(BSIM4v5SPgmPtr, BSIM4v5sNodePrime, BSIM4v5gNodeMid) - TSTALLOC(BSIM4v5BPgmPtr, BSIM4v5bNodePrime, BSIM4v5gNodeMid) + TSTALLOC(BSIM4v5GMdpPtr, BSIM4v5gNodeMid, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5GMgpPtr, BSIM4v5gNodeMid, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5GMgmPtr, BSIM4v5gNodeMid, BSIM4v5gNodeMid); + TSTALLOC(BSIM4v5GMgePtr, BSIM4v5gNodeMid, BSIM4v5gNodeExt); + TSTALLOC(BSIM4v5GMspPtr, BSIM4v5gNodeMid, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5GMbpPtr, BSIM4v5gNodeMid, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5DPgmPtr, BSIM4v5dNodePrime, BSIM4v5gNodeMid); + TSTALLOC(BSIM4v5GPgmPtr, BSIM4v5gNodePrime, BSIM4v5gNodeMid); + TSTALLOC(BSIM4v5GEgmPtr, BSIM4v5gNodeExt, BSIM4v5gNodeMid); + TSTALLOC(BSIM4v5SPgmPtr, BSIM4v5sNodePrime, BSIM4v5gNodeMid); + TSTALLOC(BSIM4v5BPgmPtr, BSIM4v5bNodePrime, BSIM4v5gNodeMid); } if ((here->BSIM4v5rbodyMod ==1) || (here->BSIM4v5rbodyMod ==2)) - { TSTALLOC(BSIM4v5DPdbPtr, BSIM4v5dNodePrime, BSIM4v5dbNode) - TSTALLOC(BSIM4v5SPsbPtr, BSIM4v5sNodePrime, BSIM4v5sbNode) + { TSTALLOC(BSIM4v5DPdbPtr, BSIM4v5dNodePrime, BSIM4v5dbNode); + TSTALLOC(BSIM4v5SPsbPtr, BSIM4v5sNodePrime, BSIM4v5sbNode); - TSTALLOC(BSIM4v5DBdpPtr, BSIM4v5dbNode, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5DBdbPtr, BSIM4v5dbNode, BSIM4v5dbNode) - TSTALLOC(BSIM4v5DBbpPtr, BSIM4v5dbNode, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5DBbPtr, BSIM4v5dbNode, BSIM4v5bNode) + TSTALLOC(BSIM4v5DBdpPtr, BSIM4v5dbNode, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5DBdbPtr, BSIM4v5dbNode, BSIM4v5dbNode); + TSTALLOC(BSIM4v5DBbpPtr, BSIM4v5dbNode, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5DBbPtr, BSIM4v5dbNode, BSIM4v5bNode); - TSTALLOC(BSIM4v5BPdbPtr, BSIM4v5bNodePrime, BSIM4v5dbNode) - TSTALLOC(BSIM4v5BPbPtr, BSIM4v5bNodePrime, BSIM4v5bNode) - TSTALLOC(BSIM4v5BPsbPtr, BSIM4v5bNodePrime, BSIM4v5sbNode) + TSTALLOC(BSIM4v5BPdbPtr, BSIM4v5bNodePrime, BSIM4v5dbNode); + TSTALLOC(BSIM4v5BPbPtr, BSIM4v5bNodePrime, BSIM4v5bNode); + TSTALLOC(BSIM4v5BPsbPtr, BSIM4v5bNodePrime, BSIM4v5sbNode); - TSTALLOC(BSIM4v5SBspPtr, BSIM4v5sbNode, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5SBbpPtr, BSIM4v5sbNode, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5SBbPtr, BSIM4v5sbNode, BSIM4v5bNode) - TSTALLOC(BSIM4v5SBsbPtr, BSIM4v5sbNode, BSIM4v5sbNode) + TSTALLOC(BSIM4v5SBspPtr, BSIM4v5sbNode, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5SBbpPtr, BSIM4v5sbNode, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5SBbPtr, BSIM4v5sbNode, BSIM4v5bNode); + TSTALLOC(BSIM4v5SBsbPtr, BSIM4v5sbNode, BSIM4v5sbNode); - TSTALLOC(BSIM4v5BdbPtr, BSIM4v5bNode, BSIM4v5dbNode) - TSTALLOC(BSIM4v5BbpPtr, BSIM4v5bNode, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5BsbPtr, BSIM4v5bNode, BSIM4v5sbNode) - TSTALLOC(BSIM4v5BbPtr, BSIM4v5bNode, BSIM4v5bNode) + TSTALLOC(BSIM4v5BdbPtr, BSIM4v5bNode, BSIM4v5dbNode); + TSTALLOC(BSIM4v5BbpPtr, BSIM4v5bNode, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5BsbPtr, BSIM4v5bNode, BSIM4v5sbNode); + TSTALLOC(BSIM4v5BbPtr, BSIM4v5bNode, BSIM4v5bNode); } if (model->BSIM4v5rdsMod) - { TSTALLOC(BSIM4v5DgpPtr, BSIM4v5dNode, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5DspPtr, BSIM4v5dNode, BSIM4v5sNodePrime) - TSTALLOC(BSIM4v5DbpPtr, BSIM4v5dNode, BSIM4v5bNodePrime) - TSTALLOC(BSIM4v5SdpPtr, BSIM4v5sNode, BSIM4v5dNodePrime) - TSTALLOC(BSIM4v5SgpPtr, BSIM4v5sNode, BSIM4v5gNodePrime) - TSTALLOC(BSIM4v5SbpPtr, BSIM4v5sNode, BSIM4v5bNodePrime) + { TSTALLOC(BSIM4v5DgpPtr, BSIM4v5dNode, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5DspPtr, BSIM4v5dNode, BSIM4v5sNodePrime); + TSTALLOC(BSIM4v5DbpPtr, BSIM4v5dNode, BSIM4v5bNodePrime); + TSTALLOC(BSIM4v5SdpPtr, BSIM4v5sNode, BSIM4v5dNodePrime); + TSTALLOC(BSIM4v5SgpPtr, BSIM4v5sNode, BSIM4v5gNodePrime); + TSTALLOC(BSIM4v5SbpPtr, BSIM4v5sNode, BSIM4v5bNodePrime); } } } diff --git a/src/spicelib/devices/bsim4v6/b4v6set.c b/src/spicelib/devices/bsim4v6/b4v6set.c index fe2e32cb0..93e573eaf 100644 --- a/src/spicelib/devices/bsim4v6/b4v6set.c +++ b/src/spicelib/devices/bsim4v6/b4v6set.c @@ -2310,96 +2310,96 @@ BSIM4v6instance **InstArray; /* set Sparse Matrix Pointers * macro to make elements with built-in out-of-memory test */ #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);\ -} +} } while(0) - TSTALLOC(BSIM4v6DPbpPtr, BSIM4v6dNodePrime, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6GPbpPtr, BSIM4v6gNodePrime, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6SPbpPtr, BSIM4v6sNodePrime, BSIM4v6bNodePrime) + TSTALLOC(BSIM4v6DPbpPtr, BSIM4v6dNodePrime, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6GPbpPtr, BSIM4v6gNodePrime, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6SPbpPtr, BSIM4v6sNodePrime, BSIM4v6bNodePrime); - TSTALLOC(BSIM4v6BPdpPtr, BSIM4v6bNodePrime, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6BPgpPtr, BSIM4v6bNodePrime, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6BPspPtr, BSIM4v6bNodePrime, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6BPbpPtr, BSIM4v6bNodePrime, BSIM4v6bNodePrime) + TSTALLOC(BSIM4v6BPdpPtr, BSIM4v6bNodePrime, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6BPgpPtr, BSIM4v6bNodePrime, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6BPspPtr, BSIM4v6bNodePrime, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6BPbpPtr, BSIM4v6bNodePrime, BSIM4v6bNodePrime); - TSTALLOC(BSIM4v6DdPtr, BSIM4v6dNode, BSIM4v6dNode) - TSTALLOC(BSIM4v6GPgpPtr, BSIM4v6gNodePrime, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6SsPtr, BSIM4v6sNode, BSIM4v6sNode) - TSTALLOC(BSIM4v6DPdpPtr, BSIM4v6dNodePrime, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6SPspPtr, BSIM4v6sNodePrime, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6DdpPtr, BSIM4v6dNode, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6GPdpPtr, BSIM4v6gNodePrime, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6GPspPtr, BSIM4v6gNodePrime, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6SspPtr, BSIM4v6sNode, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6DPspPtr, BSIM4v6dNodePrime, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6DPdPtr, BSIM4v6dNodePrime, BSIM4v6dNode) - TSTALLOC(BSIM4v6DPgpPtr, BSIM4v6dNodePrime, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6SPgpPtr, BSIM4v6sNodePrime, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6SPsPtr, BSIM4v6sNodePrime, BSIM4v6sNode) - TSTALLOC(BSIM4v6SPdpPtr, BSIM4v6sNodePrime, BSIM4v6dNodePrime) + TSTALLOC(BSIM4v6DdPtr, BSIM4v6dNode, BSIM4v6dNode); + TSTALLOC(BSIM4v6GPgpPtr, BSIM4v6gNodePrime, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6SsPtr, BSIM4v6sNode, BSIM4v6sNode); + TSTALLOC(BSIM4v6DPdpPtr, BSIM4v6dNodePrime, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6SPspPtr, BSIM4v6sNodePrime, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6DdpPtr, BSIM4v6dNode, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6GPdpPtr, BSIM4v6gNodePrime, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6GPspPtr, BSIM4v6gNodePrime, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6SspPtr, BSIM4v6sNode, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6DPspPtr, BSIM4v6dNodePrime, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6DPdPtr, BSIM4v6dNodePrime, BSIM4v6dNode); + TSTALLOC(BSIM4v6DPgpPtr, BSIM4v6dNodePrime, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6SPgpPtr, BSIM4v6sNodePrime, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6SPsPtr, BSIM4v6sNodePrime, BSIM4v6sNode); + TSTALLOC(BSIM4v6SPdpPtr, BSIM4v6sNodePrime, BSIM4v6dNodePrime); - TSTALLOC(BSIM4v6QqPtr, BSIM4v6qNode, BSIM4v6qNode) - TSTALLOC(BSIM4v6QbpPtr, BSIM4v6qNode, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6QdpPtr, BSIM4v6qNode, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6QspPtr, BSIM4v6qNode, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6QgpPtr, BSIM4v6qNode, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6DPqPtr, BSIM4v6dNodePrime, BSIM4v6qNode) - TSTALLOC(BSIM4v6SPqPtr, BSIM4v6sNodePrime, BSIM4v6qNode) - TSTALLOC(BSIM4v6GPqPtr, BSIM4v6gNodePrime, BSIM4v6qNode) + TSTALLOC(BSIM4v6QqPtr, BSIM4v6qNode, BSIM4v6qNode); + TSTALLOC(BSIM4v6QbpPtr, BSIM4v6qNode, BSIM4v6bNodePrime) ; + TSTALLOC(BSIM4v6QdpPtr, BSIM4v6qNode, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6QspPtr, BSIM4v6qNode, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6QgpPtr, BSIM4v6qNode, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6DPqPtr, BSIM4v6dNodePrime, BSIM4v6qNode); + TSTALLOC(BSIM4v6SPqPtr, BSIM4v6sNodePrime, BSIM4v6qNode); + TSTALLOC(BSIM4v6GPqPtr, BSIM4v6gNodePrime, BSIM4v6qNode); if (here->BSIM4v6rgateMod != 0) - { TSTALLOC(BSIM4v6GEgePtr, BSIM4v6gNodeExt, BSIM4v6gNodeExt) - TSTALLOC(BSIM4v6GEgpPtr, BSIM4v6gNodeExt, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6GPgePtr, BSIM4v6gNodePrime, BSIM4v6gNodeExt) - TSTALLOC(BSIM4v6GEdpPtr, BSIM4v6gNodeExt, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6GEspPtr, BSIM4v6gNodeExt, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6GEbpPtr, BSIM4v6gNodeExt, BSIM4v6bNodePrime) + { TSTALLOC(BSIM4v6GEgePtr, BSIM4v6gNodeExt, BSIM4v6gNodeExt); + TSTALLOC(BSIM4v6GEgpPtr, BSIM4v6gNodeExt, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6GPgePtr, BSIM4v6gNodePrime, BSIM4v6gNodeExt); + TSTALLOC(BSIM4v6GEdpPtr, BSIM4v6gNodeExt, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6GEspPtr, BSIM4v6gNodeExt, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6GEbpPtr, BSIM4v6gNodeExt, BSIM4v6bNodePrime); - TSTALLOC(BSIM4v6GMdpPtr, BSIM4v6gNodeMid, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6GMgpPtr, BSIM4v6gNodeMid, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6GMgmPtr, BSIM4v6gNodeMid, BSIM4v6gNodeMid) - TSTALLOC(BSIM4v6GMgePtr, BSIM4v6gNodeMid, BSIM4v6gNodeExt) - TSTALLOC(BSIM4v6GMspPtr, BSIM4v6gNodeMid, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6GMbpPtr, BSIM4v6gNodeMid, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6DPgmPtr, BSIM4v6dNodePrime, BSIM4v6gNodeMid) - TSTALLOC(BSIM4v6GPgmPtr, BSIM4v6gNodePrime, BSIM4v6gNodeMid) - TSTALLOC(BSIM4v6GEgmPtr, BSIM4v6gNodeExt, BSIM4v6gNodeMid) - TSTALLOC(BSIM4v6SPgmPtr, BSIM4v6sNodePrime, BSIM4v6gNodeMid) - TSTALLOC(BSIM4v6BPgmPtr, BSIM4v6bNodePrime, BSIM4v6gNodeMid) + TSTALLOC(BSIM4v6GMdpPtr, BSIM4v6gNodeMid, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6GMgpPtr, BSIM4v6gNodeMid, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6GMgmPtr, BSIM4v6gNodeMid, BSIM4v6gNodeMid); + TSTALLOC(BSIM4v6GMgePtr, BSIM4v6gNodeMid, BSIM4v6gNodeExt); + TSTALLOC(BSIM4v6GMspPtr, BSIM4v6gNodeMid, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6GMbpPtr, BSIM4v6gNodeMid, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6DPgmPtr, BSIM4v6dNodePrime, BSIM4v6gNodeMid); + TSTALLOC(BSIM4v6GPgmPtr, BSIM4v6gNodePrime, BSIM4v6gNodeMid); + TSTALLOC(BSIM4v6GEgmPtr, BSIM4v6gNodeExt, BSIM4v6gNodeMid); + TSTALLOC(BSIM4v6SPgmPtr, BSIM4v6sNodePrime, BSIM4v6gNodeMid); + TSTALLOC(BSIM4v6BPgmPtr, BSIM4v6bNodePrime, BSIM4v6gNodeMid); } if ((here->BSIM4v6rbodyMod ==1) || (here->BSIM4v6rbodyMod ==2)) - { TSTALLOC(BSIM4v6DPdbPtr, BSIM4v6dNodePrime, BSIM4v6dbNode) - TSTALLOC(BSIM4v6SPsbPtr, BSIM4v6sNodePrime, BSIM4v6sbNode) + { TSTALLOC(BSIM4v6DPdbPtr, BSIM4v6dNodePrime, BSIM4v6dbNode); + TSTALLOC(BSIM4v6SPsbPtr, BSIM4v6sNodePrime, BSIM4v6sbNode); - TSTALLOC(BSIM4v6DBdpPtr, BSIM4v6dbNode, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6DBdbPtr, BSIM4v6dbNode, BSIM4v6dbNode) - TSTALLOC(BSIM4v6DBbpPtr, BSIM4v6dbNode, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6DBbPtr, BSIM4v6dbNode, BSIM4v6bNode) + TSTALLOC(BSIM4v6DBdpPtr, BSIM4v6dbNode, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6DBdbPtr, BSIM4v6dbNode, BSIM4v6dbNode); + TSTALLOC(BSIM4v6DBbpPtr, BSIM4v6dbNode, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6DBbPtr, BSIM4v6dbNode, BSIM4v6bNode); - TSTALLOC(BSIM4v6BPdbPtr, BSIM4v6bNodePrime, BSIM4v6dbNode) - TSTALLOC(BSIM4v6BPbPtr, BSIM4v6bNodePrime, BSIM4v6bNode) - TSTALLOC(BSIM4v6BPsbPtr, BSIM4v6bNodePrime, BSIM4v6sbNode) + TSTALLOC(BSIM4v6BPdbPtr, BSIM4v6bNodePrime, BSIM4v6dbNode); + TSTALLOC(BSIM4v6BPbPtr, BSIM4v6bNodePrime, BSIM4v6bNode); + TSTALLOC(BSIM4v6BPsbPtr, BSIM4v6bNodePrime, BSIM4v6sbNode); - TSTALLOC(BSIM4v6SBspPtr, BSIM4v6sbNode, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6SBbpPtr, BSIM4v6sbNode, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6SBbPtr, BSIM4v6sbNode, BSIM4v6bNode) - TSTALLOC(BSIM4v6SBsbPtr, BSIM4v6sbNode, BSIM4v6sbNode) + TSTALLOC(BSIM4v6SBspPtr, BSIM4v6sbNode, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6SBbpPtr, BSIM4v6sbNode, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6SBbPtr, BSIM4v6sbNode, BSIM4v6bNode); + TSTALLOC(BSIM4v6SBsbPtr, BSIM4v6sbNode, BSIM4v6sbNode); - TSTALLOC(BSIM4v6BdbPtr, BSIM4v6bNode, BSIM4v6dbNode) - TSTALLOC(BSIM4v6BbpPtr, BSIM4v6bNode, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6BsbPtr, BSIM4v6bNode, BSIM4v6sbNode) - TSTALLOC(BSIM4v6BbPtr, BSIM4v6bNode, BSIM4v6bNode) + TSTALLOC(BSIM4v6BdbPtr, BSIM4v6bNode, BSIM4v6dbNode); + TSTALLOC(BSIM4v6BbpPtr, BSIM4v6bNode, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6BsbPtr, BSIM4v6bNode, BSIM4v6sbNode); + TSTALLOC(BSIM4v6BbPtr, BSIM4v6bNode, BSIM4v6bNode); } if (model->BSIM4v6rdsMod) - { TSTALLOC(BSIM4v6DgpPtr, BSIM4v6dNode, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6DspPtr, BSIM4v6dNode, BSIM4v6sNodePrime) - TSTALLOC(BSIM4v6DbpPtr, BSIM4v6dNode, BSIM4v6bNodePrime) - TSTALLOC(BSIM4v6SdpPtr, BSIM4v6sNode, BSIM4v6dNodePrime) - TSTALLOC(BSIM4v6SgpPtr, BSIM4v6sNode, BSIM4v6gNodePrime) - TSTALLOC(BSIM4v6SbpPtr, BSIM4v6sNode, BSIM4v6bNodePrime) + { TSTALLOC(BSIM4v6DgpPtr, BSIM4v6dNode, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6DspPtr, BSIM4v6dNode, BSIM4v6sNodePrime); + TSTALLOC(BSIM4v6DbpPtr, BSIM4v6dNode, BSIM4v6bNodePrime); + TSTALLOC(BSIM4v6SdpPtr, BSIM4v6sNode, BSIM4v6dNodePrime); + TSTALLOC(BSIM4v6SgpPtr, BSIM4v6sNode, BSIM4v6gNodePrime); + TSTALLOC(BSIM4v6SbpPtr, BSIM4v6sNode, BSIM4v6bNodePrime); } } } /* end of loop through all the BSIM4v6 device models */ diff --git a/src/spicelib/devices/bsimsoi/b4soiset.c b/src/spicelib/devices/bsimsoi/b4soiset.c index eb1e21db4..29d6df025 100644 --- a/src/spicelib/devices/bsimsoi/b4soiset.c +++ b/src/spicelib/devices/bsimsoi/b4soiset.c @@ -2515,32 +2515,32 @@ B4SOIinstance **InstArray; /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) { - TSTALLOC(B4SOITemptempPtr, B4SOItempNode, B4SOItempNode) - TSTALLOC(B4SOITempdpPtr, B4SOItempNode, B4SOIdNodePrime) - TSTALLOC(B4SOITempspPtr, B4SOItempNode, B4SOIsNodePrime) - TSTALLOC(B4SOITempgPtr, B4SOItempNode, B4SOIgNode) - TSTALLOC(B4SOITempbPtr, B4SOItempNode, B4SOIbNode) + TSTALLOC(B4SOITemptempPtr, B4SOItempNode, B4SOItempNode); + TSTALLOC(B4SOITempdpPtr, B4SOItempNode, B4SOIdNodePrime); + TSTALLOC(B4SOITempspPtr, B4SOItempNode, B4SOIsNodePrime); + TSTALLOC(B4SOITempgPtr, B4SOItempNode, B4SOIgNode); + TSTALLOC(B4SOITempbPtr, B4SOItempNode, B4SOIbNode); - TSTALLOC(B4SOIGtempPtr, B4SOIgNode, B4SOItempNode) + TSTALLOC(B4SOIGtempPtr, B4SOIgNode, B4SOItempNode); - TSTALLOC(B4SOIDPtempPtr, B4SOIdNodePrime, B4SOItempNode) - TSTALLOC(B4SOISPtempPtr, B4SOIsNodePrime, B4SOItempNode) - TSTALLOC(B4SOIEtempPtr, B4SOIeNode, B4SOItempNode) - TSTALLOC(B4SOIBtempPtr, B4SOIbNode, B4SOItempNode) + TSTALLOC(B4SOIDPtempPtr, B4SOIdNodePrime, B4SOItempNode); + TSTALLOC(B4SOISPtempPtr, B4SOIsNodePrime, B4SOItempNode); + TSTALLOC(B4SOIEtempPtr, B4SOIeNode, B4SOItempNode); + TSTALLOC(B4SOIBtempPtr, B4SOIbNode, B4SOItempNode); if (here->B4SOIbodyMod == 1) { - TSTALLOC(B4SOIPtempPtr, B4SOIpNode, B4SOItempNode) + TSTALLOC(B4SOIPtempPtr, B4SOIpNode, B4SOItempNode); } /* v3.0 */ 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 */ } else if (here->B4SOIbodyMod == 1) { - TSTALLOC(B4SOIBpPtr, B4SOIbNode, B4SOIpNode) - TSTALLOC(B4SOIPbPtr, B4SOIpNode, B4SOIbNode) - TSTALLOC(B4SOIPpPtr, B4SOIpNode, B4SOIpNode) + TSTALLOC(B4SOIBpPtr, B4SOIbNode, B4SOIpNode); + TSTALLOC(B4SOIPbPtr, B4SOIpNode, B4SOIbNode); + TSTALLOC(B4SOIPpPtr, B4SOIpNode, B4SOIpNode); /* 4.1 for Igb2_agbcp2 */ - TSTALLOC(B4SOIPgPtr , B4SOIpNode, B4SOIgNode) - TSTALLOC(B4SOIGpPtr , B4SOIgNode, B4SOIpNode) + TSTALLOC(B4SOIPgPtr , B4SOIpNode, B4SOIgNode); + TSTALLOC(B4SOIGpPtr , B4SOIgNode, B4SOIpNode); } /* v3.1 added for RF */ if (here->B4SOIrgateMod != 0) - { TSTALLOC(B4SOIGEgePtr, B4SOIgNodeExt, B4SOIgNodeExt) - TSTALLOC(B4SOIGEgPtr, B4SOIgNodeExt, B4SOIgNode) - TSTALLOC(B4SOIGgePtr, B4SOIgNode, B4SOIgNodeExt) - TSTALLOC(B4SOIGEdpPtr, B4SOIgNodeExt, B4SOIdNodePrime) - TSTALLOC(B4SOIGEspPtr, B4SOIgNodeExt, B4SOIsNodePrime) + { TSTALLOC(B4SOIGEgePtr, B4SOIgNodeExt, B4SOIgNodeExt); + TSTALLOC(B4SOIGEgPtr, B4SOIgNodeExt, B4SOIgNode); + TSTALLOC(B4SOIGgePtr, B4SOIgNode, B4SOIgNodeExt); + TSTALLOC(B4SOIGEdpPtr, B4SOIgNodeExt, B4SOIdNodePrime); + TSTALLOC(B4SOIGEspPtr, B4SOIgNodeExt, B4SOIsNodePrime); if (here->B4SOIsoiMod !=2) /* v3.2 */ - TSTALLOC(B4SOIGEbPtr, B4SOIgNodeExt, B4SOIbNode) + TSTALLOC(B4SOIGEbPtr, B4SOIgNodeExt, B4SOIbNode); - TSTALLOC(B4SOIGMdpPtr, B4SOIgNodeMid, B4SOIdNodePrime) - TSTALLOC(B4SOIGMgPtr, B4SOIgNodeMid, B4SOIgNode) - TSTALLOC(B4SOIGMgmPtr, B4SOIgNodeMid, B4SOIgNodeMid) - TSTALLOC(B4SOIGMgePtr, B4SOIgNodeMid, B4SOIgNodeExt) - TSTALLOC(B4SOIGMspPtr, B4SOIgNodeMid, B4SOIsNodePrime) + TSTALLOC(B4SOIGMdpPtr, B4SOIgNodeMid, B4SOIdNodePrime); + TSTALLOC(B4SOIGMgPtr, B4SOIgNodeMid, B4SOIgNode); + TSTALLOC(B4SOIGMgmPtr, B4SOIgNodeMid, B4SOIgNodeMid); + TSTALLOC(B4SOIGMgePtr, B4SOIgNodeMid, B4SOIgNodeExt); + TSTALLOC(B4SOIGMspPtr, B4SOIgNodeMid, B4SOIsNodePrime); if (here->B4SOIsoiMod !=2) /* v3.2 */ - TSTALLOC(B4SOIGMbPtr, B4SOIgNodeMid, B4SOIbNode) + TSTALLOC(B4SOIGMbPtr, B4SOIgNodeMid, B4SOIbNode); - TSTALLOC(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode) - TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid) - TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid) - TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid) - TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid) - TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid) + TSTALLOC(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode); + TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid); + TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid); + TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid); + TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid); + TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid); } /* v3.1 added for RF end */ @@ -2589,74 +2589,74 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ /* v3.1 */ if (here->B4SOIsoiMod != 2) /* v3.2 */ { - TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) - TSTALLOC(B4SOIGbPtr, B4SOIgNode, B4SOIbNode) - TSTALLOC(B4SOIDPbPtr, B4SOIdNodePrime, B4SOIbNode) - TSTALLOC(B4SOISPbPtr, B4SOIsNodePrime, B4SOIbNode) - TSTALLOC(B4SOIBePtr, B4SOIbNode, B4SOIeNode) - TSTALLOC(B4SOIBgPtr, B4SOIbNode, B4SOIgNode) - TSTALLOC(B4SOIBdpPtr, B4SOIbNode, B4SOIdNodePrime) - TSTALLOC(B4SOIBspPtr, B4SOIbNode, B4SOIsNodePrime) - TSTALLOC(B4SOIBbPtr, B4SOIbNode, B4SOIbNode) + TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode); + TSTALLOC(B4SOIGbPtr, B4SOIgNode, B4SOIbNode); + TSTALLOC(B4SOIDPbPtr, B4SOIdNodePrime, B4SOIbNode); + TSTALLOC(B4SOISPbPtr, B4SOIsNodePrime, B4SOIbNode); + TSTALLOC(B4SOIBePtr, B4SOIbNode, B4SOIeNode); + TSTALLOC(B4SOIBgPtr, B4SOIbNode, B4SOIgNode); + TSTALLOC(B4SOIBdpPtr, B4SOIbNode, B4SOIdNodePrime); + TSTALLOC(B4SOIBspPtr, B4SOIbNode, B4SOIsNodePrime); + TSTALLOC(B4SOIBbPtr, B4SOIbNode, B4SOIbNode); } /* v3.1 */ - TSTALLOC(B4SOIEgPtr, B4SOIeNode, B4SOIgNode) - TSTALLOC(B4SOIEdpPtr, B4SOIeNode, B4SOIdNodePrime) - TSTALLOC(B4SOIEspPtr, B4SOIeNode, B4SOIsNodePrime) - TSTALLOC(B4SOIGePtr, B4SOIgNode, B4SOIeNode) - TSTALLOC(B4SOIDPePtr, B4SOIdNodePrime, B4SOIeNode) - TSTALLOC(B4SOISPePtr, B4SOIsNodePrime, B4SOIeNode) + TSTALLOC(B4SOIEgPtr, B4SOIeNode, B4SOIgNode); + TSTALLOC(B4SOIEdpPtr, B4SOIeNode, B4SOIdNodePrime); + TSTALLOC(B4SOIEspPtr, B4SOIeNode, B4SOIsNodePrime); + TSTALLOC(B4SOIGePtr, B4SOIgNode, B4SOIeNode); + TSTALLOC(B4SOIDPePtr, B4SOIdNodePrime, B4SOIeNode); + TSTALLOC(B4SOISPePtr, B4SOIsNodePrime, B4SOIeNode); - TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) - TSTALLOC(B4SOIEePtr, B4SOIeNode, B4SOIeNode) + TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode); + TSTALLOC(B4SOIEePtr, B4SOIeNode, B4SOIeNode); - TSTALLOC(B4SOIGgPtr, B4SOIgNode, B4SOIgNode) - TSTALLOC(B4SOIGdpPtr, B4SOIgNode, B4SOIdNodePrime) - TSTALLOC(B4SOIGspPtr, B4SOIgNode, B4SOIsNodePrime) + TSTALLOC(B4SOIGgPtr, B4SOIgNode, B4SOIgNode); + TSTALLOC(B4SOIGdpPtr, B4SOIgNode, B4SOIdNodePrime); + TSTALLOC(B4SOIGspPtr, B4SOIgNode, B4SOIsNodePrime); - TSTALLOC(B4SOIDPgPtr, B4SOIdNodePrime, B4SOIgNode) - TSTALLOC(B4SOIDPdpPtr, B4SOIdNodePrime, B4SOIdNodePrime) - TSTALLOC(B4SOIDPspPtr, B4SOIdNodePrime, B4SOIsNodePrime) - TSTALLOC(B4SOIDPdPtr, B4SOIdNodePrime, B4SOIdNode) + TSTALLOC(B4SOIDPgPtr, B4SOIdNodePrime, B4SOIgNode); + TSTALLOC(B4SOIDPdpPtr, B4SOIdNodePrime, B4SOIdNodePrime); + TSTALLOC(B4SOIDPspPtr, B4SOIdNodePrime, B4SOIsNodePrime); + TSTALLOC(B4SOIDPdPtr, B4SOIdNodePrime, B4SOIdNode); - TSTALLOC(B4SOISPgPtr, B4SOIsNodePrime, B4SOIgNode) - TSTALLOC(B4SOISPdpPtr, B4SOIsNodePrime, B4SOIdNodePrime) - TSTALLOC(B4SOISPspPtr, B4SOIsNodePrime, B4SOIsNodePrime) - TSTALLOC(B4SOISPsPtr, B4SOIsNodePrime, B4SOIsNode) + TSTALLOC(B4SOISPgPtr, B4SOIsNodePrime, B4SOIgNode); + TSTALLOC(B4SOISPdpPtr, B4SOIsNodePrime, B4SOIdNodePrime); + TSTALLOC(B4SOISPspPtr, B4SOIsNodePrime, B4SOIsNodePrime); + TSTALLOC(B4SOISPsPtr, B4SOIsNodePrime, B4SOIsNode); - TSTALLOC(B4SOIDdPtr, B4SOIdNode, B4SOIdNode) - TSTALLOC(B4SOIDdpPtr, B4SOIdNode, B4SOIdNodePrime) + TSTALLOC(B4SOIDdPtr, B4SOIdNode, B4SOIdNode); + TSTALLOC(B4SOIDdpPtr, B4SOIdNode, B4SOIdNodePrime); - TSTALLOC(B4SOISsPtr, B4SOIsNode, B4SOIsNode) - TSTALLOC(B4SOISspPtr, B4SOIsNode, B4SOIsNodePrime) + TSTALLOC(B4SOISsPtr, B4SOIsNode, B4SOIsNode); + TSTALLOC(B4SOISspPtr, B4SOIsNode, B4SOIsNodePrime); /* v4.0 */ if (here->B4SOIrbodyMod == 1) - { TSTALLOC(B4SOIDPdbPtr, B4SOIdNodePrime, B4SOIdbNode) - TSTALLOC(B4SOISPsbPtr, B4SOIsNodePrime, B4SOIsbNode) + { TSTALLOC(B4SOIDPdbPtr, B4SOIdNodePrime, B4SOIdbNode); + TSTALLOC(B4SOISPsbPtr, B4SOIsNodePrime, B4SOIsbNode); - TSTALLOC(B4SOIDBdpPtr, B4SOIdbNode, B4SOIdNodePrime) - TSTALLOC(B4SOIDBdbPtr, B4SOIdbNode, B4SOIdbNode) - TSTALLOC(B4SOIDBbPtr, B4SOIdbNode, B4SOIbNode) + TSTALLOC(B4SOIDBdpPtr, B4SOIdbNode, B4SOIdNodePrime); + TSTALLOC(B4SOIDBdbPtr, B4SOIdbNode, B4SOIdbNode); + TSTALLOC(B4SOIDBbPtr, B4SOIdbNode, B4SOIbNode); - TSTALLOC(B4SOISBspPtr, B4SOIsbNode, B4SOIsNodePrime) - TSTALLOC(B4SOISBsbPtr, B4SOIsbNode, B4SOIsbNode) - TSTALLOC(B4SOISBbPtr, B4SOIsbNode, B4SOIbNode) + TSTALLOC(B4SOISBspPtr, B4SOIsbNode, B4SOIsNodePrime); + TSTALLOC(B4SOISBsbPtr, B4SOIsbNode, B4SOIsbNode); + TSTALLOC(B4SOISBbPtr, B4SOIsbNode, B4SOIbNode); - TSTALLOC(B4SOIBdbPtr, B4SOIbNode, B4SOIdbNode) - TSTALLOC(B4SOIBsbPtr, B4SOIbNode, B4SOIsbNode) + TSTALLOC(B4SOIBdbPtr, B4SOIbNode, B4SOIdbNode); + TSTALLOC(B4SOIBsbPtr, B4SOIbNode, B4SOIsbNode); } if (model->B4SOIrdsMod) - { TSTALLOC(B4SOIDgPtr, B4SOIdNode, B4SOIgNode) - TSTALLOC(B4SOIDspPtr, B4SOIdNode, B4SOIsNodePrime) - TSTALLOC(B4SOISdpPtr, B4SOIsNode, B4SOIdNodePrime) - TSTALLOC(B4SOISgPtr, B4SOIsNode, B4SOIgNode) + { TSTALLOC(B4SOIDgPtr, B4SOIdNode, B4SOIgNode); + TSTALLOC(B4SOIDspPtr, B4SOIdNode, B4SOIsNodePrime); + TSTALLOC(B4SOISdpPtr, B4SOIsNode, B4SOIdNodePrime); + TSTALLOC(B4SOISgPtr, B4SOIsNode, B4SOIgNode); if (model->B4SOIsoiMod != 2) { - TSTALLOC(B4SOIDbPtr, B4SOIdNode, B4SOIbNode) - TSTALLOC(B4SOISbPtr, B4SOIsNode, B4SOIbNode) + TSTALLOC(B4SOIDbPtr, B4SOIdNode, 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 */ if (here->B4SOIdebugMod != 0) { - TSTALLOC(B4SOIVbsPtr, B4SOIvbsNode, B4SOIvbsNode) - TSTALLOC(B4SOIIdsPtr, B4SOIidsNode, B4SOIidsNode) - TSTALLOC(B4SOIIcPtr, B4SOIicNode, B4SOIicNode) - TSTALLOC(B4SOIIbsPtr, B4SOIibsNode, B4SOIibsNode) - TSTALLOC(B4SOIIbdPtr, B4SOIibdNode, B4SOIibdNode) - TSTALLOC(B4SOIIiiPtr, B4SOIiiiNode, B4SOIiiiNode) - TSTALLOC(B4SOIIgPtr, B4SOIigNode, B4SOIigNode) - TSTALLOC(B4SOIGiggPtr, B4SOIgiggNode, B4SOIgiggNode) - TSTALLOC(B4SOIGigdPtr, B4SOIgigdNode, B4SOIgigdNode) - TSTALLOC(B4SOIGigbPtr, B4SOIgigbNode, B4SOIgigbNode) - TSTALLOC(B4SOIIgidlPtr, B4SOIigidlNode, B4SOIigidlNode) - TSTALLOC(B4SOIItunPtr, B4SOIitunNode, B4SOIitunNode) - TSTALLOC(B4SOIIbpPtr, B4SOIibpNode, B4SOIibpNode) - TSTALLOC(B4SOICbbPtr, B4SOIcbbNode, B4SOIcbbNode) - TSTALLOC(B4SOICbdPtr, B4SOIcbdNode, B4SOIcbdNode) - TSTALLOC(B4SOICbgPtr, B4SOIcbgNode, B4SOIcbgNode) - TSTALLOC(B4SOIQbfPtr, B4SOIqbfNode, B4SOIqbfNode) - TSTALLOC(B4SOIQjsPtr, B4SOIqjsNode, B4SOIqjsNode) - TSTALLOC(B4SOIQjdPtr, B4SOIqjdNode, B4SOIqjdNode) + TSTALLOC(B4SOIVbsPtr, B4SOIvbsNode, B4SOIvbsNode); + TSTALLOC(B4SOIIdsPtr, B4SOIidsNode, B4SOIidsNode); + TSTALLOC(B4SOIIcPtr, B4SOIicNode, B4SOIicNode); + TSTALLOC(B4SOIIbsPtr, B4SOIibsNode, B4SOIibsNode); + TSTALLOC(B4SOIIbdPtr, B4SOIibdNode, B4SOIibdNode); + TSTALLOC(B4SOIIiiPtr, B4SOIiiiNode, B4SOIiiiNode); + TSTALLOC(B4SOIIgPtr, B4SOIigNode, B4SOIigNode); + TSTALLOC(B4SOIGiggPtr, B4SOIgiggNode, B4SOIgiggNode); + TSTALLOC(B4SOIGigdPtr, B4SOIgigdNode, B4SOIgigdNode); + TSTALLOC(B4SOIGigbPtr, B4SOIgigbNode, B4SOIgigbNode); + TSTALLOC(B4SOIIgidlPtr, B4SOIigidlNode, B4SOIigidlNode); + TSTALLOC(B4SOIItunPtr, B4SOIitunNode, B4SOIitunNode); + TSTALLOC(B4SOIIbpPtr, B4SOIibpNode, B4SOIibpNode); + TSTALLOC(B4SOICbbPtr, B4SOIcbbNode, B4SOIcbbNode); + TSTALLOC(B4SOICbdPtr, B4SOIcbdNode, B4SOIcbdNode); + TSTALLOC(B4SOICbgPtr, B4SOIcbgNode, B4SOIcbgNode); + TSTALLOC(B4SOIQbfPtr, B4SOIqbfNode, B4SOIqbfNode); + TSTALLOC(B4SOIQjsPtr, B4SOIqjsNode, B4SOIqjsNode); + TSTALLOC(B4SOIQjdPtr, B4SOIqjdNode, B4SOIqjdNode); } diff --git a/src/spicelib/devices/cap/capsetup.c b/src/spicelib/devices/cap/capsetup.c index e37e4136d..f41c85fdf 100644 --- a/src/spicelib/devices/cap/capsetup.c +++ b/src/spicelib/devices/cap/capsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(CAPposPosptr,CAPposNode,CAPposNode) - TSTALLOC(CAPnegNegptr,CAPnegNode,CAPnegNode) - TSTALLOC(CAPposNegptr,CAPposNode,CAPnegNode) - TSTALLOC(CAPnegPosptr,CAPnegNode,CAPposNode) + TSTALLOC(CAPposPosptr,CAPposNode,CAPposNode); + TSTALLOC(CAPnegNegptr,CAPnegNode,CAPnegNode); + TSTALLOC(CAPposNegptr,CAPposNode,CAPnegNode); + TSTALLOC(CAPnegPosptr,CAPnegNode,CAPposNode); } } return(OK); diff --git a/src/spicelib/devices/cccs/cccsset.c b/src/spicelib/devices/cccs/cccsset.c index baaeea27e..99087d9eb 100644 --- a/src/spicelib/devices/cccs/cccsset.c +++ b/src/spicelib/devices/cccs/cccsset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(CCCSposContBrptr,CCCSposNode,CCCScontBranch) - TSTALLOC(CCCSnegContBrptr,CCCSnegNode,CCCScontBranch) + TSTALLOC(CCCSposContBrptr,CCCSposNode,CCCScontBranch); + TSTALLOC(CCCSnegContBrptr,CCCSnegNode,CCCScontBranch); } } return(OK); diff --git a/src/spicelib/devices/ccvs/ccvsset.c b/src/spicelib/devices/ccvs/ccvsset.c index 3cedc4fec..5edea19dd 100644 --- a/src/spicelib/devices/ccvs/ccvsset.c +++ b/src/spicelib/devices/ccvs/ccvsset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(CCVSposIbrptr, CCVSposNode, CCVSbranch) - TSTALLOC(CCVSnegIbrptr, CCVSnegNode, CCVSbranch) - TSTALLOC(CCVSibrNegptr, CCVSbranch, CCVSnegNode) - TSTALLOC(CCVSibrPosptr, CCVSbranch, CCVSposNode) - TSTALLOC(CCVSibrContBrptr, CCVSbranch, CCVScontBranch) + TSTALLOC(CCVSposIbrptr, CCVSposNode, CCVSbranch); + TSTALLOC(CCVSnegIbrptr, CCVSnegNode, CCVSbranch); + TSTALLOC(CCVSibrNegptr, CCVSbranch, CCVSnegNode); + TSTALLOC(CCVSibrPosptr, CCVSbranch, CCVSposNode); + TSTALLOC(CCVSibrContBrptr, CCVSbranch, CCVScontBranch); } } return(OK); diff --git a/src/spicelib/devices/cpl/cplsetup.c b/src/spicelib/devices/cpl/cplsetup.c index f936bd374..37fc7d732 100644 --- a/src/spicelib/devices/cpl/cplsetup.c +++ b/src/spicelib/devices/cpl/cplsetup.c @@ -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 */ #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);\ -} +} } while(0) noL = here->dimension; diff --git a/src/spicelib/devices/csw/cswsetup.c b/src/spicelib/devices/csw/cswsetup.c index f2fd38fa5..5794a33d7 100644 --- a/src/spicelib/devices/csw/cswsetup.c +++ b/src/spicelib/devices/csw/cswsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(CSWposPosptr, CSWposNode, CSWposNode) - TSTALLOC(CSWposNegptr, CSWposNode, CSWnegNode) - TSTALLOC(CSWnegPosptr, CSWnegNode, CSWposNode) - TSTALLOC(CSWnegNegptr, CSWnegNode, CSWnegNode) + TSTALLOC(CSWposPosptr, CSWposNode, CSWposNode); + TSTALLOC(CSWposNegptr, CSWposNode, CSWnegNode); + TSTALLOC(CSWnegPosptr, CSWnegNode, CSWposNode); + TSTALLOC(CSWnegNegptr, CSWnegNode, CSWnegNode); } } return(OK); diff --git a/src/spicelib/devices/dio/diosetup.c b/src/spicelib/devices/dio/diosetup.c index 8f39b2933..fc0d37b16 100644 --- a/src/spicelib/devices/dio/diosetup.c +++ b/src/spicelib/devices/dio/diosetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(DIOposPosPrimePtr,DIOposNode,DIOposPrimeNode) - TSTALLOC(DIOnegPosPrimePtr,DIOnegNode,DIOposPrimeNode) - TSTALLOC(DIOposPrimePosPtr,DIOposPrimeNode,DIOposNode) - TSTALLOC(DIOposPrimeNegPtr,DIOposPrimeNode,DIOnegNode) - TSTALLOC(DIOposPosPtr,DIOposNode,DIOposNode) - TSTALLOC(DIOnegNegPtr,DIOnegNode,DIOnegNode) - TSTALLOC(DIOposPrimePosPrimePtr,DIOposPrimeNode,DIOposPrimeNode) + TSTALLOC(DIOposPosPrimePtr,DIOposNode,DIOposPrimeNode); + TSTALLOC(DIOnegPosPrimePtr,DIOnegNode,DIOposPrimeNode); + TSTALLOC(DIOposPrimePosPtr,DIOposPrimeNode,DIOposNode); + TSTALLOC(DIOposPrimeNegPtr,DIOposPrimeNode,DIOnegNode); + TSTALLOC(DIOposPosPtr,DIOposNode,DIOposNode); + TSTALLOC(DIOnegNegPtr,DIOnegNode,DIOnegNode); + TSTALLOC(DIOposPrimePosPrimePtr,DIOposPrimeNode,DIOposPrimeNode); } } return(OK); diff --git a/src/spicelib/devices/hfet1/hfetsetup.c b/src/spicelib/devices/hfet1/hfetsetup.c index 26c0174a4..410ccedfd 100644 --- a/src/spicelib/devices/hfet1/hfetsetup.c +++ b/src/spicelib/devices/hfet1/hfetsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(HFETAdrainDrainPrimePtr,HFETAdrainNode,HFETAdrainPrimeNode) - TSTALLOC(HFETAgatePrimeDrainPrimePtr,HFETAgatePrimeNode,HFETAdrainPrimeNode) - TSTALLOC(HFETAgatePrimeSourcePrimePtr,HFETAgatePrimeNode,HFETAsourcePrimeNode) - TSTALLOC(HFETAsourceSourcePrimePtr,HFETAsourceNode,HFETAsourcePrimeNode) - TSTALLOC(HFETAdrainPrimeDrainPtr,HFETAdrainPrimeNode,HFETAdrainNode) - TSTALLOC(HFETAdrainPrimeGatePrimePtr,HFETAdrainPrimeNode,HFETAgatePrimeNode) - TSTALLOC(HFETAdrainPrimeSourcePrimePtr,HFETAdrainPrimeNode,HFETAsourcePrimeNode) - TSTALLOC(HFETAsourcePrimeGatePrimePtr,HFETAsourcePrimeNode,HFETAgatePrimeNode) - TSTALLOC(HFETAsourcePrimeSourcePtr,HFETAsourcePrimeNode,HFETAsourceNode) - TSTALLOC(HFETAsourcePrimeDrainPrimePtr,HFETAsourcePrimeNode,HFETAdrainPrimeNode) - TSTALLOC(HFETAdrainDrainPtr,HFETAdrainNode,HFETAdrainNode) - TSTALLOC(HFETAgatePrimeGatePrimePtr,HFETAgatePrimeNode,HFETAgatePrimeNode) - TSTALLOC(HFETAsourceSourcePtr,HFETAsourceNode,HFETAsourceNode) - TSTALLOC(HFETAdrainPrimeDrainPrimePtr,HFETAdrainPrimeNode,HFETAdrainPrimeNode) - TSTALLOC(HFETAsourcePrimeSourcePrimePtr,HFETAsourcePrimeNode,HFETAsourcePrimeNode) - TSTALLOC(HFETAdrainPrimeDrainPrmPrmPtr,HFETAdrainPrimeNode,HFETAdrainPrmPrmNode) - TSTALLOC(HFETAdrainPrmPrmDrainPrimePtr,HFETAdrainPrmPrmNode,HFETAdrainPrimeNode) - TSTALLOC(HFETAdrainPrmPrmGatePrimePtr,HFETAdrainPrmPrmNode,HFETAgatePrimeNode) - TSTALLOC(HFETAgatePrimeDrainPrmPrmPtr,HFETAgatePrimeNode,HFETAdrainPrmPrmNode) - TSTALLOC(HFETAdrainPrmPrmDrainPrmPrmPtr,HFETAdrainPrmPrmNode,HFETAdrainPrmPrmNode) - TSTALLOC(HFETAsourcePrimeSourcePrmPrmPtr,HFETAsourcePrimeNode,HFETAsourcePrmPrmNode) - TSTALLOC(HFETAsourcePrmPrmSourcePrimePtr,HFETAsourcePrmPrmNode,HFETAsourcePrimeNode) - TSTALLOC(HFETAsourcePrmPrmGatePrimePtr,HFETAsourcePrmPrmNode,HFETAgatePrimeNode) - TSTALLOC(HFETAgatePrimeSourcePrmPrmPtr,HFETAgatePrimeNode,HFETAsourcePrmPrmNode) - TSTALLOC(HFETAsourcePrmPrmSourcePrmPrmPtr,HFETAsourcePrmPrmNode,HFETAsourcePrmPrmNode) - TSTALLOC(HFETAgateGatePtr,HFETAgateNode,HFETAgateNode) - TSTALLOC(HFETAgateGatePrimePtr,HFETAgateNode,HFETAgatePrimeNode) - TSTALLOC(HFETAgatePrimeGatePtr,HFETAgatePrimeNode,HFETAgateNode) + TSTALLOC(HFETAdrainDrainPrimePtr,HFETAdrainNode,HFETAdrainPrimeNode); + TSTALLOC(HFETAgatePrimeDrainPrimePtr,HFETAgatePrimeNode,HFETAdrainPrimeNode); + TSTALLOC(HFETAgatePrimeSourcePrimePtr,HFETAgatePrimeNode,HFETAsourcePrimeNode); + TSTALLOC(HFETAsourceSourcePrimePtr,HFETAsourceNode,HFETAsourcePrimeNode); + TSTALLOC(HFETAdrainPrimeDrainPtr,HFETAdrainPrimeNode,HFETAdrainNode); + TSTALLOC(HFETAdrainPrimeGatePrimePtr,HFETAdrainPrimeNode,HFETAgatePrimeNode); + TSTALLOC(HFETAdrainPrimeSourcePrimePtr,HFETAdrainPrimeNode,HFETAsourcePrimeNode); + TSTALLOC(HFETAsourcePrimeGatePrimePtr,HFETAsourcePrimeNode,HFETAgatePrimeNode); + TSTALLOC(HFETAsourcePrimeSourcePtr,HFETAsourcePrimeNode,HFETAsourceNode); + TSTALLOC(HFETAsourcePrimeDrainPrimePtr,HFETAsourcePrimeNode,HFETAdrainPrimeNode); + TSTALLOC(HFETAdrainDrainPtr,HFETAdrainNode,HFETAdrainNode); + TSTALLOC(HFETAgatePrimeGatePrimePtr,HFETAgatePrimeNode,HFETAgatePrimeNode); + TSTALLOC(HFETAsourceSourcePtr,HFETAsourceNode,HFETAsourceNode); + TSTALLOC(HFETAdrainPrimeDrainPrimePtr,HFETAdrainPrimeNode,HFETAdrainPrimeNode); + TSTALLOC(HFETAsourcePrimeSourcePrimePtr,HFETAsourcePrimeNode,HFETAsourcePrimeNode); + TSTALLOC(HFETAdrainPrimeDrainPrmPrmPtr,HFETAdrainPrimeNode,HFETAdrainPrmPrmNode); + TSTALLOC(HFETAdrainPrmPrmDrainPrimePtr,HFETAdrainPrmPrmNode,HFETAdrainPrimeNode); + TSTALLOC(HFETAdrainPrmPrmGatePrimePtr,HFETAdrainPrmPrmNode,HFETAgatePrimeNode); + TSTALLOC(HFETAgatePrimeDrainPrmPrmPtr,HFETAgatePrimeNode,HFETAdrainPrmPrmNode); + TSTALLOC(HFETAdrainPrmPrmDrainPrmPrmPtr,HFETAdrainPrmPrmNode,HFETAdrainPrmPrmNode); + TSTALLOC(HFETAsourcePrimeSourcePrmPrmPtr,HFETAsourcePrimeNode,HFETAsourcePrmPrmNode); + TSTALLOC(HFETAsourcePrmPrmSourcePrimePtr,HFETAsourcePrmPrmNode,HFETAsourcePrimeNode); + TSTALLOC(HFETAsourcePrmPrmGatePrimePtr,HFETAsourcePrmPrmNode,HFETAgatePrimeNode); + TSTALLOC(HFETAgatePrimeSourcePrmPrmPtr,HFETAgatePrimeNode,HFETAsourcePrmPrmNode); + TSTALLOC(HFETAsourcePrmPrmSourcePrmPrmPtr,HFETAsourcePrmPrmNode,HFETAsourcePrmPrmNode); + TSTALLOC(HFETAgateGatePtr,HFETAgateNode,HFETAgateNode); + TSTALLOC(HFETAgateGatePrimePtr,HFETAgateNode,HFETAgatePrimeNode); + TSTALLOC(HFETAgatePrimeGatePtr,HFETAgatePrimeNode,HFETAgateNode); } } return(OK); diff --git a/src/spicelib/devices/hfet2/hfet2setup.c b/src/spicelib/devices/hfet2/hfet2setup.c index 72bf46852..96044f989 100644 --- a/src/spicelib/devices/hfet2/hfet2setup.c +++ b/src/spicelib/devices/hfet2/hfet2setup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(HFET2drainDrainPrimePtr,HFET2drainNode,HFET2drainPrimeNode) - TSTALLOC(HFET2gateDrainPrimePtr,HFET2gateNode,HFET2drainPrimeNode) - TSTALLOC(HFET2gateSourcePrimePtr,HFET2gateNode,HFET2sourcePrimeNode) - TSTALLOC(HFET2sourceSourcePrimePtr,HFET2sourceNode,HFET2sourcePrimeNode) - TSTALLOC(HFET2drainPrimeDrainPtr,HFET2drainPrimeNode,HFET2drainNode) - TSTALLOC(HFET2drainPrimeGatePtr,HFET2drainPrimeNode,HFET2gateNode) - TSTALLOC(HFET2drainPriHFET2ourcePrimePtr,HFET2drainPrimeNode,HFET2sourcePrimeNode) - TSTALLOC(HFET2sourcePrimeGatePtr,HFET2sourcePrimeNode,HFET2gateNode) - TSTALLOC(HFET2sourcePriHFET2ourcePtr,HFET2sourcePrimeNode,HFET2sourceNode) - TSTALLOC(HFET2sourcePrimeDrainPrimePtr,HFET2sourcePrimeNode,HFET2drainPrimeNode) - TSTALLOC(HFET2drainDrainPtr,HFET2drainNode,HFET2drainNode) - TSTALLOC(HFET2gateGatePtr,HFET2gateNode,HFET2gateNode) - TSTALLOC(HFET2sourceSourcePtr,HFET2sourceNode,HFET2sourceNode) - TSTALLOC(HFET2drainPrimeDrainPrimePtr,HFET2drainPrimeNode,HFET2drainPrimeNode) - TSTALLOC(HFET2sourcePriHFET2ourcePrimePtr,HFET2sourcePrimeNode,HFET2sourcePrimeNode) + TSTALLOC(HFET2drainDrainPrimePtr,HFET2drainNode,HFET2drainPrimeNode); + TSTALLOC(HFET2gateDrainPrimePtr,HFET2gateNode,HFET2drainPrimeNode); + TSTALLOC(HFET2gateSourcePrimePtr,HFET2gateNode,HFET2sourcePrimeNode); + TSTALLOC(HFET2sourceSourcePrimePtr,HFET2sourceNode,HFET2sourcePrimeNode); + TSTALLOC(HFET2drainPrimeDrainPtr,HFET2drainPrimeNode,HFET2drainNode); + TSTALLOC(HFET2drainPrimeGatePtr,HFET2drainPrimeNode,HFET2gateNode); + TSTALLOC(HFET2drainPriHFET2ourcePrimePtr,HFET2drainPrimeNode,HFET2sourcePrimeNode); + TSTALLOC(HFET2sourcePrimeGatePtr,HFET2sourcePrimeNode,HFET2gateNode); + TSTALLOC(HFET2sourcePriHFET2ourcePtr,HFET2sourcePrimeNode,HFET2sourceNode); + TSTALLOC(HFET2sourcePrimeDrainPrimePtr,HFET2sourcePrimeNode,HFET2drainPrimeNode); + TSTALLOC(HFET2drainDrainPtr,HFET2drainNode,HFET2drainNode); + TSTALLOC(HFET2gateGatePtr,HFET2gateNode,HFET2gateNode); + TSTALLOC(HFET2sourceSourcePtr,HFET2sourceNode,HFET2sourceNode); + TSTALLOC(HFET2drainPrimeDrainPrimePtr,HFET2drainPrimeNode,HFET2drainPrimeNode); + TSTALLOC(HFET2sourcePriHFET2ourcePrimePtr,HFET2sourcePrimeNode,HFET2sourcePrimeNode); } } diff --git a/src/spicelib/devices/hisim2/hsm2set.c b/src/spicelib/devices/hisim2/hsm2set.c index 305b18105..7b7412a5c 100644 --- a/src/spicelib/devices/hisim2/hsm2set.c +++ b/src/spicelib/devices/hisim2/hsm2set.c @@ -774,33 +774,33 @@ int HSM2setup( /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(HSM2DPbpPtr, HSM2dNodePrime, HSM2bNodePrime) - TSTALLOC(HSM2SPbpPtr, HSM2sNodePrime, HSM2bNodePrime) - TSTALLOC(HSM2GPbpPtr, HSM2gNodePrime, HSM2bNodePrime) + TSTALLOC(HSM2DPbpPtr, HSM2dNodePrime, HSM2bNodePrime); + TSTALLOC(HSM2SPbpPtr, HSM2sNodePrime, HSM2bNodePrime); + TSTALLOC(HSM2GPbpPtr, HSM2gNodePrime, HSM2bNodePrime); - TSTALLOC(HSM2BPdpPtr, HSM2bNodePrime, HSM2dNodePrime) - TSTALLOC(HSM2BPspPtr, HSM2bNodePrime, HSM2sNodePrime) - TSTALLOC(HSM2BPgpPtr, HSM2bNodePrime, HSM2gNodePrime) - TSTALLOC(HSM2BPbpPtr, HSM2bNodePrime, HSM2bNodePrime) + TSTALLOC(HSM2BPdpPtr, HSM2bNodePrime, HSM2dNodePrime); + TSTALLOC(HSM2BPspPtr, HSM2bNodePrime, HSM2sNodePrime); + TSTALLOC(HSM2BPgpPtr, HSM2bNodePrime, HSM2gNodePrime); + TSTALLOC(HSM2BPbpPtr, HSM2bNodePrime, HSM2bNodePrime); - TSTALLOC(HSM2DdPtr, HSM2dNode, HSM2dNode) - TSTALLOC(HSM2GPgpPtr, HSM2gNodePrime, HSM2gNodePrime) - TSTALLOC(HSM2SsPtr, HSM2sNode, HSM2sNode) - TSTALLOC(HSM2DPdpPtr, HSM2dNodePrime, HSM2dNodePrime) - TSTALLOC(HSM2SPspPtr, HSM2sNodePrime, HSM2sNodePrime) - TSTALLOC(HSM2DdpPtr, HSM2dNode, HSM2dNodePrime) - TSTALLOC(HSM2GPdpPtr, HSM2gNodePrime, HSM2dNodePrime) - TSTALLOC(HSM2GPspPtr, HSM2gNodePrime, HSM2sNodePrime) - TSTALLOC(HSM2SspPtr, HSM2sNode, HSM2sNodePrime) - TSTALLOC(HSM2DPspPtr, HSM2dNodePrime, HSM2sNodePrime) - TSTALLOC(HSM2DPdPtr, HSM2dNodePrime, HSM2dNode) - TSTALLOC(HSM2DPgpPtr, HSM2dNodePrime, HSM2gNodePrime) - TSTALLOC(HSM2SPgpPtr, HSM2sNodePrime, HSM2gNodePrime) - TSTALLOC(HSM2SPsPtr, HSM2sNodePrime, HSM2sNode) + TSTALLOC(HSM2DdPtr, HSM2dNode, HSM2dNode); + TSTALLOC(HSM2GPgpPtr, HSM2gNodePrime, HSM2gNodePrime); + TSTALLOC(HSM2SsPtr, HSM2sNode, HSM2sNode); + TSTALLOC(HSM2DPdpPtr, HSM2dNodePrime, HSM2dNodePrime); + TSTALLOC(HSM2SPspPtr, HSM2sNodePrime, HSM2sNodePrime); + TSTALLOC(HSM2DdpPtr, HSM2dNode, HSM2dNodePrime); + TSTALLOC(HSM2GPdpPtr, HSM2gNodePrime, HSM2dNodePrime); + TSTALLOC(HSM2GPspPtr, HSM2gNodePrime, HSM2sNodePrime); + TSTALLOC(HSM2SspPtr, HSM2sNode, HSM2sNodePrime); + TSTALLOC(HSM2DPspPtr, HSM2dNodePrime, HSM2sNodePrime); + TSTALLOC(HSM2DPdPtr, HSM2dNodePrime, HSM2dNode); + TSTALLOC(HSM2DPgpPtr, HSM2dNodePrime, HSM2gNodePrime); + TSTALLOC(HSM2SPgpPtr, HSM2sNodePrime, HSM2gNodePrime); + TSTALLOC(HSM2SPsPtr, HSM2sNodePrime, HSM2sNode); TSTALLOC(HSM2SPdpPtr, HSM2sNodePrime, HSM2dNodePrime); if ( here->HSM2_corg == 1 ) { diff --git a/src/spicelib/devices/hisimhv1/hsmhvset.c b/src/spicelib/devices/hisimhv1/hsmhvset.c index 12b000329..a3bd0db4e 100644 --- a/src/spicelib/devices/hisimhv1/hsmhvset.c +++ b/src/spicelib/devices/hisimhv1/hsmhvset.c @@ -938,35 +938,35 @@ int HSMHVsetup( /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(HSMHVDPbpPtr, HSMHVdNodePrime, HSMHVbNodePrime) - TSTALLOC(HSMHVSPbpPtr, HSMHVsNodePrime, HSMHVbNodePrime) - TSTALLOC(HSMHVGPbpPtr, HSMHVgNodePrime, HSMHVbNodePrime) + TSTALLOC(HSMHVDPbpPtr, HSMHVdNodePrime, HSMHVbNodePrime); + TSTALLOC(HSMHVSPbpPtr, HSMHVsNodePrime, HSMHVbNodePrime); + TSTALLOC(HSMHVGPbpPtr, HSMHVgNodePrime, HSMHVbNodePrime); - TSTALLOC(HSMHVBPdPtr, HSMHVbNodePrime, HSMHVdNode) - TSTALLOC(HSMHVBPsPtr, HSMHVbNodePrime, HSMHVsNode) - TSTALLOC(HSMHVBPdpPtr, HSMHVbNodePrime, HSMHVdNodePrime) - TSTALLOC(HSMHVBPspPtr, HSMHVbNodePrime, HSMHVsNodePrime) - TSTALLOC(HSMHVBPgpPtr, HSMHVbNodePrime, HSMHVgNodePrime) - TSTALLOC(HSMHVBPbpPtr, HSMHVbNodePrime, HSMHVbNodePrime) + TSTALLOC(HSMHVBPdPtr, HSMHVbNodePrime, HSMHVdNode); + TSTALLOC(HSMHVBPsPtr, HSMHVbNodePrime, HSMHVsNode); + TSTALLOC(HSMHVBPdpPtr, HSMHVbNodePrime, HSMHVdNodePrime); + TSTALLOC(HSMHVBPspPtr, HSMHVbNodePrime, HSMHVsNodePrime); + TSTALLOC(HSMHVBPgpPtr, HSMHVbNodePrime, HSMHVgNodePrime); + TSTALLOC(HSMHVBPbpPtr, HSMHVbNodePrime, HSMHVbNodePrime); - TSTALLOC(HSMHVDdPtr, HSMHVdNode, HSMHVdNode) - TSTALLOC(HSMHVGPgpPtr, HSMHVgNodePrime, HSMHVgNodePrime) - TSTALLOC(HSMHVSsPtr, HSMHVsNode, HSMHVsNode) - TSTALLOC(HSMHVDPdpPtr, HSMHVdNodePrime, HSMHVdNodePrime) - TSTALLOC(HSMHVSPspPtr, HSMHVsNodePrime, HSMHVsNodePrime) - TSTALLOC(HSMHVDdpPtr, HSMHVdNode, HSMHVdNodePrime) - TSTALLOC(HSMHVGPdpPtr, HSMHVgNodePrime, HSMHVdNodePrime) - TSTALLOC(HSMHVGPspPtr, HSMHVgNodePrime, HSMHVsNodePrime) - TSTALLOC(HSMHVSspPtr, HSMHVsNode, HSMHVsNodePrime) - TSTALLOC(HSMHVDPspPtr, HSMHVdNodePrime, HSMHVsNodePrime) - TSTALLOC(HSMHVDPdPtr, HSMHVdNodePrime, HSMHVdNode) - TSTALLOC(HSMHVDPgpPtr, HSMHVdNodePrime, HSMHVgNodePrime) - TSTALLOC(HSMHVSPgpPtr, HSMHVsNodePrime, HSMHVgNodePrime) - TSTALLOC(HSMHVSPsPtr, HSMHVsNodePrime, HSMHVsNode) + TSTALLOC(HSMHVDdPtr, HSMHVdNode, HSMHVdNode); + TSTALLOC(HSMHVGPgpPtr, HSMHVgNodePrime, HSMHVgNodePrime); + TSTALLOC(HSMHVSsPtr, HSMHVsNode, HSMHVsNode); + TSTALLOC(HSMHVDPdpPtr, HSMHVdNodePrime, HSMHVdNodePrime); + TSTALLOC(HSMHVSPspPtr, HSMHVsNodePrime, HSMHVsNodePrime); + TSTALLOC(HSMHVDdpPtr, HSMHVdNode, HSMHVdNodePrime); + TSTALLOC(HSMHVGPdpPtr, HSMHVgNodePrime, HSMHVdNodePrime); + TSTALLOC(HSMHVGPspPtr, HSMHVgNodePrime, HSMHVsNodePrime); + TSTALLOC(HSMHVSspPtr, HSMHVsNode, HSMHVsNodePrime); + TSTALLOC(HSMHVDPspPtr, HSMHVdNodePrime, HSMHVsNodePrime); + TSTALLOC(HSMHVDPdPtr, HSMHVdNodePrime, HSMHVdNode); + TSTALLOC(HSMHVDPgpPtr, HSMHVdNodePrime, HSMHVgNodePrime); + TSTALLOC(HSMHVSPgpPtr, HSMHVsNodePrime, HSMHVgNodePrime); + TSTALLOC(HSMHVSPsPtr, HSMHVsNodePrime, HSMHVsNode); TSTALLOC(HSMHVSPdpPtr, HSMHVsNodePrime, HSMHVdNodePrime); TSTALLOC(HSMHVGgPtr, HSMHVgNode, HSMHVgNode); @@ -1019,44 +1019,44 @@ if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ TSTALLOC(HSMHVSPsubPtr, HSMHVsNodePrime, HSMHVsubNode); } if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ - TSTALLOC(HSMHVTemptempPtr, HSMHVtempNode, HSMHVtempNode) - TSTALLOC(HSMHVTempdPtr, HSMHVtempNode, HSMHVdNode) - TSTALLOC(HSMHVTempdpPtr, HSMHVtempNode, HSMHVdNodePrime) - TSTALLOC(HSMHVTempsPtr, HSMHVtempNode, HSMHVsNode) - TSTALLOC(HSMHVTempspPtr, HSMHVtempNode, HSMHVsNodePrime) - TSTALLOC(HSMHVDPtempPtr, HSMHVdNodePrime, HSMHVtempNode) - TSTALLOC(HSMHVSPtempPtr, HSMHVsNodePrime, HSMHVtempNode) + TSTALLOC(HSMHVTemptempPtr, HSMHVtempNode, HSMHVtempNode); + TSTALLOC(HSMHVTempdPtr, HSMHVtempNode, HSMHVdNode); + TSTALLOC(HSMHVTempdpPtr, HSMHVtempNode, HSMHVdNodePrime); + TSTALLOC(HSMHVTempsPtr, HSMHVtempNode, HSMHVsNode); + TSTALLOC(HSMHVTempspPtr, HSMHVtempNode, HSMHVsNodePrime); + TSTALLOC(HSMHVDPtempPtr, HSMHVdNodePrime, HSMHVtempNode); + TSTALLOC(HSMHVSPtempPtr, HSMHVsNodePrime, HSMHVtempNode); - TSTALLOC(HSMHVTempgpPtr, HSMHVtempNode, HSMHVgNodePrime) - TSTALLOC(HSMHVTempbpPtr, HSMHVtempNode, HSMHVbNodePrime) + TSTALLOC(HSMHVTempgpPtr, HSMHVtempNode, HSMHVgNodePrime); + TSTALLOC(HSMHVTempbpPtr, HSMHVtempNode, HSMHVbNodePrime); - TSTALLOC(HSMHVGPtempPtr, HSMHVgNodePrime, HSMHVtempNode) - TSTALLOC(HSMHVBPtempPtr, HSMHVbNodePrime, HSMHVtempNode) + TSTALLOC(HSMHVGPtempPtr, HSMHVgNodePrime, HSMHVtempNode); + TSTALLOC(HSMHVBPtempPtr, HSMHVbNodePrime, HSMHVtempNode); - TSTALLOC(HSMHVDBtempPtr, HSMHVdbNode, HSMHVtempNode) - TSTALLOC(HSMHVSBtempPtr, HSMHVsbNode, HSMHVtempNode) + TSTALLOC(HSMHVDBtempPtr, HSMHVdbNode, HSMHVtempNode); + TSTALLOC(HSMHVSBtempPtr, HSMHVsbNode, HSMHVtempNode); TSTALLOC(HSMHVDtempPtr, HSMHVdNode, HSMHVtempNode); TSTALLOC(HSMHVStempPtr, HSMHVsNode, HSMHVtempNode); } if ( model->HSMHV_conqs ) { /* flat handling of NQS */ - TSTALLOC(HSMHVDPqiPtr, HSMHVdNodePrime, HSMHVqiNode) - TSTALLOC(HSMHVGPqiPtr, HSMHVgNodePrime, HSMHVqiNode) - TSTALLOC(HSMHVGPqbPtr, HSMHVgNodePrime, HSMHVqbNode) - TSTALLOC(HSMHVSPqiPtr, HSMHVsNodePrime, HSMHVqiNode) - TSTALLOC(HSMHVBPqbPtr, HSMHVbNodePrime, HSMHVqbNode) - TSTALLOC(HSMHVQIdpPtr, HSMHVqiNode, HSMHVdNodePrime) - TSTALLOC(HSMHVQIgpPtr, HSMHVqiNode, HSMHVgNodePrime) - TSTALLOC(HSMHVQIspPtr, HSMHVqiNode, HSMHVsNodePrime) - TSTALLOC(HSMHVQIbpPtr, HSMHVqiNode, HSMHVbNodePrime) - TSTALLOC(HSMHVQIqiPtr, HSMHVqiNode, HSMHVqiNode) - TSTALLOC(HSMHVQBdpPtr, HSMHVqbNode, HSMHVdNodePrime) - TSTALLOC(HSMHVQBgpPtr, HSMHVqbNode, HSMHVgNodePrime) - TSTALLOC(HSMHVQBspPtr, HSMHVqbNode, HSMHVsNodePrime) - TSTALLOC(HSMHVQBbpPtr, HSMHVqbNode, HSMHVbNodePrime) - TSTALLOC(HSMHVQBqbPtr, HSMHVqbNode, HSMHVqbNode) + TSTALLOC(HSMHVDPqiPtr, HSMHVdNodePrime, HSMHVqiNode); + TSTALLOC(HSMHVGPqiPtr, HSMHVgNodePrime, HSMHVqiNode); + TSTALLOC(HSMHVGPqbPtr, HSMHVgNodePrime, HSMHVqbNode); + TSTALLOC(HSMHVSPqiPtr, HSMHVsNodePrime, HSMHVqiNode); + TSTALLOC(HSMHVBPqbPtr, HSMHVbNodePrime, HSMHVqbNode); + TSTALLOC(HSMHVQIdpPtr, HSMHVqiNode, HSMHVdNodePrime); + TSTALLOC(HSMHVQIgpPtr, HSMHVqiNode, HSMHVgNodePrime); + TSTALLOC(HSMHVQIspPtr, HSMHVqiNode, HSMHVsNodePrime); + TSTALLOC(HSMHVQIbpPtr, HSMHVqiNode, HSMHVbNodePrime); + TSTALLOC(HSMHVQIqiPtr, HSMHVqiNode, HSMHVqiNode); + TSTALLOC(HSMHVQBdpPtr, HSMHVqbNode, HSMHVdNodePrime); + TSTALLOC(HSMHVQBgpPtr, HSMHVqbNode, HSMHVgNodePrime); + TSTALLOC(HSMHVQBspPtr, HSMHVqbNode, HSMHVsNodePrime); + TSTALLOC(HSMHVQBbpPtr, HSMHVqbNode, HSMHVbNodePrime); + TSTALLOC(HSMHVQBqbPtr, HSMHVqbNode, HSMHVqbNode); if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ - TSTALLOC(HSMHVQItempPtr, HSMHVqiNode, HSMHVtempNode) - TSTALLOC(HSMHVQBtempPtr, HSMHVqbNode, HSMHVtempNode) + TSTALLOC(HSMHVQItempPtr, HSMHVqiNode, HSMHVtempNode); + TSTALLOC(HSMHVQBtempPtr, HSMHVqbNode, HSMHVtempNode); } } diff --git a/src/spicelib/devices/ind/indsetup.c b/src/spicelib/devices/ind/indsetup.c index d686adbe7..b42bb9fbe 100644 --- a/src/spicelib/devices/ind/indsetup.c +++ b/src/spicelib/devices/ind/indsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(INDposIbrptr,INDposNode,INDbrEq) - TSTALLOC(INDnegIbrptr,INDnegNode,INDbrEq) - TSTALLOC(INDibrNegptr,INDbrEq,INDnegNode) - TSTALLOC(INDibrPosptr,INDbrEq,INDposNode) - TSTALLOC(INDibrIbrptr,INDbrEq,INDbrEq) + TSTALLOC(INDposIbrptr,INDposNode,INDbrEq); + TSTALLOC(INDnegIbrptr,INDnegNode,INDbrEq); + TSTALLOC(INDibrNegptr,INDbrEq,INDnegNode); + TSTALLOC(INDibrPosptr,INDbrEq,INDposNode); + TSTALLOC(INDibrIbrptr,INDbrEq,INDbrEq); } } return(OK); diff --git a/src/spicelib/devices/ind/mutsetup.c b/src/spicelib/devices/ind/mutsetup.c index 096f8d5b4..fd19a3710 100644 --- a/src/spicelib/devices/ind/mutsetup.c +++ b/src/spicelib/devices/ind/mutsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(MUTbr1br2,MUTind1->INDbrEq,MUTind2->INDbrEq) - TSTALLOC(MUTbr2br1,MUTind2->INDbrEq,MUTind1->INDbrEq) + TSTALLOC(MUTbr1br2,MUTind1->INDbrEq,MUTind2->INDbrEq); + TSTALLOC(MUTbr2br1,MUTind2->INDbrEq,MUTind1->INDbrEq); } } return(OK); diff --git a/src/spicelib/devices/jfet/jfetset.c b/src/spicelib/devices/jfet/jfetset.c index 4bcf17d70..026595d85 100644 --- a/src/spicelib/devices/jfet/jfetset.c +++ b/src/spicelib/devices/jfet/jfetset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(JFETdrainDrainPrimePtr,JFETdrainNode,JFETdrainPrimeNode) - TSTALLOC(JFETgateDrainPrimePtr,JFETgateNode,JFETdrainPrimeNode) - TSTALLOC(JFETgateSourcePrimePtr,JFETgateNode,JFETsourcePrimeNode) - TSTALLOC(JFETsourceSourcePrimePtr,JFETsourceNode,JFETsourcePrimeNode) - TSTALLOC(JFETdrainPrimeDrainPtr,JFETdrainPrimeNode,JFETdrainNode) - TSTALLOC(JFETdrainPrimeGatePtr,JFETdrainPrimeNode,JFETgateNode) - TSTALLOC(JFETdrainPrimeSourcePrimePtr,JFETdrainPrimeNode,JFETsourcePrimeNode) - TSTALLOC(JFETsourcePrimeGatePtr,JFETsourcePrimeNode,JFETgateNode) - TSTALLOC(JFETsourcePrimeSourcePtr,JFETsourcePrimeNode,JFETsourceNode) - TSTALLOC(JFETsourcePrimeDrainPrimePtr,JFETsourcePrimeNode,JFETdrainPrimeNode) - TSTALLOC(JFETdrainDrainPtr,JFETdrainNode,JFETdrainNode) - TSTALLOC(JFETgateGatePtr,JFETgateNode,JFETgateNode) - TSTALLOC(JFETsourceSourcePtr,JFETsourceNode,JFETsourceNode) - TSTALLOC(JFETdrainPrimeDrainPrimePtr,JFETdrainPrimeNode,JFETdrainPrimeNode) - TSTALLOC(JFETsourcePrimeSourcePrimePtr,JFETsourcePrimeNode,JFETsourcePrimeNode) + TSTALLOC(JFETdrainDrainPrimePtr,JFETdrainNode,JFETdrainPrimeNode); + TSTALLOC(JFETgateDrainPrimePtr,JFETgateNode,JFETdrainPrimeNode); + TSTALLOC(JFETgateSourcePrimePtr,JFETgateNode,JFETsourcePrimeNode); + TSTALLOC(JFETsourceSourcePrimePtr,JFETsourceNode,JFETsourcePrimeNode); + TSTALLOC(JFETdrainPrimeDrainPtr,JFETdrainPrimeNode,JFETdrainNode); + TSTALLOC(JFETdrainPrimeGatePtr,JFETdrainPrimeNode,JFETgateNode); + TSTALLOC(JFETdrainPrimeSourcePrimePtr,JFETdrainPrimeNode,JFETsourcePrimeNode); + TSTALLOC(JFETsourcePrimeGatePtr,JFETsourcePrimeNode,JFETgateNode); + TSTALLOC(JFETsourcePrimeSourcePtr,JFETsourcePrimeNode,JFETsourceNode); + TSTALLOC(JFETsourcePrimeDrainPrimePtr,JFETsourcePrimeNode,JFETdrainPrimeNode); + TSTALLOC(JFETdrainDrainPtr,JFETdrainNode,JFETdrainNode); + TSTALLOC(JFETgateGatePtr,JFETgateNode,JFETgateNode); + TSTALLOC(JFETsourceSourcePtr,JFETsourceNode,JFETsourceNode); + TSTALLOC(JFETdrainPrimeDrainPrimePtr,JFETdrainPrimeNode,JFETdrainPrimeNode); + TSTALLOC(JFETsourcePrimeSourcePrimePtr,JFETsourcePrimeNode,JFETsourcePrimeNode); } } return(OK); diff --git a/src/spicelib/devices/jfet2/jfet2set.c b/src/spicelib/devices/jfet2/jfet2set.c index af6964496..ece5ef269 100644 --- a/src/spicelib/devices/jfet2/jfet2set.c +++ b/src/spicelib/devices/jfet2/jfet2set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(JFET2drainDrainPrimePtr,JFET2drainNode,JFET2drainPrimeNode) - TSTALLOC(JFET2gateDrainPrimePtr,JFET2gateNode,JFET2drainPrimeNode) - TSTALLOC(JFET2gateSourcePrimePtr,JFET2gateNode,JFET2sourcePrimeNode) - TSTALLOC(JFET2sourceSourcePrimePtr,JFET2sourceNode,JFET2sourcePrimeNode) - TSTALLOC(JFET2drainPrimeDrainPtr,JFET2drainPrimeNode,JFET2drainNode) - TSTALLOC(JFET2drainPrimeGatePtr,JFET2drainPrimeNode,JFET2gateNode) - TSTALLOC(JFET2drainPrimeSourcePrimePtr,JFET2drainPrimeNode,JFET2sourcePrimeNode) - TSTALLOC(JFET2sourcePrimeGatePtr,JFET2sourcePrimeNode,JFET2gateNode) - TSTALLOC(JFET2sourcePrimeSourcePtr,JFET2sourcePrimeNode,JFET2sourceNode) - TSTALLOC(JFET2sourcePrimeDrainPrimePtr,JFET2sourcePrimeNode,JFET2drainPrimeNode) - TSTALLOC(JFET2drainDrainPtr,JFET2drainNode,JFET2drainNode) - TSTALLOC(JFET2gateGatePtr,JFET2gateNode,JFET2gateNode) - TSTALLOC(JFET2sourceSourcePtr,JFET2sourceNode,JFET2sourceNode) - TSTALLOC(JFET2drainPrimeDrainPrimePtr,JFET2drainPrimeNode,JFET2drainPrimeNode) - TSTALLOC(JFET2sourcePrimeSourcePrimePtr,JFET2sourcePrimeNode,JFET2sourcePrimeNode) + TSTALLOC(JFET2drainDrainPrimePtr,JFET2drainNode,JFET2drainPrimeNode); + TSTALLOC(JFET2gateDrainPrimePtr,JFET2gateNode,JFET2drainPrimeNode); + TSTALLOC(JFET2gateSourcePrimePtr,JFET2gateNode,JFET2sourcePrimeNode); + TSTALLOC(JFET2sourceSourcePrimePtr,JFET2sourceNode,JFET2sourcePrimeNode); + TSTALLOC(JFET2drainPrimeDrainPtr,JFET2drainPrimeNode,JFET2drainNode); + TSTALLOC(JFET2drainPrimeGatePtr,JFET2drainPrimeNode,JFET2gateNode); + TSTALLOC(JFET2drainPrimeSourcePrimePtr,JFET2drainPrimeNode,JFET2sourcePrimeNode); + TSTALLOC(JFET2sourcePrimeGatePtr,JFET2sourcePrimeNode,JFET2gateNode); + TSTALLOC(JFET2sourcePrimeSourcePtr,JFET2sourcePrimeNode,JFET2sourceNode); + TSTALLOC(JFET2sourcePrimeDrainPrimePtr,JFET2sourcePrimeNode,JFET2drainPrimeNode); + TSTALLOC(JFET2drainDrainPtr,JFET2drainNode,JFET2drainNode); + TSTALLOC(JFET2gateGatePtr,JFET2gateNode,JFET2gateNode); + TSTALLOC(JFET2sourceSourcePtr,JFET2sourceNode,JFET2sourceNode); + TSTALLOC(JFET2drainPrimeDrainPrimePtr,JFET2drainPrimeNode,JFET2drainPrimeNode); + TSTALLOC(JFET2sourcePrimeSourcePrimePtr,JFET2sourcePrimeNode,JFET2sourcePrimeNode); } } return(OK); diff --git a/src/spicelib/devices/ltra/ltraset.c b/src/spicelib/devices/ltra/ltraset.c index 408a90dc5..273fc38ef 100644 --- a/src/spicelib/devices/ltra/ltraset.c +++ b/src/spicelib/devices/ltra/ltraset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(LTRAibr1Pos1Ptr, LTRAbrEq1, LTRAposNode1) - TSTALLOC(LTRAibr1Neg1Ptr, LTRAbrEq1, LTRAnegNode1) - TSTALLOC(LTRAibr1Pos2Ptr, LTRAbrEq1, LTRAposNode2) - TSTALLOC(LTRAibr1Neg2Ptr, LTRAbrEq1, LTRAnegNode2) - TSTALLOC(LTRAibr1Ibr1Ptr, LTRAbrEq1, LTRAbrEq1) - TSTALLOC(LTRAibr1Ibr2Ptr, LTRAbrEq1, LTRAbrEq2) - TSTALLOC(LTRAibr2Pos1Ptr, LTRAbrEq2, LTRAposNode1) - TSTALLOC(LTRAibr2Neg1Ptr, LTRAbrEq2, LTRAnegNode1) - TSTALLOC(LTRAibr2Pos2Ptr, LTRAbrEq2, LTRAposNode2) - TSTALLOC(LTRAibr2Neg2Ptr, LTRAbrEq2, LTRAnegNode2) - TSTALLOC(LTRAibr2Ibr1Ptr, LTRAbrEq2, LTRAbrEq1) - TSTALLOC(LTRAibr2Ibr2Ptr, LTRAbrEq2, LTRAbrEq2) - TSTALLOC(LTRApos1Ibr1Ptr, LTRAposNode1, LTRAbrEq1) - TSTALLOC(LTRAneg1Ibr1Ptr, LTRAnegNode1, LTRAbrEq1) - TSTALLOC(LTRApos2Ibr2Ptr, LTRAposNode2, LTRAbrEq2) - TSTALLOC(LTRAneg2Ibr2Ptr, LTRAnegNode2, LTRAbrEq2) + TSTALLOC(LTRAibr1Pos1Ptr, LTRAbrEq1, LTRAposNode1); + TSTALLOC(LTRAibr1Neg1Ptr, LTRAbrEq1, LTRAnegNode1); + TSTALLOC(LTRAibr1Pos2Ptr, LTRAbrEq1, LTRAposNode2); + TSTALLOC(LTRAibr1Neg2Ptr, LTRAbrEq1, LTRAnegNode2); + TSTALLOC(LTRAibr1Ibr1Ptr, LTRAbrEq1, LTRAbrEq1); + TSTALLOC(LTRAibr1Ibr2Ptr, LTRAbrEq1, LTRAbrEq2); + TSTALLOC(LTRAibr2Pos1Ptr, LTRAbrEq2, LTRAposNode1); + TSTALLOC(LTRAibr2Neg1Ptr, LTRAbrEq2, LTRAnegNode1); + TSTALLOC(LTRAibr2Pos2Ptr, LTRAbrEq2, LTRAposNode2); + TSTALLOC(LTRAibr2Neg2Ptr, LTRAbrEq2, LTRAnegNode2); + TSTALLOC(LTRAibr2Ibr1Ptr, LTRAbrEq2, LTRAbrEq1); + TSTALLOC(LTRAibr2Ibr2Ptr, LTRAbrEq2, LTRAbrEq2); + TSTALLOC(LTRApos1Ibr1Ptr, LTRAposNode1, LTRAbrEq1); + TSTALLOC(LTRAneg1Ibr1Ptr, LTRAnegNode1, LTRAbrEq1); + TSTALLOC(LTRApos2Ibr2Ptr, LTRAposNode2, LTRAbrEq2); + TSTALLOC(LTRAneg2Ibr2Ptr, LTRAnegNode2, LTRAbrEq2); /* * the following are done so that SMPpreOrder does not screw up on * occasion - for example, when one end of the lossy line is hanging */ - TSTALLOC(LTRApos1Pos1Ptr, LTRAposNode1, LTRAposNode1) - TSTALLOC(LTRAneg1Neg1Ptr, LTRAnegNode1, LTRAnegNode1) - TSTALLOC(LTRApos2Pos2Ptr, LTRAposNode2, LTRAposNode2) - TSTALLOC(LTRAneg2Neg2Ptr, LTRAnegNode2, LTRAnegNode2) + TSTALLOC(LTRApos1Pos1Ptr, LTRAposNode1, LTRAposNode1); + TSTALLOC(LTRAneg1Neg1Ptr, LTRAnegNode1, LTRAnegNode1); + TSTALLOC(LTRApos2Pos2Ptr, LTRAposNode2, LTRAposNode2); + TSTALLOC(LTRAneg2Neg2Ptr, LTRAnegNode2, LTRAnegNode2); } } return (OK); diff --git a/src/spicelib/devices/mes/messetup.c b/src/spicelib/devices/mes/messetup.c index 129b93da6..a65449159 100644 --- a/src/spicelib/devices/mes/messetup.c +++ b/src/spicelib/devices/mes/messetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(MESdrainDrainPrimePtr,MESdrainNode,MESdrainPrimeNode) - TSTALLOC(MESgateDrainPrimePtr,MESgateNode,MESdrainPrimeNode) - TSTALLOC(MESgateSourcePrimePtr,MESgateNode,MESsourcePrimeNode) - TSTALLOC(MESsourceSourcePrimePtr,MESsourceNode,MESsourcePrimeNode) - TSTALLOC(MESdrainPrimeDrainPtr,MESdrainPrimeNode,MESdrainNode) - TSTALLOC(MESdrainPrimeGatePtr,MESdrainPrimeNode,MESgateNode) - TSTALLOC(MESdrainPrimeSourcePrimePtr,MESdrainPrimeNode,MESsourcePrimeNode) - TSTALLOC(MESsourcePrimeGatePtr,MESsourcePrimeNode,MESgateNode) - TSTALLOC(MESsourcePrimeSourcePtr,MESsourcePrimeNode,MESsourceNode) - TSTALLOC(MESsourcePrimeDrainPrimePtr,MESsourcePrimeNode,MESdrainPrimeNode) - TSTALLOC(MESdrainDrainPtr,MESdrainNode,MESdrainNode) - TSTALLOC(MESgateGatePtr,MESgateNode,MESgateNode) - TSTALLOC(MESsourceSourcePtr,MESsourceNode,MESsourceNode) - TSTALLOC(MESdrainPrimeDrainPrimePtr,MESdrainPrimeNode,MESdrainPrimeNode) - TSTALLOC(MESsourcePrimeSourcePrimePtr,MESsourcePrimeNode,MESsourcePrimeNode) + TSTALLOC(MESdrainDrainPrimePtr,MESdrainNode,MESdrainPrimeNode); + TSTALLOC(MESgateDrainPrimePtr,MESgateNode,MESdrainPrimeNode); + TSTALLOC(MESgateSourcePrimePtr,MESgateNode,MESsourcePrimeNode); + TSTALLOC(MESsourceSourcePrimePtr,MESsourceNode,MESsourcePrimeNode); + TSTALLOC(MESdrainPrimeDrainPtr,MESdrainPrimeNode,MESdrainNode); + TSTALLOC(MESdrainPrimeGatePtr,MESdrainPrimeNode,MESgateNode); + TSTALLOC(MESdrainPrimeSourcePrimePtr,MESdrainPrimeNode,MESsourcePrimeNode); + TSTALLOC(MESsourcePrimeGatePtr,MESsourcePrimeNode,MESgateNode); + TSTALLOC(MESsourcePrimeSourcePtr,MESsourcePrimeNode,MESsourceNode); + TSTALLOC(MESsourcePrimeDrainPrimePtr,MESsourcePrimeNode,MESdrainPrimeNode); + TSTALLOC(MESdrainDrainPtr,MESdrainNode,MESdrainNode); + TSTALLOC(MESgateGatePtr,MESgateNode,MESgateNode); + TSTALLOC(MESsourceSourcePtr,MESsourceNode,MESsourceNode); + TSTALLOC(MESdrainPrimeDrainPrimePtr,MESdrainPrimeNode,MESdrainPrimeNode); + TSTALLOC(MESsourcePrimeSourcePrimePtr,MESsourcePrimeNode,MESsourcePrimeNode); } } return(OK); diff --git a/src/spicelib/devices/mesa/mesasetup.c b/src/spicelib/devices/mesa/mesasetup.c index c13cdf4eb..ed775721c 100644 --- a/src/spicelib/devices/mesa/mesasetup.c +++ b/src/spicelib/devices/mesa/mesasetup.c @@ -369,38 +369,38 @@ MESAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) } #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);\ -} +} } while(0) - TSTALLOC(MESAdrainDrainPtr,MESAdrainNode,MESAdrainNode) - TSTALLOC(MESAdrainPrimeDrainPrimePtr,MESAdrainPrimeNode,MESAdrainPrimeNode) - TSTALLOC(MESAdrainPrmPrmDrainPrmPrmPtr,MESAdrainPrmPrmNode,MESAdrainPrmPrmNode) - TSTALLOC(MESAgateGatePtr,MESAgateNode,MESAgateNode) - TSTALLOC(MESAgatePrimeGatePrimePtr,MESAgatePrimeNode,MESAgatePrimeNode) - TSTALLOC(MESAsourceSourcePtr,MESAsourceNode,MESAsourceNode) - TSTALLOC(MESAsourcePrimeSourcePrimePtr,MESAsourcePrimeNode,MESAsourcePrimeNode) - TSTALLOC(MESAsourcePrmPrmSourcePrmPrmPtr,MESAsourcePrmPrmNode,MESAsourcePrmPrmNode) - TSTALLOC(MESAdrainDrainPrimePtr,MESAdrainNode,MESAdrainPrimeNode) - TSTALLOC(MESAdrainPrimeDrainPtr,MESAdrainPrimeNode,MESAdrainNode) - TSTALLOC(MESAgatePrimeDrainPrimePtr,MESAgatePrimeNode,MESAdrainPrimeNode) - TSTALLOC(MESAdrainPrimeGatePrimePtr,MESAdrainPrimeNode,MESAgatePrimeNode) - TSTALLOC(MESAgatePrimeSourcePrimePtr,MESAgatePrimeNode,MESAsourcePrimeNode) - TSTALLOC(MESAsourcePrimeGatePrimePtr,MESAsourcePrimeNode,MESAgatePrimeNode) - TSTALLOC(MESAsourceSourcePrimePtr,MESAsourceNode,MESAsourcePrimeNode) - TSTALLOC(MESAsourcePrimeSourcePtr,MESAsourcePrimeNode,MESAsourceNode) - TSTALLOC(MESAdrainPrimeSourcePrimePtr,MESAdrainPrimeNode,MESAsourcePrimeNode) - TSTALLOC(MESAsourcePrimeDrainPrimePtr,MESAsourcePrimeNode,MESAdrainPrimeNode) - TSTALLOC(MESAgatePrimeGatePtr,MESAgatePrimeNode,MESAgateNode) - TSTALLOC(MESAgateGatePrimePtr,MESAgateNode,MESAgatePrimeNode) - TSTALLOC(MESAsourcePrmPrmSourcePrimePtr,MESAsourcePrmPrmNode,MESAsourcePrimeNode) - TSTALLOC(MESAsourcePrimeSourcePrmPrmPtr,MESAsourcePrimeNode,MESAsourcePrmPrmNode) - TSTALLOC(MESAsourcePrmPrmGatePrimePtr,MESAsourcePrmPrmNode,MESAgatePrimeNode) - TSTALLOC(MESAgatePrimeSourcePrmPrmPtr,MESAgatePrimeNode,MESAsourcePrmPrmNode) - TSTALLOC(MESAdrainPrmPrmDrainPrimePtr,MESAdrainPrmPrmNode,MESAdrainPrimeNode) - TSTALLOC(MESAdrainPrimeDrainPrmPrmPtr,MESAdrainPrimeNode,MESAdrainPrmPrmNode) - TSTALLOC(MESAdrainPrmPrmGatePrimePtr,MESAdrainPrmPrmNode,MESAgatePrimeNode) - TSTALLOC(MESAgatePrimeDrainPrmPrmPtr,MESAgatePrimeNode,MESAdrainPrmPrmNode) + TSTALLOC(MESAdrainDrainPtr,MESAdrainNode,MESAdrainNode); + TSTALLOC(MESAdrainPrimeDrainPrimePtr,MESAdrainPrimeNode,MESAdrainPrimeNode); + TSTALLOC(MESAdrainPrmPrmDrainPrmPrmPtr,MESAdrainPrmPrmNode,MESAdrainPrmPrmNode); + TSTALLOC(MESAgateGatePtr,MESAgateNode,MESAgateNode); + TSTALLOC(MESAgatePrimeGatePrimePtr,MESAgatePrimeNode,MESAgatePrimeNode); + TSTALLOC(MESAsourceSourcePtr,MESAsourceNode,MESAsourceNode); + TSTALLOC(MESAsourcePrimeSourcePrimePtr,MESAsourcePrimeNode,MESAsourcePrimeNode); + TSTALLOC(MESAsourcePrmPrmSourcePrmPrmPtr,MESAsourcePrmPrmNode,MESAsourcePrmPrmNode); + TSTALLOC(MESAdrainDrainPrimePtr,MESAdrainNode,MESAdrainPrimeNode); + TSTALLOC(MESAdrainPrimeDrainPtr,MESAdrainPrimeNode,MESAdrainNode); + TSTALLOC(MESAgatePrimeDrainPrimePtr,MESAgatePrimeNode,MESAdrainPrimeNode); + TSTALLOC(MESAdrainPrimeGatePrimePtr,MESAdrainPrimeNode,MESAgatePrimeNode); + TSTALLOC(MESAgatePrimeSourcePrimePtr,MESAgatePrimeNode,MESAsourcePrimeNode); + TSTALLOC(MESAsourcePrimeGatePrimePtr,MESAsourcePrimeNode,MESAgatePrimeNode) ; + TSTALLOC(MESAsourceSourcePrimePtr,MESAsourceNode,MESAsourcePrimeNode); + TSTALLOC(MESAsourcePrimeSourcePtr,MESAsourcePrimeNode,MESAsourceNode); + TSTALLOC(MESAdrainPrimeSourcePrimePtr,MESAdrainPrimeNode,MESAsourcePrimeNode); + TSTALLOC(MESAsourcePrimeDrainPrimePtr,MESAsourcePrimeNode,MESAdrainPrimeNode); + TSTALLOC(MESAgatePrimeGatePtr,MESAgatePrimeNode,MESAgateNode); + TSTALLOC(MESAgateGatePrimePtr,MESAgateNode,MESAgatePrimeNode); + TSTALLOC(MESAsourcePrmPrmSourcePrimePtr,MESAsourcePrmPrmNode,MESAsourcePrimeNode); + TSTALLOC(MESAsourcePrimeSourcePrmPrmPtr,MESAsourcePrimeNode,MESAsourcePrmPrmNode); + TSTALLOC(MESAsourcePrmPrmGatePrimePtr,MESAsourcePrmPrmNode,MESAgatePrimeNode); + TSTALLOC(MESAgatePrimeSourcePrmPrmPtr,MESAgatePrimeNode,MESAsourcePrmPrmNode); + TSTALLOC(MESAdrainPrmPrmDrainPrimePtr,MESAdrainPrmPrmNode,MESAdrainPrimeNode); + TSTALLOC(MESAdrainPrimeDrainPrmPrmPtr,MESAdrainPrimeNode,MESAdrainPrmPrmNode); + TSTALLOC(MESAdrainPrmPrmGatePrimePtr,MESAdrainPrmPrmNode,MESAgatePrimeNode); + TSTALLOC(MESAgatePrimeDrainPrmPrmPtr,MESAgatePrimeNode,MESAdrainPrmPrmNode); } } return(OK); diff --git a/src/spicelib/devices/mos1/mos1set.c b/src/spicelib/devices/mos1/mos1set.c index 32a4c37b9..521ff3fbf 100644 --- a/src/spicelib/devices/mos1/mos1set.c +++ b/src/spicelib/devices/mos1/mos1set.c @@ -180,31 +180,31 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, /* macro to make elements with built in test for out of memory */ #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);\ -} - TSTALLOC(MOS1DdPtr,MOS1dNode,MOS1dNode) - TSTALLOC(MOS1GgPtr,MOS1gNode,MOS1gNode) - TSTALLOC(MOS1SsPtr,MOS1sNode,MOS1sNode) - TSTALLOC(MOS1BbPtr,MOS1bNode,MOS1bNode) - TSTALLOC(MOS1DPdpPtr,MOS1dNodePrime,MOS1dNodePrime) - TSTALLOC(MOS1SPspPtr,MOS1sNodePrime,MOS1sNodePrime) - TSTALLOC(MOS1DdpPtr,MOS1dNode,MOS1dNodePrime) - TSTALLOC(MOS1GbPtr,MOS1gNode,MOS1bNode) - TSTALLOC(MOS1GdpPtr,MOS1gNode,MOS1dNodePrime) - TSTALLOC(MOS1GspPtr,MOS1gNode,MOS1sNodePrime) - TSTALLOC(MOS1SspPtr,MOS1sNode,MOS1sNodePrime) - TSTALLOC(MOS1BdpPtr,MOS1bNode,MOS1dNodePrime) - TSTALLOC(MOS1BspPtr,MOS1bNode,MOS1sNodePrime) - TSTALLOC(MOS1DPspPtr,MOS1dNodePrime,MOS1sNodePrime) - TSTALLOC(MOS1DPdPtr,MOS1dNodePrime,MOS1dNode) - TSTALLOC(MOS1BgPtr,MOS1bNode,MOS1gNode) - TSTALLOC(MOS1DPgPtr,MOS1dNodePrime,MOS1gNode) - TSTALLOC(MOS1SPgPtr,MOS1sNodePrime,MOS1gNode) - TSTALLOC(MOS1SPsPtr,MOS1sNodePrime,MOS1sNode) - TSTALLOC(MOS1DPbPtr,MOS1dNodePrime,MOS1bNode) - TSTALLOC(MOS1SPbPtr,MOS1sNodePrime,MOS1bNode) - TSTALLOC(MOS1SPdpPtr,MOS1sNodePrime,MOS1dNodePrime) +} } while(0) + TSTALLOC(MOS1DdPtr,MOS1dNode,MOS1dNode); + TSTALLOC(MOS1GgPtr,MOS1gNode,MOS1gNode); + TSTALLOC(MOS1SsPtr,MOS1sNode,MOS1sNode); + TSTALLOC(MOS1BbPtr,MOS1bNode,MOS1bNode); + TSTALLOC(MOS1DPdpPtr,MOS1dNodePrime,MOS1dNodePrime); + TSTALLOC(MOS1SPspPtr,MOS1sNodePrime,MOS1sNodePrime); + TSTALLOC(MOS1DdpPtr,MOS1dNode,MOS1dNodePrime); + TSTALLOC(MOS1GbPtr,MOS1gNode,MOS1bNode); + TSTALLOC(MOS1GdpPtr,MOS1gNode,MOS1dNodePrime); + TSTALLOC(MOS1GspPtr,MOS1gNode,MOS1sNodePrime); + TSTALLOC(MOS1SspPtr,MOS1sNode,MOS1sNodePrime); + TSTALLOC(MOS1BdpPtr,MOS1bNode,MOS1dNodePrime); + TSTALLOC(MOS1BspPtr,MOS1bNode,MOS1sNodePrime); + TSTALLOC(MOS1DPspPtr,MOS1dNodePrime,MOS1sNodePrime); + TSTALLOC(MOS1DPdPtr,MOS1dNodePrime,MOS1dNode); + TSTALLOC(MOS1BgPtr,MOS1bNode,MOS1gNode); + TSTALLOC(MOS1DPgPtr,MOS1dNodePrime,MOS1gNode); + TSTALLOC(MOS1SPgPtr,MOS1sNodePrime,MOS1gNode); + TSTALLOC(MOS1SPsPtr,MOS1sNodePrime,MOS1sNode); + TSTALLOC(MOS1DPbPtr,MOS1dNodePrime,MOS1bNode); + TSTALLOC(MOS1SPbPtr,MOS1sNodePrime,MOS1bNode); + TSTALLOC(MOS1SPdpPtr,MOS1sNodePrime,MOS1dNodePrime); } } diff --git a/src/spicelib/devices/mos2/mos2set.c b/src/spicelib/devices/mos2/mos2set.c index 3bf2fb4ba..c86daaf37 100644 --- a/src/spicelib/devices/mos2/mos2set.c +++ b/src/spicelib/devices/mos2/mos2set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(MOS2DdPtr, MOS2dNode, MOS2dNode) - TSTALLOC(MOS2GgPtr, MOS2gNode, MOS2gNode) - TSTALLOC(MOS2SsPtr, MOS2sNode, MOS2sNode) - TSTALLOC(MOS2BbPtr, MOS2bNode, MOS2bNode) - TSTALLOC(MOS2DPdpPtr, MOS2dNodePrime, MOS2dNodePrime) - TSTALLOC(MOS2SPspPtr, MOS2sNodePrime, MOS2sNodePrime) - TSTALLOC(MOS2DdpPtr, MOS2dNode, MOS2dNodePrime) - TSTALLOC(MOS2GbPtr, MOS2gNode, MOS2bNode) - TSTALLOC(MOS2GdpPtr, MOS2gNode, MOS2dNodePrime) - TSTALLOC(MOS2GspPtr, MOS2gNode, MOS2sNodePrime) - TSTALLOC(MOS2SspPtr, MOS2sNode, MOS2sNodePrime) - TSTALLOC(MOS2BdpPtr, MOS2bNode, MOS2dNodePrime) - TSTALLOC(MOS2BspPtr, MOS2bNode, MOS2sNodePrime) - TSTALLOC(MOS2DPspPtr, MOS2dNodePrime, MOS2sNodePrime) - TSTALLOC(MOS2DPdPtr, MOS2dNodePrime, MOS2dNode) - TSTALLOC(MOS2BgPtr, MOS2bNode, MOS2gNode) - TSTALLOC(MOS2DPgPtr, MOS2dNodePrime, MOS2gNode) - TSTALLOC(MOS2SPgPtr, MOS2sNodePrime, MOS2gNode) - TSTALLOC(MOS2SPsPtr, MOS2sNodePrime, MOS2sNode) - TSTALLOC(MOS2DPbPtr, MOS2dNodePrime, MOS2bNode) - TSTALLOC(MOS2SPbPtr, MOS2sNodePrime, MOS2bNode) - TSTALLOC(MOS2SPdpPtr, MOS2sNodePrime, MOS2dNodePrime) + TSTALLOC(MOS2DdPtr, MOS2dNode, MOS2dNode); + TSTALLOC(MOS2GgPtr, MOS2gNode, MOS2gNode); + TSTALLOC(MOS2SsPtr, MOS2sNode, MOS2sNode); + TSTALLOC(MOS2BbPtr, MOS2bNode, MOS2bNode); + TSTALLOC(MOS2DPdpPtr, MOS2dNodePrime, MOS2dNodePrime); + TSTALLOC(MOS2SPspPtr, MOS2sNodePrime, MOS2sNodePrime); + TSTALLOC(MOS2DdpPtr, MOS2dNode, MOS2dNodePrime); + TSTALLOC(MOS2GbPtr, MOS2gNode, MOS2bNode); + TSTALLOC(MOS2GdpPtr, MOS2gNode, MOS2dNodePrime); + TSTALLOC(MOS2GspPtr, MOS2gNode, MOS2sNodePrime); + TSTALLOC(MOS2SspPtr, MOS2sNode, MOS2sNodePrime); + TSTALLOC(MOS2BdpPtr, MOS2bNode, MOS2dNodePrime); + TSTALLOC(MOS2BspPtr, MOS2bNode, MOS2sNodePrime); + TSTALLOC(MOS2DPspPtr, MOS2dNodePrime, MOS2sNodePrime); + TSTALLOC(MOS2DPdPtr, MOS2dNodePrime, MOS2dNode); + TSTALLOC(MOS2BgPtr, MOS2bNode, MOS2gNode); + TSTALLOC(MOS2DPgPtr, MOS2dNodePrime, MOS2gNode); + TSTALLOC(MOS2SPgPtr, MOS2sNodePrime, MOS2gNode); + TSTALLOC(MOS2SPsPtr, MOS2sNodePrime, MOS2sNode); + TSTALLOC(MOS2DPbPtr, MOS2dNodePrime, MOS2bNode); + TSTALLOC(MOS2SPbPtr, MOS2sNodePrime, MOS2bNode); + TSTALLOC(MOS2SPdpPtr, MOS2sNodePrime, MOS2dNodePrime); } } diff --git a/src/spicelib/devices/mos3/mos3set.c b/src/spicelib/devices/mos3/mos3set.c index 334160723..5ff4ca879 100644 --- a/src/spicelib/devices/mos3/mos3set.c +++ b/src/spicelib/devices/mos3/mos3set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(MOS3DdPtr, MOS3dNode, MOS3dNode) - TSTALLOC(MOS3GgPtr, MOS3gNode, MOS3gNode) - TSTALLOC(MOS3SsPtr, MOS3sNode, MOS3sNode) - TSTALLOC(MOS3BbPtr, MOS3bNode, MOS3bNode) - TSTALLOC(MOS3DPdpPtr, MOS3dNodePrime, MOS3dNodePrime) - TSTALLOC(MOS3SPspPtr, MOS3sNodePrime, MOS3sNodePrime) - TSTALLOC(MOS3DdpPtr, MOS3dNode, MOS3dNodePrime) - TSTALLOC(MOS3GbPtr, MOS3gNode, MOS3bNode) - TSTALLOC(MOS3GdpPtr, MOS3gNode, MOS3dNodePrime) - TSTALLOC(MOS3GspPtr, MOS3gNode, MOS3sNodePrime) - TSTALLOC(MOS3SspPtr, MOS3sNode, MOS3sNodePrime) - TSTALLOC(MOS3BdpPtr, MOS3bNode, MOS3dNodePrime) - TSTALLOC(MOS3BspPtr, MOS3bNode, MOS3sNodePrime) - TSTALLOC(MOS3DPspPtr, MOS3dNodePrime, MOS3sNodePrime) - TSTALLOC(MOS3DPdPtr, MOS3dNodePrime, MOS3dNode) - TSTALLOC(MOS3BgPtr, MOS3bNode, MOS3gNode) - TSTALLOC(MOS3DPgPtr, MOS3dNodePrime, MOS3gNode) - TSTALLOC(MOS3SPgPtr, MOS3sNodePrime, MOS3gNode) - TSTALLOC(MOS3SPsPtr, MOS3sNodePrime, MOS3sNode) - TSTALLOC(MOS3DPbPtr, MOS3dNodePrime, MOS3bNode) - TSTALLOC(MOS3SPbPtr, MOS3sNodePrime, MOS3bNode) - TSTALLOC(MOS3SPdpPtr, MOS3sNodePrime, MOS3dNodePrime) + TSTALLOC(MOS3DdPtr, MOS3dNode, MOS3dNode); + TSTALLOC(MOS3GgPtr, MOS3gNode, MOS3gNode); + TSTALLOC(MOS3SsPtr, MOS3sNode, MOS3sNode); + TSTALLOC(MOS3BbPtr, MOS3bNode, MOS3bNode); + TSTALLOC(MOS3DPdpPtr, MOS3dNodePrime, MOS3dNodePrime); + TSTALLOC(MOS3SPspPtr, MOS3sNodePrime, MOS3sNodePrime); + TSTALLOC(MOS3DdpPtr, MOS3dNode, MOS3dNodePrime); + TSTALLOC(MOS3GbPtr, MOS3gNode, MOS3bNode); + TSTALLOC(MOS3GdpPtr, MOS3gNode, MOS3dNodePrime); + TSTALLOC(MOS3GspPtr, MOS3gNode, MOS3sNodePrime); + TSTALLOC(MOS3SspPtr, MOS3sNode, MOS3sNodePrime); + TSTALLOC(MOS3BdpPtr, MOS3bNode, MOS3dNodePrime); + TSTALLOC(MOS3BspPtr, MOS3bNode, MOS3sNodePrime); + TSTALLOC(MOS3DPspPtr, MOS3dNodePrime, MOS3sNodePrime); + TSTALLOC(MOS3DPdPtr, MOS3dNodePrime, MOS3dNode); + TSTALLOC(MOS3BgPtr, MOS3bNode, MOS3gNode); + TSTALLOC(MOS3DPgPtr, MOS3dNodePrime, MOS3gNode); + TSTALLOC(MOS3SPgPtr, MOS3sNodePrime, MOS3gNode); + TSTALLOC(MOS3SPsPtr, MOS3sNodePrime, MOS3sNode); + TSTALLOC(MOS3DPbPtr, MOS3dNodePrime, MOS3bNode); + TSTALLOC(MOS3SPbPtr, MOS3sNodePrime, MOS3bNode); + TSTALLOC(MOS3SPdpPtr, MOS3sNodePrime, MOS3dNodePrime); } } diff --git a/src/spicelib/devices/mos6/mos6set.c b/src/spicelib/devices/mos6/mos6set.c index 28554c50f..8a1cd3d80 100644 --- a/src/spicelib/devices/mos6/mos6set.c +++ b/src/spicelib/devices/mos6/mos6set.c @@ -189,32 +189,32 @@ MOS6setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, } /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(MOS6DdPtr,MOS6dNode,MOS6dNode) - TSTALLOC(MOS6GgPtr,MOS6gNode,MOS6gNode) - TSTALLOC(MOS6SsPtr,MOS6sNode,MOS6sNode) - TSTALLOC(MOS6BbPtr,MOS6bNode,MOS6bNode) - TSTALLOC(MOS6DPdpPtr,MOS6dNodePrime,MOS6dNodePrime) - TSTALLOC(MOS6SPspPtr,MOS6sNodePrime,MOS6sNodePrime) - TSTALLOC(MOS6DdpPtr,MOS6dNode,MOS6dNodePrime) - TSTALLOC(MOS6GbPtr,MOS6gNode,MOS6bNode) - TSTALLOC(MOS6GdpPtr,MOS6gNode,MOS6dNodePrime) - TSTALLOC(MOS6GspPtr,MOS6gNode,MOS6sNodePrime) - TSTALLOC(MOS6SspPtr,MOS6sNode,MOS6sNodePrime) - TSTALLOC(MOS6BdpPtr,MOS6bNode,MOS6dNodePrime) - TSTALLOC(MOS6BspPtr,MOS6bNode,MOS6sNodePrime) - TSTALLOC(MOS6DPspPtr,MOS6dNodePrime,MOS6sNodePrime) - TSTALLOC(MOS6DPdPtr,MOS6dNodePrime,MOS6dNode) - TSTALLOC(MOS6BgPtr,MOS6bNode,MOS6gNode) - TSTALLOC(MOS6DPgPtr,MOS6dNodePrime,MOS6gNode) - TSTALLOC(MOS6SPgPtr,MOS6sNodePrime,MOS6gNode) - TSTALLOC(MOS6SPsPtr,MOS6sNodePrime,MOS6sNode) - TSTALLOC(MOS6DPbPtr,MOS6dNodePrime,MOS6bNode) - TSTALLOC(MOS6SPbPtr,MOS6sNodePrime,MOS6bNode) - TSTALLOC(MOS6SPdpPtr,MOS6sNodePrime,MOS6dNodePrime) + TSTALLOC(MOS6DdPtr,MOS6dNode,MOS6dNode); + TSTALLOC(MOS6GgPtr,MOS6gNode,MOS6gNode); + TSTALLOC(MOS6SsPtr,MOS6sNode,MOS6sNode); + TSTALLOC(MOS6BbPtr,MOS6bNode,MOS6bNode); + TSTALLOC(MOS6DPdpPtr,MOS6dNodePrime,MOS6dNodePrime); + TSTALLOC(MOS6SPspPtr,MOS6sNodePrime,MOS6sNodePrime); + TSTALLOC(MOS6DdpPtr,MOS6dNode,MOS6dNodePrime); + TSTALLOC(MOS6GbPtr,MOS6gNode,MOS6bNode); + TSTALLOC(MOS6GdpPtr,MOS6gNode,MOS6dNodePrime); + TSTALLOC(MOS6GspPtr,MOS6gNode,MOS6sNodePrime); + TSTALLOC(MOS6SspPtr,MOS6sNode,MOS6sNodePrime); + TSTALLOC(MOS6BdpPtr,MOS6bNode,MOS6dNodePrime); + TSTALLOC(MOS6BspPtr,MOS6bNode,MOS6sNodePrime); + TSTALLOC(MOS6DPspPtr,MOS6dNodePrime,MOS6sNodePrime); + TSTALLOC(MOS6DPdPtr,MOS6dNodePrime,MOS6dNode); + TSTALLOC(MOS6BgPtr,MOS6bNode,MOS6gNode); + TSTALLOC(MOS6DPgPtr,MOS6dNodePrime,MOS6gNode); + TSTALLOC(MOS6SPgPtr,MOS6sNodePrime,MOS6gNode); + TSTALLOC(MOS6SPsPtr,MOS6sNodePrime,MOS6sNode); + TSTALLOC(MOS6DPbPtr,MOS6dNodePrime,MOS6bNode); + TSTALLOC(MOS6SPbPtr,MOS6sNodePrime,MOS6bNode); + TSTALLOC(MOS6SPdpPtr,MOS6sNodePrime,MOS6dNodePrime); } } diff --git a/src/spicelib/devices/mos9/mos9set.c b/src/spicelib/devices/mos9/mos9set.c index 129ebccfe..b32c91b2a 100644 --- a/src/spicelib/devices/mos9/mos9set.c +++ b/src/spicelib/devices/mos9/mos9set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(MOS9DdPtr, MOS9dNode, MOS9dNode) - TSTALLOC(MOS9GgPtr, MOS9gNode, MOS9gNode) - TSTALLOC(MOS9SsPtr, MOS9sNode, MOS9sNode) - TSTALLOC(MOS9BbPtr, MOS9bNode, MOS9bNode) - TSTALLOC(MOS9DPdpPtr, MOS9dNodePrime, MOS9dNodePrime) - TSTALLOC(MOS9SPspPtr, MOS9sNodePrime, MOS9sNodePrime) - TSTALLOC(MOS9DdpPtr, MOS9dNode, MOS9dNodePrime) - TSTALLOC(MOS9GbPtr, MOS9gNode, MOS9bNode) - TSTALLOC(MOS9GdpPtr, MOS9gNode, MOS9dNodePrime) - TSTALLOC(MOS9GspPtr, MOS9gNode, MOS9sNodePrime) - TSTALLOC(MOS9SspPtr, MOS9sNode, MOS9sNodePrime) - TSTALLOC(MOS9BdpPtr, MOS9bNode, MOS9dNodePrime) - TSTALLOC(MOS9BspPtr, MOS9bNode, MOS9sNodePrime) - TSTALLOC(MOS9DPspPtr, MOS9dNodePrime, MOS9sNodePrime) - TSTALLOC(MOS9DPdPtr, MOS9dNodePrime, MOS9dNode) - TSTALLOC(MOS9BgPtr, MOS9bNode, MOS9gNode) - TSTALLOC(MOS9DPgPtr, MOS9dNodePrime, MOS9gNode) - TSTALLOC(MOS9SPgPtr, MOS9sNodePrime, MOS9gNode) - TSTALLOC(MOS9SPsPtr, MOS9sNodePrime, MOS9sNode) - TSTALLOC(MOS9DPbPtr, MOS9dNodePrime, MOS9bNode) - TSTALLOC(MOS9SPbPtr, MOS9sNodePrime, MOS9bNode) - TSTALLOC(MOS9SPdpPtr, MOS9sNodePrime, MOS9dNodePrime) + TSTALLOC(MOS9DdPtr, MOS9dNode, MOS9dNode); + TSTALLOC(MOS9GgPtr, MOS9gNode, MOS9gNode); + TSTALLOC(MOS9SsPtr, MOS9sNode, MOS9sNode); + TSTALLOC(MOS9BbPtr, MOS9bNode, MOS9bNode); + TSTALLOC(MOS9DPdpPtr, MOS9dNodePrime, MOS9dNodePrime); + TSTALLOC(MOS9SPspPtr, MOS9sNodePrime, MOS9sNodePrime); + TSTALLOC(MOS9DdpPtr, MOS9dNode, MOS9dNodePrime); + TSTALLOC(MOS9GbPtr, MOS9gNode, MOS9bNode); + TSTALLOC(MOS9GdpPtr, MOS9gNode, MOS9dNodePrime); + TSTALLOC(MOS9GspPtr, MOS9gNode, MOS9sNodePrime); + TSTALLOC(MOS9SspPtr, MOS9sNode, MOS9sNodePrime); + TSTALLOC(MOS9BdpPtr, MOS9bNode, MOS9dNodePrime); + TSTALLOC(MOS9BspPtr, MOS9bNode, MOS9sNodePrime); + TSTALLOC(MOS9DPspPtr, MOS9dNodePrime, MOS9sNodePrime); + TSTALLOC(MOS9DPdPtr, MOS9dNodePrime, MOS9dNode); + TSTALLOC(MOS9BgPtr, MOS9bNode, MOS9gNode); + TSTALLOC(MOS9DPgPtr, MOS9dNodePrime, MOS9gNode); + TSTALLOC(MOS9SPgPtr, MOS9sNodePrime, MOS9gNode); + TSTALLOC(MOS9SPsPtr, MOS9sNodePrime, MOS9sNode); + TSTALLOC(MOS9DPbPtr, MOS9dNodePrime, MOS9bNode); + TSTALLOC(MOS9SPbPtr, MOS9sNodePrime, MOS9bNode); + TSTALLOC(MOS9SPdpPtr, MOS9sNodePrime, MOS9dNodePrime); } } diff --git a/src/spicelib/devices/nbjt/nbjtset.c b/src/spicelib/devices/nbjt/nbjtset.c index b9da8fb7a..110a57a09 100644 --- a/src/spicelib/devices/nbjt/nbjtset.c +++ b/src/spicelib/devices/nbjt/nbjtset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(NBJTcolColPtr, NBJTcolNode, NBJTcolNode) - TSTALLOC(NBJTbaseBasePtr, NBJTbaseNode, NBJTbaseNode) - TSTALLOC(NBJTemitEmitPtr, NBJTemitNode, NBJTemitNode) - TSTALLOC(NBJTcolBasePtr, NBJTcolNode, NBJTbaseNode) - TSTALLOC(NBJTcolEmitPtr, NBJTcolNode, NBJTemitNode) - TSTALLOC(NBJTbaseColPtr, NBJTbaseNode, NBJTcolNode) - TSTALLOC(NBJTbaseEmitPtr, NBJTbaseNode, NBJTemitNode) - TSTALLOC(NBJTemitColPtr, NBJTemitNode, NBJTcolNode) - TSTALLOC(NBJTemitBasePtr, NBJTemitNode, NBJTbaseNode) + TSTALLOC(NBJTcolColPtr, NBJTcolNode, NBJTcolNode); + TSTALLOC(NBJTbaseBasePtr, NBJTbaseNode, NBJTbaseNode); + TSTALLOC(NBJTemitEmitPtr, NBJTemitNode, NBJTemitNode); + TSTALLOC(NBJTcolBasePtr, NBJTcolNode, NBJTbaseNode); + TSTALLOC(NBJTcolEmitPtr, NBJTcolNode, NBJTemitNode); + TSTALLOC(NBJTbaseColPtr, NBJTbaseNode, NBJTcolNode); + TSTALLOC(NBJTbaseEmitPtr, NBJTbaseNode, NBJTemitNode); + TSTALLOC(NBJTemitColPtr, NBJTemitNode, NBJTcolNode); + TSTALLOC(NBJTemitBasePtr, NBJTemitNode, NBJTbaseNode); } /* Clean up lists */ killCoordInfo(xCoordList); diff --git a/src/spicelib/devices/nbjt2/nbt2set.c b/src/spicelib/devices/nbjt2/nbt2set.c index 385fcc5b6..231ee561d 100644 --- a/src/spicelib/devices/nbjt2/nbt2set.c +++ b/src/spicelib/devices/nbjt2/nbt2set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(NBJT2colColPtr, NBJT2colNode, NBJT2colNode) - TSTALLOC(NBJT2colBasePtr, NBJT2colNode, NBJT2baseNode) - TSTALLOC(NBJT2colEmitPtr, NBJT2colNode, NBJT2emitNode) - TSTALLOC(NBJT2baseColPtr, NBJT2baseNode, NBJT2colNode) - TSTALLOC(NBJT2baseBasePtr, NBJT2baseNode, NBJT2baseNode) - TSTALLOC(NBJT2baseEmitPtr, NBJT2baseNode, NBJT2emitNode) - TSTALLOC(NBJT2emitColPtr, NBJT2emitNode, NBJT2colNode) - TSTALLOC(NBJT2emitBasePtr, NBJT2emitNode, NBJT2baseNode) - TSTALLOC(NBJT2emitEmitPtr, NBJT2emitNode, NBJT2emitNode) + TSTALLOC(NBJT2colColPtr, NBJT2colNode, NBJT2colNode); + TSTALLOC(NBJT2colBasePtr, NBJT2colNode, NBJT2baseNode); + TSTALLOC(NBJT2colEmitPtr, NBJT2colNode, NBJT2emitNode); + TSTALLOC(NBJT2baseColPtr, NBJT2baseNode, NBJT2colNode); + TSTALLOC(NBJT2baseBasePtr, NBJT2baseNode, NBJT2baseNode); + TSTALLOC(NBJT2baseEmitPtr, NBJT2baseNode, NBJT2emitNode); + TSTALLOC(NBJT2emitColPtr, NBJT2emitNode, NBJT2colNode); + TSTALLOC(NBJT2emitBasePtr, NBJT2emitNode, NBJT2baseNode); + TSTALLOC(NBJT2emitEmitPtr, NBJT2emitNode, NBJT2emitNode); } /* Clean up lists */ killCoordInfo(xCoordList); diff --git a/src/spicelib/devices/ndev/ndevset.c b/src/spicelib/devices/ndev/ndevset.c index 9f7e0ecd4..b6fe6b484 100644 --- a/src/spicelib/devices/ndev/ndevset.c +++ b/src/spicelib/devices/ndev/ndevset.c @@ -51,9 +51,9 @@ int NDEVsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states send(model->sock,&(here->Ndevinfo),sizeof(here->Ndevinfo),0); /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) for(i=0;iterm;i++) for(j=0;jterm;j++) diff --git a/src/spicelib/devices/numd/numdset.c b/src/spicelib/devices/numd/numdset.c index 5e4108e91..027a68db7 100644 --- a/src/spicelib/devices/numd/numdset.c +++ b/src/spicelib/devices/numd/numdset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(NUMDposPosPtr, NUMDposNode, NUMDposNode) - TSTALLOC(NUMDnegNegPtr, NUMDnegNode, NUMDnegNode) - TSTALLOC(NUMDnegPosPtr, NUMDnegNode, NUMDposNode) - TSTALLOC(NUMDposNegPtr, NUMDposNode, NUMDnegNode) + TSTALLOC(NUMDposPosPtr, NUMDposNode, NUMDposNode); + TSTALLOC(NUMDnegNegPtr, NUMDnegNode, NUMDnegNode); + TSTALLOC(NUMDnegPosPtr, NUMDnegNode, NUMDposNode); + TSTALLOC(NUMDposNegPtr, NUMDposNode, NUMDnegNode); } /* Clean up lists */ killCoordInfo(xCoordList); diff --git a/src/spicelib/devices/numd2/nud2set.c b/src/spicelib/devices/numd2/nud2set.c index 521fec661..fde80d7ad 100644 --- a/src/spicelib/devices/numd2/nud2set.c +++ b/src/spicelib/devices/numd2/nud2set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(NUMD2posPosPtr, NUMD2posNode, NUMD2posNode) - TSTALLOC(NUMD2negNegPtr, NUMD2negNode, NUMD2negNode) - TSTALLOC(NUMD2negPosPtr, NUMD2negNode, NUMD2posNode) - TSTALLOC(NUMD2posNegPtr, NUMD2posNode, NUMD2negNode) + TSTALLOC(NUMD2posPosPtr, NUMD2posNode, NUMD2posNode); + TSTALLOC(NUMD2negNegPtr, NUMD2negNode, NUMD2negNode); + TSTALLOC(NUMD2negPosPtr, NUMD2negNode, NUMD2posNode); + TSTALLOC(NUMD2posNegPtr, NUMD2posNode, NUMD2negNode); } /* Clean up lists */ killCoordInfo(xCoordList); diff --git a/src/spicelib/devices/numos/nummset.c b/src/spicelib/devices/numos/nummset.c index 895901ba8..4d1af7282 100644 --- a/src/spicelib/devices/numos/nummset.c +++ b/src/spicelib/devices/numos/nummset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(NUMOSdrainDrainPtr, NUMOSdrainNode, NUMOSdrainNode) - TSTALLOC(NUMOSdrainSourcePtr, NUMOSdrainNode, NUMOSsourceNode) - TSTALLOC(NUMOSdrainGatePtr, NUMOSdrainNode, NUMOSgateNode) - TSTALLOC(NUMOSdrainBulkPtr, NUMOSdrainNode, NUMOSbulkNode) - TSTALLOC(NUMOSsourceDrainPtr, NUMOSsourceNode, NUMOSdrainNode) - TSTALLOC(NUMOSsourceSourcePtr, NUMOSsourceNode, NUMOSsourceNode) - TSTALLOC(NUMOSsourceGatePtr, NUMOSsourceNode, NUMOSgateNode) - TSTALLOC(NUMOSsourceBulkPtr, NUMOSsourceNode, NUMOSbulkNode) - TSTALLOC(NUMOSgateDrainPtr, NUMOSgateNode, NUMOSdrainNode) - TSTALLOC(NUMOSgateSourcePtr, NUMOSgateNode, NUMOSsourceNode) - TSTALLOC(NUMOSgateGatePtr, NUMOSgateNode, NUMOSgateNode) - TSTALLOC(NUMOSgateBulkPtr, NUMOSgateNode, NUMOSbulkNode) - TSTALLOC(NUMOSbulkDrainPtr, NUMOSbulkNode, NUMOSdrainNode) - TSTALLOC(NUMOSbulkSourcePtr, NUMOSbulkNode, NUMOSsourceNode) - TSTALLOC(NUMOSbulkGatePtr, NUMOSbulkNode, NUMOSgateNode) - TSTALLOC(NUMOSbulkBulkPtr, NUMOSbulkNode, NUMOSbulkNode) + TSTALLOC(NUMOSdrainDrainPtr, NUMOSdrainNode, NUMOSdrainNode); + TSTALLOC(NUMOSdrainSourcePtr, NUMOSdrainNode, NUMOSsourceNode); + TSTALLOC(NUMOSdrainGatePtr, NUMOSdrainNode, NUMOSgateNode); + TSTALLOC(NUMOSdrainBulkPtr, NUMOSdrainNode, NUMOSbulkNode); + TSTALLOC(NUMOSsourceDrainPtr, NUMOSsourceNode, NUMOSdrainNode); + TSTALLOC(NUMOSsourceSourcePtr, NUMOSsourceNode, NUMOSsourceNode); + TSTALLOC(NUMOSsourceGatePtr, NUMOSsourceNode, NUMOSgateNode); + TSTALLOC(NUMOSsourceBulkPtr, NUMOSsourceNode, NUMOSbulkNode); + TSTALLOC(NUMOSgateDrainPtr, NUMOSgateNode, NUMOSdrainNode); + TSTALLOC(NUMOSgateSourcePtr, NUMOSgateNode, NUMOSsourceNode); + TSTALLOC(NUMOSgateGatePtr, NUMOSgateNode, NUMOSgateNode); + TSTALLOC(NUMOSgateBulkPtr, NUMOSgateNode, NUMOSbulkNode); + TSTALLOC(NUMOSbulkDrainPtr, NUMOSbulkNode, NUMOSdrainNode); + TSTALLOC(NUMOSbulkSourcePtr, NUMOSbulkNode, NUMOSsourceNode); + TSTALLOC(NUMOSbulkGatePtr, NUMOSbulkNode, NUMOSgateNode); + TSTALLOC(NUMOSbulkBulkPtr, NUMOSbulkNode, NUMOSbulkNode); } /* Clean up lists */ killCoordInfo(xCoordList); diff --git a/src/spicelib/devices/res/ressetup.c b/src/spicelib/devices/res/ressetup.c index 80c7c0e5b..0b70e4e7d 100644 --- a/src/spicelib/devices/res/ressetup.c +++ b/src/spicelib/devices/res/ressetup.c @@ -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 */ #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);\ -} +} } while(0) TSTALLOC(RESposPosptr, RESposNode, RESposNode); TSTALLOC(RESnegNegptr, RESnegNode, RESnegNode); diff --git a/src/spicelib/devices/soi3/soi3set.c b/src/spicelib/devices/soi3/soi3set.c index 4eb10b95b..879852314 100644 --- a/src/spicelib/devices/soi3/soi3set.c +++ b/src/spicelib/devices/soi3/soi3set.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(SOI3D_dPtr,SOI3dNode,SOI3dNode) - TSTALLOC(SOI3D_dpPtr,SOI3dNode,SOI3dNodePrime) - TSTALLOC(SOI3DP_dPtr,SOI3dNodePrime,SOI3dNode) + TSTALLOC(SOI3D_dPtr,SOI3dNode,SOI3dNode); + TSTALLOC(SOI3D_dpPtr,SOI3dNode,SOI3dNodePrime); + TSTALLOC(SOI3DP_dPtr,SOI3dNodePrime,SOI3dNode); - TSTALLOC(SOI3S_sPtr,SOI3sNode,SOI3sNode) - TSTALLOC(SOI3S_spPtr,SOI3sNode,SOI3sNodePrime) - TSTALLOC(SOI3SP_sPtr,SOI3sNodePrime,SOI3sNode) + TSTALLOC(SOI3S_sPtr,SOI3sNode,SOI3sNode); + TSTALLOC(SOI3S_spPtr,SOI3sNode,SOI3sNodePrime); + TSTALLOC(SOI3SP_sPtr,SOI3sNodePrime,SOI3sNode); - TSTALLOC(SOI3GF_gfPtr,SOI3gfNode,SOI3gfNode) - TSTALLOC(SOI3GF_gbPtr,SOI3gfNode,SOI3gbNode) - TSTALLOC(SOI3GF_dpPtr,SOI3gfNode,SOI3dNodePrime) - TSTALLOC(SOI3GF_spPtr,SOI3gfNode,SOI3sNodePrime) - TSTALLOC(SOI3GF_bPtr,SOI3gfNode,SOI3bNode) + TSTALLOC(SOI3GF_gfPtr,SOI3gfNode,SOI3gfNode); + TSTALLOC(SOI3GF_gbPtr,SOI3gfNode,SOI3gbNode); + TSTALLOC(SOI3GF_dpPtr,SOI3gfNode,SOI3dNodePrime); + TSTALLOC(SOI3GF_spPtr,SOI3gfNode,SOI3sNodePrime); + TSTALLOC(SOI3GF_bPtr,SOI3gfNode,SOI3bNode); - TSTALLOC(SOI3GB_gfPtr,SOI3gbNode,SOI3gfNode) - TSTALLOC(SOI3GB_gbPtr,SOI3gbNode,SOI3gbNode) - TSTALLOC(SOI3GB_dpPtr,SOI3gbNode,SOI3dNodePrime) - TSTALLOC(SOI3GB_spPtr,SOI3gbNode,SOI3sNodePrime) - TSTALLOC(SOI3GB_bPtr,SOI3gbNode,SOI3bNode) + TSTALLOC(SOI3GB_gfPtr,SOI3gbNode,SOI3gfNode); + TSTALLOC(SOI3GB_gbPtr,SOI3gbNode,SOI3gbNode); + TSTALLOC(SOI3GB_dpPtr,SOI3gbNode,SOI3dNodePrime); + TSTALLOC(SOI3GB_spPtr,SOI3gbNode,SOI3sNodePrime); + TSTALLOC(SOI3GB_bPtr,SOI3gbNode,SOI3bNode); - TSTALLOC(SOI3B_gfPtr,SOI3bNode,SOI3gfNode) - TSTALLOC(SOI3B_gbPtr,SOI3bNode,SOI3gbNode) - TSTALLOC(SOI3B_dpPtr,SOI3bNode,SOI3dNodePrime) - TSTALLOC(SOI3B_spPtr,SOI3bNode,SOI3sNodePrime) - TSTALLOC(SOI3B_bPtr,SOI3bNode,SOI3bNode) + TSTALLOC(SOI3B_gfPtr,SOI3bNode,SOI3gfNode); + TSTALLOC(SOI3B_gbPtr,SOI3bNode,SOI3gbNode); + TSTALLOC(SOI3B_dpPtr,SOI3bNode,SOI3dNodePrime); + TSTALLOC(SOI3B_spPtr,SOI3bNode,SOI3sNodePrime); + TSTALLOC(SOI3B_bPtr,SOI3bNode,SOI3bNode); - TSTALLOC(SOI3DP_gfPtr,SOI3dNodePrime,SOI3gfNode) - TSTALLOC(SOI3DP_gbPtr,SOI3dNodePrime,SOI3gbNode) - TSTALLOC(SOI3DP_dpPtr,SOI3dNodePrime,SOI3dNodePrime) - TSTALLOC(SOI3DP_spPtr,SOI3dNodePrime,SOI3sNodePrime) - TSTALLOC(SOI3DP_bPtr,SOI3dNodePrime,SOI3bNode) + TSTALLOC(SOI3DP_gfPtr,SOI3dNodePrime,SOI3gfNode); + TSTALLOC(SOI3DP_gbPtr,SOI3dNodePrime,SOI3gbNode); + TSTALLOC(SOI3DP_dpPtr,SOI3dNodePrime,SOI3dNodePrime); + TSTALLOC(SOI3DP_spPtr,SOI3dNodePrime,SOI3sNodePrime); + TSTALLOC(SOI3DP_bPtr,SOI3dNodePrime,SOI3bNode); - TSTALLOC(SOI3SP_gfPtr,SOI3sNodePrime,SOI3gfNode) - TSTALLOC(SOI3SP_gbPtr,SOI3sNodePrime,SOI3gbNode) - TSTALLOC(SOI3SP_dpPtr,SOI3sNodePrime,SOI3dNodePrime) - TSTALLOC(SOI3SP_spPtr,SOI3sNodePrime,SOI3sNodePrime) - TSTALLOC(SOI3SP_bPtr,SOI3sNodePrime,SOI3bNode) + TSTALLOC(SOI3SP_gfPtr,SOI3sNodePrime,SOI3gfNode); + TSTALLOC(SOI3SP_gbPtr,SOI3sNodePrime,SOI3gbNode); + TSTALLOC(SOI3SP_dpPtr,SOI3sNodePrime,SOI3dNodePrime); + TSTALLOC(SOI3SP_spPtr,SOI3sNodePrime,SOI3sNodePrime); + TSTALLOC(SOI3SP_bPtr,SOI3sNodePrime,SOI3bNode); if (here->SOI3rt == 0) { - TSTALLOC(SOI3TOUT_ibrPtr,SOI3toutNode,SOI3branch) - TSTALLOC(SOI3IBR_toutPtr,SOI3branch,SOI3toutNode) + TSTALLOC(SOI3TOUT_ibrPtr,SOI3toutNode,SOI3branch); + TSTALLOC(SOI3IBR_toutPtr,SOI3branch,SOI3toutNode); } else { - TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode) + TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode); if (here->SOI3numThermalNodes > 1) { - TSTALLOC(SOI3TOUT_tout1Ptr,SOI3toutNode,SOI3tout1Node) - TSTALLOC(SOI3TOUT1_toutPtr,SOI3tout1Node,SOI3toutNode) - TSTALLOC(SOI3TOUT1_tout1Ptr,SOI3tout1Node,SOI3tout1Node) + TSTALLOC(SOI3TOUT_tout1Ptr,SOI3toutNode,SOI3tout1Node); + TSTALLOC(SOI3TOUT1_toutPtr,SOI3tout1Node,SOI3toutNode); + TSTALLOC(SOI3TOUT1_tout1Ptr,SOI3tout1Node,SOI3tout1Node); } if (here->SOI3numThermalNodes > 2) { - TSTALLOC(SOI3TOUT1_tout2Ptr,SOI3tout1Node,SOI3tout2Node) - TSTALLOC(SOI3TOUT2_tout1Ptr,SOI3tout2Node,SOI3tout1Node) - TSTALLOC(SOI3TOUT2_tout2Ptr,SOI3tout2Node,SOI3tout2Node) + TSTALLOC(SOI3TOUT1_tout2Ptr,SOI3tout1Node,SOI3tout2Node); + TSTALLOC(SOI3TOUT2_tout1Ptr,SOI3tout2Node,SOI3tout1Node); + TSTALLOC(SOI3TOUT2_tout2Ptr,SOI3tout2Node,SOI3tout2Node); } if (here->SOI3numThermalNodes > 3) { - TSTALLOC(SOI3TOUT2_tout3Ptr,SOI3tout2Node,SOI3tout3Node) - TSTALLOC(SOI3TOUT3_tout2Ptr,SOI3tout3Node,SOI3tout2Node) - TSTALLOC(SOI3TOUT3_tout3Ptr,SOI3tout3Node,SOI3tout3Node) + TSTALLOC(SOI3TOUT2_tout3Ptr,SOI3tout2Node,SOI3tout3Node); + TSTALLOC(SOI3TOUT3_tout2Ptr,SOI3tout3Node,SOI3tout2Node); + TSTALLOC(SOI3TOUT3_tout3Ptr,SOI3tout3Node,SOI3tout3Node); } if (here->SOI3numThermalNodes > 4) { - TSTALLOC(SOI3TOUT3_tout4Ptr,SOI3tout3Node,SOI3tout4Node) - TSTALLOC(SOI3TOUT4_tout3Ptr,SOI3tout4Node,SOI3tout3Node) - TSTALLOC(SOI3TOUT4_tout4Ptr,SOI3tout4Node,SOI3tout4Node) + TSTALLOC(SOI3TOUT3_tout4Ptr,SOI3tout3Node,SOI3tout4Node); + TSTALLOC(SOI3TOUT4_tout3Ptr,SOI3tout4Node,SOI3tout3Node); + TSTALLOC(SOI3TOUT4_tout4Ptr,SOI3tout4Node,SOI3tout4Node); } - TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode) - TSTALLOC(SOI3TOUT_gfPtr,SOI3toutNode,SOI3gfNode) - TSTALLOC(SOI3TOUT_gbPtr,SOI3toutNode,SOI3gbNode) - TSTALLOC(SOI3TOUT_dpPtr,SOI3toutNode,SOI3dNodePrime) - TSTALLOC(SOI3TOUT_spPtr,SOI3toutNode,SOI3sNodePrime) - TSTALLOC(SOI3TOUT_bPtr,SOI3toutNode,SOI3bNode) + TSTALLOC(SOI3TOUT_toutPtr,SOI3toutNode,SOI3toutNode); + TSTALLOC(SOI3TOUT_gfPtr,SOI3toutNode,SOI3gfNode); + TSTALLOC(SOI3TOUT_gbPtr,SOI3toutNode,SOI3gbNode); + TSTALLOC(SOI3TOUT_dpPtr,SOI3toutNode,SOI3dNodePrime); + TSTALLOC(SOI3TOUT_spPtr,SOI3toutNode,SOI3sNodePrime); + TSTALLOC(SOI3TOUT_bPtr,SOI3toutNode,SOI3bNode); - TSTALLOC(SOI3GF_toutPtr,SOI3gfNode,SOI3toutNode) - TSTALLOC(SOI3GB_toutPtr,SOI3gbNode,SOI3toutNode) - TSTALLOC(SOI3DP_toutPtr,SOI3dNodePrime,SOI3toutNode) - TSTALLOC(SOI3SP_toutPtr,SOI3sNodePrime,SOI3toutNode) - TSTALLOC(SOI3B_toutPtr,SOI3bNode,SOI3toutNode) + TSTALLOC(SOI3GF_toutPtr,SOI3gfNode,SOI3toutNode); + TSTALLOC(SOI3GB_toutPtr,SOI3gbNode,SOI3toutNode); + TSTALLOC(SOI3DP_toutPtr,SOI3dNodePrime,SOI3toutNode); + TSTALLOC(SOI3SP_toutPtr,SOI3sNodePrime,SOI3toutNode); + TSTALLOC(SOI3B_toutPtr,SOI3bNode,SOI3toutNode); } } } diff --git a/src/spicelib/devices/sw/swsetup.c b/src/spicelib/devices/sw/swsetup.c index 44b0f803e..384e05324 100644 --- a/src/spicelib/devices/sw/swsetup.c +++ b/src/spicelib/devices/sw/swsetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(SWposPosptr, SWposNode, SWposNode) - TSTALLOC(SWposNegptr, SWposNode, SWnegNode) - TSTALLOC(SWnegPosptr, SWnegNode, SWposNode) - TSTALLOC(SWnegNegptr, SWnegNode, SWnegNode) + TSTALLOC(SWposPosptr, SWposNode, SWposNode); + TSTALLOC(SWposNegptr, SWposNode, SWnegNode); + TSTALLOC(SWnegPosptr, SWnegNode, SWposNode); + TSTALLOC(SWnegNegptr, SWnegNode, SWnegNode); } } return(OK); diff --git a/src/spicelib/devices/tra/trasetup.c b/src/spicelib/devices/tra/trasetup.c index 197dcda75..67d280a15 100644 --- a/src/spicelib/devices/tra/trasetup.c +++ b/src/spicelib/devices/tra/trasetup.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(TRAibr1Ibr2Ptr, TRAbrEq1, TRAbrEq2) - TSTALLOC(TRAibr1Int1Ptr, TRAbrEq1, TRAintNode1) - TSTALLOC(TRAibr1Neg1Ptr, TRAbrEq1, TRAnegNode1) - TSTALLOC(TRAibr1Neg2Ptr, TRAbrEq1, TRAnegNode2) - TSTALLOC(TRAibr1Pos2Ptr, TRAbrEq1, TRAposNode2) - TSTALLOC(TRAibr2Ibr1Ptr, TRAbrEq2, TRAbrEq1) - TSTALLOC(TRAibr2Int2Ptr, TRAbrEq2, TRAintNode2) - TSTALLOC(TRAibr2Neg1Ptr, TRAbrEq2, TRAnegNode1) - TSTALLOC(TRAibr2Neg2Ptr, TRAbrEq2, TRAnegNode2) - TSTALLOC(TRAibr2Pos1Ptr, TRAbrEq2, TRAposNode1) - TSTALLOC(TRAint1Ibr1Ptr, TRAintNode1, TRAbrEq1) - TSTALLOC(TRAint1Int1Ptr, TRAintNode1, TRAintNode1) - TSTALLOC(TRAint1Pos1Ptr, TRAintNode1, TRAposNode1) - TSTALLOC(TRAint2Ibr2Ptr, TRAintNode2, TRAbrEq2) - TSTALLOC(TRAint2Int2Ptr, TRAintNode2, TRAintNode2) - TSTALLOC(TRAint2Pos2Ptr, TRAintNode2, TRAposNode2) - TSTALLOC(TRAneg1Ibr1Ptr, TRAnegNode1, TRAbrEq1) - TSTALLOC(TRAneg2Ibr2Ptr, TRAnegNode2, TRAbrEq2) - TSTALLOC(TRApos1Int1Ptr, TRAposNode1, TRAintNode1) - TSTALLOC(TRApos1Pos1Ptr, TRAposNode1, TRAposNode1) - TSTALLOC(TRApos2Int2Ptr, TRAposNode2, TRAintNode2) - TSTALLOC(TRApos2Pos2Ptr, TRAposNode2, TRAposNode2) + TSTALLOC(TRAibr1Ibr2Ptr, TRAbrEq1, TRAbrEq2); + TSTALLOC(TRAibr1Int1Ptr, TRAbrEq1, TRAintNode1); + TSTALLOC(TRAibr1Neg1Ptr, TRAbrEq1, TRAnegNode1); + TSTALLOC(TRAibr1Neg2Ptr, TRAbrEq1, TRAnegNode2); + TSTALLOC(TRAibr1Pos2Ptr, TRAbrEq1, TRAposNode2); + TSTALLOC(TRAibr2Ibr1Ptr, TRAbrEq2, TRAbrEq1); + TSTALLOC(TRAibr2Int2Ptr, TRAbrEq2, TRAintNode2); + TSTALLOC(TRAibr2Neg1Ptr, TRAbrEq2, TRAnegNode1); + TSTALLOC(TRAibr2Neg2Ptr, TRAbrEq2, TRAnegNode2); + TSTALLOC(TRAibr2Pos1Ptr, TRAbrEq2, TRAposNode1); + TSTALLOC(TRAint1Ibr1Ptr, TRAintNode1, TRAbrEq1); + TSTALLOC(TRAint1Int1Ptr, TRAintNode1, TRAintNode1); + TSTALLOC(TRAint1Pos1Ptr, TRAintNode1, TRAposNode1); + TSTALLOC(TRAint2Ibr2Ptr, TRAintNode2, TRAbrEq2); + TSTALLOC(TRAint2Int2Ptr, TRAintNode2, TRAintNode2); + TSTALLOC(TRAint2Pos2Ptr, TRAintNode2, TRAposNode2); + TSTALLOC(TRAneg1Ibr1Ptr, TRAnegNode1, TRAbrEq1); + TSTALLOC(TRAneg2Ibr2Ptr, TRAnegNode2, TRAbrEq2); + TSTALLOC(TRApos1Int1Ptr, TRAposNode1, TRAintNode1); + TSTALLOC(TRApos1Pos1Ptr, TRAposNode1, TRAposNode1); + TSTALLOC(TRApos2Int2Ptr, TRAposNode2, TRAintNode2); + TSTALLOC(TRApos2Pos2Ptr, TRAposNode2, TRAposNode2); if(!here->TRAnlGiven) { here->TRAnl = .25; diff --git a/src/spicelib/devices/txl/txlsetup.c b/src/spicelib/devices/txl/txlsetup.c index 9a176a7b4..f30d9c66b 100644 --- a/src/spicelib/devices/txl/txlsetup.c +++ b/src/spicelib/devices/txl/txlsetup.c @@ -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 */ #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);\ -} +} } while(0) if (! here->TXLibr1Given) { error = CKTmkCur(ckt, &tmp, here->TXLname, "branch1"); diff --git a/src/spicelib/devices/vbic/vbicsetup.c b/src/spicelib/devices/vbic/vbicsetup.c index b233105c5..248a98b8c 100644 --- a/src/spicelib/devices/vbic/vbicsetup.c +++ b/src/spicelib/devices/vbic/vbicsetup.c @@ -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 */ #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);\ -} - TSTALLOC(VBICcollCollPtr,VBICcollNode,VBICcollNode) - TSTALLOC(VBICbaseBasePtr,VBICbaseNode,VBICbaseNode) - TSTALLOC(VBICemitEmitPtr,VBICemitNode,VBICemitNode) - TSTALLOC(VBICsubsSubsPtr,VBICsubsNode,VBICsubsNode) - TSTALLOC(VBICcollCXCollCXPtr,VBICcollCXNode,VBICcollCXNode) - TSTALLOC(VBICcollCICollCIPtr,VBICcollCINode,VBICcollCINode) - TSTALLOC(VBICbaseBXBaseBXPtr,VBICbaseBXNode,VBICbaseBXNode) - TSTALLOC(VBICbaseBIBaseBIPtr,VBICbaseBINode,VBICbaseBINode) - TSTALLOC(VBICemitEIEmitEIPtr,VBICemitEINode,VBICemitEINode) - TSTALLOC(VBICbaseBPBaseBPPtr,VBICbaseBPNode,VBICbaseBPNode) - TSTALLOC(VBICsubsSISubsSIPtr,VBICsubsSINode,VBICsubsSINode) +} } while(0) + TSTALLOC(VBICcollCollPtr,VBICcollNode,VBICcollNode); + TSTALLOC(VBICbaseBasePtr,VBICbaseNode,VBICbaseNode); + TSTALLOC(VBICemitEmitPtr,VBICemitNode,VBICemitNode); + TSTALLOC(VBICsubsSubsPtr,VBICsubsNode,VBICsubsNode); + TSTALLOC(VBICcollCXCollCXPtr,VBICcollCXNode,VBICcollCXNode); + TSTALLOC(VBICcollCICollCIPtr,VBICcollCINode,VBICcollCINode); + TSTALLOC(VBICbaseBXBaseBXPtr,VBICbaseBXNode,VBICbaseBXNode); + TSTALLOC(VBICbaseBIBaseBIPtr,VBICbaseBINode,VBICbaseBINode); + TSTALLOC(VBICemitEIEmitEIPtr,VBICemitEINode,VBICemitEINode); + TSTALLOC(VBICbaseBPBaseBPPtr,VBICbaseBPNode,VBICbaseBPNode); + TSTALLOC(VBICsubsSISubsSIPtr,VBICsubsSINode,VBICsubsSINode); - TSTALLOC(VBICbaseEmitPtr,VBICbaseNode,VBICemitNode) - TSTALLOC(VBICemitBasePtr,VBICemitNode,VBICbaseNode) - TSTALLOC(VBICbaseCollPtr,VBICbaseNode,VBICcollNode) - TSTALLOC(VBICcollBasePtr,VBICcollNode,VBICbaseNode) - TSTALLOC(VBICcollCollCXPtr,VBICcollNode,VBICcollCXNode) - TSTALLOC(VBICbaseBaseBXPtr,VBICbaseNode,VBICbaseBXNode) - TSTALLOC(VBICemitEmitEIPtr,VBICemitNode,VBICemitEINode) - TSTALLOC(VBICsubsSubsSIPtr,VBICsubsNode,VBICsubsSINode) - TSTALLOC(VBICcollCXCollCIPtr,VBICcollCXNode,VBICcollCINode) - TSTALLOC(VBICcollCXBaseBXPtr,VBICcollCXNode,VBICbaseBXNode) - TSTALLOC(VBICcollCXBaseBIPtr,VBICcollCXNode,VBICbaseBINode) - TSTALLOC(VBICcollCXBaseBPPtr,VBICcollCXNode,VBICbaseBPNode) - TSTALLOC(VBICcollCIBaseBIPtr,VBICcollCINode,VBICbaseBINode) - TSTALLOC(VBICcollCIEmitEIPtr,VBICcollCINode,VBICemitEINode) - TSTALLOC(VBICbaseBXBaseBIPtr,VBICbaseBXNode,VBICbaseBINode) - TSTALLOC(VBICbaseBXEmitEIPtr,VBICbaseBXNode,VBICemitEINode) - TSTALLOC(VBICbaseBXBaseBPPtr,VBICbaseBXNode,VBICbaseBPNode) - TSTALLOC(VBICbaseBXSubsSIPtr,VBICbaseBXNode,VBICsubsSINode) - TSTALLOC(VBICbaseBIEmitEIPtr,VBICbaseBINode,VBICemitEINode) - TSTALLOC(VBICbaseBPSubsSIPtr,VBICbaseBPNode,VBICsubsSINode) + TSTALLOC(VBICbaseEmitPtr,VBICbaseNode,VBICemitNode); + TSTALLOC(VBICemitBasePtr,VBICemitNode,VBICbaseNode); + TSTALLOC(VBICbaseCollPtr,VBICbaseNode,VBICcollNode); + TSTALLOC(VBICcollBasePtr,VBICcollNode,VBICbaseNode); + TSTALLOC(VBICcollCollCXPtr,VBICcollNode,VBICcollCXNode); + TSTALLOC(VBICbaseBaseBXPtr,VBICbaseNode,VBICbaseBXNode); + TSTALLOC(VBICemitEmitEIPtr,VBICemitNode,VBICemitEINode); + TSTALLOC(VBICsubsSubsSIPtr,VBICsubsNode,VBICsubsSINode); + TSTALLOC(VBICcollCXCollCIPtr,VBICcollCXNode,VBICcollCINode); + TSTALLOC(VBICcollCXBaseBXPtr,VBICcollCXNode,VBICbaseBXNode); + TSTALLOC(VBICcollCXBaseBIPtr,VBICcollCXNode,VBICbaseBINode); + TSTALLOC(VBICcollCXBaseBPPtr,VBICcollCXNode,VBICbaseBPNode); + TSTALLOC(VBICcollCIBaseBIPtr,VBICcollCINode,VBICbaseBINode); + TSTALLOC(VBICcollCIEmitEIPtr,VBICcollCINode,VBICemitEINode); + TSTALLOC(VBICbaseBXBaseBIPtr,VBICbaseBXNode,VBICbaseBINode); + TSTALLOC(VBICbaseBXEmitEIPtr,VBICbaseBXNode,VBICemitEINode); + TSTALLOC(VBICbaseBXBaseBPPtr,VBICbaseBXNode,VBICbaseBPNode); + TSTALLOC(VBICbaseBXSubsSIPtr,VBICbaseBXNode,VBICsubsSINode); + TSTALLOC(VBICbaseBIEmitEIPtr,VBICbaseBINode,VBICemitEINode); + TSTALLOC(VBICbaseBPSubsSIPtr,VBICbaseBPNode,VBICsubsSINode); - TSTALLOC(VBICcollCXCollPtr,VBICcollCXNode,VBICcollNode) - TSTALLOC(VBICbaseBXBasePtr,VBICbaseBXNode,VBICbaseNode) - TSTALLOC(VBICemitEIEmitPtr,VBICemitEINode,VBICemitNode) - TSTALLOC(VBICsubsSISubsPtr,VBICsubsSINode,VBICsubsNode) - TSTALLOC(VBICcollCICollCXPtr,VBICcollCINode,VBICcollCXNode) - TSTALLOC(VBICbaseBICollCXPtr,VBICbaseBINode,VBICcollCXNode) - TSTALLOC(VBICbaseBPCollCXPtr,VBICbaseBPNode,VBICcollCXNode) - TSTALLOC(VBICbaseBXCollCIPtr,VBICbaseBXNode,VBICcollCINode) - TSTALLOC(VBICbaseBICollCIPtr,VBICbaseBINode,VBICcollCINode) - TSTALLOC(VBICemitEICollCIPtr,VBICemitEINode,VBICcollCINode) - TSTALLOC(VBICbaseBPCollCIPtr,VBICbaseBPNode,VBICcollCINode) - TSTALLOC(VBICbaseBIBaseBXPtr,VBICbaseBINode,VBICbaseBXNode) - TSTALLOC(VBICemitEIBaseBXPtr,VBICemitEINode,VBICbaseBXNode) - TSTALLOC(VBICbaseBPBaseBXPtr,VBICbaseBPNode,VBICbaseBXNode) - TSTALLOC(VBICsubsSIBaseBXPtr,VBICsubsSINode,VBICbaseBXNode) - TSTALLOC(VBICemitEIBaseBIPtr,VBICemitEINode,VBICbaseBINode) - TSTALLOC(VBICbaseBPBaseBIPtr,VBICbaseBPNode,VBICbaseBINode) - TSTALLOC(VBICsubsSICollCIPtr,VBICsubsSINode,VBICcollCINode) - TSTALLOC(VBICsubsSIBaseBIPtr,VBICsubsSINode,VBICbaseBINode) - TSTALLOC(VBICsubsSIBaseBPPtr,VBICsubsSINode,VBICbaseBPNode) + TSTALLOC(VBICcollCXCollPtr,VBICcollCXNode,VBICcollNode); + TSTALLOC(VBICbaseBXBasePtr,VBICbaseBXNode,VBICbaseNode); + TSTALLOC(VBICemitEIEmitPtr,VBICemitEINode,VBICemitNode); + TSTALLOC(VBICsubsSISubsPtr,VBICsubsSINode,VBICsubsNode); + TSTALLOC(VBICcollCICollCXPtr,VBICcollCINode,VBICcollCXNode); + TSTALLOC(VBICbaseBICollCXPtr,VBICbaseBINode,VBICcollCXNode); + TSTALLOC(VBICbaseBPCollCXPtr,VBICbaseBPNode,VBICcollCXNode); + TSTALLOC(VBICbaseBXCollCIPtr,VBICbaseBXNode,VBICcollCINode); + TSTALLOC(VBICbaseBICollCIPtr,VBICbaseBINode,VBICcollCINode); + TSTALLOC(VBICemitEICollCIPtr,VBICemitEINode,VBICcollCINode); + TSTALLOC(VBICbaseBPCollCIPtr,VBICbaseBPNode,VBICcollCINode); + TSTALLOC(VBICbaseBIBaseBXPtr,VBICbaseBINode,VBICbaseBXNode); + TSTALLOC(VBICemitEIBaseBXPtr,VBICemitEINode,VBICbaseBXNode); + TSTALLOC(VBICbaseBPBaseBXPtr,VBICbaseBPNode,VBICbaseBXNode); + TSTALLOC(VBICsubsSIBaseBXPtr,VBICsubsSINode,VBICbaseBXNode); + TSTALLOC(VBICemitEIBaseBIPtr,VBICemitEINode,VBICbaseBINode); + TSTALLOC(VBICbaseBPBaseBIPtr,VBICbaseBPNode,VBICbaseBINode); + TSTALLOC(VBICsubsSICollCIPtr,VBICsubsSINode,VBICcollCINode); + TSTALLOC(VBICsubsSIBaseBIPtr,VBICsubsSINode,VBICbaseBINode); + TSTALLOC(VBICsubsSIBaseBPPtr,VBICsubsSINode,VBICbaseBPNode); } } diff --git a/src/spicelib/devices/vccs/vccsset.c b/src/spicelib/devices/vccs/vccsset.c index 16e951218..0399385e2 100644 --- a/src/spicelib/devices/vccs/vccsset.c +++ b/src/spicelib/devices/vccs/vccsset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(VCCSposContPosptr, VCCSposNode, VCCScontPosNode) - TSTALLOC(VCCSposContNegptr, VCCSposNode, VCCScontNegNode) - TSTALLOC(VCCSnegContPosptr, VCCSnegNode, VCCScontPosNode) - TSTALLOC(VCCSnegContNegptr, VCCSnegNode, VCCScontNegNode) + TSTALLOC(VCCSposContPosptr, VCCSposNode, VCCScontPosNode); + TSTALLOC(VCCSposContNegptr, VCCSposNode, VCCScontNegNode); + TSTALLOC(VCCSnegContPosptr, VCCSnegNode, VCCScontPosNode); + TSTALLOC(VCCSnegContNegptr, VCCSnegNode, VCCScontNegNode); } } return(OK); diff --git a/src/spicelib/devices/vcvs/vcvsset.c b/src/spicelib/devices/vcvs/vcvsset.c index b34db5d5e..33ad194d2 100644 --- a/src/spicelib/devices/vcvs/vcvsset.c +++ b/src/spicelib/devices/vcvs/vcvsset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(VCVSposIbrptr, VCVSposNode, VCVSbranch) - TSTALLOC(VCVSnegIbrptr, VCVSnegNode, VCVSbranch) - TSTALLOC(VCVSibrPosptr, VCVSbranch, VCVSposNode) - TSTALLOC(VCVSibrNegptr, VCVSbranch, VCVSnegNode) - TSTALLOC(VCVSibrContPosptr, VCVSbranch, VCVScontPosNode) - TSTALLOC(VCVSibrContNegptr, VCVSbranch, VCVScontNegNode) + TSTALLOC(VCVSposIbrptr, VCVSposNode, VCVSbranch); + TSTALLOC(VCVSnegIbrptr, VCVSnegNode, VCVSbranch); + TSTALLOC(VCVSibrPosptr, VCVSbranch, VCVSposNode); + TSTALLOC(VCVSibrNegptr, VCVSbranch, VCVSnegNode); + TSTALLOC(VCVSibrContPosptr, VCVSbranch, VCVScontPosNode); + TSTALLOC(VCVSibrContNegptr, VCVSbranch, VCVScontNegNode); } } return(OK); diff --git a/src/spicelib/devices/vsrc/vsrcpzs.c b/src/spicelib/devices/vsrc/vsrcpzs.c index 616802832..42b125cbd 100644 --- a/src/spicelib/devices/vsrc/vsrcpzs.c +++ b/src/spicelib/devices/vsrc/vsrcpzs.c @@ -38,15 +38,15 @@ VSRCpzSetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, /* macro to make elements with built in test for out of memory */ #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);\ -} +} } while(0) - TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch) - TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch) - TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode) - TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode) - TSTALLOC(VSRCibrIbrptr, VSRCbranch, VSRCbranch) + TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch); + TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch); + TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode); + TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode); + TSTALLOC(VSRCibrIbrptr, VSRCbranch, VSRCbranch); } } return(OK); diff --git a/src/spicelib/devices/vsrc/vsrcset.c b/src/spicelib/devices/vsrc/vsrcset.c index 0428bbc86..79160d7a0 100644 --- a/src/spicelib/devices/vsrc/vsrcset.c +++ b/src/spicelib/devices/vsrc/vsrcset.c @@ -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 */ #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);\ -} +} } while(0) - TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch) - TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch) - TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode) - TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode) + TSTALLOC(VSRCposIbrptr, VSRCposNode, VSRCbranch); + TSTALLOC(VSRCnegIbrptr, VSRCnegNode, VSRCbranch); + TSTALLOC(VSRCibrNegptr, VSRCbranch, VSRCnegNode); + TSTALLOC(VSRCibrPosptr, VSRCbranch, VSRCposNode); } } return(OK); diff --git a/src/xspice/mif/mifsetup.c b/src/xspice/mif/mifsetup.c index cd9a3b365..5e10ad61c 100644 --- a/src/xspice/mif/mifsetup.c +++ b/src/xspice/mif/mifsetup.c @@ -56,17 +56,17 @@ NON-STANDARD FEATURES /* define macro for easy creation of matrix entries/pointers for outputs */ #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) { \ return(E_NOMEM); \ - } + } } while(0) /* define macro for easy creation of matrix entries/pointers for inputs */ #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) { \ return(E_NOMEM); \ - } + } } while(0)