
<<file ///StdCell/SCChanUtilImpl.mesa>>

<<chan utility routines>>
<<>>
DIRECTORY
RTSets,
SC,
SCChanUtil,
SCInstUtil,
SCNetUtil,
SCPrivate,
SCRowUtil;

SCChanUtilImpl: CEDAR PROGRAM
IMPORTS SCChanUtil, SCInstUtil, SCNetUtil, SCRowUtil
EXPORTS SCChanUtil
SHARES SC =

BEGIN

<<clear routing data >>
ClearRouteDat: PUBLIC PROCEDURE [handle: SC.Handle] = {

RowProc: SCRowUtil.EachRowProc = {
lgRow.nFtsOnRow _ 0;
lgRow.dimInvalid _ TRUE};

NetProc: SCNetUtil.EachNetProc = {
net.ftsOnRow _ RTSets.RTMdSetEmpty;
net.chanExits[left] _ net.chanExits[right] _ RTSets.RTMdSetEmpty};

[] _ SCRowUtil.EnumerateRows[handle, RowProc];

[] _ SCNetUtil.EnumerateNets[handle, NetProc]};

<<>>
<<initialize the channel widths >>
InitChanWidths: PUBLIC PROCEDURE [handle: SC.Handle] = {

RowChanProc: SCChanUtil.EachRowChanProc = {
rowChan.chanWidth _ rowChan.initChanWidth};

SideChanProc: SCChanUtil.EachSideChanProc = {
sideChan.sideChanWidth _ sideChan.initSideChanWidth};

[] _ SCChanUtil.EnumerateRowChans[handle, RowChanProc];
[] _ SCChanUtil.EnumerateSideChans[handle, SideChanProc]};

    EnumerateRowChans: PUBLIC PROC [handle: SC.Handle, eachRowChan: SCChanUtil.EachRowChanProc] RETURNS [quit: BOOL _ FALSE] = {

        layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
        rowChans: SCPrivate.RowChans _ layoutData.rowChans;
    FOR chan: NAT IN [1 .. rowChans.count] WHILE ~quit DO 
        quit _ eachRowChan[chan, rowChans.chans[chan]];
    ENDLOOP};


    EnumerateSideChans: PUBLIC PROC [handle: SC.Handle, eachSideChan: SCChanUtil.EachSideChanProc] RETURNS [quit: BOOL _ FALSE] = {

        layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
        sideChans: SCPrivate.SideChans _ layoutData.sideChans;
    FOR lrSide: SCPrivate.LRSide IN SCPrivate.LRSide WHILE ~quit DO 
        quit _ eachSideChan[lrSide, sideChans[lrSide]];
    ENDLOOP};
         
    EnumerateExits: PUBLIC PROC [handle: SC.Handle, rowChan: SCPrivate.RowChan, lrSide: SCPrivate.LRSide, eachExit: 
    SCChanUtil.EachExitProc] RETURNS [quit: BOOL _ FALSE] = {

    FOR exit: NAT IN [1 .. rowChan.numExits[lrSide]] WHILE ~quit DO 
        quit _ eachExit[exit, lrSide, rowChan, rowChan.exits[lrSide][exit]];
    ENDLOOP};

EnumeratePinsOnChan: PUBLIC PROC [handle: SC.Handle,  chan: SCPrivate.MaxChanSr, action: SCChanUtil.EachPinProc] = {
side: SC.Side;
row: NAT;

ForEachPin: SCInstUtil.EachPinProc = {
[] _ action[instance, netPin, side]}; 

ForEachIntInstance: SCRowUtil.EachInstProc = {
[] _ SCInstUtil.EnumeratePinsOnInst[instance, ForEachPin]};

side _ top; row _ chan - 1;
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, row, ForEachIntInstance];
side _ bottom; row _ chan;
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, row, ForEachIntInstance]};

END.