DIRECTORY
IO, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil,  SCPrivate, SCRowUtil, SCPlaceUtil, Rope, RTSets,  SCSmash, SCUtil, SCWidthUtil, TerminalIO;

SCSmashImpl: CEDAR PROGRAM
IMPORTS IO, RTBasic, SC, SCChanUtil, SCInstUtil, SCNetUtil, SCWidthUtil, SCPlaceUtil, SCRowUtil, SCSmash, SCUtil, RTSets, TerminalIO
EXPORTS SCSmash
SHARES SC = { 

debug: BOOLEAN _ FALSE;

GetGoodFtPos: PROC [net: SCPrivate.Net, row: SCPrivate.MaxRowSr, nLgsOnRow: SCPrivate.ZMaxPosSr] RETURNS [midPos: SCPrivate.MaxPosSr] = {
minPos: SC.Number _ LAST[SC.Number];
maxPos: SC.Number _ FIRST[SC.Number];

EachPin: SCNetUtil.EachPinProc = {
instance: SCPrivate.Instance _ netPin.instance;
SELECT instance.whichClass  FROM
ft, logic => {
SELECT instance.curRow FROM
row, row+1, row-1 => {
minPos _ MIN[minPos, instance.curPos];
maxPos _ MAX[maxPos, instance.curPos]};
ENDCASE;
};
ENDCASE
};

[]  _ SCNetUtil.EnumeratePinsOnNet[net, EachPin];
IF minPos = LAST[SC.Number] AND maxPos = FIRST[SC.Number] THEN midPos _ (1+ nLgsOnRow)/2  -- no instances in channels near row
ELSE {
minPos _ SELECT minPos FROM
< 1 => 1, > nLgsOnRow => nLgsOnRow+1, ENDCASE => minPos;
maxPos _ SELECT maxPos FROM
< 1 => 1, > nLgsOnRow => nLgsOnRow+1, ENDCASE => maxPos;
midPos _ (minPos + maxPos)/2}};

AddFt: PROCEDURE[handle: SC.Handle, lgRow: SCPrivate.LgRow, net: SCPrivate.Net]
RETURNS [ftInst: SCPrivate.Instance] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
bpRows: SCPrivate.BpRows _ layoutData.bpRows;
row: SCPrivate.MaxRowSr _ lgRow.rowNum;
savPos: SCPrivate.MaxPosSr _ 1;
ftInst _ NewFt[handle, net, lgRow];
IF net.ftsOnRow[(row)-1] THEN SC.Error[programmingError, NIL];
net.ftsOnRow _ RTSets.RTMdSetUnion[net.ftsOnRow, 
RTSets.RTMdSetGenerateElement[(row)-1]];
savPos _ GetGoodFtPos[net, row, lgRow.nLgsOnRow]; -- find a good (not best) position for better performance
SCPlaceUtil.PutLgPos[handle, ftInst, row, savPos, SCInstUtil.defltLgOrien, TRUE]}; 

