DIRECTORY
RTSets,
SC,
SCInstUtil,
SCPlaceUtil,
SCPrivate,
SCRowUtil,
Rope,
TerminalIO;

SCPlaceUtilImpl: CEDAR PROGRAM
IMPORTS Rope, RTSets, SC, SCInstUtil, SCRowUtil, TerminalIO
EXPORTS SCPlaceUtil
SHARES SC =

BEGIN
PutLgRow: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, row: SCPrivate.MaxRowSr, orien: SCPrivate.OrientationOrNone _ 0] = 

BEGIN
layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance.curRow _ row;
instance.curPos _ lgRow.nLgsOnRow;
lgRow.size.p _ lgRow.size.p + SCInstUtil.InstWidth[instance];
lgRow.size.q _ MAX[lgRow.size.q, SCInstUtil.InstWidth[instance]];
lgRow.nLgsOnRow _ lgRow.nLgsOnRow +1;
lgRow.lgsOnRow[lgRow.nLgsOnRow] _ instance;

IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltLgOrien;

IF instance.whichClass = ft THEN
{net: SCPrivate.Net _ instance.ftNet;
lgRow.nFtsOnRow _ lgRow.nFtsOnRow +1;
net.ftsOnRow _ RTSets.RTMdSetUnion[net.ftsOnRow, 
RTSets.RTMdSetGenerateElement[(row)-1]]};
END;

PutLgPos: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, row: SCPrivate.MaxRowSr, pos: SCPrivate.MaxPosSr, orien: SCPrivate.OrientationOrNone _ 0] = {

EachInst:  SCRowUtil.EachInstProc = {
lgRow.lgsOnRow[pos+1] _ instance;
SELECT instance.whichClass FROM
ft, logic => instance.curPos _ pos+1;
ENDCASE}; 

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance.curRow _ row;
instance.curPos _ pos;
lgRow.size.p _ lgRow.size.p + SCInstUtil.InstWidth[instance];
lgRow.size.q _ MAX[lgRow.size.q, SCInstUtil.InstWidth[instance]];
IF 1 > pos OR pos > lgRow.nLgsOnRow+1 THEN 
SC.Error[programmingError, "pos must be in range 1 .. lgRow.nLgsOnRow"];

IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltLgOrien;

[] _ SCRowUtil.EnumerateInstsOnRowDecreasing[handle, row, pos, lgRow.nLgsOnRow, EachInst];
lgRow.lgsOnRow[pos] _ instance;

IF instance.whichClass = ft THEN
{net: SCPrivate.Net _ instance.ftNet;
lgRow.nFtsOnRow _ lgRow.nFtsOnRow +1;
net.ftsOnRow _ RTSets.RTMdSetUnion[net.ftsOnRow, 
RTSets.RTMdSetGenerateElement[(row)-1]]};

lgRow.nLgsOnRow _ lgRow.nLgsOnRow +1;
SCInstUtil.LgOffsets[handle, row, pos, 0]};

ExchPosRow: PUBLIC PROCEDURE[handle: SC.Handle, index1, index2: SCPrivate.MaxPosSr, row: SCPrivate.MaxRowSr] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
instance1: SCPrivate.Instance _ lgRow.lgsOnRow[index1];
instance2: SCPrivate.Instance _ lgRow.lgsOnRow[index2];
lgRow.lgsOnRow[index1] _ instance2;
lgRow.lgsOnRow[index2] _ instance1;

SELECT instance1.whichClass FROM
ft, logic => instance1.curPos _ index2;
ENDCASE;

SELECT instance2.whichClass FROM
ft, logic => instance2.curPos _ index1;
ENDCASE;

SCInstUtil.LgOffsets[handle, row, index1, index2]};

RemvLgComp: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
row: SCPrivate.MaxRowSr;
pos: SCPrivate.MaxPosSr;
widthOfComp: SC.Number _ SCInstUtil.InstWidth[instance];
heightOfComp: SC.Number _ SCInstUtil.InstHeight[instance];

SELECT instance.whichClass FROM
ft, logic => {
row _ instance.curRow; pos _ instance.curPos;
instance.curPos _ 0; instance.curRow _ 0; instance.curOrien _ 0};
ENDCASE;

BEGIN
EachInst: SCRowUtil.EachInstProc = {
lgRow.lgsOnRow[pos-1] _ instance;
SELECT instance.whichClass FROM
ft, logic => instance.curPos _ pos;
ENDCASE};

lgRow: SCPrivate.LgRow _ layoutData.lgRows.rows[row];
IF lgRow.lgsOnRow[pos] # instance THEN SC.Error[programmingError, "Invalid row"];

