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; Tile *tp = *tpptr;
int xj, yj; 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; xj = (LEFT(tile) + RIGHT(tile)) / 2;
yj = (TOP(tile) + BOTTOM(tile)) / 2; yj = (TOP(tile) + BOTTOM(tile)) / 2;
ResNewSDDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue); ResNewSDDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue);
@ -168,6 +176,14 @@ ResSubstrateFunc(tile, dinfo, tpptr)
Tile *tp = *tpptr; Tile *tp = *tpptr;
int xj, yj; 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; xj = (LEFT(tile) + RIGHT(tile)) / 2;
yj = (TOP(tile) + BOTTOM(tile)) / 2; yj = (TOP(tile) + BOTTOM(tile)) / 2;
ResNewSubDevice(tp, tile, xj, yj, OTHERPLANE, &ResNodeQueue); 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 bool
ResEachTile(tile, dinfo, startpoint) ResEachTile(tile, startpoint)
Tile *tile; Tile *tile;
TileType dinfo;
Point *startpoint; Point *startpoint;
{ {
@ -207,17 +227,35 @@ ResEachTile(tile, dinfo, startpoint)
tElement *tcell; tElement *tcell;
tileJunk *tstructs= (tileJunk *)TiGetClientPTR(tile); tileJunk *tstructs= (tileJunk *)TiGetClientPTR(tile);
ExtDevice *devptr; ExtDevice *devptr;
int sides;
ResTileCount++; ResTileCount++;
/* Process startpoint, if any. */ /* 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)) 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 else
{
sides = 0;
t1 = TiGetTypeExact(tile); t1 = TiGetTypeExact(tile);
}
if (startpoint != (Point *) NULL) if (startpoint != (Point *) NULL)
{ {
@ -229,7 +267,7 @@ ResEachTile(tile, dinfo, startpoint)
resptr->rn_noderes = 0; resptr->rn_noderes = 0;
ResAddToQueue(resptr, &ResNodeQueue); ResAddToQueue(resptr, &ResNodeQueue);
NEWBREAK(resptr, tile, x, y, NULL); NEWBREAK(resptr, tile, x, y, NULL);
resCurrentNode = resptr; if (resCurrentNode == NULL) resCurrentNode = resptr;
resNodeIsPort(resptr, x, y, tile); resNodeIsPort(resptr, x, y, tile);
} }
@ -286,6 +324,7 @@ ResEachTile(tile, dinfo, startpoint)
*/ */
/* left */ /* left */
if (!(sides & IGNORE_LEFT))
for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp=RT(tp)) for (tp = BL(tile); BOTTOM(tp) < TOP(tile); tp=RT(tp))
{ {
t2 = TiGetRightType(tp); t2 = TiGetRightType(tp);
@ -318,6 +357,7 @@ ResEachTile(tile, dinfo, startpoint)
} }
/* right */ /* right */
if (!(sides & IGNORE_RIGHT))
for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp)) for (tp = TR(tile); TOP(tp) > BOTTOM(tile); tp=LB(tp))
{ {
t2 = TiGetLeftType(tp); t2 = TiGetLeftType(tp);
@ -350,6 +390,7 @@ ResEachTile(tile, dinfo, startpoint)
} }
/* top */ /* top */
if (!(sides & IGNORE_TOP))
for (tp = RT(tile); RIGHT(tp) > LEFT(tile); tp = BL(tp)) for (tp = RT(tile); RIGHT(tp) > LEFT(tile); tp = BL(tp))
{ {
t2 = TiGetBottomType(tp); t2 = TiGetBottomType(tp);
@ -382,6 +423,7 @@ ResEachTile(tile, dinfo, startpoint)
} }
/* bottom */ /* bottom */
if (!(sides & IGNORE_BOTTOM))
for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp)) for (tp = LB(tile); LEFT(tp) < RIGHT(tile); tp=TR(tp))
{ {
t2 = TiGetTopType(tp); t2 = TiGetTopType(tp);
@ -478,7 +520,7 @@ ResEachTile(tile, dinfo, startpoint)
resAllPortNodes(tile, &ResNodeQueue); resAllPortNodes(tile, &ResNodeQueue);
merged = ResCalcTileResistance(tile, dinfo, tstructs, &ResNodeQueue, merged = ResCalcTileResistance(tile, tstructs, &ResNodeQueue,
&ResNodeList); &ResNodeList);
return(merged); return(merged);

201
resis/ResMain.c
View File

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

58
resis/ResMakeRes.c
View File

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