DetermineExits: PROCEDURE[handle: SC.Handle, side: SCPrivate.LRSide, net: SCPrivate.Net]
RETURNS [onChan: SCPrivate.ChanSet _ RTSets.RTMdSetEmpty] = {

ChanExitProc: SCChanUtil.EachRowChanProc = {
IF onChan[(chan) - 1] THEN AddExit[handle, rowChan, side, net]};

EachPinProc: SCNetUtil.EachPinProc = {
instance: SCPrivate.Instance _ netPin.instance;
pin: SCPrivate.ObjectPin _ netPin.pin;

IF instance.whichClass = io THEN {
p: SCInstUtil.PinDescription _ SCInstUtil.PosOf[instance, pin];
IF instance.curSide = side
AND instance.curPos > 0 AND p.sideOn = chanSide THEN {
IF rowChans.count <= 2 THEN 
onChan _ RTSets.RTMdSetGenerateElement[(1)-1]
ELSE {
ChanProc: SCChanUtil.EachRowChanProc = {
IF touchesChan[(chan)-1] THEN {

SetMinMaxDists: PROCEDURE [] =
{IF dist < minDist THEN {minDistChan _ chan; minDist _ dist};
IF chanPos > maxChanPos THEN {maxChan _ chan; maxChanPos _ chanPos};
IF chanPos < minChanPos THEN {minChan _ chan; minChanPos _ chanPos}};

chanPos: SC.Number _ rowChan.chanPos + rowChan.chanWidth/2;
dist: SC.Number _ ABS[chanPos - holdBpPos];
layoutParms: SCPrivate.LayoutParms _ layoutData.layoutParms;

SELECT TRUE FROM
~layoutParms.useInteriorChanExits => SetMinMaxDists;

layoutParms.useInteriorChanExits =>
IF (1 < chan AND chan < rowChans.count) THEN SetMinMaxDists;

ENDCASE}};

minDist, minChanPos: SC.Number _ LAST[INT];
maxChanPos: SC.Number _ -LAST[INT];
minDistChan, maxChan, minChan: SCPrivate.ZMaxChanSr _ 0;
holdBpPos: SC.Number _ SCInstUtil.BpPos[handle, instance] + p.yPos;

[] _ SCChanUtil.EnumerateRowChans[handle, ChanProc];

SELECT TRUE FROM
holdBpPos > maxChanPos AND maxChan > 0 =>
onChan _ RTSets.RTMdSetUnion[onChan, RTSets.RTMdSetGenerateElement[(maxChan)-1]];

holdBpPos < minChanPos AND minChan > 0 =>
onChan _ RTSets.RTMdSetUnion[onChan, RTSets.RTMdSetGenerateElement[(minChan)-1]];

minDistChan > 0 =>
onChan _ RTSets.RTMdSetUnion[onChan, RTSets.RTMdSetGenerateElement[(minDistChan)-1]];
ENDCASE}}}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
chanSide: RTBasic.Side _ RTBasic.OtherSide[side];
instList: SCPrivate.InstanceList _ SCNetUtil.InstsOnNets[LIST[net]];
touchesChan: SCPrivate.ChanSet _ SCInstUtil.ChansForInsts[handle, instList];

net.chanExits[side] _ RTSets.RTMdSetEmpty;

[] _ SCNetUtil.EnumeratePinsOnNet[net, EachPinProc];
[] _ SCChanUtil.EnumerateRowChans[handle, ChanExitProc]};

DoChans: PROC [handle: SC.Handle, net: SCPrivate.Net, lChan, uChan, maxChan: SCPrivate.MaxChanSr] ~ {

lastTopology: SCPrivate.UpperLowerConnection _ net.routeTopology[lChan-1];
FOR chan: SCPrivate.MaxChanSr IN [lChan .. uChan] DO 
IF chan = maxChan THEN
net.routeTopology[chan] _ [full, full]
ELSE IF chan = maxChan -1 THEN {
net.routeTopology[chan] _
IF lastTopology.upper = full THEN [min, full] ELSE [full, full]}
ELSE 
net.routeTopology[chan] _
IF lastTopology.upper = full THEN [min, min] ELSE [full, full];
lastTopology _ net.routeTopology[chan];
ENDLOOP};

ConnectRows: PROCEDURE[handle: SC.Handle, net: SCPrivate.Net, onRow: SCPrivate.RowSet, leftOnChan, rightOnChan, inDoChans: SCPrivate.ChanSet, inDoRows: SCPrivate.RowSet] 
RETURNS [doChanWidth: SCPrivate.ChanSet, doRowWidths: SCPrivate.RowSet] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
onChan: SCPrivate.ChanSet _ RTSets.RTMdSetUnion[leftOnChan, rightOnChan];
lRow: SCPrivate.MaxRowSr _ 1;
uRow: SCPrivate.ZMaxRowSr _ lgRows.count;
found: BOOLEAN _ FALSE;
doRowWidths _ inDoRows;
doChanWidth _ inDoChans;

WHILE lRow <= lgRows.count AND NOT found DO
IF onRow[(lRow)-1] THEN found _ TRUE
ELSE lRow _ lRow + 1;
ENDLOOP;
found _ FALSE;
WHILE uRow >= 1 AND ~found DO
IF onRow[(uRow)-1] THEN found _ TRUE
ELSE uRow _ uRow -1;
ENDLOOP;

IF lRow = 1 THEN {
net.routeTopology[1] _ [full, full];
net.routeTopology[2] _ IF lgRows.count <= 2 THEN [full, full] ELSE [full, min];
DoChans[handle, net, 3, uRow+1, rowChans.count]}
ELSE IF lRow = lgRows.count THEN {
net.routeTopology[rowChans.count-1] _ [full, full];
net.routeTopology[rowChans.count] _ [full, full]}
ELSE {
net.routeTopology[lRow] _ IF onChan[lRow-1] THEN [min, min] ELSE [none, none];
DoChans[handle, net, lRow+1, uRow+1, rowChans.count]};

FOR row: SCPrivate.MaxRowSr IN [lRow .. uRow] DO 
IF ~onRow[(row)-1] THEN {
[] _ AddFt[handle, lgRows.rows[row], net];
doRowWidths _ RTSets.RTMdSetUnion[doRowWidths, RTSets.RTMdSetGenerateElement[(row)-1]];
doChanWidth _ RTSets.RTMdSetUnion[doChanWidth, 
RTSets.RTMdSetAddElement[(row)-1, 
RTSets.RTMdSetGenerateElement[(row + 1)-1]]]};
ENDLOOP};

