DIRECTORY
CD,
CDBasics,
CDOrient,
CoreClasses,
Rope,
SC,
SCInstUtil,
SCPrivate,
SCRowUtil,
SCUtil,
RTBasic,
RTSets;

SCInstUtilImpl: CEDAR PROGRAM
IMPORTS CDBasics, SC, SCInstUtil, SCRowUtil, SCUtil, Rope, RTBasic, RTSets
EXPORTS SCInstUtil
SHARES SC =

BEGIN
defltLgOrien: PUBLIC SCPrivate.Orientation _ 1;
defltBpOrien: PUBLIC ARRAY SC.Side OF SCPrivate.Orientation _ [3, 1, 4, 2];


InstWidth: PUBLIC PROCEDURE[inst: SCPrivate.Instance] RETURNS[width: SC.Number] = 

BEGIN
orien: SCPrivate.OrientationOrNone _ inst.curOrien;

SELECT orien FROM
0, 1, 3, 5, 6 => width _ inst.object.size.p;
2, 4, 7, 8 => width _ inst.object.size.q;
ENDCASE;
END;

InstHeight: PUBLIC PROCEDURE[inst: SCPrivate.Instance] RETURNS[height: SC.Number] = 

BEGIN
orien: SCPrivate.OrientationOrNone _ inst.curOrien;

SELECT orien FROM
0, 1, 3, 5, 6 => height _ inst.object.size.q;
2, 4, 7, 8 => height _ inst.object.size.p;
ENDCASE;
END;

BpHeight: PUBLIC PROCEDURE[inst: SCPrivate.Instance] RETURNS[height: SC.Number] = {

IF inst.whichClass # io THEN
SC.Error[programmingError, Rope.Cat["Instance: ", inst.name, " should be an IO"]];

SELECT inst.curSide FROM
top, bottom => height _ InstHeight[inst];
left, right => height _ InstWidth[inst];
ENDCASE => SC.Error[programmingError, NIL]};

BpWidth: PUBLIC PROCEDURE[inst: SCPrivate.Instance] RETURNS[width: SC.Number] = {

IF inst.whichClass # io THEN
SC.Error[programmingError, Rope.Cat["Instance: ", inst.name, " should be an IO"]];

SELECT inst.curSide FROM
top, bottom => width _ InstWidth[inst];
left, right => width _ InstHeight[inst];
ENDCASE => SC.Error[programmingError, NIL]};
MinMaxBPOffset: PUBLIC PROCEDURE[handle: SC.Handle, side: SC.Side] RETURNS [minOffset, maxOffset: SC.Number] = {

InstProc: SCRowUtil.EachInstProc = {
minOffset _ MIN[minOffset, instance.offset];
maxOffset _ MAX[maxOffset, instance.offset]};

minOffset _ LAST[INT];
maxOffset _ -minOffset;
[] _ SCRowUtil.EnumerateAllInstsOnSide[handle, side, InstProc]};

BpOffsets: PUBLIC PROCEDURE[handle: SC.Handle, side: SC.Side, pos1, pos2: SCPrivate.ZMaxPosSr] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
offset: SC.Number;
posA: SCPrivate.ZMaxPosSr _ MIN[pos1, pos2];
posB: SCPrivate.ZMaxPosSr _ MAX[pos1, pos2];
IF posA <= 1 THEN {posA _ 1; offset _ 0}
ELSE
{inst: SCPrivate.Instance _ bpRow.bpsOnSide[posA-1];
IF side = bottom OR side = right THEN offset _ inst.offset + InstWidth[inst] + bpRow.bpSpacing
ELSE offset _ inst.offset + bpRow.bpSpacing};
IF posB = 0 OR posB > bpRow.nBpsOnSide THEN posB _ bpRow.nBpsOnSide;

FOR posIndex: SCPrivate.ZMaxPosSr IN [posA .. posB] DO 
inst: SCPrivate.Instance _ bpRow.bpsOnSide[posIndex];
width: SC.Number _ BpWidth[inst];
IF side = bottom OR side = right THEN inst.offset _ offset
ELSE inst.offset _ offset + width;
offset _ offset + width + bpRow.bpSpacing;
ENDLOOP}; 

CheckBpOffsets: PUBLIC PROCEDURE[handle: SC.Handle, side: SC.Side] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
offset: SC.Number _ 0;

