
<<file ///StdCell/SCNetUtilImpl.mesa>>

<<chan utility routines>>
<<>>
DIRECTORY
Rope,
Route,
RTSets,
SC,
SCInstUtil,
SCNetUtil,
SCPrivate,
SCUtil;

SCNetUtilImpl: CEDAR PROGRAM
IMPORTS SCInstUtil, SCNetUtil, SCUtil
EXPORTS SCNetUtil
SHARES SC =

BEGIN

<<find nets attached to component >>
NetsOnInst: PUBLIC PROCEDURE[insts: SCPrivate.InstanceList] RETURNS [nets: SCPrivate.NetList _ NIL] = 

BEGIN
PinProc: SCInstUtil.EachPinProc = {
IF netPin.net # NIL THEN {
net: SCPrivate.Net _ NIL;
FOR netList: SCPrivate.NetList _ nets, netList.rest WHILE netList # NIL AND net # NIL DO
IF netList.first = netPin.net THEN net _ netList.first;
ENDLOOP;
IF net # NIL THEN nets _ CONS[net, nets]}};

FOR instList: SCPrivate.InstanceList _ insts, instList.rest WHILE instList # NIL DO
inst: SCPrivate.Instance _ instList.first;
[] _ SCInstUtil.EnumeratePinsOnInst[inst, PinProc];
ENDLOOP;
END;

<<determine components on net >>
InstsOnNets: PUBLIC PROCEDURE[nets: SCPrivate.NetList] RETURNS [insts: SCPrivate.InstanceList _ NIL] = {

InstProc: SCNetUtil.EachInstProc = {
IF instance # NIL THEN insts _ CONS[instance, insts]};

[] _ SCNetUtil.EnumerateInstsOnNets[nets, InstProc]};

<<determine components on net >>
EnumerateInstsOnNets: PUBLIC PROCEDURE[nets: SCPrivate.NetList, eachInst: SCNetUtil.EachInstProc] RETURNS [quit: BOOL _ FALSE] = {

PinProc: SCNetUtil.EachPinProc = {
instance: SCPrivate.Instance _ netPin.instance;
IF instance # NIL THEN {
found: BOOLEAN _ FALSE;
FOR instanceList: SCPrivate.InstanceList _ insts, instanceList.rest WHILE instanceList # NIL AND ~found DO
IF instanceList.first = instance THEN found _ TRUE;
ENDLOOP;
IF ~found THEN
{insts _ CONS[instance, insts]; quit _ eachInst[instance]}}};

insts: SCPrivate.InstanceList _ NIL;
FOR netList: SCPrivate.NetList _ nets, netList.rest WHILE netList # NIL AND ~quit DO
[] _ SCNetUtil.EnumeratePinsOnNet[netList.first, PinProc];
ENDLOOP;
};

    EnumerateNets: PUBLIC PROC [handle: SC.Handle, eachNet: SCNetUtil.EachNetProc] RETURNS [quit: BOOL _ FALSE] = {

        structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
        nets: SCPrivate.Nets _ structureData.nets;
    FOR n: NAT IN [1 .. nets.count] WHILE ~quit DO 
        quit _ eachNet[n, nets.nets[n]];
    ENDLOOP;
        };
         
    EnumeratePinsOnNet: PUBLIC PROC [net: SCPrivate.Net, eachPin: SCNetUtil.EachPinProc] RETURNS [quit: BOOL _ FALSE] = {

    FOR pinList: SCPrivate.NetPinsList _ net.pins, pinList.rest WHILE pinList # NIL AND ~quit DO 
        quit _ eachPin[pinList.first];
    ENDLOOP};

    AddConnection: PUBLIC PROCEDURE [handle: SC.Handle, net: SCPrivate.Net, instance: SCPrivate.Instance, pin: SCPrivate.ObjectPin, 
    pinIndex: NAT] = {

        netPin: SCPrivate.NetPin _ NEW[SCPrivate.NetPinRec];
        netPin.instance _ instance;
        netPin.pin _ pin;
        instance.pinNets.n[pinIndex] _ [pin, net];
        net.pins _ CONS[netPin, net.pins]};

    RemoveConnection: PUBLIC PROCEDURE [handle: SC.Handle, net: SCPrivate.Net, instance: SCPrivate.Instance, pin: SCPrivate.ObjectPin, 
    pinIndex: NAT] = {
        };

    DefineNet: PUBLIC PROCEDURE [handle: SC.Handle, netName: Rope.ROPE]
        RETURNS [net: SCPrivate.Net _ NIL] = {
        <<>>
        <<define a net>>
        structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
        rules: Route.DesignRules _ handle.rules.rowRules;
        nets: SCPrivate.Nets _ structureData.nets;
        acBus: SCPrivate.AcBus _ SCUtil.FindBus[handle, netName];
        nets.count _ nets.count + 1;
        net _ NEW[SCPrivate.NetRec _ [name: netName, netNum: nets.count, trunkWidth: rules.trunkWidth, branchWidth: rules.branchWidth]];
        net.netNum _ nets.count;
        nets.nets[nets.count] _ net;

        <<get  signals to roue without feedthrus>>
        IF acBus = NIL THEN net.feedThrusAllowed _ TRUE
        ELSE {net.feedThrusAllowed _ FALSE; acBus.net _ net};

        net.ftsOnRow _ RTSets.RTMdSetEmpty;
        net.rowExits[left] _ net.rowExits[right] _ RTSets.RTMdSetEmpty};

<<remove the fts on a net list >>
RemoveFtsOnNet: PUBLIC PROCEDURE[handle: SC.Handle, net: SCPrivate.Net] = {

EachPin: SCNetUtil.EachPinProc = {
IF netPin.pinClass = compPin THEN {
IF netPin.instance.whichClass # ft THEN pinList _ CONS [netPin, pinList]
ELSE pinList _ CONS [netPin, pinList]}};

pinList: SCPrivate.NetPinsList _ NIL;
[] _ SCNetUtil.EnumeratePinsOnNet[net, EachPin];
net.pins _ pinList};
END.