DIRECTORY
Basics, 
CD, CDBasics, CDCells, CDDirectory, CDInstances, CDLayers, CDProperties, CDRects, CDSymbolicObjects, CDTexts, 
Convert, 
CoreClasses, CoreFlat, CoreOps, CoreProperties,
CoreGeometry, CoreGeometryBackdoor,
GList, HashTable,
PWObjects, Rope;

CoreGeometryImpl: CEDAR PROGRAM
IMPORTS Basics, CD, CDBasics, CDCells, CDDirectory, CDInstances, CDLayers, CDProperties, CDRects, CDSymbolicObjects, CDTexts, Convert, CoreClasses, CoreFlat, CoreGeometry, CoreOps, CoreProperties, GList, HashTable, PWObjects, Rope
EXPORTS CoreGeometry, CoreGeometryBackdoor
SHARES CDCells, CDRects ~ BEGIN OPEN CoreGeometry, CoreGeometryBackdoor;
CreateDecoration: PUBLIC PROC [name: ROPE] RETURNS [decoration: Decoration] ~ {
decoration _ NEW [DecorationRec _ [
name: name, 
pinsProp: CoreProperties.RegisterProperty[
Convert.AtomFromRope[Rope.Cat[name, "Pins"]], 
CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]
], 
objectProp: CoreProperties.RegisterProperty[
Convert.AtomFromRope[Rope.Cat[name, "Object"]], 
CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]
], 
geometryProp: CoreProperties.RegisterProperty[
Convert.AtomFromRope[Rope.Cat[name, "Geometry"]], 
CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]
], 
transProp: CoreProperties.RegisterProperty[
Convert.AtomFromRope[Rope.Cat[name, "Trans"]], 
CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]
]
]];
};
RawEnumeratePins: PUBLIC PROC [prop: ATOM, value: REF, eachInstance: EachInstanceProc] RETURNS [quit: BOOL _ FALSE] = {
IF value=NIL THEN RETURN;
WITH value SELECT FROM
instances: InstanceSeq	=> FOR i: NAT IN [0 .. instances.size) 
DO IF eachInstance[instances[i]] THEN RETURN [TRUE] ENDLOOP;
instances: Instances	=> WHILE instances#NIL DO 
IF eachInstance[instances.first] THEN RETURN [TRUE];
instances _ instances.rest;
ENDLOOP;
wire: Wire			=> quit _ RawEnumeratePins[prop, CoreProperties.GetWireProp[wire, prop], eachInstance];
wires: LIST OF Wire	=> WHILE wires#NIL DO
IF RawEnumeratePins[prop, CoreProperties.GetWireProp[wires.first, prop], eachInstance] THEN RETURN [TRUE];
wires _ wires.rest;
ENDLOOP;
transWireIR: TransWireIR	=> {
ir: Rect _ transWireIR.ir;
FOR i: NAT IN [0 .. transWireIR.size) DO
TransEachPin: EachInstanceProc = {
IF TransfedNotAtEdge[trans, ir, instance] THEN RETURN;
quit _ eachInstance[Transform[trans, instance]];
};
trans: Transformation _ transWireIR[i].trans;
IF RawEnumeratePins[prop, CoreProperties.GetWireProp[transWireIR[i].wire, prop], TransEachPin] 
THEN RETURN [TRUE];
ENDLOOP;
};
lazyEnumerate: LazyEnumerateData	=> quit _ lazyEnumerate.proc[eachInstance, lazyEnumerate.data1, lazyEnumerate.data2];
ENDCASE	=> ERROR; -- value unknown to this module.  Pins were probably created without using the procedural interface.
};
EnumeratePins: PUBLIC PROC [decoration: Decoration, public: Wire, eachInstance: EachInstanceProc] RETURNS [quit: BOOL] = {
quit _ RawEnumeratePins[decoration.pinsProp, CoreProperties.GetWireProp[public, decoration.pinsProp], eachInstance];
};
CountPins: PUBLIC PROC [decoration: Decoration, public: Wire] RETURNS [count: INT _ 0] = {
CountEachInstance: EachInstanceProc = {count _ count + 1};
value: REF _ CoreProperties.GetWireProp[public, decoration.pinsProp];
IF value=NIL THEN RETURN;
WITH value SELECT FROM
instances: InstanceSeq	=> count _ instances.size;
instances: Instances		=> count _ Length[instances];
ENDCASE					=> [] _ RawEnumeratePins[decoration.pinsProp, value, CountEachInstance];
};
HasPins: PUBLIC PROC [decoration: Decoration, public: Wire] RETURNS [BOOL] = {
ReturnFirstPin: EachInstanceProc = {quit _ TRUE};
RETURN [EnumeratePins[decoration, public, ReturnFirstPin]];
};

GetPins: PUBLIC PROC [decoration: Decoration, public: Wire] RETURNS [pins: Instances _ NIL] = {
ConsEachPin: EachInstanceProc = {pins _ CONS [instance, pins]};
[] _ EnumeratePins[decoration, public, ConsEachPin];
};
PutPins: PUBLIC PROC [decoration: Decoration, public: Wire, pins: Instances] = {
size: NAT = Length[pins];
IF size#0 AND size<maxInstanceSeq THEN {
instances: InstanceSeq = NEW [InstanceSeqRec[size]];
FOR i: NAT IN [0 .. size) DO
instances[i] _ pins.first; pins _ pins.rest;
ENDLOOP;
CoreProperties.PutWireProp[public, decoration.pinsProp, instances];
} ELSE CoreProperties.PutWireProp[public, decoration.pinsProp, pins];
};