FOR posIndex: SCPrivate.ZMaxPosSr IN [1 .. bpRow.nBpsOnSide] DO 
inst: SCPrivate.Instance _ bpRow.bpsOnSide[posIndex];
width: SC.Number _ BpWidth[inst];
IF side = bottom OR side = right THEN {
IF inst.offset # offset THEN SC.Error[programmingError, "Not suppose to happen"]}
ELSE {
IF inst.offset # offset + width THEN SC.Error[programmingError, "Not suppose to happen"]};
offset _ offset + width + bpRow.bpSpacing;
ENDLOOP}; 

BpPos: PUBLIC PROCEDURE[handle: SC.Handle, inst: SCPrivate.Instance] RETURNS[result: SC.Number] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[inst.curSide];
IF inst.whichClass # io THEN
SC.Error[programmingError, "objet must be of type io"];
SELECT inst.curSide FROM
right => result _ bpRow.sideOrg.q + inst.offset;
bottom => result _ bpRow.sideOrg.p + inst.offset;
left => result _ bpRow.sideOrg.q - inst.offset;
top => result _ bpRow.sideOrg.p - inst.offset;
ENDCASE};

InstPosOf: PUBLIC PROCEDURE[handle: SC.Handle, inst: SCPrivate.Instance, pin: SCPrivate.ObjectPin] RETURNS[pos: SCPrivate.PQPos] = {

x, y, xPos, yPos: SC.Number;
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
SELECT pin.pinPos.side FROM
bottom => {x _ pin.pinPos.location; y _ pin.pinPos.depth};
right => {x _ InstWidth[inst] - pin.pinPos.depth; y _ pin.pinPos.location};
top => {x _ InstWidth[inst] - pin.pinPos.location; y _ InstHeight[inst] - pin.pinPos.depth};
left => {x _ pin.pinPos.depth; y _ InstHeight[inst] - pin.pinPos.location};
ENDCASE; 

SELECT inst.curOrien FROM
1 => {xPos _ x; yPos _ y};
2 => {xPos _ y; yPos _ InstWidth[inst] - x};
3 => {xPos _ InstWidth[inst] - x; yPos _ InstHeight[inst] - y};
4 => {xPos _ InstHeight[inst] - y; yPos _ x};
5 => {xPos _ InstWidth[inst] - x; yPos _ y};
6 => {xPos _ x; yPos _ InstHeight[inst] - y};
7 => {xPos _ y; yPos _ x};
8 => {xPos _ InstHeight[inst] - y; yPos _ InstWidth[inst] - x};
ENDCASE;

SELECT inst.whichClass FROM
logic, ft => {
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[inst.curRow];
pos _ [lgRow.rowOrg.p + inst.offset + xPos, lgRow.rowOrg.q + yPos]};
io => {
bpRow: SCPrivate.BpRow _ layoutData.bpRows[inst.curSide];
SELECT inst.curSide FROM
right => pos _ [bpRow.sideOrg.p + xPos, bpRow.sideOrg.q + inst.offset + yPos];
bottom => pos _ [bpRow.sideOrg.p + inst.offset + xPos, bpRow.sideOrg.q + yPos];
left => pos _ [bpRow.sideOrg.p + xPos, bpRow.sideOrg.q - inst.offset + yPos];
top => pos _ [bpRow.sideOrg.p - inst.offset + xPos, bpRow.sideOrg.q + yPos];
ENDCASE};
ENDCASE};


PosOf: PUBLIC PROCEDURE[inst: SCPrivate.Instance, pin: SCPrivate.ObjectPin]
RETURNS [pinDes: SCInstUtil.PinDescription] = {

x, y: SC.Number;
SELECT pin.pinPos.side FROM
bottom => {x _ pin.pinPos.location; y _ pin.pinPos.depth};
right => {x _ InstWidth[inst] - pin.pinPos.depth; y _ pin.pinPos.location};
top => {x _ InstWidth[inst] - pin.pinPos.location; y _ InstHeight[inst] - pin.pinPos.depth};
left => {x _ pin.pinPos.depth; y _ InstHeight[inst] - pin.pinPos.location};
ENDCASE; 

SELECT inst.curOrien FROM
1 => {pinDes.xPos _ x; pinDes.yPos _ y};
2 => {pinDes.xPos _ y; pinDes.yPos _ InstWidth[inst] - x};
3 => {pinDes.xPos _ InstWidth[inst] - x; pinDes.yPos _ InstHeight[inst] - y};
4 => {pinDes.xPos _ InstHeight[inst] - y; pinDes.yPos _ x};
5 => {pinDes.xPos _ InstWidth[inst] - x; pinDes.yPos _ y};
6 => {pinDes.xPos _ x; pinDes.yPos _ InstHeight[inst] - y};
7 => {pinDes.xPos _ y; pinDes.yPos _ x};
8 => {pinDes.xPos _ InstHeight[inst] - y; pinDes.yPos _ InstWidth[inst] - x};
ENDCASE;

pinDes.sideOn _ SCUtil.SideTranslate[pin.pinPos.side, inst.curOrien]};