lgRow.size.p _ lgRow.size.p - widthOfComp;
IF heightOfComp >= lgRow.size.q THEN lgRow.dimInvalid _ TRUE;

[] _ SCRowUtil.EnumerateInstsOnRow[handle, row, pos + 1, lgRow.nLgsOnRow, EachInst];

lgRow.nLgsOnRow _ lgRow.nLgsOnRow -1;
IF instance.whichClass = ft THEN {
net: SCPrivate.Net _ instance.ftNet;
IF lgRow.nFtsOnRow <= 0 THEN SC.Error[programmingError, "Invalid row"];
lgRow.nFtsOnRow _ lgRow.nFtsOnRow - 1;
net.ftsOnRow _ RTSets.RTMdSetDifference[net.ftsOnRow, RTSets.RTMdSetGenerateElement[(row)-1]]};
END};
PutBpSide: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, side: SC.SideOrNone, orien: SCPrivate.OrientationOrNone _ 0] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
instance.curSide _ side;
instance.curPos _ bpRow.nBpsOnSide;
bpRow.size.p _ bpRow.size.p + SCInstUtil.BpWidth[instance];
bpRow.size.q _ MAX[bpRow.size.q, SCInstUtil.BpHeight[instance]];
bpRow.nBpsOnSide _ bpRow.nBpsOnSide +1;
bpRow.bpsOnSide[bpRow.nBpsOnSide] _ instance;
IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltBpOrien[side]};

PutBpPos: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance, side: SC.Side, pos: SCPrivate.MaxPosSr, orien: SCPrivate.OrientationOrNone _ 0] = {

EachInst:  SCRowUtil.EachInstProc = {
bpRow.bpsOnSide[pos+1] _ instance;
instance.curPos _ pos+1};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];

instance.curSide _ side;
instance.curPos _ pos;
bpRow.size.p _ bpRow.size.p + SCInstUtil.BpWidth[instance];
bpRow.size.q _ MAX[bpRow.size.q, SCInstUtil.BpHeight[instance]];
[] _ SCRowUtil.EnumerateInstsOnSideDecreasing[handle, side, pos, bpRow.nBpsOnSide, EachInst];
bpRow.nBpsOnSide _ bpRow.nBpsOnSide + 1;
bpRow.bpsOnSide[pos] _ instance;
IF orien # 0 THEN instance.curOrien _ orien
ELSE IF instance.fnlOrien > 0 THEN instance.curOrien _ instance.fnlOrien
ELSE IF instance.curOrien > 0 THEN NULL
ELSE IF instance.initOrien > 0 THEN instance.curOrien _ instance.initOrien
ELSE instance.curOrien _ SCInstUtil.defltBpOrien[side];
SCInstUtil.BpOffsets[handle, side, pos, 0]};

ExchPosSide: PUBLIC PROCEDURE[handle: SC.Handle, index1, index2: SCPrivate.MaxPosSr, side: SC.Side] = {

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
instance1: SCPrivate.Instance _ bpRow.bpsOnSide[index1];
instance2: SCPrivate.Instance _ bpRow.bpsOnSide[index2];
bpRow.bpsOnSide[index1] _ instance2;
bpRow.bpsOnSide[index2] _ instance1;
instance1.curPos _ index2;
instance2.curPos _ index1;
SCInstUtil.BpOffsets[handle, side, index1, index2]};

RemvBpComp: PUBLIC PROCEDURE[handle: SC.Handle, instance: SCPrivate.Instance] = {

side: SC.SideOrNone;
pos: SCPrivate.MaxPosSr;

IF instance.whichClass = io THEN {
side _ instance.curSide;
pos _ instance.curPos;
instance.curPos _ 0;
instance.curSide _ none;
instance.curOrien _ 0};

IF side # none THEN 
SC.Error[programmingError, Rope.Cat["invalid instance: ", instance.name, " on side"]];

BEGIN
EachInst:  SCRowUtil.EachInstProc = {
bpRow.bpsOnSide[pos-1] _ instance;
instance.curPos _ pos-1};

layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData];
bpRow: SCPrivate.BpRow _ layoutData.bpRows[side];
bpRow.size.p _ bpRow.size.p - SCInstUtil.BpWidth[instance];
IF SCInstUtil.BpHeight[instance] >= bpRow.size.q THEN bpRow.dimInvalid _ TRUE;
IF bpRow.nBpsOnSide <= 0 THEN
SC.Error[programmingError, "invalid side"];
IF bpRow.bpsOnSide[pos] # instance THEN
SC.Error[programmingError, Rope.Cat["instance: ", instance.name, " not in specified position"]];
[] _ SCRowUtil.EnumerateInstsOnSide[handle, side, pos, bpRow.nBpsOnSide, EachInst];
bpRow.nBpsOnSide _ bpRow.nBpsOnSide -1;
END};

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