AddPins: PUBLIC PROC [decoration: Decoration, public: Wire, pins: Instances] = {
ConsEachPin: EachInstanceProc = {pins _ CONS [instance, pins]};
IF pins=NIL THEN RETURN;
[] _ EnumeratePins[decoration, public, ConsEachPin];
PutPins[decoration, public, pins];
};
HasObject: PUBLIC PROC [decoration: Decoration, cellType: CellType] RETURNS [BOOL] = {
RETURN [GetObject[decoration, cellType]#NIL];
};

GetObject: PUBLIC PROC [decoration: Decoration, cellType: CellType] RETURNS [object: Object] = {
object _ NARROW [CoreProperties.GetCellTypeProp[cellType, decoration.objectProp]];
};

PutObject: PUBLIC PROC [decoration: Decoration, cellType: CellType, object: Object] = {
CoreProperties.PutCellTypeProp[cellType, decoration.objectProp, object];
};
EnumerateFlatGeometry: PUBLIC PROC [decoration: Decoration, root: CellType, leafProc: LeafProc, eachFlatWire: EachFlatWireProc _ NIL, eachFlatCell: EachFlatCellProc _ NIL] = {
TransBoundFlat: CoreFlat.BoundFlatCellProc = {
trans: Transformation = GetTrans[decoration, instance];
refTrans: REF Transformation = NARROW [data];
currentTrans: Transformation = CDBasics.ComposeTransform[itemInCell: trans, cellInWorld: refTrans^];
BoundFlat[cell, target, flatCell, instance, index, parent, flatParent, NEW [Transformation _ currentTrans], bindings];
};
BoundFlat: CoreFlat.BoundFlatCellProc = {
refTrans: REF Transformation = NARROW [data];
IF leafProc[cell] THEN {
IF eachFlatCell#NIL THEN eachFlatCell[bindings: bindings, cell: cell, flatCell: flatCell, trans: refTrans^];
RETURN;
};
IF cell.class=CoreClasses.recordCellClass THEN {
RecordGeometry: CoreOps.EachWireProc = {
refBoundWire: FlatWire _ NARROW [HashTable.Fetch[bindings, wire].value];
IF NOT HasGeometry[decoration, wire] THEN RETURN;
eachFlatWire[wire, IF refBoundWire#NIL THEN refBoundWire^ ELSE [flatCell: flatCell, wire: wire], refTrans^];
};
rct: CoreClasses.RecordCellType = NARROW [cell.data];
IF eachFlatWire#NIL THEN [] _ CoreOps.VisitWireSeq[rct.internal, RecordGeometry];
CoreFlat.NextBoundCellType[cell, target, flatCell, instance, index, parent, flatParent, data, bindings, TransBoundFlat];
}
ELSE CoreFlat.NextBoundCellType[cell, target, flatCell, instance, index, parent, flatParent, data, bindings, BoundFlat];
};
BoundFlat[cell: root, bindings: CoreFlat.InitialBindingTable[root], data: NEW [Transformation _ []]];
};

RawEnumerateGeometry: PUBLIC PROC [prop: ATOM, value: REF, eachInstance: EachInstanceProc] RETURNS [quit: BOOL _ FALSE] = {
IF value=NIL THEN RETURN;
WITH value SELECT FROM
instances: Instances	=> WHILE instances#NIL DO 
IF eachInstance[instances.first] THEN RETURN [TRUE];
instances _ instances.rest;
ENDLOOP;
instances: InstanceSeq	=> FOR i: NAT IN [0 .. instances.size) 
DO IF eachInstance[instances[i]] THEN RETURN [TRUE] ENDLOOP;
lazyEnumerate: LazyEnumerateData	=> quit _ lazyEnumerate.proc[eachInstance, lazyEnumerate.data1, lazyEnumerate.data2];
ENDCASE	=> ERROR; -- decoration unknown to this module.  Geometry was probably created without using the procedural interface.
};
EnumerateGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire, eachInstance: EachInstanceProc] RETURNS [quit: BOOL] = {
quit _ RawEnumerateGeometry[decoration.geometryProp, CoreProperties.GetWireProp[internal, decoration.geometryProp], eachInstance];
};
HasGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire] RETURNS [BOOL] = {
HasGeom: EachInstanceProc = {quit _ TRUE};
RETURN [EnumerateGeometry[decoration, internal, HasGeom]];
};
GetGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire] RETURNS [geometry: Instances _ NIL] = {
ConsEachGeom: EachInstanceProc = {geometry _ CONS [instance, geometry]};
[] _ EnumerateGeometry[decoration, internal, ConsEachGeom];
};
PutGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire, geometry: Instances] = {
size: INT = Length[geometry];
IF size#0 AND size<maxInstanceSeq THEN {
instances: InstanceSeq _ NEW [InstanceSeqRec[NAT[size]]];
FOR i: NAT IN [0 .. NAT[size]) DO
instances[i] _ geometry.first; geometry _ geometry.rest;
ENDLOOP;
CoreProperties.PutWireProp[internal, decoration.geometryProp, instances];
} ELSE CoreProperties.PutWireProp[internal, decoration.geometryProp, geometry];
};

AddGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire, geometry: Instances] = {
ConsEachGeom: EachInstanceProc = {geometry _ CONS [instance, geometry]};
IF geometry=NIL THEN RETURN;
[] _ EnumerateGeometry[decoration, internal, ConsEachGeom];
PutGeometry[decoration, internal, geometry];
};
GetTrans: PUBLIC PROC [decoration: Decoration, cellInstance: CellInstance] RETURNS [trans: Transformation] = {
refTrans: REF Transformation _ NARROW [CoreProperties.GetCellInstanceProp[cellInstance, decoration.transProp]];
trans _ refTrans^;
};