RotateRect: PUBLIC PROCEDURE[inst: SCPrivate.Instance, defRect: SC.Rect]
RETURNS [SC.Rect] = {

newRect: SC.Rect;
SELECT inst.curOrien FROM
1 =>
{newRect.x1 _ defRect.x1; newRect.y1 _ defRect.y1;
newRect.x2 _ defRect.x2; newRect.y2 _ defRect.y2};
2 =>
{newRect.x1 _ defRect.y1; newRect.y1 _ InstWidth[inst] - defRect.x1;
newRect.x2 _ defRect.y2; newRect.y2 _ InstWidth[inst] - defRect.x2};
3 =>
{newRect.x1 _ InstWidth[inst] - defRect.x1; newRect.y1 _ InstHeight[inst] - defRect.y1;
newRect.x2 _ InstWidth[inst] - defRect.x2; newRect.y2 _ InstHeight[inst] - defRect.y2};
4 =>
{newRect.x1 _ InstHeight[inst] - defRect.y1; newRect.y1 _ defRect.x1;
newRect.x2 _ InstHeight[inst] - defRect.y2; newRect.y2 _ defRect.x2};
5 =>
{newRect.x1 _ InstWidth[inst] - defRect.x1; newRect.y1 _ defRect.y1;
newRect.x2 _ InstWidth[inst] - defRect.x2; newRect.y2 _ defRect.y2};
6 =>
{newRect.x1 _ defRect.x1; newRect.y1 _ InstHeight[inst] - defRect.y1;
newRect.x2 _ defRect.x2; newRect.y2 _ InstHeight[inst] - defRect.y2};
7 =>
{newRect.x1 _ defRect.y1; newRect.y1 _ defRect.x1;
newRect.x2 _ defRect.y2; newRect.y2 _ defRect.x2};
8 =>
{newRect.x1 _ InstHeight[inst] - defRect.y1; newRect.y1 _ InstWidth[inst] - defRect.x1;
newRect.x2 _ InstHeight[inst] - defRect.y2; newRect.y2 _ InstWidth[inst] - defRect.x2};
ENDCASE;
RETURN[CDBasics.NormalizeRect[newRect]]};

LgOffsets: PUBLIC PROCEDURE[handle: SC.Handle, row: SCPrivate.ZMaxRowSr, pos1, pos2: SCPrivate.ZMaxPosSr] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
lgRow: SCPrivate.LgRow _ lgRows.rows[row];
offset: SC.Number;
posA: SCPrivate.ZMaxPosSr _ MIN[pos1, pos2];
posB: SCPrivate.ZMaxPosSr _ MAX[pos1, pos2];
IF posA <= 1 THEN {posA _ 1; offset _ 0}
ELSE
{inst: SCPrivate.Instance _ lgRow.lgsOnRow[posA-1];
offset _ inst.offset + InstWidth[inst]};
IF posB = 0 OR posB > lgRow.nLgsOnRow THEN posB _ lgRow.nLgsOnRow;

FOR posIndex: SCPrivate.MaxPosSr IN [posA .. posB] DO 
inst: SCPrivate.Instance _ lgRow.lgsOnRow[posIndex];
SELECT inst.whichClass FROM
ft, logic => {inst.offset _ offset; offset _ offset + InstWidth[inst]};
ENDCASE;
ENDLOOP;

IF posB = lgRow.nLgsOnRow THEN
{lgRow.size.p _ offset;
IF lgRow.size.p >= lgRows.maxRowWidth THEN
{lgRows.maxRowWidth _ lgRow.size.p; lgRows.numMaxRows _ 1}
ELSE [lgRows.maxRowWidth, lgRows.numMaxRows] _ SCRowUtil.FindMaxRow[handle]}}; 

AllOffsets: PUBLIC PROCEDURE [handle: SC.Handle] = {

RowRroc: SCRowUtil.EachRowProc = {
LgOffsets[handle, row, 0, SCPrivate.maxPos]};
SideProc: SCRowUtil.EachSideProc = {
BpOffsets[handle, side, 0, SCPrivate.maxPos]};
[] _ SCRowUtil.EnumerateRows[handle, RowRroc];
[] _ SCRowUtil.EnumerateSides[handle, SideProc]};

AsgnChanPos: PUBLIC PROCEDURE[handle: SC.Handle] = 

BEGIN
EachSide: SCRowUtil.EachSideProc = {
IF bpRow.dimInvalid THEN SCRowUtil.ComputeSideHeight[handle, side];
sideDim[side] _ bpRow.size.p + (bpRow.nBpsOnSide -1) * bpRow.bpSpacing};

EachRow: SCRowUtil.EachRowProc = {
IF lgRow.dimInvalid THEN SCRowUtil.ComputeRowHeight[handle, lgRow.rowNum]};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
parms: SCPrivate.Parms _ NARROW[handle.parms];
lgRows: SCPrivate.LgRows _ layoutData.lgRows;
bpRows: SCPrivate.BpRows _ layoutData.bpRows;
sideChans: SCPrivate.SideChans _ layoutData.sideChans;
rowChans: SCPrivate.RowChans _ layoutData.rowChans;
nChans: SCPrivate.MaxChanSr _ rowChans.count;
pitch: SC.Number _ RTBasic.IRSize[parms.ftObject.cdOb].x;
sideDim: ARRAY SC.Side OF SC.Number;
upperActiveLimit, rightActiveLimit, realTotHeight: SC.Number;

