<> <> <> <> <<-- ExchInsts - exchange two like instances>> <<-- ReverseOrientation - reverse orientation of an instance>> <<-- 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>> DIRECTORY IO, Rope, RTSets, SC, SCInstUtil, SCNetUtil, SCPlaceUtil, SCPrivate, SCRowUtil, TerminalIO; SCPlaceUtilImpl: CEDAR PROGRAM IMPORTS IO, Rope, RTSets, SC, SCInstUtil, SCNetUtil, SCPlaceUtil, SCRowUtil, TerminalIO EXPORTS SCPlaceUtil SHARES SC = BEGIN <<>> <> ExchInsts: PUBLIC PROCEDURE[handle: SC.Handle, instance1, instance2: SCPrivate.Instance] = { IF Compatable[instance1, instance2] THEN { SELECT instance1.whichClass FROM logic, ft => { i2Row: SCPrivate.MaxRowSr _ instance2.curRow; i1Row: SCPrivate.MaxRowSr _ instance1.curRow; i1Pos: SCPrivate.MaxPosSr _ instance1.curPos; IF i1Row = i2Row THEN ExchPosRow[handle, i1Pos, instance2.curPos, i1Row] ELSE { i1Orien: SCPrivate.OrientationOrNone _ instance1.curOrien; i2Pos: SCPrivate.MaxPosSr; i2Orien: SCPrivate.OrientationOrNone; SCPlaceUtil.RemvLgComp[handle, instance1, FALSE]; i2Pos _ instance2.curPos; i2Orien _ instance2.curOrien; SCPlaceUtil.RemvLgComp[handle, instance2, FALSE]; SCPlaceUtil.PutLgPos[handle, instance1, i2Row, i2Pos, i2Orien, TRUE]; SCPlaceUtil.PutLgPos[handle, instance2, i1Row, i1Pos, i1Orien, TRUE]}; -- CheckPlace[handle]; }; io => { i2Side: SC.Side _ instance2.curSide; i1Side: SC.Side _ instance1.curSide; i1Pos: SCPrivate.MaxPosSr _ instance1.curPos; IF i1Side = i2Side THEN ExchPosSide[handle, i1Pos, instance2.curPos, i1Side] ELSE { i2Pos: SCPrivate.MaxPosSr; SCPlaceUtil.RemvBpComp[handle, instance1, FALSE]; i2Pos _ instance2.curPos; SCPlaceUtil.RemvBpComp[handle, instance2, FALSE]; SCPlaceUtil.PutBpPos[handle, instance1, i2Side, i2Pos, SCInstUtil.defltBpOrien[i2Side], TRUE]; SCPlaceUtil.PutBpPos[handle, instance2, i1Side, i1Pos, SCInstUtil.defltBpOrien[i1Side], TRUE]}; -- SCInstUtil.CheckBpOffsets[handle, i1Side]; -- IF i1Side # i2Side THEN SCInstUtil.CheckBpOffsets[handle, i2Side] }; ENDCASE} ELSE SC.Error[programmingError, "Not suppose to happen."]}; Compatable: PROCEDURE[instance1, instance2: SCPrivate.Instance] RETURNS [compat: BOOLEAN] = { compat _ IF instance1.whichClass = io THEN instance2.whichClass = io ELSE IF instance1.whichClass = logic OR instance1.whichClass = ft THEN instance2.whichClass = logic OR instance2.whichClass = ft ELSE FALSE}; ReverseOrientation: PUBLIC PROCEDURE[instance: SCPrivate.Instance] = { <> scOrien: SCPrivate.OrientationOrNone _ instance.curOrien; SELECT instance.curOrien FROM 0 => instance.curOrien _ 0; 1 => instance.curOrien _ 5; 2 => instance.curOrien _ 8; 3 => instance.curOrien _ 6; 4 => instance.curOrien _ 7; 5 => instance.curOrien _ 1; 6 => instance.curOrien _ 3; 7 => instance.curOrien _ 4; 8 => instance.curOrien _ 2; ENDCASE}; <<>> <> 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, updateOffsets: BOOLEAN] = { <> 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; IF updateOffsets THEN SCInstUtil.LgOffsets[handle, row, pos, SCPrivate.maxPos]}; <> 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, updateOffsets: BOOLEAN] = { <> 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]; structureData: SCPrivate.StructureData _ NARROW[handle.structureData]; lgRow: SCPrivate.LgRow; 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; lgRow _ layoutData.lgRows.rows[row]; lgRow.size.p _ lgRow.size.p - widthOfComp; IF heightOfComp >= lgRow.size.q THEN lgRow.dimInvalid _ TRUE; IF lgRow.lgsOnRow[pos] # instance THEN SC.Error[programmingError, "Invalid row"]; [] _ SCRowUtil.EnumerateInstsOnRow[handle, row, pos + 1, lgRow.nLgsOnRow, EachInst]; lgRow.nLgsOnRow _ lgRow.nLgsOnRow -1; IF updateOffsets THEN SCInstUtil.LgOffsets[handle, row, pos, SCPrivate.maxPos]; IF instance.whichClass = ft THEN { DeleteFt: SCInstUtil.EachInstanceProc = { newNum: SCPrivate.MaxInstanceSr _ instance.num-1; structureData.instances.inst[newNum] _ instance; instance.num _ newNum; instance.ftNet _ NIL; instance.object _ NIL; structureData.instances.count _ structureData.instances.count -1; structureData.instances.numFts _ structureData.instances.numFts -1; SCNetUtil.RemoveConnections[handle, instance]}; 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]]; [] _ SCInstUtil.EnumerateInstances[handle, instance.num+1, structureData.instances.count, DeleteFt]}}; <<>> <> 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, updateOffsets: BOOLEAN _ TRUE] = { <> 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]; IF updateOffsets THEN SCInstUtil.BpOffsets[handle, side, pos, SCPrivate.maxPos]}; <> 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, updateOffsets: BOOLEAN] = { side: SC.SideOrNone; pos: SCPrivate.MaxPosSr; bpRow: SCPrivate.BpRow; layoutData: SCPrivate.LayoutData _ NARROW[handle.layoutData]; widthOfComp: SC.Number _ SCInstUtil.BpWidth[instance]; heightOfComp: SC.Number _ SCInstUtil.BpHeight[instance]; EachInst: SCRowUtil.EachInstProc = { bpRow.bpsOnSide[pos-1] _ instance; instance.curPos _ pos-1}; IF instance.whichClass # io THEN SC.Error[programmingError, Rope.Cat["invalid instance: ", instance.name]]; IF instance.curSide = none THEN SC.Error[programmingError, Rope.Cat["invalid side for instance", instance.name]]; side _ instance.curSide; pos _ instance.curPos; instance.curPos _ 0; instance.curSide _ none; instance.curOrien _ 0; bpRow _ layoutData.bpRows[side]; bpRow.size.p _ bpRow.size.p - widthOfComp; 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"]]; <> IF heightOfComp >= bpRow.size.q THEN bpRow.dimInvalid _ TRUE; [] _ SCRowUtil.EnumerateInstsOnSide[handle, side, pos + 1, bpRow.nBpsOnSide, EachInst]; bpRow.bpsOnSide[bpRow.nBpsOnSide] _ NIL; bpRow.nBpsOnSide _ bpRow.nBpsOnSide -1; IF updateOffsets THEN SCInstUtil.BpOffsets[handle, side, pos, SCPrivate.maxPos]}; WriteCurPlace: PUBLIC PROCEDURE [handle: SC.Handle] = { EachInst: SCInstUtil.EachInstanceProc = { TerminalIO.PutRope[Rope.Cat[" instance: ", instance.name, ", object: ", instance.object.name]]; SELECT instance.whichClass FROM ft, logic => {TerminalIO.PutF1[", logic row: %g", IO.int[instance.curRow]]}; io => {TerminalIO.PutRope[Rope.Cat[", IO side: ", SCRowUtil.sideName[instance.curSide]]]}; ENDCASE; TerminalIO.PutF[", pos: %g\n", IO.int[instance.curPos]]}; [] _ SCInstUtil.EnumerateAllInstances[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, FALSE]; 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, FALSE]; instance.curSide _ none; instance.curPos _ 0; instance.curOrien _ 0; IF initPrePlace THEN {instance.preSide _ none; instance.prePos _ 0; instance.preOrien _ 0}}; ENDCASE}; [] _ SCInstUtil.EnumerateAllInstances[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.