epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

rewrite `TSTALLOC()' macro for auto indentation 

checked for object code invariance
pre-master-46
rlar 13 years ago
parent
83205d6c30
commit
14687910d9
55 changed files with 1534 additions and 1534 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      src/spicelib/devices/asrc/asrcset.c
  2. 50
      src/spicelib/devices/bjt/bjtsetup.c
  3. 48
      src/spicelib/devices/bsim1/b1set.c
  4. 48
      src/spicelib/devices/bsim2/b2set.c
  5. 66
      src/spicelib/devices/bsim3/b3set.c
  6. 204
      src/spicelib/devices/bsim3soi_dd/b3soiddset.c
  7. 176
      src/spicelib/devices/bsim3soi_fd/b3soifdset.c
  8. 148
      src/spicelib/devices/bsim3soi_pd/b3soipdset.c
  9. 70
      src/spicelib/devices/bsim3v0/b3v0set.c
  10. 72
      src/spicelib/devices/bsim3v1/b3v1set.c
  11. 66
      src/spicelib/devices/bsim3v32/b3v32set.c
  12. 162
      src/spicelib/devices/bsim4/b4set.c
  13. 144
      src/spicelib/devices/bsim4v4/b4v4set.c
  14. 162
      src/spicelib/devices/bsim4v5/b4v5set.c
  15. 162
      src/spicelib/devices/bsim4v6/b4v6set.c
  16. 210
      src/spicelib/devices/bsimsoi/b4soiset.c
  17. 12
      src/spicelib/devices/cap/capsetup.c
  18. 8
      src/spicelib/devices/cccs/cccsset.c
  19. 14
      src/spicelib/devices/ccvs/ccvsset.c
  20. 4
      src/spicelib/devices/cpl/cplsetup.c
  21. 12
      src/spicelib/devices/csw/cswsetup.c
  22. 18
      src/spicelib/devices/dio/diosetup.c
  23. 60
      src/spicelib/devices/hfet1/hfetsetup.c
  24. 34
      src/spicelib/devices/hfet2/hfet2setup.c
  25. 52
      src/spicelib/devices/hisim2/hsm2set.c
  26. 116
      src/spicelib/devices/hisimhv1/hsmhvset.c
  27. 14
      src/spicelib/devices/ind/indsetup.c
  28. 8
      src/spicelib/devices/ind/mutsetup.c
  29. 36
      src/spicelib/devices/jfet/jfetset.c
  30. 36
      src/spicelib/devices/jfet2/jfet2set.c
  31. 44
      src/spicelib/devices/ltra/ltraset.c
  32. 34
      src/spicelib/devices/mes/messetup.c
  33. 60
      src/spicelib/devices/mesa/mesasetup.c
  34. 48
      src/spicelib/devices/mos1/mos1set.c
  35. 48
      src/spicelib/devices/mos2/mos2set.c
  36. 48
      src/spicelib/devices/mos3/mos3set.c
  37. 48
      src/spicelib/devices/mos6/mos6set.c
  38. 48
      src/spicelib/devices/mos9/mos9set.c
  39. 24
      src/spicelib/devices/nbjt/nbjtset.c
  40. 22
      src/spicelib/devices/nbjt2/nbt2set.c
  41. 4
      src/spicelib/devices/ndev/ndevset.c
  42. 12
      src/spicelib/devices/numd/numdset.c
  43. 12
      src/spicelib/devices/numd2/nud2set.c
  44. 36
      src/spicelib/devices/numos/nummset.c
  45. 4
      src/spicelib/devices/res/ressetup.c
  46. 124
      src/spicelib/devices/soi3/soi3set.c
  47. 12
      src/spicelib/devices/sw/swsetup.c
  48. 48
      src/spicelib/devices/tra/trasetup.c
  49. 4
      src/spicelib/devices/txl/txlsetup.c
  50. 106
      src/spicelib/devices/vbic/vbicsetup.c
  51. 12
      src/spicelib/devices/vccs/vccsset.c
  52. 16
      src/spicelib/devices/vcvs/vcvsset.c
  53. 14
      src/spicelib/devices/vsrc/vsrcpzs.c
  54. 12
      src/spicelib/devices/vsrc/vsrcset.c
  55. 8
      src/xspice/mif/mifsetup.c

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

@ -54,14 +54,14 @@ ASRCsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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 */

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

@ -420,28 +420,28 @@ BJTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -368,32 +368,32 @@ B1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -535,32 +535,32 @@ B2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -1030,43 +1030,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);
}
}

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

@ -1215,129 +1215,129 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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(B3SOIDDGtempPtr, B3SOIDDgNode, B3SOIDDtempNode)
TSTALLOC(B3SOIDDDPtempPtr, B3SOIDDdNodePrime, B3SOIDDtempNode)
TSTALLOC(B3SOIDDSPtempPtr, B3SOIDDsNodePrime, B3SOIDDtempNode)
TSTALLOC(B3SOIDDEtempPtr, B3SOIDDeNode, B3SOIDDtempNode)
TSTALLOC(B3SOIDDBtempPtr, B3SOIDDbNode, B3SOIDDtempNode)
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);
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(B3SOIDDEePtr, B3SOIDDeNode, B3SOIDDeNode)
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(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode)
TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime)
TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime)
TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode)
TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode)
TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime)
TSTALLOC(B3SOIDDSsPtr, B3SOIDDsNode, B3SOIDDsNode)
TSTALLOC(B3SOIDDSspPtr, B3SOIDDsNode, B3SOIDDsNodePrime)
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(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(B3SOIDDSPgPtr, B3SOIDDsNodePrime, B3SOIDDgNode);
TSTALLOC(B3SOIDDSPdpPtr, B3SOIDDsNodePrime, B3SOIDDdNodePrime);
TSTALLOC(B3SOIDDSPspPtr, B3SOIDDsNodePrime, B3SOIDDsNodePrime);
TSTALLOC(B3SOIDDSPsPtr, B3SOIDDsNodePrime, B3SOIDDsNode);
TSTALLOC(B3SOIDDDdPtr, B3SOIDDdNode, B3SOIDDdNode);
TSTALLOC(B3SOIDDDdpPtr, B3SOIDDdNode, B3SOIDDdNodePrime);
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);
}
}

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

@ -1213,120 +1213,120 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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(B3SOIFDGtempPtr, B3SOIFDgNode, B3SOIFDtempNode)
TSTALLOC(B3SOIFDDPtempPtr, B3SOIFDdNodePrime, B3SOIFDtempNode)
TSTALLOC(B3SOIFDSPtempPtr, B3SOIFDsNodePrime, B3SOIFDtempNode)
TSTALLOC(B3SOIFDEtempPtr, B3SOIFDeNode, B3SOIFDtempNode)
TSTALLOC(B3SOIFDBtempPtr, B3SOIFDbNode, B3SOIFDtempNode)
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);
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);
}
}

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

@ -1347,98 +1347,98 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode)
TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode)
TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode)
TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode)
TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode)
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);
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(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(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(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode)
TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime)
TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime)
TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode)
TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode)
TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime)
TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode)
TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime)
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(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode);
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(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode);
TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime);
TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime);
TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode);
TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode);
TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime);
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);
}

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

@ -848,43 +848,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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(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)
} } 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(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);
}
}

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

@ -908,43 +908,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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(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(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)
} } 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(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);
}
}

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

@ -1029,43 +1029,43 @@ IFuid tmpName;
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -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);\
}
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(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)
} } while(0)
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(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);
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(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(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);
}
if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2))
{ 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(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(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode)
TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime)
TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode)
TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode)
{ 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(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(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);
}
}
}

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

@ -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);
}
}
}

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

@ -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);\
}
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(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)
} } while(0)
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(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);
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(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(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);
}
if ((here->BSIM4v5rbodyMod ==1) || (here->BSIM4v5rbodyMod ==2))
{ 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(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(BSIM4v5BdbPtr, BSIM4v5bNode, BSIM4v5dbNode)
TSTALLOC(BSIM4v5BbpPtr, BSIM4v5bNode, BSIM4v5bNodePrime)
TSTALLOC(BSIM4v5BsbPtr, BSIM4v5bNode, BSIM4v5sbNode)
TSTALLOC(BSIM4v5BbPtr, BSIM4v5bNode, BSIM4v5bNode)
{ 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(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(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);
}
}
}

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

@ -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);\
}
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(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)
} } while(0)
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(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);
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(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(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);
}
if ((here->BSIM4v6rbodyMod ==1) || (here->BSIM4v6rbodyMod ==2))
{ 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(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(BSIM4v6BdbPtr, BSIM4v6bNode, BSIM4v6dbNode)
TSTALLOC(BSIM4v6BbpPtr, BSIM4v6bNode, BSIM4v6bNodePrime)
TSTALLOC(BSIM4v6BsbPtr, BSIM4v6bNode, BSIM4v6sbNode)
TSTALLOC(BSIM4v6BbPtr, BSIM4v6bNode, BSIM4v6bNode)
{ 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(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(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 */

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

@ -2515,32 +2515,32 @@ B4SOIinstance **InstArray;
/* macro to make elements with built in test for out of memory */
#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(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode)
TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid)
TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid)
TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid)
TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid)
TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid)
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);
}
/* 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);
}

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

@ -101,14 +101,14 @@ CAPsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -45,12 +45,12 @@ CCCSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -54,15 +54,15 @@ CCVSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -185,9 +185,9 @@ CPLsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */
#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;

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

@ -60,14 +60,14 @@ CSWsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -219,17 +219,17 @@ DIOsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -363,38 +363,38 @@ HFETAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -177,25 +177,25 @@ int HFET2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -774,33 +774,33 @@ int HSM2setup(
/* macro to make elements with built in test for out of memory */
#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);\
}
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(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)
} } while(0)
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(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 ) {

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

@ -938,35 +938,35 @@ int HSMHVsetup(
/* macro to make elements with built in test for out of memory */
#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);\
}
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(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)
} } while(0)
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(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);
}
}

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

@ -89,15 +89,15 @@ INDsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -69,12 +69,12 @@ MUTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -159,25 +159,25 @@ JFETsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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(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)
} } 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);
}
}
return(OK);

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

@ -99,25 +99,25 @@ JFET2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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(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)
} } 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);
}
}
return(OK);

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

@ -186,34 +186,34 @@ LTRAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
}
/* macro to make elements with built in test for out of memory */
#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);

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

@ -132,25 +132,25 @@ MESsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -369,38 +369,38 @@ MESAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
}
#define TSTALLOC(ptr,first,second) \
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);

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

@ -180,31 +180,31 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -202,32 +202,32 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -227,32 +227,32 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -189,32 +189,32 @@ MOS6setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
}
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -227,32 +227,32 @@ MOS9setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -228,19 +228,19 @@ NBJTsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);\
}
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)
} } 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);
}
/* Clean up lists */
killCoordInfo(xCoordList);

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

@ -244,19 +244,19 @@ NBJT2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -51,9 +51,9 @@ int NDEVsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states
send(model->sock,&(here->Ndevinfo),sizeof(here->Ndevinfo),0);
/* 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;i<here->term;i++)
for(j=0;j<here->term;j++)

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

@ -217,14 +217,14 @@ NUMDsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -242,14 +242,14 @@ NUMD2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -241,26 +241,26 @@ NUMOSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -34,9 +34,9 @@ RESsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit*ckt, int *state)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -566,94 +566,94 @@ SOI3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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(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(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(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(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(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);
}
}
}

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

@ -52,14 +52,14 @@ SWsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -64,32 +64,32 @@ TRAsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */
#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;

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

@ -120,9 +120,9 @@ TXLsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit*ckt, int *state)
/* macro to make elements with built in test for out of memory */
#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");

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

@ -472,62 +472,62 @@ VBICsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);
}
}

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

@ -36,14 +36,14 @@ VCCSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -46,16 +46,16 @@ VCVSsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -38,15 +38,15 @@ VSRCpzSetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
/* macro to make elements with built in test for out of memory */
#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);

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

@ -45,14 +45,14 @@ VSRCsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *state)
/* macro to make elements with built in test for out of memory */
#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);

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

@ -56,17 +56,17 @@ NON-STANDARD FEATURES
/* define macro for easy creation of matrix entries/pointers for outputs */
#define 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)

Write Preview
Loading…
Cancel
Save