[] _ SCRowUtil.EnumerateSides[handle, EachSide];

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

rowChans.chans[1].chanPos _ bpRows[bottom].size.q;
sideChans[left].sideChanPos _ bpRows[left].size.q;

lgRows.horzRowOrg _ bpRows[left].size.q + sideChans[left].sideChanResult;
lgRows.rows[1].rowOrg.p _ lgRows.horzRowOrg + ((lgRows.maxRowWidth - lgRows.rows[1].size.p)/2)/pitch*pitch;
lgRows.rows[1].rowOrg.q _ rowChans.chans[1].chanPos + rowChans.chans[1].chanResult;

FOR chan: SCPrivate.MaxChanSr IN [2 .. nChans] DO 
rowChans.chans[chan].chanPos _ lgRows.rows[chan-1].rowOrg.q + lgRows.rows[chan-1].size.q;
IF chan <= lgRows.count THEN {
lgRows.rows[chan].rowOrg.q _ rowChans.chans[chan].chanPos + MAX[rowChans.chans[chan].chanWidth, rowChans.chans[chan].minChanWidth];
lgRows.rows[chan].rowOrg.p _ lgRows.horzRowOrg + ((lgRows.maxRowWidth - lgRows.rows[chan].size.p)/2)/pitch*pitch};
ENDLOOP;

sideChans[right].sideChanPos _ lgRows.horzRowOrg + lgRows.maxRowWidth;


upperActiveLimit _ rowChans.chans[nChans].chanPos + MAX[rowChans.chans[nChans].chanWidth, rowChans.chans[nChans].minChanWidth];
layoutData.totHeight _ realTotHeight _ upperActiveLimit + bpRows[top].size.q;

rightActiveLimit _ sideChans[right].sideChanPos +
MAX[sideChans[right].sideChanWidth, sideChans[right].minSideChanWidth];

layoutData.totWidth _ rightActiveLimit + bpRows[right].size.q;

bpRows[bottom].sideOrg.q _ 0;
bpRows[bottom].sideOrg.p _ lgRows.horzRowOrg + (lgRows.maxRowWidth - sideDim[bottom]) / 2;

bpRows[right].sideOrg.p _ rightActiveLimit;
bpRows[right].sideOrg.q _ (realTotHeight - sideDim[right])/ 2;

bpRows[top].sideOrg.p _ lgRows.horzRowOrg + (lgRows.maxRowWidth + sideDim[top])/ 2;
bpRows[top].sideOrg.q _ upperActiveLimit;

bpRows[left].sideOrg.p _ 0;
bpRows[left].sideOrg.q _ (realTotHeight +sideDim[left])/ 2;
END;

ChansForInsts: PUBLIC PROCEDURE[handle: SC.Handle, insts: SCPrivate.InstanceList]
RETURNS [touchesChan: SCPrivate.ChanSet _ RTSets.RTMdSetEmpty] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
FOR instList: SCPrivate.InstanceList _ insts, instList.rest WHILE instList # NIL DO 
inst: SCPrivate.Instance _ instList.first;
SELECT inst.whichClass FROM
ft, logic => {IF inst.curRow > 0 THEN
{touchesChan _ RTSets.RTMdSetUnion[touchesChan, RTSets.RTMdSetGenerateElement[(inst.curRow+1)-1]];
touchesChan _ RTSets.RTMdSetUnion[touchesChan , RTSets.RTMdSetGenerateElement[(inst.curRow)-1]]}};
io => {IF inst.curSide = bottom THEN
touchesChan _ RTSets.RTMdSetUnion[touchesChan, RTSets.RTMdSetGenerateElement[(1)-1]];
IF inst.curSide = top THEN
touchesChan _ RTSets.RTMdSetUnion[touchesChan, RTSets.RTMdSetGenerateElement[(layoutData.rowChans.count)-1]]};
ENDCASE;
ENDLOOP};

