DIRECTORY CD, CDBasics, CDCells, CDDirectory, CDInstances, CDOrient, CDProperties, CDSymbolicObjects, Convert, PWPins, Rope; PWPinsImpl: CEDAR PROGRAM IMPORTS CD, CDBasics, CDCells, CDDirectory, CDInstances, CDOrient, CDProperties, CDSymbolicObjects, Convert, Rope EXPORTS PWPins SHARES CDCells, CDSymbolicObjects = BEGIN OPEN PWPins; GetSide: PUBLIC PROC [ob: CD.Object, pin: CD.Instance] RETURNS [side: Side] = { LargerSide: PROC [hSide, vSide: Side] RETURNS [side: Side] = { delta: INT _ pinRect.x2-pinRect.x1- (pinRect.y2-pinRect.y1); side _ IF delta=0 THEN ERROR ELSE IF delta>0 THEN hSide ELSE vSide; }; rect: CD.Rect _ CD.InterestRect[ob]; -- the border pinRect: CD.Rect _ CDSymbolicObjects.Denotes[pin]; -- bbox of the pin (CDInstances.InstRectO) side _ SELECT TRUE FROM pinRect.x1 = pinRect.x2 AND pinRect.y1 = pinRect.y2 => SELECT pinRect.x1 FROM rect.x1 => left, rect.y1 => bottom, rect.x2 => right, rect.y2 => top, ENDCASE => none, pinRect.x1 = pinRect.x2 => SELECT pinRect.x1 FROM rect.x1 => left, rect.x2 => right, ENDCASE => none, pinRect.y1 = pinRect.y2 => SELECT pinRect.y1 FROM rect.y1 => bottom, rect.y2 => top, ENDCASE => none, rect.y1 = pinRect.y1 AND rect.y2 = pinRect.y2 => ERROR, -- pin on 2 opposite sides rect.x1 = pinRect.x1 AND rect.x2 = pinRect.x2 => ERROR, -- pin on 2 opposite sides rect.y2 = pinRect.y2 AND rect.x1 = pinRect.x1 => LargerSide[top, left], rect.y2 = pinRect.y2 AND rect.x2 = pinRect.x2 => LargerSide[top, right], rect.y1 = pinRect.y1 AND rect.x1 = pinRect.x1 => LargerSide[bottom, left], rect.y1 = pinRect.y1 AND rect.x2 = pinRect.x2 => LargerSide[bottom, right], rect.y2 = pinRect.y2 => top, rect.y1 = pinRect.y1 => bottom, rect.x1 = pinRect.x1 => left, rect.x2 = pinRect.x2 => right, ENDCASE => none; }; EnumerateDeepPinsInContext: PUBLIC EnumerationProc = { value: REF; IF ~filter[CDOrient.MapRect[ itemInCell: CD.InterestRect[ob], cellSize: ob.size, cellInstOrient: orientation, cellInstPos: location]] THEN RETURN; value _ CDProperties.GetObjectProp[ob, enumerationProcProp]; IF value#NIL THEN RETURN [NARROW [value, REF EnumerationProc]^[ob, location, orientation, properties, eachPin, stopEnumerateDeepPins, filter]]; value _ CDProperties.GetProp[ob.class, enumerationProcProp]; IF value#NIL THEN RETURN [NARROW [value, REF EnumerationProc]^[ob, location, orientation, properties, eachPin, stopEnumerateDeepPins, filter]]; ob _ CDDirectory.Expand[ob, NIL, NIL].new; quit _ ob#NIL AND EnumerateDeepPinsInContext[ob, location, orientation, NIL, eachPin, stopEnumerateDeepPins, filter]; }; PinEnumerateDeepPinsInContext: EnumerationProc = { quit _ eachPin[NEW [CD.InstanceRep _ [ob: ob, location: location, orientation: orientation, properties: CDProperties.DCopyProps[properties]]]]; }; CellEnumerateDeepPinsInContext: EnumerationProc = { cellPtr: CD.CellPtr _ NARROW [ob.specificRef]; FOR list: CD.InstanceList _ cellPtr.contents, list.rest WHILE (list#NIL AND ~quit) DO IF ~stopEnumerateDeepPins OR CDProperties.GetInstanceProp[list.first, $StopEnumerateDeepPins]=NIL THEN quit _ EnumerateDeepPinsInContext[ list.first.ob, CDBasics.BaseOfRect[ CDOrient.MapRect[ itemInCell: CDInstances.InstRectO[list.first], cellSize: ob.size, cellInstOrient: orientation, cellInstPos: location]], CDOrient.ComposeOrient[list.first.orientation, orientation], list.first.properties, eachPin, stopEnumerateDeepPins, filter]; ENDLOOP; }; EnumerateDeepPins: PUBLIC PROC [ob: CD.Object, eachPin: InstanceEnumerator, stopEnumerateDeepPins: BOOL _ TRUE] RETURNS [quit: BOOL] = { DefaultFilter: FilterProc = {}; quit _ EnumerateDeepPinsInContext[ob: ob, eachPin: eachPin, stopEnumerateDeepPins: stopEnumerateDeepPins, filter: DefaultFilter]; }; EnumerateEdgePins: PUBLIC PROC [ob: CD.Object, eachPin: InstanceEnumerator, stopEnumerateDeepPins: BOOL _ TRUE] RETURNS [quit: BOOL] = { iRectShrank: CD.Rect _ CDBasics.Extend[CD.InterestRect[ob], -1]; EdgeFilter: FilterProc = {isSubInteresting _ ~CDBasics.Inside[subRect, iRectShrank]}; EachPinFilter: InstanceEnumerator -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE] -- = { IF GetSide[ob, inst]#none THEN quit _ eachPin[inst]; }; quit _ EnumerateDeepPinsInContext[ob: ob, eachPin: EachPinFilter, stopEnumerateDeepPins: stopEnumerateDeepPins, filter: EdgeFilter]; }; ChangePins: PUBLIC PROC [ob: CD.Object, changePinProc: ChangePinProc _ DefaultChangePinProc, stopEnumerateDeepPins: BOOL _ TRUE] RETURNS [cell: CD.Object] = BEGIN cellPtr: CD.CellPtr; KeepPinOnEdge: InstanceEnumerator -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE] -- = { newInst: CD.Instance _ changePinProc[inst]; IF newInst#NIL THEN cellPtr.contents _ CONS [newInst, cellPtr.contents]; }; inst: CD.Instance _ NEW [CD.InstanceRep _ [ob: ob]]; IF stopEnumerateDeepPins THEN CDProperties.PutInstanceProp[inst, $StopEnumerateDeepPins, $StopEnumerateDeepPins]; cell _ CDCells.CreateEmptyCell[]; cellPtr _ NARROW [cell.specificRef]; [] _ EnumerateEdgePins[ob, KeepPinOnEdge]; cellPtr.contents _ CONS[inst, cellPtr.contents]; CDCells.SetInterestRect[cell, CD.InterestRect[ob]]; [] _ CDCells.RepositionCell[cell, NIL]; END; DefaultChangePinProc: PUBLIC ChangePinProc = {newPin _ oldPin}; RenamePins: PUBLIC PROC [ob: CD.Object, renameProc: RenameProc _ DefaultRenameProc, stopEnumerateDeepPins: BOOL _ TRUE] RETURNS [cell: CD.Object] = { ChangePin: ChangePinProc = { newRope: ROPE _ renameProc[CDSymbolicObjects.GetName[oldPin]]; IF Rope.IsEmpty[newRope] THEN RETURN; newPin _ CDInstances.Copy[oldPin]; CDSymbolicObjects.SetName[newPin, newRope]; }; cell _ ChangePins[ob, ChangePin, stopEnumerateDeepPins]; }; DefaultRenameProc: PUBLIC RenameProc = {newRope _ oldRope}; Index: PUBLIC PROC [rope: ROPE, index: INT] RETURNS [indexedRope: ROPE] = { indexedRope _ Rope.Cat[rope, "[", Convert.RopeFromInt[index], "]"]; }; enumerationProcProp: PUBLIC ATOM _ $EnumerationProcPWPins; [] _ CDProperties.RegisterProperty[enumerationProcProp, $PWPins]; CDProperties.InstallProcs[enumerationProcProp, [makeCopy: CDProperties.CopyVal]]; [] _ CDProperties.RegisterProperty[$StopEnumerateDeepPins, $PWPins]; CDProperties.InstallProcs[$StopEnumerateDeepPins, [makeCopy: CDProperties.CopyVal]]; CDProperties.PutProp[CDSymbolicObjects.pinClass, enumerationProcProp, NEW [EnumerationProc _ PinEnumerateDeepPinsInContext]]; CDProperties.PutProp[CDSymbolicObjects.segmentClass, enumerationProcProp, NEW [EnumerationProc _ PinEnumerateDeepPinsInContext]]; CDProperties.PutProp[CDSymbolicObjects.markClass, enumerationProcProp, NEW [EnumerationProc _ PinEnumerateDeepPinsInContext]]; CDProperties.PutProp[CDCells.cellClass, enumerationProcProp, NEW [EnumerationProc _ CellEnumerateDeepPinsInContext]]; END. ΎPWPinsImpl.mesa Copyright c 1985 by Xerox Corporation. All rights reversed. Created by Bertrand Serlet, June, 1985 10:07:28 am PDT Bertrand Serlet, March 25, 1986 11:09:02 pm PST Curry, January 28, 1986 1:42:02 pm PST pinRect.x1 = pinRect.x2 AND pinRect.y1 = pinRect.y2 => none, Because we must finally get instances, this one has in its parameters all necessary information for reconstructing the application. Useful in many RenameProcs for indexing names. e.g. Index["foo", 4]="foo[4]" [] _ CDProperties.RegisterAndInstall[enumerationProcProp, [makeCopy: CDProperties.CopyVal], $PWPins]; [] _ CDProperties.RegisterAndInstall[$StopEnumerateDeepPins, [makeCopy: CDProperties.CopyVal], $PWPins]; Κί˜šœ™Jšœ Οmœ1™Jšœžœ2˜Jšžœžœžœ˜%Jšœ"˜"Jšœ+˜+J˜—Jšœ8˜8Jšœ˜—J˜Jšœžœ"˜;J˜Jšœ-‘™Lš œžœžœžœ žœžœžœ˜KJšœC˜CJšœ˜—J˜Jšœžœžœ˜:J˜Jšœe™eJšœA˜AJšœQ˜QJ˜Jšœh™hJšœD˜DJšœT˜TK˜KšœFžœ4˜}KšœJžœ4˜KšœGžœ4˜~Kšœ=žœ5˜uJ˜Jšžœ˜—J˜—…—#±