EachInst: SCInstUtil.EachInstanceProc = {
TerminalIO.WriteRope[Rope.Cat[" instance: ", instance.name, ", object: ", instance.object.name]];
SELECT instance.whichClass FROM
ft, logic => {TerminalIO.WriteRope[", logic row: "]; TerminalIO.WriteInt[instance.curRow]}; 
io => {TerminalIO.WriteRope[Rope.Cat[", IO side: ", SCRowUtil.sideName[instance.curSide]]]}; 
ENDCASE;
TerminalIO.WriteRope[", pos: "]; TerminalIO.WriteInt[instance.curPos];
TerminalIO.WriteLn[]};

[] _ SCInstUtil.EnumerateInstances[handle, EachInst]};

ClrCurPlac: PUBLIC PROCEDURE[handle: SC.Handle, initPrePlace: BOOLEAN] = {

EachInst: SCInstUtil.EachInstanceProc = {
SELECT instance.whichClass FROM
logic, ft =>
{IF instance.curRow > 0 THEN RemvLgComp[handle, instance];
instance.curRow _ 0; instance.curPos _ 0; instance.curOrien _ 0;
IF initPrePlace THEN
{instance.preRow _ 0; instance.prePos _ 0; instance.preOrien _ 0}};

io =>
{IF instance.curSide > none THEN RemvBpComp[handle, instance];
instance.curSide _ none; instance.curPos _ 0; instance.curOrien _ 0;
IF initPrePlace THEN
{instance.preSide _ none; instance.prePos _ 0; instance.preOrien _ 0}};

ENDCASE};

[] _ SCInstUtil.EnumerateInstances[handle, EachInst]};

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

EachRow: SCRowUtil.EachRowProc = {
EachInst: SCRowUtil.EachInstProc = {
IF instance.curRow # row OR instance.curPos # pos THEN
SC.Error[programmingError, "Invalid row or position for instance"]};
[] _ SCRowUtil.EnumerateAllInstsOnRow[handle, row, EachInst]};

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

END.
hfile ///StdCell/SCPlaceUtilImpl.mesa
placement utility routines
-- PutLgRow - put component in row and position
-- ExchPosRow - exchange components in positions index1 and index2
-- RemvLgComp - remove a logic instance from current placement
-- PutBpSide - add a bp instance to a side
-- PutBpPos - 
-- ExchPosSide - exchange components in positions index1 and index2
-- RemvBpComp - remove a bp instance from current placement
-- WriteCurPlace - write the current placement
-- ClrCurPlac - clear the current placement
-- CheckPlace -- check the placement consistancy

add a logic instance to a row 
putlgpos add a lg instance to a row in a position 
exchange components in positions index1 and index2 
now modify instance data 
remove a logic instance from current placement 
remove instance from row 