CheckInst: PUBLIC PROCEDURE[handle: SC.Handle, inst: SCPrivate.Instance] = {
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
SELECT inst.whichClass FROM
logic, ft =>
{row: SC.Number _ inst.curRow;
pos: SC.Number _ inst.curPos;
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
IF row <= 0 OR row > layoutData.rowChans.count THEN
{IF ~(row = 0 AND pos = 0 AND inst.whichClass = ft) THEN
SC.Error[programmingError, " "]}
ELSE IF pos <= 0 OR pos > lgRow.nLgsOnRow THEN
SC.Error[programmingError, " "]
ELSE
{trialInst: SCPrivate.Instance _ lgRow.lgsOnRow[pos];
IF inst # trialInst THEN
SC.Error[programmingError, " "]}};
io =>
{side: SC.Side _ inst.curSide;
pos: SC.Number _ inst.curPos;
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
IF side = none THEN
SC.Error[programmingError, " "]
ELSE IF pos <= 0 OR pos > bpRow.nBpsOnSide THEN
SC.Error[programmingError, " "]
ELSE
{trialInst: SCPrivate.Instance _ bpRow.bpsOnSide[pos];
IF inst # trialInst THEN
SC.Error[programmingError, " "]}};
ENDCASE};

CheckInsts: PUBLIC PROCEDURE[handle: SC.Handle] = {

EachInst: SCInstUtil.EachInstanceProc = {
CheckInst[handle, instance]};
[] _ SCInstUtil.EnumerateAllInstances[handle, EachInst]};

EnumerateAllInstances: PUBLIC PROC [handle: SC.Handle, eachInstance: SCInstUtil.EachInstanceProc] RETURNS [quit: BOOL] = {

structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
quit _ EnumerateInstances[handle, 1, structureData.instances.count, eachInstance]};

EnumerateInstances: PUBLIC PROC [handle: SC.Handle, startInst, stopInst: SCPrivate.MaxInstanceSr, eachInstance: SCInstUtil.EachInstanceProc] RETURNS [quit: BOOL _ FALSE] = {

structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
FOR inst: SCPrivate.MaxInstanceSr IN [startInst .. stopInst] WHILE ~quit DO
quit _ eachInstance[structureData.instances.inst[inst]];
ENDLOOP};

EnumeratePinsOnInst: PUBLIC PROC [instance: SCPrivate.Instance, eachPin: SCInstUtil.EachPinProc] RETURNS [quit: BOOL _ FALSE] = {

FOR pin: NAT IN [0 .. instance.pinNets.size) WHILE ~quit DO 
quit _ eachPin[instance, pin, instance.pinNets.n[pin]];
ENDLOOP};

DefineInstance: PUBLIC PROCEDURE [handle: SC.Handle, instanceName: Rope.ROPE, object: SCPrivate.Object, coreInstance: CoreClasses.CellInstance, equivName: Rope.ROPE _ NIL]
RETURNS [instance: SCPrivate.Instance _ NIL] = {

structureData: SCPrivate.StructureData _ NARROW[handle.structureData];
instances: SCPrivate.Instances _ structureData.instances;
object.numTimesUsed _ object.numTimesUsed + 1;

SELECT object.typeClass FROM
logic =>
{instance _ NEW[logic SCPrivate.InstanceRec];
instance.whichClass _ logic;
instances.numLogics _ instances.numLogics + 1};
ft =>
{instance _ NEW[ft SCPrivate.InstanceRec];
instance.whichClass _ ft;
instances.numFts _ instances.numFts + 1};
io =>
{instance _ NEW[io SCPrivate.InstanceRec];
instance.equivPortClass _ equivName;
instance.whichClass _ io;
instances.numIOs _ instances.numIOs + 1};
ENDCASE => SC.Error[callingError, Rope.Cat["Feedthrus not allowed in input: ",  instance.name, ", object: ", object.name,  "\n"]];
instance.name _ instanceName;
instance.object _ object;

instance.pinNets _ NEW[SCPrivate.PinNetsRec[object.numPins]];
instances.count _ instances.count + 1;
instance.num _ instances.count;
instances.inst[instances.count] _ instance};

NumInstsOnList: PUBLIC PROCEDURE [instances: SCPrivate.InstanceList] RETURNS [count: SCPrivate.ZMaxInstanceSr _ 0] = {
FOR instList: SCPrivate.InstanceList _ instances, instList.rest WHILE instList # NIL DO
count _ count + 1;
ENDLOOP};

CDOrien: PUBLIC PROCEDURE[instance: SCPrivate.Instance] RETURNS [orien: CD.Orientation] = {

SELECT instance.curOrien FROM
0 => orien _ CDOrient.original;
1 => orien _ CDOrient.original;
2 => orien _ CDOrient.rotate270;
3 => orien _ CDOrient.rotate180;
4 => orien _ CDOrient.rotate90;
5 => orien _ CDOrient.mirrorX;
6 => orien _ CDOrient.rotate180X;
7 => orien _ CDOrient.rotate270X;
8 => orien _ CDOrient.rotate90X;
ENDCASE};
END.

ΚSCInstUtilImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Preas April 9, 1986 3:26:51 pm PST
compoments utility routines
-- InstWidth - find width of component at current orientation
-- InstHeight - find height of component at current orientation
-- BpHeight - find height of bp when considering side it is on
-- BpWidth - find width of bp when considering side it is on
-- MinMaxBPOffset - find min and max offsets of bonding pads on side
-- BpOffsets - find offsets of bonding pads on side
-- BpPos - find position of inst on side
-- PosOf- find the position (side, x, and y) of a component on a pin
-- RotateRect- Rotate a rectangle of a cell
-- LgOffsets- determine offsets of components in row
-- AllOffsets - determine all component offsets
-- AsgnChanPos - assign current positions to horizontal and vertical channels
-- CheckInsts - check row and position of comps
-- CheckInst - check row and position of a inst
-- EnumeratePinsOnInst - enumerate the net pins on an instance
find width of component at current orientation
find current orientation
now get width based on orientation
find height of component at current orientation
find current orientation
now get height based on orientation 
find height of bp when considering its side
(this is, the dimension perpendicular to side) 
find height of bp when considering side it is on
this is along to side

find offsets of bonding pads on side 
find offsets of bonding pads on side 
check offsets of bonding pads on side 
find position of inst on side
assumes that channel and bp positions have been assigned.
find position of pin on an inst
assumes that channel and instance positions have been assigned.

this code is copied from PosOf for efficiency
first find the position at normal orientation 
now rotate the pin position to current orien 
find the position (side, x, and y) of a component on a pin 

first find the position at normal orientation 
now rotate the pin position to current orien 
find the position of a rotated rectangle wintin a component
now rotate the pin position to current orien 
determine offsets of components in row 
compute offsets of all comps on row
update max row widths 
determine all component offsets 
assign current positions to horizontal and vertical channels 
compute the minimum channel dimensions
row 1 and channel 1 data
now the interior channels 
now the right side 
get total height and width 
now update the side orgs 
update right side data
update top side data
update left side data
find chans that these comps touch 
check row and position of a inst 
check row and position of a inst 

