From c0dbb2067b5a4d0d2a32dff84c2e8cd3e57b5254 Mon Sep 17 00:00:00 2001 From: "R. Timothy Edwards" Date: Tue, 20 Jan 2026 12:59:36 -0500 Subject: [PATCH] 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. --- VERSION | 2 +- resis/ResBasic.c | 52 ++++++++++-- resis/ResMain.c | 201 ++++++++++++++++++++++++++++++--------------- resis/ResMakeRes.c | 58 ++++++++----- 4 files changed, 220 insertions(+), 93 deletions(-) diff --git a/VERSION b/VERSION index 3f87a080..5d316489 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -8.3.591 +8.3.592 diff --git a/resis/ResBasic.c b/resis/ResBasic.c index 6e45a953..e92c479d 100644 --- a/resis/ResBasic.c +++ b/resis/ResBasic.c @@ -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); diff --git a/resis/ResMain.c b/resis/ResMain.c index 0d76140d..676c08fc 100644 --- a/resis/ResMain.c +++ b/resis/ResMain.c @@ -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", diff --git a/resis/ResMakeRes.c b/resis/ResMakeRes.c index 97d22afe..7b5ce462 100644 --- a/resis/ResMakeRes.c +++ b/resis/ResMakeRes.c @@ -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); } } }