add a bp instance to a side 
add a bp instance to a side in a position
exchange components in positions index1 and index2 
remove a bp instance from current placement 
check if side is valid 
remove instance from side 
clear the current placement in preparation for reinitialization 
check the placement consistancy
�Ê	­˜Jš
œ$™$J˜Jš
œ™JšœÏnœ$™/Jšœ�
œ5™BJšœ�
œ1™>Jšœ�	œ™*Jšœ�œ™Jšœ�œ5™CJšœ�
œ.™;Jšœ�
œ™.Jšœ�
œ™+Jšœ�
œ#™0J˜š
Ïk	˜	Jš
œ˜Jšžœ
˜Jš
œ˜Jš
œ˜J˜
J˜
Jš
œ˜Jš
œ˜J˜—šœžœ
ž˜Jšžœžœ#˜;Jšžœ˜Jšžœ
žœ˜J˜Jš
ž˜J™Jš
œ™š�œžœ
ž	œ	žœj˜�
J˜Jš
ž˜Jšœ#žœ˜=Jš
œ5˜5Jš
œ˜Jš
œ"˜"Jš
œ=˜=Jšœžœ/˜AJš
œ%˜%Jš
œ+˜+J˜Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ-˜1J˜šžœž˜ Jš
œ%˜%Jš
œ%˜%š
œ1˜1Jš
œ)˜)——Jšžœ
˜J˜—š�œžœ
ž	œ	žœ„
˜©
Jš
œ2™2J˜š
œ%˜%Jš
œ!˜!šžœž˜Jš
œ%˜%Jšžœ˜
—J˜—Jšœ#žœ˜=Jš
œ5˜5Jš
œ˜Jš
œ˜Jš
œ=˜=Jšœžœ/˜Ašžœ$žœ
˜+JšžœF˜H—J˜Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ-˜1J˜Jš
œZ˜ZJš
œ˜J˜šžœž˜ Jš
œ%˜%Jš
œ%˜%š
œ1˜1Jš
œ)˜)—J˜—Jš
œ%˜%Jš
œ+˜+J˜—Jš
œ3™3š�
œžœ
ž	œ	žœI˜pJ˜Jšœ#žœ˜=Jš
œ5˜5Jš
œ7˜7Jš
œ7˜7Jš
œ#˜#Jš
œ#˜#J˜Jš
œ™šžœž˜ Jš
œ'˜'Jšžœ
˜—J˜šžœž˜ Jš
œ'˜'Jšžœ
˜—J˜Jš
œ3˜3J˜—Jš
œ/™/š�
œžœ
ž	œ	žœ*˜QJ˜Jšœ#žœ˜=Jš
œ˜Jš
œ˜Jšœ
žœ)˜8Jšœžœ*˜:J˜šžœž˜š
œ˜Jš
œ-˜-Jš
œA˜A—šžœ
˜J˜——Jš
œ™š
ž˜˜$Jš
œ!˜!šžœž˜Jš
œ#˜#Jšžœ˜	—J˜—Jš
œ5˜5Jšžœ žœ
žœ(˜QJ˜Jš
œ*˜*Jšžœžœžœ
˜=J˜Jš
œT˜TJ˜Jš
œ%˜%šžœžœ˜"Jš
œ$˜$Jšžœžœ
žœ(˜GJš
œ&˜&Jš
œ_˜_—Jšžœ˜—J™J™—Jš
œ™š
�	œžœ
ž	œ	žœ-žœ8˜�
J˜Jšœ#žœ˜=Jš
œ1˜1Jš
œ˜Jš
œ#˜#Jš
œ;˜;Jšœžœ.˜@Jš
œ'˜'Jš
œ-˜-Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ5˜9—š
�œžœ
ž	œ	žœ-žœK˜Ÿ
J˜Jš
œ)™)š
œ%˜%Jš
œ"˜"Jš
œ˜J˜—Jšœ#žœ˜=Jš
œ1˜1J˜Jš
œ˜Jš
œ˜Jš
œ;˜;Jšœžœ.˜@Jš
œ]˜]Jš
œ(˜(Jš
œ ˜ Jšžœžœ˜+Jšžœ
žœžœ&˜HJšžœ
žœžœ
ž˜'Jšžœ
žœžœ'˜JJšžœ3˜7Jš
œ,˜,J˜—Jš
œ3™3š
�œžœ
ž	œ	žœ3žœ
˜gJ˜Jšœ#žœ˜=Jš
œ1˜1Jš
œ8˜8Jš
œ8˜8Jš
œ$˜$Jš
œ$˜$Jš
œ˜Jš
œ˜Jš
œ5˜5—Jš
œ,™,š�
œžœ
ž	œ	žœ*˜QJ˜Jšœžœ˜Jš
œ˜J˜šžœžœ˜"Jš
œ˜J˜J˜Jš
œ˜Jš
œ˜—J˜Jš
œ™šžœ
žœ
˜šžœT˜VJ˜——Jš
œ™š
ž˜š
œ%˜%Jš
œ"˜"Jš
œ˜J˜—Jšœ#žœ˜=Jš
œ1˜1Jš
œ;˜;Jšžœ/žœžœ
˜Nšžœž˜Jšžœ)˜+—šžœ!ž˜'Jšžœ^˜`—Jš
œS˜SJš
œ'˜'Jšžœ˜—J˜—š�
œžœ
ž	œ
žœ˜7J˜š
œ)˜)Jš
œa˜ašžœž˜Jš
œ\˜\Jš
œ]˜]Jšžœ
˜—Jš
œF˜FJš
œ˜J˜—Jš
œ6˜6J˜—Jš
œ@™@š
�
œžœ
ž	œ	žœžœ˜JJ˜š
œ)˜)šžœž˜š
œ˜Jšœ
žœžœ˜:Jš
œ@˜@šžœž˜Jš
œC˜C——J˜š
œ˜Jšœ
žœžœ˜>Jš
œD˜Dšžœž˜Jš
œG˜G—J˜—Jšžœ˜	—J˜—Jš
œ6˜6—J˜š�
œžœ
ž	œ	žœ˜3J™J˜š
œ"˜"š
œ$˜$šžœžœž˜6JšžœB˜D——Jš
œ>˜>J˜—Jš
œ/˜/—J˜Jšžœ
˜——…—%Ö3ë