SmashNets: PUBLIC PROCEDURE[handle: SC.Handle, nets: SCPrivate.NetList, doWidths: BOOLEAN, inDoChans: SCPrivate.ChanSet, inDoSides: SCPrivate.LRSideSet, inDoRows: SCPrivate.RowSet]
RETURNS [doChanWidths: SCPrivate.ChanSet, doSideWidths: SCPrivate.LRSideSet, doRowWidths: SCPrivate.RowSet] = {

EachNet: SCNetUtil.EachNetProc = {
onSide: SCPrivate.SideSet;
onRow: SCPrivate.RowSet;
leftOnChan, rightOnChan: SCPrivate.ChanSet _ RTSets.RTMdSetEmpty;
instList: SCPrivate.InstanceList _ SCNetUtil.InstsOnNets[LIST[net]];
numInstances: SCPrivate.ZMaxInstanceSr _ SCInstUtil.NumInstsOnList[instList];

doChanWidths _ inDoChans;
doSideWidths _ inDoSides;
doRowWidths _ inDoRows;

CleanUpNet[handle, net];

[onSide, onRow] _ SCRowUtil.RowsForInsts[instList];

IF onSide[LOOPHOLE[SC.Side[left], INTEGER]] THEN
{leftOnChan _ DetermineExits[handle, left, net];
doSideWidths _ RTSets.RTSmSetUnion[doSideWidths, RTSets.RTSmSetGenerateElement[LOOPHOLE[SCPrivate.LRSide[left], INTEGER]]]};
doChanWidths _ RTSets.RTMdSetUnion[doChanWidths, leftOnChan];

IF onSide[LOOPHOLE[SC.Side[right], INTEGER]] THEN
{rightOnChan _ DetermineExits[handle, right, net];
doSideWidths _ RTSets.RTSmSetUnion[doSideWidths, RTSets.RTSmSetGenerateElement[LOOPHOLE[SCPrivate.LRSide[right], INTEGER]]]};
doChanWidths _ RTSets.RTMdSetUnion[doChanWidths, rightOnChan];

IF onSide[LOOPHOLE[SC.Side[bottom], INTEGER]] AND ~ onRow[(1)-1] THEN {
[] _ AddFt[handle, lgRows.rows[1], net];
doRowWidths _ RTSets.RTMdSetUnion[doRowWidths, RTSets.RTMdSetGenerateElement[(1)-1]];
onRow _ RTSets.RTMdSetUnion[ RTSets.RTMdSetGenerateElement[(1)-1], onRow];
doChanWidths _ RTSets.RTMdSetUnion[ RTSets.RTMdSetUnion[doChanWidths, RTSets.RTMdSetGenerateElement[(1)-1]], RTSets.RTMdSetGenerateElement[(2)-1]]};

IF (onSide[LOOPHOLE[SC.Side[top], INTEGER]]) AND ~onRow[(lgRows.count)-1] THEN {
[] _ AddFt[handle, lgRows.rows[lgRows.count], net];
doRowWidths _ RTSets.RTMdSetUnion[doRowWidths, RTSets.RTMdSetGenerateElement[(lgRows.count)-1]];
onRow _ RTSets.RTMdSetUnion[ RTSets.RTMdSetGenerateElement[(lgRows.count)-1], onRow];
doChanWidths _ RTSets.RTMdSetUnion[ RTSets.RTMdSetUnion[doChanWidths , RTSets.RTMdSetGenerateElement[(lgRows.count)-1]], RTSets.RTMdSetGenerateElement[(lgRows.count + 1)-1]]};

[doChanWidths, doRowWidths] _ ConnectRows[handle, net, onRow, leftOnChan, rightOnChan, doChanWidths, doRowWidths];
IF doWidths THEN {
EachRow: SCRowUtil.EachRowProc  = {IF doRowWidths[row - 1] THEN SCInstUtil.LgOffsets[handle, row, 0, SCPrivate.maxPos]};
EachChan: SCChanUtil.EachRowChanProc  = {IF doChanWidths[chan - 1] THEN
[rowChan.chanWidth, rowChan.wireLength] _ SCWidthUtil.GetChanWidth[handle, rowChan, areaFom, TRUE]};

[] _ SCRowUtil.EnumerateRows[handle, EachRow];
[] _ SCChanUtil.EnumerateRowChans[handle, EachChan]}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
FOR netLst: SCPrivate.NetList _ nets, netLst.rest WHILE netLst # NIL DO 
[] _ EachNet[netLst.first.num, netLst.first];
ENDLOOP;

IF debug THEN {CheckExits[handle]; CheckFts[handle]};
};

SmashAllNets: PUBLIC PROCEDURE [handle: SC.Handle, doChanWidths: BOOLEAN] = {

NetProc: SCNetUtil.EachNetProc = {
[] _ SmashNets[handle, LIST[net], doChanWidths, RTSets.RTMdSetEmpty, RTSets.RTSmSetEmpty, RTSets.RTMdSetEmpty]};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
TerminalIO.PutRope["Begin topological route\n"];
SCChanUtil.InitChanWidths[handle];
SCInstUtil.AsgnChanPos[handle];
[] _ SCNetUtil.EnumerateNets[handle, NetProc];
SCInstUtil.AllOffsets[handle];
[lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle];
SCWidthUtil.AllChanWidths[handle, areaFom];
SCInstUtil.AsgnChanPos[handle];
[] _ SCUtil.WriteResults["End topological route\n estimated size:", handle, 0]};

RemoveSmash: PUBLIC PROCEDURE [handle: SC.Handle] = {
NetProc: SCNetUtil.EachNetProc = {
[] _ SCSmash.RemoveNetsWFts[handle, LIST[net], FALSE, RTSets.RTMdSetEmpty, RTSets.RTSmSetEmpty, RTSets.RTMdSetEmpty]};

TerminalIO.PutRope["Remove topological route\n"];
[] _ SCNetUtil.EnumerateNets[handle, NetProc];
SCInstUtil.AllOffsets[handle];
TerminalIO.PutRope["End remove topological route\n"]};

ReSmash: PUBLIC PROCEDURE [handle: SC.Handle, doChanWidths: BOOLEAN] = {
RemoveSmash[handle];
SmashAllNets[handle, doChanWidths]};

NewFt: PUBLIC PROCEDURE[handle: SC.Handle, net: SCPrivate.Net, lgRow: SCPrivate.LgRow] RETURNS [ftInst: SCPrivate.Instance] = {
parms: SCPrivate.Parms _ NARROW[handle.parms];
name: Rope.ROPE _ IO.PutFR["%g-%g", IO.rope[net.name], IO.int[lgRow.rowNum]];
ftInst _ SCInstUtil.DefineInstance[handle, name, parms.ftObject, NIL, NIL];
ftInst.ftNet _ net;
SCNetUtil.AddConnection[handle, net, ftInst, parms.ftObject.pins.p[0], 0, ftPin];
SCNetUtil.AddConnection[handle, net, ftInst, parms.ftObject.pins.p[1], 1, ftPin]};
AddExit: PUBLIC PROCEDURE[handle: SC.Handle, rowChan: SCPrivate.RowChan, side: SC.Side, net: SCPrivate.Net] = {

IF rowChan.chanNum = 0 THEN SC.Error[programmingError, NIL]
ELSE {
index: NAT _ rowChan.numExits[side] _ rowChan.numExits[side] + 1;
net.chanExits[side] _
RTSets.RTMdSetUnion[net.chanExits[side], RTSets.RTMdSetGenerateElement[(rowChan.chanNum)-1]];
rowChan.exits[side][index].net _ net;
rowChan.exits[side][index].pos _ 0;
rowChan.exits[side][index].layer _ handle.rules.rowRules.trunkLayer}};

RemvAllExits: PUBLIC PROCEDURE[handle: SC.Handle, net: SCPrivate.Net, lRSide: SCPrivate.LRSide] = {

ChanProc: SCChanUtil.EachRowChanProc = {
RemoveExit[handle, net, rowChan, lRSide]};

[] _ SCChanUtil.EnumerateRowChans[handle, ChanProc]};

RemoveExit: PUBLIC PROCEDURE[handle: SC.Handle, net: SCPrivate.Net, rowChan: SCPrivate.RowChan, lrSide: SCPrivate.LRSide] = {
ChanExitProc: SCChanUtil.EachExitProc = {
IF exit.net # net THEN {
index _ index + 1;
rowChan.exits[lrSide][index] _ rowChan.exits[lrSide][exitNum]}};

index: SCPrivate.ZMaxExitsSr _ 0;
net.chanExits[lrSide] _ RTSets.RTMdSetDifference[net.chanExits[lrSide], RTSets.RTMdSetGenerateElement[(rowChan.chanNum)-1]];
[] _ SCChanUtil.EnumerateExits[handle, rowChan, lrSide, ChanExitProc];
rowChan.numExits[lrSide] _ index};

