luke
/
magic
mirror of https://github.com/RTimothyEdwards/magic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Corrected an error in "extresist" that can cause a segfault which 

is unrelated to recent code changes, and also corrected a bunch
of code to (somewhat) more properly handle non-Manhattan geometry.
This commit is contained in:
R. Timothy Edwards 2026-01-20 12:59:36 -05:00
parent b59708e27a
commit c0dbb2067b
4 changed files with 220 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@ -1 +1 @@
8.3.591
8.3.592

52
resis/ResBasic.c
View File

@ -135,6 +135,14 @@ ResMultiPlaneFunc(tile, dinfo, tpptr)
Tile *tp = *tpptr;
int xj, yj;
/* Simplified split tile handling---Ignore the right side of
* tiles that have non-space types on both sides.
*/
if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
xj = (LEFT(tile) + RIGHT(tile)) / 2;
yj = (TOP(tile) + BOTTOM(tile)) / 2;
ResNewSDDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue);
@ -168,6 +176,14 @@ ResSubstrateFunc(tile, dinfo, tpptr)
Tile *tp = *tpptr;
int xj, yj;
/* Simplified split tile handling---Ignore the right side of
* tiles that have non-space types on both sides.
*/
if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
xj = (LEFT(tile) + RIGHT(tile)) / 2;
yj = (TOP(tile) + BOTTOM(tile)) / 2;
ResNewSubDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue);
@ -191,10 +207,14 @@ ResSubstrateFunc(tile, dinfo, tpptr)
*--------------------------------------------------------------------------
*/
#define IGNORE_LEFT 1
#define IGNORE_RIGHT 2
#define IGNORE_TOP 4
#define IGNORE_BOTTOM 8
bool
ResEachTile(tile, dinfo, startpoint)
ResEachTile(tile, startpoint)
Tile *tile;
TileType dinfo;
Point *startpoint;
{
@ -207,17 +227,35 @@ ResEachTile(tile, dinfo, startpoint)
tElement *tcell;
tileJunk *tstructs= (tileJunk *)TiGetClientPTR(tile);
ExtDevice *devptr;
int sides;
ResTileCount++;
/* Process startpoint, if any. */
/* Simplification: Split tiles handle either the non-space side,
* or if neither side is space, then handle the left side.
*/
if (IsSplit(tile))
{
t1 = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
if (TiGetLeftType(tile) == TT_SPACE)
{
t1 = SplitRightType(tile);
sides = IGNORE_LEFT;
sides |= (SplitDirection(tile)) ? IGNORE_BOTTOM : IGNORE_TOP;
}
else
{
t1 = SplitLeftType(tile);
sides = IGNORE_RIGHT;
sides |= (SplitDirection(tile)) ? IGNORE_TOP : IGNORE_BOTTOM;
}
}
else
{
sides = 0;
t1 = TiGetTypeExact(tile);
}
if (startpoint != (Point *) NULL)
{
@ -229,7 +267,7 @@ ResEachTile(tile, dinfo, startpoint)
resptr->rn_noderes = 0;
ResAddToQueue(resptr, &ResNodeQueue);
NEWBREAK(resptr, tile, x, y, NULL);
resCurrentNode = resptr;
if (resCurrentNode == NULL) resCurrentNode = resptr;
resNodeIsPort(resptr, x, y, tile);
}
@ -286,6 +324,7 @@ ResEachTile(tile, dinfo, startpoint)
*/
/* left */
if (!(sides & IGNORE_LEFT))
for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp=RT(tp))
{
t2 = TiGetRightType(tp);
@ -318,6 +357,7 @@ ResEachTile(tile, dinfo, startpoint)
}
/* right */
if (!(sides & IGNORE_RIGHT))
for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp))
{
t2 = TiGetLeftType(tp);
@ -350,6 +390,7 @@ ResEachTile(tile, dinfo, startpoint)
}
/* top */
if (!(sides & IGNORE_TOP))
for (tp = RT(tile); RIGHT(tp) > LEFT(tile); tp = BL(tp))
{
t2 = TiGetBottomType(tp);
@ -382,6 +423,7 @@ ResEachTile(tile, dinfo, startpoint)
}
/* bottom */
if (!(sides & IGNORE_BOTTOM))
for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
{
t2 = TiGetTopType(tp);
@ -478,7 +520,7 @@ ResEachTile(tile, dinfo, startpoint)
resAllPortNodes(tile, &ResNodeQueue);
merged = ResCalcTileResistance(tile, dinfo, tstructs, &ResNodeQueue,
merged = ResCalcTileResistance(tile, tstructs, &ResNodeQueue,
&ResNodeList);
return(merged);

201
resis/ResMain.c
View File

@ -41,7 +41,6 @@ int ResTileCount = 0; /* Number of tiles rn_status */
extern ExtRegion *ResFirst();
extern Tile *FindStartTile();
extern int ResEachTile();
extern int ResLaplaceTile();
extern ResSimNode *ResInitializeNode();
TileTypeBitMask ResSDTypesBitMask;
TileTypeBitMask ResSubTypesBitMask;
@ -361,6 +360,14 @@ ResAddBreakpointFunc(tile, dinfo, node)
if (TiGetClient(tile) == CLIENTDEFAULT)
return 0;
/* To simplify processing, if a split tile does not have TT_SPACE
* on either side, then only the left side is processed.
*/
if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
NEWPORT(node, tile);
return 0;
@ -421,7 +428,7 @@ ResFindNewContactTiles(contacts)
#endif
if ((IsSplit(tile) && TTMaskHasType(&mask, TiGetRightType(tile)))
|| TTMaskHasType(&mask, TiGetType(tile)))
|| TTMaskHasType(&mask, TiGetLeftType(tile)))
{
tileJunk *j = (tileJunk *)TiGetClientPTR(tile);
cElement *ce;
@ -497,18 +504,13 @@ ResProcessTiles(goodies, origin)
resNode *resptr;
int (*tilefunc)();
#ifdef LAPLACE
tilefunc = (ResOptionsFlags & ResOpt_DoLaplace) ? ResLaplaceTile : ResEachTile;
#else
tilefunc = ResEachTile;
#endif
if (ResOptionsFlags & ResOpt_Signal)
{
startTile = FindStartTile(goodies, origin);
if (startTile == NULL) return(1);
if (startTile == NULL)
return 1;
resCurrentNode = NULL;
(void) (*tilefunc)(startTile, origin);
(void) ResEachTile(startTile, origin);
}
#ifdef ARIEL
else if (ResOptionsFlags & ResOpt_Power)
@ -550,7 +552,7 @@ ResProcessTiles(goodies, origin)
RES_TILE_DONE) == 0)
{
resCurrentNode = fix->fp_node;
(void) (*tilefunc)(tile, (Point *)NULL);
(void) ResEachTile(startile, (Point *)NULL);
}
}
}
@ -590,7 +592,7 @@ ResProcessTiles(goodies, origin)
if ((j->tj_status & RES_TILE_DONE) == 0)
{
resCurrentNode = resptr2;
merged |= (*tilefunc)(tile, (Point *)NULL);
merged |= ResEachTile(tile, (Point *)NULL);
}
if (merged & ORIGIN) break;
}
@ -619,7 +621,7 @@ ResProcessTiles(goodies, origin)
if (cp->cp_cnode[tilenum] == resptr2)
{
resCurrentNode = resptr2;
merged |= (*tilefunc)(tile,(Point *)NULL);
merged |= ResEachTile(tile, (Point *)NULL);
}
else
{
@ -699,28 +701,28 @@ ResCalcPerimOverlap(tile, dev)
/* left */
for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp = RT(tp))
{
if TTMaskHasType(omask, TiGetType(tp))
if TTMaskHasType(omask, TiGetRightType(tp))
overlap += MIN(TOP(tile), TOP(tp)) - MAX(BOTTOM(tile), BOTTOM(tp));
}
/* right */
for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp))
{
if TTMaskHasType(omask, TiGetType(tp))
if TTMaskHasType(omask, TiGetLeftType(tp))
overlap += MIN(TOP(tile), TOP(tp)) - MAX(BOTTOM(tile), BOTTOM(tp));
}
/* top */
for (tp = RT(tile); RIGHT(tp) > LEFT(tile); tp = BL(tp))
{
if TTMaskHasType(omask, TiGetType(tp))
if TTMaskHasType(omask, TiGetBottomType(tp))
overlap += MIN(RIGHT(tile), RIGHT(tp)) - MAX(LEFT(tile), LEFT(tp));
}
/* bottom */
for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
{
if TTMaskHasType(omask, TiGetType(tp))
if TTMaskHasType(omask, TiGetTopType(tp))
overlap += MIN(RIGHT(tile), RIGHT(tp)) - MAX(LEFT(tile), LEFT(tp));
}
dev->overlap += overlap;
@ -750,6 +752,14 @@ resMakeDevFunc(tile, dinfo, cx)
ResDevTile *thisDev = (ResDevTile *)cx->tc_filter->tf_arg;
Rect devArea;
TileType ttype;
/* To simplify processing, if a split tile does not have TT_SPACE
* on either side, then only the left side is processed.
*/
if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
TiToRect(tile, &devArea);
GeoTransRect(&cx->tc_scx->scx_trans, &devArea, &thisDev->area);
@ -796,6 +806,11 @@ resMakeDevFunc(tile, dinfo, cx)
#define DEV_PROCESSED 1
#define IGNORE_LEFT 1
#define IGNORE_RIGHT 2
#define IGNORE_TOP 4
#define IGNORE_BOTTOM 8
int
resExpandDevFunc(tile, dinfo, cx)
Tile *tile;
@ -811,6 +826,14 @@ resExpandDevFunc(tile, dinfo, cx)
int pNum;
Rect area;
/* To simplify processing, if a split tile does not have TT_SPACE
* on either side, then only the left side is processed.
*/
if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
pNum = DBPlane(thisDev->type);
if (devExtentsStack == NULL)
devExtentsStack = StackNew(8);
@ -822,12 +845,37 @@ resExpandDevFunc(tile, dinfo, cx)
while (!StackEmpty(devExtentsStack))
{
int sides = 0;
TileType dinfo = (TileType)0;
tp = (Tile *) STACKPOP(devExtentsStack);
STACKPUSH((ClientData)tp, devResetStack);
TiToRect(tp, &area);
if (IsSplit(tp))
{
dinfo = TiGetTypeExact(tp);
if (TiGetLeftType(tp) == TT_SPACE)
{
dinfo |= TT_SIDE; /* Look at tile right side */
sides |= IGNORE_LEFT;
if (SplitDirection(tp))
sides |= IGNORE_BOTTOM;
else
sides |= IGNORE_TOP;
}
else /* Look at tile left side */
{
sides |= IGNORE_RIGHT;
if (SplitDirection(tp))
sides |= IGNORE_TOP;
else
sides |= IGNORE_BOTTOM;
}
}
/* Paint type thisDev->type into ResUse over area of tile "tp" */
DBNMPaintPlane(ResUse->cu_def->cd_planes[pNum], TiGetTypeExact(tp),
DBNMPaintPlane(ResUse->cu_def->cd_planes[pNum], dinfo,
&area, DBStdPaintTbl(thisDev->type, pNum), (PaintUndoInfo *)NULL);
/* Add source/drain perimeter overlap to the device for this tile */
@ -838,56 +886,60 @@ resExpandDevFunc(tile, dinfo, cx)
/* device type. */
/* top */
for (tp2 = RT(tp); RIGHT(tp2) > LEFT(tp); tp2 = BL(tp2))
{
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetBottomType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
if (!(sides & IGNORE_TOP))
for (tp2 = RT(tp); RIGHT(tp2) > LEFT(tp); tp2 = BL(tp2))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetBottomType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
}
}
}
/* bottom */
for (tp2 = LB(tp); LEFT(tp2) < RIGHT(tp); tp2 = TR(tp2))
{
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetTopType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
if (!(sides & IGNORE_BOTTOM))
for (tp2 = LB(tp); LEFT(tp2) < RIGHT(tp); tp2 = TR(tp2))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetTopType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
}
}
}
/* right */
for (tp2 = TR(tp); TOP(tp2) > BOTTOM(tp); tp2 = LB(tp2))
{
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetLeftType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
if (!(sides & IGNORE_RIGHT))
for (tp2 = TR(tp); TOP(tp2) > BOTTOM(tp); tp2 = LB(tp2))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetLeftType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
}
}
}
/* left */
for (tp2 = BL(tp); BOTTOM(tp2) < TOP(tp); tp2 = RT(tp2))
{
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetRightType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
if (!(sides & IGNORE_LEFT))
for (tp2 = BL(tp); BOTTOM(tp2) < TOP(tp); tp2 = RT(tp2))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
if (TiGetClientINT(tp2) == DEV_PROCESSED) continue;
ttype = TiGetRightType(tp2);
if ((ttype == thisDev->type) || (DBIsContact(ttype)
&& TTMaskHasType(DBResidueMask(ttype), thisDev->type)))
{
TiSetClientINT(tp2, DEV_PROCESSED);
STACKPUSH((ClientData)tp2, devExtentsStack);
}
}
}
}
/* Reset the device tile client records */
@ -933,10 +985,19 @@ ResShaveContacts(tile, dinfo, def)
int pNum;
int pMask;
/* To do: Handle split tiles, although this is unlikely for
* contact types.
/* To simplify processing, if a split tile does not have TT_SPACE
* on either side, then only the left side is processed.
*/
ttype = TiGetType(tile);
if (IsSplit(tile))
{
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
ttype = (dinfo & TT_SIDE) ? TiGetRightType(tile) : TiGetLeftType(tile);
}
else
ttype = TiGetTypeExact(tile);
if (DBIsContact(ttype))
{
@ -1295,7 +1356,22 @@ ResGetTileFunc(tile, dinfo, tpptr)
TileType dinfo; /* (unused) */
Tile **tpptr;
{
if (TiGetType(tile) != TT_SPACE)
/* To simplify processing, if a split tile does not have TT_SPACE
* on either side, then only the left side is processed.
*/
TileType ttype;
if (IsSplit(tile))
{
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
if (dinfo & TT_SIDE)
return 0;
ttype = (dinfo & TT_SIDE) ? TiGetRightType(tile) : TiGetLeftType(tile);
}
else
ttype = TiGetTypeExact(tile);
if (ttype != TT_SPACE)
{
*tpptr = tile;
return 1;
@ -1314,7 +1390,8 @@ ResGetTileFunc(tile, dinfo, tpptr)
* Results: returns source diffusion tile, if it exists. Otherwise, return
* NULL.
*
* Side Effects: none
* Side Effects:
* None.
*
*-------------------------------------------------------------------------
*/
@ -1401,15 +1478,9 @@ FindStartTile(goodies, SourcePoint)
if (IsSplit(tile))
{
if (TTMaskHasType(&ExtCurStyle->exts_deviceMask, TiGetLeftType(tile)) != 0)
{
t1 = TiGetLeftType(tile);
TiSetBody(tile, t1 & ~TT_SIDE);
}
else if (TTMaskHasType(&ExtCurStyle->exts_deviceMask, TiGetRightType(tile)) != 0)
{
t1 = TiGetRightType(tile);
TiSetBody(tile, t1 & TT_SIDE);
}
else
{
TxError("Couldn't find device at %d %d\n",

58
resis/ResMakeRes.c
View File

@ -52,9 +52,8 @@ bool ResCalcEastWest();
*/
bool
ResCalcTileResistance(tile, dinfo, junk, pendingList, doneList)
ResCalcTileResistance(tile, junk, pendingList, doneList)
Tile *tile;
TileType dinfo;
tileJunk *junk;
resNode **pendingList, **doneList;
@ -88,15 +87,15 @@ ResCalcTileResistance(tile, dinfo, junk, pendingList, doneList)
if (device)
{
merged |= ResCalcNearDevice(tile, dinfo, pendingList, doneList, &ResResList);
merged |= ResCalcNearDevice(tile, pendingList, doneList, &ResResList);
}
else if (MaxY-MinY > MaxX-MinX)
{
merged |= ResCalcNorthSouth(tile, dinfo, pendingList, doneList, &ResResList);
merged |= ResCalcNorthSouth(tile, pendingList, doneList, &ResResList);
}
else
{
merged |= ResCalcEastWest(tile, dinfo, pendingList, doneList, &ResResList);
merged |= ResCalcEastWest(tile, pendingList, doneList, &ResResList);
}
/*
@ -121,14 +120,14 @@ ResCalcTileResistance(tile, dinfo, junk, pendingList, doneList)
*/
bool
ResCalcEastWest(tile, dinfo, pendingList, doneList, resList)
ResCalcEastWest(tile, pendingList, doneList, resList)
Tile *tile;
TileType dinfo;
resNode **pendingList, **doneList;
resResistor **resList;
{
int height;
bool merged;
TileType ttype;
Breakpoint *p1, *p2, *p3;
resResistor *resistor;
resElement *element;
@ -153,6 +152,16 @@ ResCalcEastWest(tile, dinfo, pendingList, doneList, resList)
return(merged);
}
/* Simplified split tile handling */
if (IsSplit(tile))
{
ttype = TiGetLeftType(tile);
if (TiGetLeftType(tile) == TT_SPACE)
ttype = TiGetRightType(tile);
}
else
ttype = TiGetTypeExact(tile);
/* Re-sort nodes left to right. */
ResSortBreaks(&junk->breakList, TRUE);
@ -242,19 +251,17 @@ ResCalcEastWest(tile, dinfo, pendingList, doneList, resList)
p2->br_this->rn_re = element;
resistor->rr_cl = (TOP(tile) + BOTTOM(tile)) >> 1;
resistor->rr_width = height;
resistor->rr_tt = ttype;
if (IsSplit(tile))
{
resistor->rr_tt = (dinfo & TT_SIDE) ? SplitRightType(tile)
: SplitLeftType(tile);
resistor->rr_status = RES_DIAGONAL;
resistor->rr_status |= (SplitDirection(tile)) ? RES_NS
: RES_EW;
}
else
{
resistor->rr_status = RES_EW;
resistor->rr_tt = TiGetTypeExact(tile);
resistor->rr_tt = ttype;
}
#ifdef ARIEL
resistor->rr_csArea = height *
@ -293,14 +300,14 @@ ResCalcEastWest(tile, dinfo, pendingList, doneList, resList)
*/
bool
ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList)
ResCalcNorthSouth(tile, pendingList, doneList, resList)
Tile *tile;
TileType dinfo;
resNode **pendingList, **doneList;
resResistor **resList;
{
int width;
bool merged;
TileType ttype;
Breakpoint *p1, *p2, *p3;
resResistor *resistor;
resElement *element;
@ -328,6 +335,16 @@ ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList)
/* Re-sort nodes south to north. */
ResSortBreaks(&junk->breakList, FALSE);
/* Simplified split tile handling */
if (IsSplit(tile))
{
ttype = TiGetLeftType(tile);
if (TiGetLeftType(tile) == TT_SPACE)
ttype = TiGetRightType(tile);
}
else
ttype = TiGetTypeExact(tile);
/*
* Eliminate breakpoints with the same Y coordinate and merge
* their nodes.
@ -412,10 +429,9 @@ ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList)
p2->br_this->rn_re = element;
resistor->rr_cl = (LEFT(tile) + RIGHT(tile)) >> 1;
resistor->rr_width = width;
resistor->rr_tt = ttype;
if (IsSplit(tile))
{
resistor->rr_tt = (dinfo & TT_SIDE) ? SplitRightType(tile)
: SplitLeftType(tile);
resistor->rr_status = RES_DIAGONAL;
resistor->rr_status |= (SplitDirection(tile)) ? RES_NS
: RES_EW;
@ -423,7 +439,6 @@ ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList)
else
{
resistor->rr_status = RES_NS;
resistor->rr_tt = TiGetTypeExact(tile);
}
#ifdef ARIEL
resistor->rr_csArea = width
@ -466,9 +481,8 @@ ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList)
*/
bool
ResCalcNearDevice(tile, dinfo, pendingList, doneList, resList)
ResCalcNearDevice(tile, pendingList, doneList, resList)
Tile *tile;
TileType dinfo;
resNode **pendingList, **doneList;
resResistor **resList;
@ -646,11 +660,11 @@ ResCalcNearDevice(tile, dinfo, pendingList, doneList, resList)
}
if (deltay > deltax)
{
return ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList);
return ResCalcNorthSouth(tile, pendingList, doneList, resList);
}
else
{
return ResCalcEastWest(tile, dinfo, pendingList, doneList, resList);
return ResCalcEastWest(tile, pendingList, doneList, resList);
}
}
@ -716,7 +730,7 @@ ResCalcNearDevice(tile, dinfo, pendingList, doneList, resList)
}
}
}
return ResCalcNorthSouth(tile, dinfo, pendingList, doneList, resList);
return ResCalcNorthSouth(tile, pendingList, doneList, resList);
}
else
{
@ -756,7 +770,7 @@ ResCalcNearDevice(tile, dinfo, pendingList, doneList, resList)
}
}
}
return ResCalcEastWest(tile, dinfo, pendingList, doneList, resList);
return ResCalcEastWest(tile, pendingList, doneList, resList);
}
}
}