define a component (an instance of object)
construct he instance record
initialize the nets connected to these pins
get the CD orientation 
Κ­˜š
œ™Icodešœ
Οm
œ1™<K™"—J˜Jš
œ™JšΟnœ1™=Jšž
œ2™?Jšœžœ3™>Jšœžœ2™<Jšœžœ3™DJšœž	œ'™3Jšœžœ ™(Jšœžœ<™DJšœž
œ™+Jšœž	œ(™4Jšœž
œ"™/Jšœžœ?™MJšœž
œ"™/Jšœž	œ#™/Jšœžœ(™>J˜š
Οk	˜	JšŸœ
˜J˜	J˜	J˜Jš
œ˜JšŸœ
˜Jš
œ˜Jš
œ
˜
Jš
œ
˜
J˜J˜Jš
œ˜J˜—šžœŸœ
Ÿ˜JšŸœŸœ6˜JJšŸœ˜JšŸœ
Ÿœ˜J˜Jš
Ÿ˜JšœŸœ˜/Jš	œŸœ
Ÿœ
ŸœŸœ&˜KJ˜—˜Jš
œ.™.š
ž	œŸœ
Ÿ	œŸœŸœ˜RJ˜Jš
Ÿ˜Jš
œ™Jš
œ3˜3J˜Jš
œ"™"šŸœŸ˜Jš
œ,˜,Jš
œ)˜)JšŸœ
˜—JšŸœ
˜J˜—Jš
œ/™/š
ž
œŸœ
Ÿ	œŸœ	Ÿœ˜TJ˜Jš
Ÿ˜Jš
œ™š
œ3˜3J˜—Jš
œ$™$šŸœŸ˜Jš
œ-˜-Jš
œ*˜*JšŸœ
˜—JšŸœ
˜J˜—Jš
œ+™+Jš
œ/™/š
žœŸœ
Ÿ	œŸœ	Ÿœ˜SJ˜šŸœŸ˜JšŸœP˜RJ˜—šŸœŸ˜Jš
œ)˜)Jš
œ(˜(JšŸœŸœŸœ˜,J˜——Jš
œ0™0Jš
œ™š
žœŸœ
Ÿ	œŸœŸœ˜QJ˜šŸœŸ˜JšŸœP˜RJ˜—šŸœŸ˜Jš
œ'˜'Jš
œ(˜(JšŸœŸœŸœ˜,—J™—Jš
œ%™%šžœŸœ
Ÿ	œ	ŸœŸœŸœŸœ˜pJ˜šžœ˜$JšœŸœ˜,JšœŸœ˜-J˜—JšœŸœ
Ÿœ˜Jš
œ˜Jš
œ@˜@J˜—Jš
œ%™%š
ž	œŸœ
Ÿ	œ	ŸœŸœ+˜bJ˜Kšœ#Ÿœ˜=Kš
œ1˜1JšœŸœ˜JšœŸœ
˜,JšœŸœ
˜,JšŸœŸœ˜(š
Ÿ˜Jš
œ4˜4JšŸœŸœŸœ9˜^JšŸœ)˜-—JšŸœ
ŸœŸœ˜DJ˜šŸœŸœŸœ
˜7Jš
œ5˜5JšœŸœ˜!JšŸœŸœŸœ˜:JšŸœ˜"Jš
œ*˜*JšŸœ˜
—J˜—Jš
œ&™&š
žœŸœ
Ÿ	œ	ŸœŸœ
˜FJ˜Kšœ#Ÿœ˜=Kš
œ1˜1JšœŸœ˜J˜šŸœŸœŸœ
˜@Jš
œ5˜5JšœŸœ˜!šŸœŸœŸœ˜'KšŸœŸœ5˜Q—šŸœ˜JšŸœŸœ6˜Z—Jš
œ*˜*JšŸœ˜
—J˜—Jš
œ™Jš
œ9™9šžœŸœ
Ÿ	œ	Ÿœ#Ÿœ	Ÿœ˜cJ˜Kšœ#Ÿœ˜=Kš
œ9˜9šŸœŸ˜JšŸœ5˜7—šŸœŸ˜Jš
œ0˜0Jš
œ1˜1Jš
œ/˜/Jš
œ.˜.JšŸœ˜	—J˜—Jš
œ™Jš
œ?™?š
ž	œŸœ
Ÿ	œ	Ÿœ=Ÿœ˜„
J˜JšœŸœ˜Kšœ#Ÿœ˜=J™Jšœžœ™-Jš
œ.™.šŸœŸ˜Jš
œ:˜:Jš
œK˜KJš
œ\˜\Jš
œK˜KšŸœ˜	J˜——Jš
œ-™-šŸœŸ˜Jš
œ˜Jš
œ,˜,Jš
œ?˜?Jš
œ-˜-Jš
œ,˜,Jš
œ-˜-Jš
œ˜Jš
œ?˜?JšŸœ
˜J˜—šŸœŸ˜š
œ˜Kš
œ=˜=Jš
œD˜D—š
œ˜Kš
œ9˜9šŸœŸ˜Jš
œN˜NJš
œO˜OJš
œM˜MJš
œL˜LJšŸœ˜	——JšŸœ˜	—J˜—J˜Jš
œ;™;šžœŸœ
Ÿ	œ4˜KJšŸœ(˜/J˜JšœŸœ˜J™Jš
œ.™.šŸœŸ˜Jš
œ:˜:Jš
œK˜KJš
œ\˜\Jš
œK˜KšŸœ˜	J˜——Jš
œ-™-šŸœŸ˜Jš
œ(˜(Jš
œ:˜:Jš
œM˜MJš
œ;˜;Jš
œ:˜:Jš
œ;˜;Jš
œ(˜(Jš
œM˜MJšŸœ
˜—J˜Jš
œF˜FJ˜—Jš
œ;™;šž
œŸœ
Ÿ	œ$Ÿœ˜HJšŸœŸœ
˜J˜Jš
œ-™-Jšœ	Ÿœ˜šŸœŸ˜š
œ˜Jš
œ2˜2Jš
œ2˜2—š
œ˜Jš
œD˜DJš
œD˜D—š
œ˜Jš
œW˜WJš
œW˜W—š
œ˜Jš
œE˜EJš
œE˜E—š
œ˜Jš
œD˜DJš
œD˜D—š
œ˜Jš
œE˜EJš
œE˜E—š
œ˜Jš
œ2˜2Jš
œ2˜2—š
œ˜Jš
œW˜WJš
œW˜W—JšŸœ
˜—JšŸœ#˜)J˜—Jš
œ'™'šž	œŸœ
Ÿ	œ	ŸœG˜mJ˜Jš
œ#™#Jšœ#Ÿœ˜=Jš
œ-˜-Jš
œ*˜*JšœŸœ˜JšœŸœ
˜,JšœŸœ
˜,JšŸœŸœ˜(š
Ÿ˜Jš
œ3˜3Jš
œ(˜(—JšŸœ
ŸœŸœ˜BJ˜šŸœŸœŸœ
˜6Jš
œ4˜4šŸœŸ˜Jš
œG˜GJšŸœ
˜—JšŸœ
˜J˜—Jš
œ™šŸœŸ˜Jš
œ˜šŸœ$Ÿ˜*Jš
œ:˜:—JšŸœK˜O—J˜—Jš
œ ™ šž
œŸœ
Ÿ	œ
Ÿœ˜4J˜šžœ˜"Jš
œ-˜-—šžœ˜$Jš
œ.˜.—Jš
œ.˜.Jš
œ1˜1J˜—Jš
œ=™=šžœŸœ
Ÿ	œ	Ÿœ˜3J˜Jš
Ÿ˜Jš
œ&™&šžœ˜$JšŸœŸœ+˜CJš
œH˜HJ˜—šžœ˜"JšŸœŸœ3˜KJ˜—Jšœ#Ÿœ˜=JšœŸœ˜.Jš
œ-˜-Jš
œ-˜-Jš
œ6˜6Jš
œ3˜3Jš
œ-˜-Jš
œ9˜9Jš	œ	Ÿœ
ŸœŸœ
Ÿœ˜$Jšœ3Ÿœ˜=J˜Jš
œ0˜0J˜Jš
œ.˜.J˜Jš
œ™Jš
œ2˜2Jš
œ2˜2J˜Jš
œI˜IJš
œk˜kJš
œS˜SJ˜Jš
œ™šŸœŸœŸœ
˜2Jš
œY˜YšŸœŸœ˜Jšœ<ŸœD˜ƒ
Jš
œr˜r—šŸœ
˜J˜—Jš
œ™š
œF˜FJ˜—Jš
œ™J˜Jšœ4ŸœH˜Jš
œM˜MJ˜š
œ1˜1JšŸœD˜G—J˜Jš
œ>˜>J˜Jš
œ™Jš
œ˜š
œZ˜ZJ˜—Jš
œ™Jš
œ+˜+š
œ>˜>J˜—Jš
œ™Jš
œS˜Sš
œ)˜)J˜—Jš
œ™Jš
œ˜Jš
œ;˜;JšŸœ
˜—J˜—Jš
œ"™"šž
œŸœ
Ÿ	œ	Ÿœ'˜QJšŸœ;˜BJ˜Jšœ#Ÿœ˜=šŸœ9ŸœŸœ
Ÿœ
˜TJš
œ*˜*šŸœŸ˜šœŸœŸ˜%š
œb˜bJš
œb˜b——šœŸœŸ˜$Jš
œU˜UšŸœŸ˜Jš
œn˜n——JšŸœ
˜—JšŸœ˜	—J˜—Jš
œ!™!šž	œŸœ
Ÿ	œ	Ÿœ&˜LJšœ#Ÿœ˜=šŸœŸ˜š
œ˜KšœŸœ˜KšœŸœ˜Kš
œ5˜5šŸœ
Ÿœ!Ÿ˜3šœ
ŸœŸœ	ŸœŸ˜8KšŸœ˜ ——šŸœ
Ÿœ
ŸœŸ˜.KšŸœ˜—š
Ÿ˜Jš
œ5˜5šŸœŸ˜KšŸœ ˜"———š
œ˜KšœŸœ˜KšœŸœ˜Kš
œ1˜1šŸœ
Ÿ˜KšŸœ˜—šŸœ
Ÿœ
ŸœŸ˜/KšŸœ˜—š
Ÿ˜Jš
œ6˜6šŸœŸ˜KšŸœ ˜"———JšŸœ˜	—J˜—Jš
œ!™!šž
œŸœ
Ÿ	œ	Ÿœ˜3J˜šžœ!˜)Jš
œ˜—Kš
œ9˜9K˜—šžœŸœ
Ÿœ
Ÿœ4ŸœŸœ˜zJ˜Jšœ)Ÿœ˜FJš
œS˜SK˜—šžœŸœ
Ÿœ
ŸœbŸœŸœŸœ˜­
J˜Jšœ)Ÿœ˜FšŸœŸœŸœŸ˜KJš
œ8˜8KšŸœ˜	—K˜—šžœŸœ
ŸœAŸœŸœŸœ˜
K˜š
ŸœŸœ
ŸœŸœŸœ
˜<Kš
œ7˜7JšŸœ˜	—J˜—šžœŸœ
Ÿ	œ
ŸœŸœTŸœŸœ
˜«
KšŸœ!Ÿœ˜0K™Kš
œ*™*K˜Kšœ)Ÿœ˜FKš
œ9˜9Kš
œ.˜.K˜Kš
œ™šŸœŸ˜š
œ˜KšœŸœ˜-Kš
œ˜Kš
œ/˜/—š
œ˜KšœŸœ˜*Kš
œ˜Kš
œ)˜)—š
œ˜KšœŸœ˜*Kš
œ$˜$Kš
œ˜Kš
œ)˜)—KšŸœŸœu˜‚
—Kš
œ˜Kš
œ˜K˜Kš
œ+™+KšœŸœ'˜=Kš
œ&˜&Kš
œ˜Kš
œ,˜,K˜—šžœŸœ
Ÿ	œ%Ÿœ*˜všŸœ=ŸœŸœ
Ÿ˜WJš
œ˜JšŸœ˜	——J˜š
žœŸœ
Ÿ	œŸœ	Ÿœ˜[Jš
œ™J˜šŸœŸ˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ!˜!Jš
œ!˜!Jš
œ ˜ JšŸœ˜	——JšŸœ
˜——…—BJ^Α