
<<SCNetUtilImpl.mesa>>
    <<Copyright Ó 1986, 1987 by Xerox Corporation.  All rights reserved.>>
    <<Frank Bowers January 27, 1986 4:15:38 pm PST>>
    <<Preas April 6, 1987 11:57:58 am PST>>
    <<Cong, August 20, 1987 5:47:10 pm PDT>>

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

SCNetUtilImpl: CEDAR PROGRAM
IMPORTS SCInstUtil, SCNetUtil, SCRowUtil
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 
        IF nets.nets[n].pins.size > 0 THEN quit _ eachNet[n, nets.nets[n]];
    ENDLOOP;
        };
         
    EnumeratePinsOnNet: PUBLIC PROC [net: SCPrivate.Net, eachPin: SCNetUtil.EachPinProc] RETURNS [quit: BOOL _ FALSE] = {

    FOR index: NAT IN [0 .. net.pins.size) WHILE ~quit DO 
        quit _ eachPin[net.pins.np[index]];
    ENDLOOP};

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

        netPin: SCPrivate.NetPin _ NEW[SCPrivate.NetPinRec _ [pinClass: pinClass, instance: instance, pin: pin]];
        pins: SCPrivate.NetPinSeq _ NEW[SCPrivate.NetPinSeqRec[net.pins.size+1]];
        FOR index: NAT IN [0 .. net.pins.size) DO
            pins[index] _ net.pins.np[index]
            ENDLOOP;
        pins[pins.size-1] _ netPin;
        instance.pinNets.n[pinIndex] _ NEW[SCPrivate.PinNetRec _ [pin: pin, pinInChan: NIL, net: net]];
        net.pins _ pins};

    RemoveConnections: PUBLIC PROCEDURE [handle: SC.Handle, instance: SCPrivate.Instance] = {
    pinNets: SCPrivate.PinNets _ instance.pinNets;
    FOR index: NAT IN [0 .. pinNets.size-1] DO
    pinNets.n[index] _ NIL;
    ENDLOOP};

    DefineNet: PUBLIC PROCEDURE [handle: SC.Handle, wire: Core.Wire, name: 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;
        nets.count _ nets.count + 1;
        net _ NEW[SCPrivate.NetRec _ [name: name, wire: wire, num: nets.count, trunkWidth: rules.trunkWidth, branchWidth: 
        rules.branchWidth, routeTopology: ALL[[none, none]], pins: NEW[SCPrivate.NetPinSeqRec[0]]]];
        net.num _ nets.count;
        nets.nets[nets.count] _ net;

        net.ftsOnRow _ RTSets.RTMdSetEmpty;
        net.chanExits[left] _ net.chanExits[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 # ftPin THEN pins[countNew] _ netPin;
countNew _ countNew + 1};

CountPins: SCNetUtil.EachPinProc = {
IF netPin.pinClass # ftPin THEN countOld _ countOld + 1};

countOld, countNew: NAT _ 0;
    pins: SCPrivate.NetPinSeq;
[] _ SCNetUtil.EnumeratePinsOnNet[net, CountPins];
    pins _ NEW[SCPrivate.NetPinSeqRec[countOld]];
[] _ SCNetUtil.EnumeratePinsOnNet[net, EachPin];
net.pins _ pins};

    ExitOnSide: PUBLIC PROC [handle: SC.Handle, net: SCPrivate.Net, side: SC.Side] RETURNS [onThisSide: BOOLEAN] ~ {

        EachInstance: SCRowUtil.EachInstProc ~ {
        CheckPin: SCInstUtil.EachPinProc = {
        <<[instance: SCPrivate.Instance, pin: NAT, netPin: SCPrivate.PinNet]>>
        <<>>
            IF netPin.net = net THEN quit _ TRUE};

        quit _ SCInstUtil.EnumeratePinsOnInst[instance, CheckPin]};

        onThisSide _ SCRowUtil.EnumerateAllInstsOnSide[handle, side, EachInstance]};

END.