RemoveNetsWFts: PUBLIC PROCEDURE[handle: SC.Handle, netLst: SCPrivate.NetList, save: BOOLEAN, inDoChans: SCPrivate.ChanSet, inDoSides: SCPrivate.LRSideSet, inDoRows: SCPrivate.RowSet]

RETURNS [doChanWidths: SCPrivate.ChanSet, doSideWidths: SCPrivate.LRSideSet, doRowWidths: SCPrivate.RowSet] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
globalRoute: SCSmash.GlobalRoute _ NEW[SCSmash.GlobalRouteRec];
layoutData.globalRoute _ globalRoute;
doChanWidths _ inDoChans;
doSideWidths _ inDoSides;
doRowWidths _ inDoRows;

IF save THEN {globalRoute.numFts _ globalRoute.numNets _ 0};

FOR nets: SCPrivate.NetList _ netLst, nets.rest WHILE nets # NIL DO 

EachInst: SCNetUtil.EachInstProc = {
IF instance.whichClass = ft THEN {
IF save THEN {
IF globalRoute.numFts >= SCSmash.maxFtsSaved THEN SC.Error[noResource, NIL];
globalRoute.numFts _ globalRoute.numFts + 1;
globalRoute.fts[globalRoute.numFts] _ NEW[SCSmash.FtDataRec _ [net, instance.curRow, instance.curPos]]};

doRowWidths _ RTSets.RTMdSetUnion[doRowWidths, RTSets.RTMdSetGenerateElement[(instance.curRow)-1]];

doChanWidths _ RTSets.RTMdSetUnion[
RTSets.RTMdSetUnion[doChanWidths,
RTSets.RTMdSetGenerateElement[(instance.curRow)-1]],
RTSets.RTMdSetGenerateElement[(instance.curRow + 1)-1]];
SCPlaceUtil.RemvLgComp[handle, instance, FALSE]}};

EachChan: SCChanUtil.EachRowChanProc = {
FOR lrSide: SCPrivate.LRSide IN SCPrivate.LRSide DO
IF net.chanExits[lrSide][(chan)-1] THEN
{doChanWidths _ RTSets.RTMdSetUnion[doChanWidths, RTSets.RTMdSetGenerateElement[(chan)-1]];
doSideWidths _ RTSets.RTSmSetUnion[doSideWidths , RTSets.RTSmSetGenerateElement[LOOPHOLE[lrSide, INTEGER]]]};
ENDLOOP};

net: SCPrivate.Net _ nets.first;
SCNetUtil.RemoveFtsOnNet[handle, net];
[] _ SCNetUtil.EnumerateInstsOnNets[LIST[net], EachInst];


IF save THEN {
IF globalRoute.numNets >= SCSmash.maxNetsSaved THEN SC.Error[noResource, NIL];
globalRoute.numNets _ globalRoute.numNets + 1;
globalRoute.nets[globalRoute.numNets].net _ net;
globalRoute.nets[globalRoute.numNets].exit[left] _ net.chanExits[left];
globalRoute.nets[globalRoute.numNets].exit[right] _ net.chanExits[right]};

[] _ SCChanUtil.EnumerateRowChans[handle, EachChan];

CleanUpNet[handle, net];
ENDLOOP;
IF debug THEN {CheckExits[handle]; CheckFts[handle]};
};

