<> <> <<-- 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 RTSets, SC, SCInstUtil, SCNetUtil, SCPlaceUtil, SCPrivate, SCRowUtil, Rope, TerminalIO; SCPlaceUtilImpl: CEDAR PROGRAM IMPORTS 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; i2Pos: SCPrivate.MaxPosSr; i2Orien: SCPrivate.OrientationOrNone; i1Row: SCPrivate.MaxRowSr _ instance1.curRow; i1Pos: SCPrivate.MaxPosSr _ instance1.curPos; i1Orien: SCPrivate.OrientationOrNone _ instance1.curOrien; SCPlaceUtil.RemvLgComp[handle, instance1]; i2Row _ instance2.curRow; i2Pos _ instance2.curPos; i2Orien _ instance2.curOrien; SCPlaceUtil.RemvLgComp[handle, instance2]; SCPlaceUtil.PutLgPos[handle, instance1, i2Row, i2Pos, i2Orien]; SCPlaceUtil.PutLgPos[handle, instance2, i1Row, i1Pos, i1Orien]}; io => { i2Side: SC.Side; i2Pos: SCPrivate.MaxPosSr; i1Side: SC.Side _ instance1.curSide; i1Pos: SCPrivate.MaxPosSr _ instance1.curPos; SCPlaceUtil.RemvBpComp[handle, instance1]; i2Side _ instance2.curSide; i2Pos _ instance2.curPos; SCPlaceUtil.RemvBpComp[handle, instance2]; SCPlaceUtil.PutBpPos[handle, instance1, i2Side, i2Pos, 0]; SCPlaceUtil.PutBpPos[handle, instance2, i1Side, i1Pos, 0]}; ENDCASE} ELSE SC.Error[programmingError, NIL]}; Compatable: PROCEDURE[instance1, instance2: SCPrivate.Instance] RETURNS [compat: BOOLEAN _ FALSE]= { IF instance1.whichClass = io AND instance2.whichClass = io THEN RETURN [TRUE] ELSE IF (instance1.whichClass = logic OR instance1.whichClass = ft) AND (instance2.whichClass = logic OR instance2.whichClass = ft) THEN RETURN [TRUE]}; 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] = { <> 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] = { <> 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 instance.whichClass = ft THEN { DeleteFt: SCInstUtil.EachInstanceProc = { newNum: SCPrivate.MaxInstanceSr _ instance.instanceNum-1; structureData.instances.inst[newNum] _ instance; instance.instanceNum _ 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.instanceNum+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] = { <> 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; 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}; 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.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]; 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.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.