PutTrans: PUBLIC PROC [decoration: Decoration, cellInstance: CellInstance, trans: Transformation] = {
CoreProperties.PutCellInstanceProp[cellInstance, decoration.transProp, NEW [Transformation _ trans]];
};
GetSides: PUBLIC PROC [ir: Rect, pin: Instance] RETURNS [sides: Sides _ noSide] = {
sides _ PinIRSides[ir, CDBasics.MoveRect[CDBasics.MapRect[CD.InterestRect[pin.obj], pin.trans], CDBasics.SubPoints[[0, 0], CDBasics.BaseOfRect[ir]]]]; 
};

PinIRSides: PROC [ir, pinIR: Rect] RETURNS [sides: Sides _ noSide] = {
objSize: CD.Position = CDBasics.SizeOfRect[ir];
sides[top] _ CDBasics.Intersect[pinIR, [0, objSize.y-1, objSize.x, objSize.y]];
sides[bottom] _ CDBasics.Intersect[pinIR, [0, 0, objSize.x, 1]];
sides[left] _ CDBasics.Intersect[pinIR, [0, 0, 1, objSize.y]];
sides[right] _ CDBasics.Intersect[pinIR, [objSize.x-1, 0, objSize.x, objSize.y]];
};

EnumerateSides: PUBLIC PROC [decoration: Decoration, cellType: CellType, wire: Wire, eachPin: EachPinProc] RETURNS [quit: BOOL] = {
EnumerateSeg: PROC [bbox: Rect, layer: CD.Layer] = {
pinIR: Rect = CDBasics.MoveRect[bbox, CDBasics.SubPoints[[0, 0], CDBasics.BaseOfRect[ir]]]; -- bbox of the pin in the obj coordinate system of the outer  
sides: Sides = PinIRSides[ir, pinIR];
layer _ CDLayers.AbstractToPaint[layer];
IF CDProperties.GetLayerProp[layer, $RoutingLayer]=NIL THEN RETURN;
FOR side: Side IN Side DO 
min, max: INT _ 0;
IF ~sides[side] THEN LOOP;
IF side=top OR side=bottom THEN {min _ pinIR.x1; max _ pinIR.x2};
IF side=left OR side=right THEN {min _ pinIR.y1; max _ pinIR.y2};
IF (quit _ eachPin[min, max, side, layer]) THEN RETURN;
ENDLOOP;
};
InternalEachPin: EachInstanceProc = {
SELECT TRUE FROM
instance.obj.class=CDRects.bareRectClass			=> EnumerateSeg[CDBasics.MapRect[CD.InterestRect[instance.obj], instance.trans], instance.obj.layer];
IsCoreGeometryPin[instance.obj]					=> 
EnumerateSeg[CDBasics.MapRect[CD.InterestRect[instance.obj], instance.trans], GetCoreGeometryPinLayer[instance]];
ENDCASE			=> quit _ FlattenInstance[instance, InternalEachPin];
};
ir: Rect = CD.InterestRect[GetObject[decoration, cellType]];
quit _ EnumeratePins[decoration, wire, InternalEachPin];
};
EnumerateWireSides: PUBLIC PROC [decoration: Decoration, cellType: CellType, eachWirePin: EachWirePinProc] RETURNS [quit: BOOL] = {
EachWireSide: CoreOps.EachWireProc = {
EachPin: EachPinProc = {quit _ eachWirePin[wire, min, max, side, layer]};
quit _ EnumerateSides[decoration, cellType, wire, EachPin];
};
quit _ CoreOps.VisitWireSeq[cellType.public, EachWireSide];
};

WMMSL: TYPE = RECORD [wire: Wire, min, max: INT, side: Side, layer: CD.Layer];

EnumerateNonOverlappingSides: PUBLIC PROC [decoration: Decoration, cellType: CellType, eachWirePin: EachWirePinProc] RETURNS [quit: BOOL] = {
list: LIST OF REF WMMSL _ NIL;
CompareWMMSL: GList.CompareProc = {
wmmsl1: REF WMMSL = NARROW [ref1];
wmmsl2: REF WMMSL = NARROW [ref2];
RETURN [Basics.CompareINT[wmmsl1.min, wmmsl2.min]];
};
EachWirePin: EachWirePinProc = {
list _ CONS [NEW [WMMSL _ [wire, min, max, side, layer]], list];
};
[] _ EnumerateWireSides[decoration, cellType, EachWirePin];
list _ NARROW [GList.Sort[list, CompareWMMSL]]; -- modifies the list for good
FOR wmmsls: LIST OF REF WMMSL _ list, wmmsls.rest WHILE wmmsls#NIL DO
wmmsl1: REF WMMSL = wmmsls.first;
merge: BOOL _ TRUE;
WHILE merge DO
FOR aux: LIST OF REF WMMSL _ wmmsls, aux.rest WHILE aux#NIL AND aux.rest#NIL DO
wmmsl2: REF WMMSL = aux.rest.first;
IF wmmsl1.wire=wmmsl2.wire AND wmmsl1.side=wmmsl2.side AND wmmsl1.layer=wmmsl2.layer AND wmmsl2.min<=wmmsl1.max  
THEN {wmmsl1.max _ MAX [wmmsl1.max, wmmsl2.max]; aux.rest _ aux.rest.rest; EXIT};
REPEAT FINISHED	=> merge _ FALSE;
ENDLOOP;
ENDLOOP;
ENDLOOP;
WHILE list#NIL DO
quit _ eachWirePin[list.first.wire, list.first.min, list.first.max, list.first.side, list.first.layer];
IF quit THEN EXIT;
list _ list.rest;
ENDLOOP;
};

WMML: TYPE = RECORD [wire: Wire, min, max: INT, layer: CD.Layer];