RestoreNetsWFts: PUBLIC PROCEDURE[handle: SC.Handle, netLst: SCPrivate.NetList, inDoChans: SCPrivate.ChanSet, inDoSides: SCPrivate.LRSideSet, inDoRows: SCPrivate.RowSet]
RETURNS [doChanWidths : SCPrivate.ChanSet, doSideWidths: SCPrivate.LRSideSet, doRowWidths: SCPrivate.RowSet]= {

ChanRowProc: SCRowUtil.EachRowProc = {
IF doRowWidths[(row)-1] THEN SCInstUtil.LgOffsets[handle, row, 0, SCPrivate.maxPos]};

CheckConnection: PROCEDURE[net: SCPrivate.Net, leftExitChan, rightExitChan: SCPrivate.RowChan] = {

instList: SCPrivate.InstanceList _ SCNetUtil.InstsOnNets[LIST[net]];
onSide: SCPrivate.SideSet;
onRow: SCPrivate.RowSet;

[onSide, onRow] _ SCRowUtil.RowsForInsts[instList];
IF leftExitChan.chanNum = 1 OR rightExitChan.chanNum = 1 THEN {
IF NOT (onSide[LOOPHOLE[SC.Side[bottom], INTEGER]] OR onRow[(1)-1]) THEN
SC.Error[programmingError, NIL]}
ELSE IF leftExitChan.chanNum = rowChans.count OR rightExitChan.chanNum = rowChans.count THEN {
IF NOT (onSide[LOOPHOLE[SC.Side[top ], INTEGER]] OR onRow[(rowChans.count-1)-1]) THEN
SC.Error[programmingError, NIL]};
IF 1 < leftExitChan.chanNum AND leftExitChan.chanNum < rowChans.count THEN {
IF NOT (onRow[(leftExitChan.chanNum) - 1] OR onRow[(leftExitChan.chanNum-1) - 1]) THEN
SC.Error[programmingError, NIL]};
IF 1 < rightExitChan.chanNum AND rightExitChan.chanNum < rowChans.count THEN {
IF NOT (onRow[(rightExitChan.chanNum)-1] OR onRow[(rightExitChan.chanNum-1)-1]) THEN
SC.Error[programmingError, NIL]}};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
globalRoute: SCSmash.GlobalRoute _ NARROW[layoutData.globalRoute];
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
doChanWidths _ inDoChans;
doSideWidths _ inDoSides;
doRowWidths _ inDoRows;

FOR ftIndex: SCSmash.ZMFtsSavedSr DECREASING IN [1 .. globalRoute.numFts] DO 
net: SCPrivate.Net _ globalRoute.fts[ftIndex].net;
row: NAT _ globalRoute.fts[ftIndex].row;
ftInst: SCPrivate.Instance _ NewFt[handle, net, lgRows.rows[row]];

SCPlaceUtil.PutLgPos[handle, ftInst, row, globalRoute.fts[ftIndex].pos, SCInstUtil.defltLgOrien, FALSE];
doRowWidths _ RTSets.RTMdSetUnion[doRowWidths, 
RTSets.RTMdSetGenerateElement[(row)-1]];
doChanWidths _ RTSets.RTMdSetUnion[doChanWidths, 
RTSets.RTMdSetAddElement[(row)-1, 
RTSets.RTMdSetGenerateElement[(row + 1)-1]]];
ENDLOOP;

[] _ SCRowUtil.EnumerateRows[handle, ChanRowProc];
FOR netIndex: SCSmash.MNetsSavedSr DECREASING IN [1 .. globalRoute.numNets] DO 
ChanRowProc: SCChanUtil.EachRowChanProc = {
FOR lrSide: SC.Side IN SCPrivate.LRSide DO
RemoveExit[handle, net, rowChan, lrSide];
IF globalRoute.nets[netIndex].exit[lrSide][(chan)-1] THEN {
exitChan[lrSide] _ rowChan;
AddExit[handle, rowChan, lrSide, net];
doChanWidths _ RTSets.RTMdSetUnion[doChanWidths, 
RTSets.RTMdSetGenerateElement[(chan)-1]];
doSideWidths _ RTSets.RTSmSetUnion[doSideWidths , RTSets.RTSmSetGenerateElement[LOOPHOLE[lrSide, INTEGER]]]};
ENDLOOP};

exitChan: ARRAY SCPrivate.LRSide OF SCPrivate.RowChan _ [NIL, NIL];
net: SCPrivate.Net _ globalRoute.nets[netIndex].net;
net.chanExits[left] _ RTSets.RTMdSetEmpty;
net.chanExits[right] _ RTSets.RTMdSetEmpty;
[] _ SCChanUtil.EnumerateRowChans[handle, ChanRowProc];

CheckConnection[net, exitChan[left], exitChan[right]];
ENDLOOP;
IF debug THEN {CheckExits[handle]; CheckFts[handle]};
};

CheckExits: PUBLIC PROCEDURE [handle: SC.Handle] = {
NetProc: SCNetUtil.EachNetProc = {
ChanExitProc: SCChanUtil.EachRowChanProc = {
SideProc: SCChanUtil.EachSideChanProc = {
ExitProc: SCChanUtil.EachExitProc = {
IF exit.net = net THEN quit _ TRUE};

exitPresent: BOOLEAN _ RTSets.RTMdSetIsSubset[ RTSets.RTMdSetGenerateElement[chan - 1], net.chanExits[lrSide]];
found: BOOLEAN _ SCChanUtil.EnumerateExits[handle, rowChan, lrSide, ExitProc];
IF exitPresent AND ~found OR ~exitPresent AND found THEN
SC.Error[programmingError, NIL]};

[] _ SCChanUtil.EnumerateSideChans[handle, SideProc]};
[] _ SCChanUtil.EnumerateRowChans[handle, ChanExitProc]};
[] _ SCNetUtil.EnumerateNets[handle, NetProc]};

CheckFts: PUBLIC PROCEDURE [handle: SC.Handle] = {

EachNet: SCNetUtil.EachNetProc = {CheckFtsOnNet[handle, net]};
[] _ SCNetUtil.EnumerateNets[handle, EachNet]};

CheckFtsOnNet: PUBLIC PROCEDURE[handle: SC.Handle, net: SCPrivate.Net] = {

EachRow: SCRowUtil.EachRowProc = {
PosProc: SCRowUtil.EachInstProc = {
IF instance.whichClass = ft THEN {
netPin1: SCPrivate.Net _ instance.pinNets.n[0].net;
netPin2: SCPrivate.Net _ instance.pinNets.n[1].net;
IF netPin1 = NIL OR netPin2 = NIL OR netPin1 # netPin2 THEN
SC.Error[programmingError, NIL];
IF netPin1 = net THEN {
IF ftsOnRow[row-1] THEN
SC.Error[programmingError, NIL];
ftsOnRow _ RTSets.RTMdSetUnion[ftsOnRow, RTSets.RTMdSetGenerateElement[(row)-1]]}}};

[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, row, PosProc]};

ftsOnRow: SCPrivate.RowSet _ RTSets.RTMdSetEmpty;
[] _ SCRowUtil.EnumerateRows[handle, EachRow];
IF ~RTSets.RTMdSetIsSame[ftsOnRow, net.ftsOnRow] THEN
SC.Error[programmingError, NIL]};

CleanUpNet: PROCEDURE [handle: SC.Handle, net: SCPrivate.Net] = {

EachChan: SCChanUtil.EachRowChanProc  = {net.routeTopology[chan] _ [none, none]};

net.ftsOnRow _ RTSets.RTMdSetEmpty;
RemvAllExits[handle, net, left];
RemvAllExits[handle, net, right];
[] _ SCChanUtil.EnumerateRowChans[handle, EachChan]};
}.
 SCSmashImpl.mesa 
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Frank Bowers February 13, 1986 11:04:31 am PST
Preas December 21, 1986 4:26:20 pm PST
add ft's on interior rows as required 

add side exits as required to net lists 
find preferred position for exit to side surface
PROC [chan: SCPrivate.MaxChanSr, rowChan: SCPrivate.RowChan] RETURNS [quit: BOOL _ FALSE];
PROC [netPin: SCPrivate.NetPin] RETURNS [quit: BOOL _ FALSE];
get position of instance on side 
exit must be on bottom channel
must compute the channel to put the exit on
PROC [chan: SCPrivate.MaxChanSr, rowChan: SCPrivate.RowChan] RETURNS [quit: BOOL _ FALSE];
find distance of port to closest existing channel
determine channel to exit

found channels to exit from, indicated in onChan 
find lowest row that needs ft 

find upper row that needs ft 
determine global route for channels between lChan and uChan inclusive  
add fts to required rows between lrow and urow  

now update the channel widths 
add feedthrus to required rows 
alter the smash of the nets
add ft to row width 
get a component entry for the ft, construct a new entry for instance 

construct and add an entry to net list for this instance 

add an exit to a channel 
remove all exits for net on a lRSide 
remove an exit for net on chan 
remove specified nets with fts 
save indicates whether current smash is to be saved 
now remove the ft 

run through the comps on this net 
now work on the exits 
save route data for specified nets 
make sure feed throughs are in proper channels
RestoreNetsWFts 
first restore the feedthroughs 
find row widths 

now the channel exits 
check to make sure the net is connected 