EnumerateSortedSides: PUBLIC PROC [decoration: Decoration, cellType: CellType, side: Side, eachSortedPin: EachSortedPinProc] RETURNS [quit: BOOL] = {
list: LIST OF REF WMML _ NIL;
sideFilter: Side = side;
CompareWMML: GList.CompareProc = {
wmml1: REF WMML = NARROW [ref1];
wmml2: REF WMML = NARROW [ref2];
RETURN [Basics.CompareINT[wmml1.min, wmml2.min]];
};
EachWirePin: EachWirePinProc = {
IF side=sideFilter THEN list _ CONS [NEW [WMML _ [wire, min, max, layer]], list];
};
[] _ EnumerateWireSides[decoration, cellType, EachWirePin];
list _ NARROW [GList.Sort[list, CompareWMML]]; -- modifies the list for good
WHILE list#NIL DO
quit _ eachSortedPin[list.first.wire, list.first.min, list.first.max, list.first.layer];
IF quit THEN EXIT;
list _ list.rest;
ENDLOOP;
};
font: CDTexts.CDFont _ CDTexts.MakeFont["Xerox/TiogaFonts/Helvetica8", 4];
CreateShell: PUBLIC PROC [decoration: Decoration, cellType: CellType, withCuteFonts: BOOL _ FALSE] RETURNS [shell: Object] = {
ConstructEachWire: CoreOps.EachWireProc = {
ConstructPins: EachInstanceProc = {
inst: CD.Instance _ IF IsCoreGeometryPin[instance.obj] 
THEN CoreGeometryPinToCDPin[instance] 
ELSE CDInstances.NewInst[instance.obj, instance.trans];
CDProperties.PutInstanceProp[inst, $SignalName, name];
instances _ CONS [inst, instances];
};
name: ROPE _ CoreOps.GetFullWireName[cellType.public, wire];
[] _ EnumeratePins[decoration, wire, ConstructPins];
IF withCuteFonts THEN {
ConstructFonts: EachPinProc = {
inst: CD.Instance _ CDInstances.NewInst[
text, 
[off: SELECT side FROM 
left => [-300, min], right => [iSize.x+10, min], 
top => [min, iSize.y+10], bottom => [min, -300], 
ENDCASE => ERROR, 
orient: SELECT side FROM 
left, right => original, top, bottom => rotate90, ENDCASE => ERROR]
];
instances _ CONS [inst, instances];
};
text: Object _ CDTexts.Create[name, font];
[] _ EnumerateSides[decoration, cellType, wire, ConstructFonts];
};
};
instances: LIST OF CD.Instance _ NIL;
ir: CD.Rect = CD.InterestRect[GetObject[decoration, cellType]];
iSize: CD.Position _ CDBasics.SizeOfRect[ir];
[] _ CoreOps.VisitWireSeq[cellType.public, ConstructEachWire];
shell _ PWObjects.CreateCell[instances, ir];
};
CheckInterface: PUBLIC PROC [decoration: Decoration, cellType: CellType] RETURNS [ok: BOOL] = {
CheckPins: PROC [wire: Wire] = {IF NOT HasPins[decoration, wire] THEN ok _ FALSE};
ok _ HasObject[decoration, cellType];
CoreOps.VisitRootAtomics[cellType.public, CheckPins];
};
CheckInternal: PUBLIC PROC [decoration: Decoration, record: CellType] RETURNS [ok: BOOL] = {
data: CoreClasses.RecordCellType = NARROW [record.data];
IF NOT CheckInterface[decoration, record] THEN RETURN [FALSE];
FOR i: NAT IN [0 .. data.size)
DO [] _ GetTrans[decoration, data[i] ! ANY => ok _ FALSE] ENDLOOP;
};
ExpandPins: PROC [decoration: Decoration, public: Wire] = {
count: INT _ CountPins[decoration, public];
SELECT TRUE FROM
count=0			=> CoreProperties.PutWireProp[public, decoration.pinsProp, NIL];
count<=decoration.expandPinsCount AND count<maxInstanceSeq	=> {
pins: InstanceSeq _ NEW [InstanceSeqRec[count]];
SetEachPin: EachInstanceProc = {count _ count - 1; pins[count] _ instance};
[] _ EnumeratePins[decoration, public, SetEachPin]; 
IF count#0 THEN ERROR;
CoreProperties.PutWireProp[public, decoration.pinsProp, pins];
};
ENDCASE	=> {};
};

PutLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, lazyPinsEnumerate: LazyEnumerateProc, data1, data2: REF _ NIL] = {
CoreProperties.PutWireProp[public, decoration.pinsProp, NEW [LazyEnumerateDataRec _ [proc: lazyPinsEnumerate, data1: data1, data2: data2]]];
ExpandPins[decoration, public];
};
PutIndirectLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, indirect: Wire] = {
CoreProperties.PutWireProp[public, decoration.pinsProp, indirect];
ExpandPins[decoration, public];
};
PutIndirectsLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, indirects: LIST OF Wire] = {
CoreProperties.PutWireProp[public, decoration.pinsProp, indirects];
ExpandPins[decoration, public];
};
AddIndirectLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, indirect: Wire] = {
value: REF _ CoreProperties.GetWireProp[public, decoration.pinsProp];
SELECT TRUE FROM
CoreProperties.GetWireProp[indirect, decoration.pinsProp]=NIL	=> {};
value=NIL		=> PutIndirectLazyPins[decoration, public, indirect];
value=indirect	=> {};
ENDCASE	=> WITH value SELECT FROM
wire: Wire	=> PutIndirectsLazyPins[decoration, public, LIST [wire, indirect]];
wires: LIST OF Wire	=> IF NOT CoreOps.Member[wires, indirect] THEN PutIndirectsLazyPins[decoration, public, CONS [indirect, wires]];
ENDCASE	=> {
pins: Instances _ NIL;
ConsEachPin: EachInstanceProc = {pins _ CONS [instance, pins]};
[] _ EnumeratePins[decoration, public, ConsEachPin]; 
[] _ EnumeratePins[decoration, indirect, ConsEachPin]; 
PutPins[decoration, public, pins];
};
};

PutTransWireIRsLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, transWires: LIST OF TransWire, ir: Rect] = {
count: NAT _ 0; -- number of TransWire in new list!
transWireIR: TransWireIR;
new: LIST OF TransWire _ NIL;
WHILE transWires#NIL DO
transWire: TransWire = transWires.first;
trans: Transformation = transWire.trans;
HasTransClipPin: CoreGeometry.EachInstanceProc = {quit _  NOT TransfedNotAtEdge[trans, ir, instance]};
IF EnumeratePins[decoration, transWire.wire, HasTransClipPin] 
THEN {count _ count + 1; new _ CONS [transWire, new]};
transWires _ transWires.rest;
ENDLOOP;
transWireIR _ NEW [TransWireIRRec[count]];
transWireIR.ir _ ir; 
FOR i: NAT IN [0 .. count) DO transWireIR[i] _ new.first; new _ new.rest ENDLOOP; 
CoreProperties.PutWireProp[public, decoration.pinsProp, transWireIR];
ExpandPins[decoration, public];
};
PutTransWireIRLazyPins: PUBLIC PROC [decoration: Decoration, public: Wire, indirect: Wire, trans: Transformation, ir: Rect] = {
PutTransWireIRsLazyPins[decoration, public, LIST [[trans, indirect]], ir];
};
PutRecordLazyPins: PUBLIC PROC [decoration: Decoration, record: CellType, ir: Rect] = {
recData: CoreClasses.RecordCellType = NARROW [record.data];
table: HashTable.Table _ HashTable.Create[record.public.size];
SetLazyPins: CoreOps.EachWireProc = {
list: LIST OF TransWire _ NARROW [HashTable.Fetch[table, wire].value];
PutTransWireIRsLazyPins[decoration, wire, list, ir];
};
FOR i: NAT IN [0 .. recData.size) DO
cellInstance: CoreClasses.CellInstance = recData[i];
trans: Transformation = GetTrans[decoration, cellInstance];
EachBind: CoreOps.EachWirePairProc = {
list: LIST OF TransWire _ NARROW [HashTable.Fetch[table, actualWire].value];
FOR aux: LIST OF TransWire _ list, aux.rest WHILE aux#NIL DO
IF aux.first=[trans, publicWire] THEN RETURN;
ENDLOOP;
list _ CONS [[trans, publicWire], list];
[] _ HashTable.Store[table, actualWire, list];
};
IF NOT CoreGeometry.HasObject[decoration, cellInstance.type] THEN ERROR; -- this sub Cell has not been decorated
[] _ CoreOps.VisitBindingSeq[cellInstance.actual, cellInstance.type.public, EachBind];
ENDLOOP;
[] _ CoreOps.VisitWireSeq[record.public, SetLazyPins];
};
PutLazyGeometry: PUBLIC PROC [decoration: Decoration, internal: Wire, lazyGeometryEnumerate: LazyEnumerateProc, data1, data2: REF _ NIL] = {
CoreProperties.PutWireProp[internal, decoration.geometryProp, NEW [LazyEnumerateDataRec _ [proc: lazyGeometryEnumerate, data1: data1, data2: data2]]];
};
Length: PUBLIC PROC [instances: Instances] RETURNS [count: INT _ 0] = {
WHILE instances#NIL DO count _ count + 1; instances _ instances.rest ENDLOOP;
};

BBox: PUBLIC PROC [instance: Instance] RETURNS [rect: Rect] = {rect _ InlineBBox[instance]};

AtEdge: PUBLIC PROC [ir: Rect, instance: Instance] RETURNS [BOOL] = {
RETURN [NOT CDBasics.Inside[InlineBBox[instance], CDBasics.Extend[ir, -1]]];
};
TransfedNotAtEdge: PUBLIC PROC [trans: Transformation, ir: Rect, instance: Instance] RETURNS [BOOL] = {
RETURN [CDBasics.Inside[
CDBasics.MapRect[instance.obj.bbox, CDBasics.ComposeTransform[instance.trans, trans]], 
CDBasics.Extend[ir, -1]
]]
};
Intersect: PUBLIC PROC [clipRect: Rect, instance: Instance] RETURNS [BOOL] = {
RETURN [CDBasics.Intersect[InlineBBox[instance], clipRect]]
};

Transform: PUBLIC PROC [trans: Transformation, instance: Instance] RETURNS [Instance] = {
RETURN [[
obj: instance.obj, 
trans: CDBasics.ComposeTransform[itemInCell: instance.trans, cellInWorld: trans]
]];
};

TransformList: PUBLIC PROC [trans: Transformation, instances: Instances] RETURNS [new: Instances _ NIL] = {
WHILE instances#NIL DO
new _ CONS [Transform[trans, instances.first], new];
instances _ instances.rest;
ENDLOOP;
};

FlattenInstance: PUBLIC PROC [instance: Instance, eachInstance: EachInstanceProc] RETURNS [quit: BOOL _ FALSE] = {
EachSubInstance: CDCells.InstEnumerator = {
quit _ eachInstance[[inst.ob, CDBasics.ComposeTransform[itemInCell: inst.trans, cellInWorld: instance.trans]]];
};
flat: Object _ NARROW [CDProperties.GetObjectProp[instance.obj, $FlattenInstanceCache]];
SELECT TRUE FROM
flat#NIL	=> quit _ CDCells.EnumerateInstances[flat, EachSubInstance];
IsCoreGeometryPin[instance.obj]					=> RETURN;
instance.obj.class=CDRects.bareRectClass			=> ERROR;
instance.obj.class=CDCells.pCellClass				=> quit _ CDCells.EnumerateInstances[instance.obj, EachSubInstance];
ENDCASE									=> {
flat _ CDDirectory.ExpandByDraw[instance.obj, TRUE, TRUE];
CDProperties.PutObjectProp[instance.obj, $FlattenInstanceCache, flat];
quit _ FlattenInstance[[flat, instance.trans], eachInstance];
};
};