audit the exits for consistancy
audit the Fts on all nets for consistancy
audit the Fts on net for consistancy
error in connection of net
more than one ft on row for this net on this row
row data does not correspond to instance data
remove the global route on nets
�Êx˜
codeš
œ™Kšœ
Ïm
œ7™BKšœ+Ïk™.Kšœ#ž™&—K˜š
ž	˜	Kšžœžœ�
˜�
K˜—šÏnœžœ
ž˜Kšžœ
žœžœm˜„
Kšžœ˜Kšžœ
žœ˜K˜Kšœžœžœ
˜K˜šŸœžœOžœ!˜‰
Kšœžœ
žœ
žœ	˜$Kšœžœ
žœ
žœ	˜%K˜šŸœ˜"Kš
œ/˜/šžœž˜ š
œ˜šžœž˜˜Kšœ	žœ˜&Kšœ	žœ˜'—Kšžœ
˜—K˜—Kš
ž˜—K˜K˜—Kš
œ1˜1Kšžœ
žœ
žœ	žœ
žœ
žœ	žœÏc$˜~šžœ˜šœ	žœž˜Kšœ&žœ˜8—šœ	žœž˜Kšœ&žœ˜8—Kš
œ˜—K˜—šŸœž	œ	žœ4˜OKšžœ!˜(Kš
œ&™&K˜Kšœ#žœ˜=Kš
œ-˜-Kš
œ-˜-K˜'Kš
œ˜Kš
œ#˜#Kšžœžœ
žœžœ˜>š
œ1˜1Kš
œ(˜(—K™Kšœ2 9˜kšœKžœ˜SK˜——šŸœž	œ	žœ4˜XKšžœ6˜=Kš
œ(™(K˜Kš
œ0™0šŸœ ˜,Kš
œZ™ZKšžœžœ&˜@K˜—šŸœ˜&Kš
œ=™=Kš
œ/˜/Kš
œ&˜&K˜Kš
œ!™!šžœžœ˜"Kš
œ?˜?šžœ˜Kšžœžœžœ˜6šžœžœ
˜Kš
œ™Kš
œ-˜-—šžœ˜Kš
œ+™+šŸœ ˜(Kšžœ9žœžœžœ™Zšžœžœ˜K˜šŸœž	œ˜Kšœ
žœžœ&˜=Kšžœžœ(˜Dšžœžœ)˜EK˜——Kšœ	žœ0˜;Kšœžœ
žœ˜+Kš
œ<˜<K˜šžœ
žœ
ž˜š
œ4˜4K˜—š
œ#˜#šžœžœžœ˜<K˜——Kšžœ˜
——K˜—Kšœžœ
žœ
žœ˜+Kšœžœžœ
žœ˜#Kš
œ8˜8Kšœžœ6˜CK˜Kš
œ1™1Kš
œ4˜4K˜Kš
œ™šžœ
žœ
ž˜šœžœ˜)Kš
œQ˜QK˜—šœžœ˜)Kš
œQ˜Q—K˜š
œ˜Kš
œU˜U—Kšžœ˜————K˜—Kšœ#žœ˜=Kš
œ3˜3Kš
œ1˜1Kšœ9žœ˜DKš
œL˜LK˜Kš
œ*˜*K˜Kš
œ4˜4K™Kš
œ1™1Kš
œ9˜9K˜—šŸœžœ
žœL˜eK˜Kš
œJ˜Jšžœžœžœ
˜5šžœž˜Kš
œ&˜&—šžœ
žœžœ˜ š
œ˜Kšžœžœ
žœ˜@——šžœ
˜š
œ˜Kšžœžœžœ˜?——Kš
œ'˜'Kšžœ˜	——K˜šŸœž	œ	žœ‰
˜ª
KšžœD˜KK˜Kšœ#žœ˜=Kš
œ-˜-Kš
œ3˜3Kš
œI˜IKš
œ˜Kš
œ)˜)Kšœžœžœ
˜Kš
œ˜Kš
œ˜K˜Kš
œ™šžœžœ
žœž˜+Kšžœžœ	ž˜$Kšžœ˜Kšžœ
˜—K™Kš
œ™Kšœžœ
˜šžœžœž˜Kšžœžœ	ž˜$Kšžœ˜Kšžœ
˜K˜—Kš
œG™Gšžœ
žœ˜Kš
œ$˜$Kšœžœžœžœ
˜OKš
œ0˜0—šžœ
žœžœ˜"Kš
œ3˜3Kš
œ1˜1—šžœ˜Kšœžœžœžœ˜NKš
œ6˜6—K˜Kš
œ0™0šžœžœžœ
˜1šžœžœ˜š
œ*˜*Kš
œW˜Wš
œ/˜/Kš
œ"˜"Kš
œ.˜.——Kšžœ˜	——K˜—š
Ÿ	œžœ
ž	œ	žœ,žœ[˜´
Kšžœh˜oK˜šŸœ˜"Kš
œ˜Kš
œ˜Kš
œA˜AKšœ9žœ˜DKš
œM˜MK˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜K˜Kš
œ3˜3K˜š	žœžœ
žœ
žœž˜0Kš
œ0˜0KšœOžœžœ˜|—Kš
œ=˜=K˜š	žœžœ
žœžœž˜1Kš
œ2˜2KšœOžœžœ˜}—Kš
œ>˜>K˜šžœžœ
žœžœžœžœ˜GKš
œ(˜(Kš
œU˜UKš
œJ˜JKš
œ”
˜”
—K˜šžœ	žœ
žœžœžœžœ˜PKš
œ3˜3Kš
œ`˜`Kš
œU˜UKš
œ¯
˜¯
—K˜Kš
œr˜rK™Kš
œ™šžœ
žœ˜KšŸœžœžœ9˜xšŸœ!žœž˜GKšœ]žœ˜d—K˜Kš
œ.˜.Kš
œ6˜6K˜——Kšœ#žœ˜=Kš
œ-˜-Kš
œ3˜3šžœ/žœ
žœ
žœ
˜HKš
œ-˜-Kšžœ
˜K˜—Kšžœžœ(˜5Kš
œ˜K˜—š
Ÿœžœ
ž	œ
žœžœ˜MKš
œ™K˜šŸœ˜"KšœžœU˜p—K˜Kšœ#žœ˜=Kš
œ-˜-Kš
œ0˜0Kš
œ"˜"Kš
œ˜Kš
œ.˜.Kš
œ˜Kš
œG˜GKš
œ+˜+Kš
œ˜Kš
œP˜PK˜—šŸœžœ
ž	œ
žœ˜5Kš
œ™šŸœ˜"Kšœ$žœžœB˜v—K˜Kš
œ1˜1Kš
œ.˜.Kš
œ˜Kš
œ6˜6K˜—š
Ÿœžœ
ž	œ
žœžœ˜HKš
œ˜Kš
œ$˜$K˜—š
Ÿœžœ
ž	œ	žœ5žœ!˜Kš
œ™Kš
œE™EKšœžœ˜.Kš	œžœžœžœžœ˜MKšœAžœžœ˜KK˜K™Kš
œ9™9Kš
œQ˜QKš
œR˜R—K™š
Ÿœžœ
ž	œ	žœ+žœ˜oKš
œ™K˜Kšžœžœ
žœžœ
˜;šžœ˜Kšœžœ7˜Aš
œ˜Kš
œ]˜]—Kš
œ%˜%Kš
œ#˜#Kš
œF˜F——K˜šŸœžœ
ž	œ	žœ:˜cKš
œ%™%K˜šŸœ ˜(Kš
œ*˜*—K˜Kš
œ5˜5K˜—šŸ
œžœ
ž	œ	žœV˜}Kš
œ™šŸœ˜)šžœžœ˜Kš
œ˜Kš
œ@˜@——K˜Kš
œ!˜!Kš
œ|˜|Kš
œF˜FKš
œ"˜"K˜—š
Ÿœžœ
ž	œ	žœ*žœ[˜·
˜Kšžœh˜o—Kš
œ™K˜Kšœ#žœ˜=Kšœ#žœ˜?Kš
œ%˜%Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ4™4Kšžœžœ0˜<K˜šžœ-žœžœ
žœ
˜DK˜šŸœ˜$šžœžœ˜"šžœžœ˜Kšžœ+žœ
žœžœ˜LKš
œ,˜,Kšœ&žœ?˜h—K˜Kš
œ™Kš
œc˜cK˜š
œ#˜#Kš
œ!˜!Kš
œ4˜4Kš
œ8˜8—Kš
œ2˜2—K˜—šŸœ ˜(šžœžœž˜3šžœ!ž˜'Kš
œ[˜[KšœPžœ	žœ˜m—Kšžœ˜	—K˜—Kš
œ ˜ K™Kš
œ"™"Kš
œ&˜&Kšœ$žœ˜9K˜K˜Kš
œ™šžœžœ˜Kšžœ-žœ
žœžœ˜NKš
œ.˜.Kš
œ0˜0Kš
œG˜GKš
œJ˜J—K˜Kš
œ4˜4K˜Kš
œ˜Kšžœ
˜—Kšžœžœ(˜5Kš
œ˜K˜—šŸœžœ
ž	œ	žœ}˜©
Kšžœh˜oKš
œ#™#K˜šŸœ˜&Kšžœžœ9˜UK˜—šŸœž	œH˜bKš
œ.™.K˜Kšœ9žœ˜DKš
œ˜Kš
œ˜K˜Kš
œ3˜3šžœžœžœ˜?š
žœ
žœ	žœ
žœžœžœž˜HKšžœžœ˜ ——šžœ
žœ'žœ(žœ˜^š
žœ
žœ	žœ
žœ
žœžœž˜UKšžœžœ˜!——šžœžœ'žœ˜Lšžœ
žœ$žœ&ž˜VKšžœžœ˜!——šžœžœ(žœ˜Nšžœ
žœ#žœ%ž˜TKšžœžœ˜"———K˜Kš
œ™Kš
œ™Kšœ#žœ˜=Kšœ#žœ˜BKš
œ3˜3Kš
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜K˜šžœž
œ
žœžœ
˜MKš
œ2˜2Kšœžœ ˜(Kš
œB˜BK˜Kšœažœ˜hš
œ/˜/Kš
œ(˜(—š
œ1˜1Kš
œ"˜"Kš
œ-˜-—Kšžœ
˜—K˜Kš
œ™Kš
œ2˜2K™Kš
œ™šžœ ž
œ
žœžœ
˜OšŸœ ˜+šžœ	žœžœž˜*Kš
œ)˜)šžœ3žœ˜;Kš
œ˜Kš
œ&˜&š
œ1˜1Kš
œ)˜)—KšœPžœ	žœ˜m—Kšžœ˜	—K˜—Kš	œ
žœžœžœžœ˜CKš
œ4˜4Kš
œ*˜*Kš
œ+˜+Kš
œ7˜7K˜Kš
œ(™(Kš
œ6˜6Kšžœ
˜—K™Kšžœžœ(˜5Kš
œ˜—˜šŸ
œžœ
ž	œ
žœ˜4Kš
œ™šŸœ˜"šŸœ ˜,šŸœ!˜)šŸœ˜%Kšžœžœžœ˜$K˜—Kšœ
žœ[˜oKšœžœ@˜Nš	žœ
žœžœžœž˜8Kšžœžœ˜!—K˜—Kš
œ6˜6—Kš
œ9˜9—Kš
œ/˜/—K˜šŸœžœ
ž	œ
žœ˜2Kš
œ)™)K˜KšŸœ7˜>Kš
œ/˜/—K˜šŸ
œžœ
ž	œ	žœ ˜JKš
œ$™$K˜šŸœ˜"šŸœ˜#šžœžœ˜"Kš
œ3˜3Kš
œ3˜3šžœžœ
žœžœ
žœž˜;Kš
œ™Kšžœžœ˜ —šžœžœ˜šžœž˜Kš
œ0™0Kšžœžœ˜ —Kš
œT˜T——K˜—Kš
œ=˜=K˜—Kš
œ1˜1Kš
œ.˜.šžœ/ž˜5Kš
œ-™-Kšžœžœ˜!——K˜šŸ
œž	œ
žœ ˜AKš
œ™K˜KšŸœI˜QK˜Kš
œ#˜#Kš
œ ˜ Kš
œ!˜!Kš
œ5˜5—Kš
œ˜———…—OÒjê