Touch: PUBLIC TouchProc = {
IF NOT CDBasics.Intersect[InlineBBox[instance1], InlineBBox[instance2]] THEN RETURN;
SELECT TRUE FROM
instance1.obj.class=CDRects.bareRectClass				=> RETURN [TouchRect[instance2, InlineBBox[instance1], instance1.obj.layer]];
IsCoreGeometryPin[instance1.obj]						=> RETURN [TouchRect[instance2, InlineBBox[instance1], GetCoreGeometryPinLayer[instance1]]];
ENDCASE													=> {
TouchInstance2: EachInstanceProc = {quit _ Touch[instance, instance2]};
RETURN [FlattenInstance[instance1, TouchInstance2]];
};
};

TouchRect: PUBLIC PROC [instance: Instance, rect: Rect, layer: CD.Layer] RETURNS [BOOL _ FALSE] = {
IF ~Intersect[rect, instance] THEN RETURN;
IF CDProperties.GetLayerProp[layer, $Well]#NIL THEN RETURN;
IF instance.obj.class=CDRects.bareRectClass THEN 
RETURN [CDLayers.AbstractToPaint[instance.obj.layer]=CDLayers.AbstractToPaint[layer]];
RETURN [Touch[
instance, 
[obj: CDRects.CreateRect[CDBasics.SizeOfRect[rect], layer], trans: [CDBasics.BaseOfRect[rect]]]
]];
};

TouchList: PUBLIC PROC [instances: Instances, instance: Instance] RETURNS [BOOL _ FALSE] = {
FOR list: Instances _ instances, list.rest WHILE list#NIL DO
IF Touch[list.first, instance] THEN RETURN [TRUE];
ENDLOOP;
};

TouchListList: PUBLIC PROC [instances1, instances2: Instances] RETURNS [BOOL _ FALSE] = {
FOR list: Instances _ instances1, list.rest WHILE list#NIL DO
IF TouchList[instances2, list.first] THEN RETURN [TRUE];
ENDLOOP;
};

CDPinToCoreGeometryPin: PUBLIC PROC [cdPin: Object, props: CD.PropList] RETURNS [coreGeometryPin: Object] = {
coreGeometryPin _ PWObjects.CreateCell[LIST [CDInstances.NewInst[ob: cdPin, properties: props]]];
CDProperties.PutObjectProp[coreGeometryPin, $CoreGeometryPin, $CoreGeometryPin];
};

CoreGeometryPinToCDPin: PUBLIC PROC [coreGeometryPin: Instance] RETURNS [cdPin: CD.Instance] = {
instance: CD.Instance _ NIL;
AffectInstance: CDCells.InstEnumerator = {IF instance#NIL THEN ERROR; instance _ inst};
IF NOT IsCoreGeometryPin[coreGeometryPin.obj] THEN ERROR;
[] _ CDCells.EnumerateInstances[coreGeometryPin.obj, AffectInstance];
cdPin _ CDInstances.Composed[instance, coreGeometryPin.trans];
};

IsCoreGeometryPin: PUBLIC PROC [coreGeometryPin: Object] RETURNS [BOOL] = {
RETURN [CDCells.IsCell[coreGeometryPin] AND CDProperties.GetObjectProp[coreGeometryPin, $CoreGeometryPin]#NIL];
};

GetCoreGeometryPinLayer: PUBLIC PROC [coreGeometryPin: Instance] RETURNS [layer: CD.Layer] = {
RETURN [CDSymbolicObjects.GetLayer[CoreGeometryPinToCDPin[coreGeometryPin]]];
};
CDProperties.PutLayerProp[CD.commentLayer, $RoutingLayer, $RoutingLayer];

END.
CoreGeometryImpl.mesa
Copyright Σ 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Bertrand Serlet, August 6, 1986 0:38:23 am PDT
Bertrand Serlet March 13, 1987 11:55:48 pm PST
Barth, February 18, 1987 8:19:50 pm PST

Creating Decoration
Pins




Object
Geometry
We came from that one from a RecordCell [vertical move]




Transformation
Enumeration of Sides for Routers
pinIR is the rectangle expressing the InterestRect of the pin in the InterestRect coordinate system of the outer.

Fabrication of Shells for Routers or for IO
Font used for the text labels

Checking of Decorations

Lazy Setting of Pins 
Replaces lazy pins by the physical instances iff it is appropriate.





We avoid duplicates 
Lazy Setting of Geometry 
Geometry Utilities


Initialization
ΚΌ˜
codeš
œ™Kš
œB™BKšœ6Οk™9Kš
œ.™.Kšœ$™'—K™š
	˜	Kš
œ˜Kšœl˜nK˜	J˜/Kš
œ#˜#K˜Kš
œ˜—K˜šΠbnΡblnœœ
˜Kšœ	œΤ
˜ζ
Kšœ#˜*Kšœœ
œ$˜H—
headš
œ™š
Οnœœ
œœœ˜Ošœ
œ˜#Kš
œ˜š
œ*˜*Kš
œ.˜.Kš
œN˜NKš
œ˜—š
œ,˜,Kš
œ0˜0Kš
œN˜NKš
œ˜—š
œ.˜.Kš
œ2˜2Kš
œN˜NKš
œ˜—š
œ+˜+Kš
œ/˜/Kš
œN˜NKš
œ
˜
—K˜—K˜——™š œœ
œœ	œ"œœœ˜wKšœœ
œ
œ
˜šœœ
˜šœœœ
œ˜>Jšœ
œœ
œœœ
˜<—šœœœ
œ
˜/Kšœœ
œœ˜4Kš
œ˜Kšœ
˜—Jš
œd˜dš
œœ
œ	œœ
˜)JšœUœ
œœ˜jJš
œ˜Jšœ
˜—š
œ˜Jš
œ˜šœœ
œ˜(š œ˜"Kšœ(œ
œ
˜6Kš
œ0˜0K˜—Jš
œ-˜-šœ]˜_Jšœ
œœ˜—Jšœ
˜—J˜—Jš
œv˜vKšœœΟcd˜v—K˜K™—š
 
œœ
œHœœ˜zKš
œt˜tK˜K™—š
 	œœ
œ(œ	œ	˜ZKš œ)˜:Kšœœ;˜EKšœœ
œ
œ
˜šœœ
˜Jš
œ1˜1Jš
œ3˜3JšœM˜T—K˜K™—š
 œœ
œ(œœ˜NKš œœ˜1Kšœ5˜;K˜K˜—š
 œœ
œ(œœ˜_Kš œœ˜?Kš
œ4˜4K˜K™—š œœ
œ<˜PKšœœ˜šœœœ˜(Kšœœ˜4šœœ
œ
˜Kš
œ,˜,Kšœ
˜—Kš
œC˜CKšœœ?˜E—K˜K˜—š œœ
œ<˜PKš œœ˜?Kšœœ
œ
œ
˜Kš
œ4˜4Kš
œ"˜"K˜——™š
 	œœ
œ.œœ˜VJšœ"œ˜-Kš
œ˜K˜—š 	œœ
œ.œ˜`Kšœ	œC˜RKš
œ˜K˜—š 	œœ
œA˜WKš
œH˜HK˜——™š
žœœ
œ_œ#œ˜―
Kš
œ7™7š œ ˜.Jš
œ7˜7Jšœ
œœ˜-Jš
œd˜dJšœGœ,˜vK˜—š 	œ
Οb
œ˜)Jšœ
œœ˜-šœœ˜Kšœœ
œT˜lKšœ
˜K˜—šœ(œ˜0š œ˜(Jšœœ)˜HJšœ
œœ
œ
˜1Jš	œœœ
œœ.˜lJ˜—Jšœ"œ
˜5Jšœœ
œ9˜QKš
œx˜xK˜
—Kšœt˜xK˜—KšœJœ˜eK˜K˜—š œœ
œœ	œ"œœœ˜{Kšœœ
œ
œ
˜šœœ
˜šœœœ
œ
˜/Kšœœ
œœ˜4Kš
œ˜Kšœ
˜—šœœœ
œ˜>Jšœ
œœ
œœœ
˜<—Jš
œv˜vKšœœ‘l˜~—K˜K™—š
 œœ
œJœœ˜€
Kš
œ‚
˜‚
K˜K™—š
 œœ
œ*œœ˜TKš œœ˜*Kšœ4˜:K˜K™—š
 œœ
œ*œœ˜iKš œ!œ˜HKš
œ;˜;K˜K™—š œœ
œB˜ZKšœœ˜šœœœ˜(Kšœœœ	˜9š	œœ
œœ˜!Kš
œ8˜8Kšœ
˜—Kš
œI˜IKšœœI˜O—K˜K˜—š œœ
œB˜ZKš œ!œ˜HKšœ
œ
œ
œ
˜Kš
œ;˜;Kš
œ,˜,K˜——™š œœ
œ6œ˜nKšœ
œœJ˜oKš
œ˜Kš
œ˜K˜—š œœ
œP˜eKšœGœ˜eK˜——™ š œœ
œœ˜SJšœ:œ[˜—
J˜J˜—Jš
œq™qš 
œœœ˜FJšœ	œ$˜/Jš
œO˜OJš
œ@˜@Jš
œ>˜>Jš
œQ˜QJ˜J˜—š
 œœ
œPœœ˜ƒ
š œœœ˜4Jšœ\‘>˜š
Jš
œ%˜%Jš
œ(˜(Jšœ1œ
œ
œ
˜Cšœœœ
˜Jšœ
œ˜Jšœœ
œ
˜Jšœ
œ
œ"˜AJšœœœ"˜AJšœ)œ
œ
˜7Jšœ
˜—J˜—š œ˜%šœ
œ
˜JšœLœB˜
š
œ'˜'JšœœQ˜q—Jšœ8˜?—J˜—Jšœœ/˜<Kš
œ8˜8J˜J™—š
 œœ
œLœœ˜ƒ
š œ˜&Kš œB˜IJš
œ;˜;J˜—Kš
œ;˜;K˜K˜—š
œœœœœ˜NJ˜—š
 œœ
œLœœ˜
Jšœœ
œ
œ
œœ
˜š œ˜#Kšœœ
œœ˜"Kšœœ
œœ˜"Kšœ-˜3K˜—š œ˜ Kšœœœœ)˜@J˜—Kš
œ;˜;Kšœœ#‘˜Mšœ	œ
œ
œ
œœœ
˜EKšœœ
œ˜!Kšœœœ
˜šœ˜šœœ
œ
œ
œœœ
œ
œ
˜OKšœœ
œ˜#šœœœœ˜qJšœœ5œ˜Q—Jšœ
œœ
˜!Jšœ
˜—Jšœ
˜—Kšœ
˜—šœœ
˜Kš
œg˜gKšœœ
œ
˜Kš
œ˜Kšœ
˜—K˜K˜—š
œœœœ	œ˜AJ˜—š
 œœ
œ\œœ˜•
Jšœœ
œ
œ
œœ
˜Jš
œ˜š œ˜"Kšœœ
œœ˜ Kšœœ
œœ˜ Kšœ+˜1K˜—š œ˜ Jš
œœœœœ#˜QJ˜—Kš
œ;˜;Kšœœ"‘˜Lšœœ
˜Kš
œX˜XKšœœ
œ
˜Kš
œ˜Kšœ
˜—K˜——šœ)™+š
œJ˜JJ™J™—š œœ
œ=œœœ˜~š œ˜+š 
œ˜#šœœœ!˜7Jšœ"˜&Jšœ3˜7—Kš
œ6˜6Kšœœ˜#J˜—Jšœœ2˜<Jš
œ4˜4šœœ˜š œ˜šœœ ˜(Jš
œ˜šœœœ
˜Kš
œ1˜1Kš
œ1˜1Kšœœ˜—šœœœ
˜Kšœ2œœ
˜C—Kš
œ˜—Kšœœ˜#J˜—Jš
œ*˜*Jš
œ@˜@J˜—J˜—Kš	œœ
œ
œœ
˜%Kšœœœ/˜?Kšœœ$˜-Jš
œ>˜>Jš
œ,˜,K˜——™š
 œœ
œ.œœ˜_Kš 	œœœ
œœœ˜RKš
œ%˜%Kš
œ5˜5K˜K™—š
 
œœ
œ,œœ˜\Kšœ#œ˜8Kš
œ
œ$œ
œœ˜>šœœ
œ˜Kšœ%œ	œœ
˜B—K˜——™Kš
œC™Cš 
œœ+˜;Kšœœ!˜+šœ
œ
˜JšœEœ˜Jšœ"œ˜?Jšœœ˜0Jš 
œA˜KJš
œ4˜4Kšœ	œ
œ
˜Kš
œ>˜>K˜—Kšœ˜—K˜K˜—š
 œœ
œ\œœ˜‚
Kšœ8œQ˜Œ
Kš
œ˜K˜K™—š œœ
œ;˜[Kš
œB˜BKš
œ˜K˜K™—š
 œœ
œ3œ
œ
˜eKš
œC˜CKš
œ˜K˜K™—š œœ
œ;˜[Kšœœ;˜Ešœ
œ
˜Kšœ:œ˜DKšœœ7˜@Kš
œ˜šœœœ
˜!Kšœ7œ˜NKš
œœ
œ	œ
œ!œ*œ˜„
šœ˜Kšœœ
˜Jš œœ˜?Jš
œ5˜5Jš
œ7˜7Kš
œ"˜"J˜———K˜K˜—š
 œœ
œ4œ
œ˜xJšœœ‘#˜3Kš
œ˜Kšœœ
œ
œ
˜šœœ
˜Jš
œ(˜(Jš
œ(˜(Jš œ+œ)˜fšœ<˜>Jšœœ˜6—Jš
œ˜Jšœ
˜—Kšœœ˜*Kš
œ˜Jš
œœ
œœ,œ˜RKš
œE˜EKš
œ˜K˜K™—š œœ
œ\˜Kšœ,œ˜JK˜K™—š œœ
œ9˜WJšœ&œ˜;Jš
œ>˜>š œ˜%Jšœœ
œ
œ&˜FKš
œ4˜4J˜—šœœ
œ˜$Jš
œ4˜4Jš
œ;˜;š œ˜&Jšœœ
œ
œ,˜LJš
œ™šœœ
œœœ
˜<Jšœœ
œ
˜-Jšœ
˜—Jšœœ˜(Jš
œ.˜.Jš
œ˜—Jš	œ
œ7œ
œ‘'˜pJš
œV˜VJšœ
˜—Jš
œ6˜6K˜——™š
 œœ
œbœœ˜Œ
Kšœ>œU˜–
K˜——™š
 œœ
œœ	œ	˜GKšœœ
œ/œ
˜MK˜—K˜š œœ
œœ.˜\K˜—š
 œœ
œ œœ˜EKšœœA˜LK˜K™—š
 œœ
œ7œœ˜gšœ˜Kš
œW˜WKš
œ˜Kš
œ˜—K˜K™—š
 	œœ
œ&œœ˜NKšœ5˜;K˜K˜—š 	œœ
œ-œ˜Yšœ˜	Kš
œ˜Kš
œP˜PKš
œ˜—J˜K˜—š
 
œœ
œ/œœ˜kšœœ
˜Jšœœ*˜4Jš
œ˜Jšœ
˜—J˜K˜—š œœ
œ6œœœ˜rš œ˜+Jš
œo˜oJ˜—JšœœC˜Xšœ
œ
˜Jšœœ=˜EJšœ'œ
˜.Jšœ.œ
˜4Jš
œm˜mšœ
˜Jšœ.œœ˜:Jš
œF˜FJš
œ=˜=J˜——K˜K˜—š œœ˜Jšœ
œBœ
œ
˜Tšœ
œ
˜Jšœ0œD˜zJšœ)œS˜‚
šœ˜Jš œ9˜GJšœ.˜4Jš
œ˜——J˜J˜—š 	œœ
œ)œœœœ˜cJšœœ
œ
˜*Jšœ)œ
œ
œ
˜;šœ*œ
˜1JšœP˜V—šœ˜Jš
œ
˜
Jš
œ_˜_Jš
œ˜—J˜J˜—š 	œœ
œ,œœœ˜\šœ(œœ
˜<Jšœœ
œœ˜2Jšœ
˜—J˜J˜—š 
œœ
œ%œœœ˜Yšœ)œœ
˜=Jšœ#œ
œœ˜8Jšœ
˜—J˜J˜—š
 œœ
œœœ˜mJšœ'œ6˜aJš
œP˜PJ˜J˜—š
 œœ
œœ	œ˜`Jšœ
œœ
˜Jš
 œœ
œ
œ
œ˜WJšœ
œ(œ
œ
˜9Jš
œE˜EJš
œ>˜>J˜J˜—š
 œœ
œœœ˜KJšœ"œ?œ˜oJ˜J˜—š
 œœ
œœ	œ˜^JšœG˜MJ˜——™Jšœœ-˜I—K˜Kšœ
˜—…—aς}Β