DIRECTORY
CD,
CDBasics,
CornerStitching,
CDOrient,
CDCells,
CDRects,
CDMenus,
CDSequencer,
CDInstances,
CDProperties,
CDDirectory,
Recognizer,
TerminalIO,
CleanObjects;

CleanObjectsImpl: CEDAR PROGRAM
IMPORTS CD, CDBasics, CornerStitching, CDOrient, CDCells, CDInstances, CDProperties,  CDDirectory, CDRects, CDMenus, CDSequencer, Recognizer, TerminalIO
EXPORTS CleanObjects = 
BEGIN 

LayerAndTessPtr: TYPE = REF LayerAndTessRec;
LayerAndTessRec: TYPE = RECORD [
design: CD.Design,
cellOb: CD.Object,
cellPtr: CD.CellPtr,
abstract: CD.Layer _ CD.combined,
actual: CD.Layer _ CD.combined,
surround: CD.Layer _ CD.combined,
surroundExt: CD.Number _ 0,
actualPlane: REF CornerStitching.Tesselation _ NIL,
surroundPlane: REF CornerStitching.Tesselation _ NIL,
instance: CD.Instance _ NIL
];

AbstractLayerRec: TYPE = RECORD [
technology: CD.Technology,
abstract: CD.Layer,
actual: CD.Layer,
surround: CD.Layer,  --The surrounding layer of an abstract layer
surroundExt: CD.Number --The extension of the surrounding layer
];

abstractLayerList: LIST OF REF AbstractLayerRec _ NIL;  --contains registered abstract Layers

RegionList: TYPE = LIST OF REF CornerStitching.Region;

CleanObjects: PUBLIC PROC [cellOb: CD.Object, design: CD.Design, recognizeObjects: BOOL _ TRUE] =
BEGIN
WITH cellOb.specificRef SELECT FROM
cp: CD.CellPtr => {
IF recognizeObjects THEN Recognizer.RecognizeObjects[design, cellOb];
CleanCell[design, cellOb];
[] _ CDCells.RepositionCell[cellOb, design];
CDDirectory.PropagateChange[cellOb, design];
};
ENDCASE => NULL;
END;

CleanObjectsAllLevels: PROC [design: CD.Design, recognizeObjects: BOOL] =
BEGIN
DoIt: CDDirectory.EachEntryAction = {
CleanObjects[cellOb: ob, design: design, recognizeObjects: recognizeObjects]
};
[] _ CDDirectory.Enumerate[design, DoIt];
CleanObjects[design.actual.first.dummyCell.ob, design, recognizeObjects]; 
END;

RecognizeAllCommand: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Recognize on all levels\n"];
CleanObjectsAllLevels[design: comm.design, recognizeObjects: TRUE];
TerminalIO.WriteRope["Recognizer and Cleaning Done\n"];
END;

RecognizeTopCommand: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Recognize on top level\n"];
CleanObjects[comm.design.actual.first.dummyCell.ob, comm.design, TRUE];
TerminalIO.WriteRope["Recognizer and Cleaning Done\n"];
END;

CleanCell: PROC [design: CD.Design, cellOb: CD.Object] =
BEGIN
passTessInfo: LayerAndTessPtr _ NEW[LayerAndTessRec _ [design, cellOb, NARROW[cellOb.specificRef]]];
FOR layerList: LIST OF CD.Layer _ design.technology.usedLayers, layerList.rest WHILE layerList #NIL DO
passTessInfo.abstract _ layerList.first;
passTessInfo.actual _ layerList.first;
passTessInfo.surround _ CD.combined;
FOR abstractList: LIST OF REF AbstractLayerRec _ abstractLayerList, abstractList.rest WHILE abstractList #NIL DO
IF abstractList.first.technology = design.technology AND abstractList.first.abstract = passTessInfo.abstract THEN {
passTessInfo.actual _ abstractList.first.actual;
passTessInfo.surround _ abstractList.first.surround;
passTessInfo.surroundExt _ abstractList.first.surroundExt;
EXIT;
}
ENDLOOP;
passTessInfo.actualPlane _ CornerStitching.NewTesselation[];
passTessInfo.surroundPlane _ CornerStitching.NewTesselation[];
FillPlanesByDrawingObjects[passTessInfo]; 
CheckRectsAgainstPlane[passTessInfo];
ENDLOOP;
END;

FillPlanesByDrawingObjects: PROC [passTessInfo: LayerAndTessPtr] =
BEGIN
pr: CD.DrawRef _ CD.CreateDrawRef[passTessInfo.design];
pr.devicePrivate _ passTessInfo;
pr.drawRect _ DrawObjectsIntoPlanes;
FOR instanceList: CD.InstanceList _ passTessInfo.cellPtr.contents, instanceList.rest WHILE instanceList #NIL DO
IF ~instanceList.first.ob.class.wireTyped AND FlattenObject[instance: instanceList.first] THEN 
instanceList.first.ob.class.drawMe[inst: instanceList.first, pos: instanceList.first.location, orient: instanceList.first.orientation, pr: pr];
ENDLOOP; 
END;

FlattenObject: PROC [instance: CD.Instance] RETURNS [BOOL _ TRUE] =
BEGIN
IF instance.ob.class.inDirectory THEN RETURN[FALSE];
END;

DrawObjectsIntoPlanes: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
passTessInfo: LayerAndTessPtr _ NARROW[pr.devicePrivate];
IF passTessInfo.actual = l THEN 
CornerStitching.ChangeRect [plane: passTessInfo.actualPlane, rect: r,  newValue: $cover]
ELSE
IF passTessInfo.surround = l THEN
CornerStitching.ChangeRect[plane: passTessInfo.surroundPlane, rect: r, newValue: $cover];
END;

CheckRectsAgainstPlane: PROC [passTessInfo: LayerAndTessPtr] =
BEGIN
FOR instanceList: CD.InstanceList _ passTessInfo.cellPtr.contents, instanceList.rest WHILE instanceList#NIL DO
IF instanceList.first.ob.class.wireTyped AND instanceList.first.ob.layer = passTessInfo.abstract AND WireNeededCleaning [instanceList.first, passTessInfo] THEN
[] _ CDCells.RemoveInstance[design: passTessInfo.design, cell: passTessInfo.cellOb, inst: instanceList.first]; 
ENDLOOP; 
END;

WireNeededCleaning: PROC [instance: CD.Instance, passTessInfo: LayerAndTessPtr] RETURNS [addedWire: BOOL _ FALSE] =
BEGIN
rect: CD.Rect _ CDInstances.InstRectI[instance];
keepList: RegionList _ NARROW[CornerStitching.EnumerateArea [plane: passTessInfo.actualPlane, rect: rect, backgroundValue: $cover]];
throwAwayList: RegionList _ NARROW[CornerStitching.EnumerateArea [plane: passTessInfo.actualPlane, rect: rect]];
IF passTessInfo.surround #CD.combined THEN  --current Layer is an abstract Layer
keepList _ UncoveredSurroundPieces[keepList, throwAwayList, passTessInfo.surroundPlane, passTessInfo.surroundExt];
keepList _ BuildKeepList[keepList, instance, rect];
IF keepList = NIL THEN RETURN[TRUE];
IF  (keepList.first.value = NIL) AND (keepList.first.rect = rect) AND (keepList.rest = NIL) THEN RETURN;   --keep whole wire
WHILE keepList #NIL DO {
location: CD.Position _ CDBasics.BaseOfRect [keepList.first.rect];
object: CD.Object _ CDRects.CreateRect[CDOrient.OrientedSize[CDBasics.SizeOfRect[keepList.first.rect],  instance.orientation], passTessInfo.abstract];
newInst: CD.Instance _ CDCells.IncludeOb[ 
design: passTessInfo.design,
cell: passTessInfo.cellOb, 
ob: object, 
position:  location, 
orientation: instance.orientation, 
cellCSystem: cdCoords,
obCSystem: interrestCoords,
mode: dontPropagate
].newInst;
CDProperties.CopyProps[instance.properties, newInst];
addedWire _ TRUE;
};
keepList _ keepList.rest;
ENDLOOP;
END;

BuildKeepList: PROC [keepList: RegionList, instance: CD.Instance, rect: CD.Rect] RETURNS [newKeepList: RegionList] =
BEGIN
xWidth: BOOL;
width: CD.Number;
length: CD.Number;
changed: BOOL _ TRUE;
wirePlane: REF CornerStitching.Tesselation _ CornerStitching.NewTesselation[];
WHILE keepList #NIL DO
CornerStitching.ChangeRect[plane: wirePlane, rect: keepList.first.rect, newValue: $cover];
keepList _ keepList.rest;
ENDLOOP;
IF CDOrient.IncludesOddRot90[instance.orientation] THEN {
xWidth _ FALSE;
width _ rect.y2-rect.y1;
length _ rect.x2-rect.x1;
}
ELSE {
xWidth _ TRUE;
width _ rect.x2-rect.x1;
length _ rect.y2-rect.y1;
};
IF length > width THEN   -- normal shaped object 
WHILE  changed DO
changed _ FALSE;
newKeepList _ NARROW[CornerStitching.EnumerateArea[plane: wirePlane, rect: rect]];
WHILE newKeepList #NIL DO
IF xWidth AND (newKeepList.first.rect.x2-newKeepList.first.rect.x1) #width THEN {
changed _ TRUE;
CornerStitching.ChangeRect[plane: wirePlane, rect: [rect.x1, newKeepList.first.rect.y1, rect.x2, newKeepList.first.rect.y2], newValue: $cover];
};
IF ~xWidth AND (newKeepList.first.rect.y2-newKeepList.first.rect.y1) #width THEN {
changed _ TRUE;
CornerStitching.ChangeRect[plane: wirePlane, rect: [newKeepList.first.rect.x1, rect.y1, newKeepList.first.rect.x2, rect.y2], newValue: $cover];
};
newKeepList _ newKeepList.rest;
ENDLOOP;
ENDLOOP;
RETURN[newKeepList _ NARROW[CornerStitching.EnumerateArea[plane: wirePlane, rect: rect]]];
END;

UncoveredSurroundPieces: PROC [keepList, throwAwayList: RegionList, surroundPlane: REF CornerStitching.Tesselation, surroundExt: CD.Number] RETURNS [newKeepList: RegionList] =
BEGIN
newKeepList _ keepList;
WHILE keepList #NIL DO
CornerStitching.ChangeRect[plane: surroundPlane, rect: CDBasics.Extend[keepList.first.rect, surroundExt], newValue: $cover];
keepList _ keepList.rest;
ENDLOOP;
 WHILE throwAwayList #NIL DO
IF ~RectCoveredCompletely[throwAwayList.first.rect, surroundPlane, surroundExt] THEN
newKeepList _ CONS[throwAwayList.first, newKeepList];
   throwAwayList _ throwAwayList.rest;
ENDLOOP;
END;

RectCoveredCompletely: PROC [rect: CD.Rect, plane: REF CornerStitching.Tesselation, surroundExt: CD.Number] RETURNS [BOOL _ TRUE] =
BEGIN
FOR surroundList: RegionList _ NARROW[CornerStitching.EnumerateArea[plane: plane, rect: CDBasics.Extend[rect, surroundExt], backgroundValue: $none]], surroundList.rest WHILE surroundList #NIL DO
IF surroundList.first.value = NIL THEN 
RETURN[FALSE];
ENDLOOP;
END;

RegisterAbstractLayer: PUBLIC PROC [technology: CD.Technology, abstract, actual, surround: CD.Layer, surroundExt: CD.Number] = 
BEGIN
abstractLayerList _ CONS[NEW[AbstractLayerRec _ [technology, abstract, actual, surround, surroundExt]], abstractLayerList];
END;

CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Recognize All", key: $RecognizeAll];
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Recognize Top", key: $RecognizeTop];
CDSequencer.ImplementCommand[a: $RecognizeAll, p: RecognizeAllCommand, queue: doQueue];
CDSequencer.ImplementCommand[a: $RecognizeTop, p: RecognizeTopCommand, queue: doQueue];

END.

ΈCleanObjectsImpl.mesa
Last Edited by: Gbier, July 11, 1985 12:181:45 pm PDT
Last Edited by: Gbier, July 26, 1985 10:56:06 am PDT
Jacobi, September 24, 1985 10:07:42 am PDT
--If a piece on the keeplist is actually a cut along the width then the piece is grown to the full width of the original wire.
--Used for verifying abstract layers.  All pieces on throwAwayList must be surrounded, otherwise the piece is moved onto the keepList
Κ	˜š
œ™Jš
œ5™5Jš
œ4™4Icode™*—J˜š
Οk	˜	Jšœ
˜Jš
œ	˜	Jš
œ˜J˜	J˜J˜J˜J˜J˜J˜
J˜J˜J˜Jš
œ
˜
—J˜šΟbœœ
˜Jšœ
œŽ
˜˜
Jšœ˜—Jšœ
˜J˜Jšœœœ˜,šœœœ˜ Jšœœ˜Jšœœ˜Jšœ	œ	˜Jšœ
œ	œ
˜!Jšœœ	œ
˜Jšœ
œ	œ
˜!Jšœ
œ˜Jšœ
œœ
˜3Jšœœœ
˜5Jšœ
œ˜J˜—J˜šœœœ˜!Jšœœ˜Jšœ
œ˜Jšœœ˜Jšœ
œ	Οc,˜AJšœ
œŸ(˜?J˜J˜—Jš
œœ
œ
œœŸ%˜]J˜Jš	œœœ
œ
œ˜6J˜šΟnœœ
œ
œœœœ˜aJš
˜šœœ
˜#šœœ
˜Jšœœ-˜EJ˜J˜,Jš
œ,˜,J˜——Jšœœ
˜Jšœ
˜—J˜š œœ
œœ˜IJš
˜šžœ!˜%Jš
œL˜LJš
œ˜—Jš
œ)˜)Jš
œJ˜JJšœ
˜—J˜š œœ˜7Jš
˜Jš
œ2˜2Jš
œC˜CJ˜7Jšœ
˜—J˜šΠbnœœ˜7Jš
˜Jš
œ1˜1JšœAœ˜GJ˜7Jšœ
˜J˜—š‘	œœ
œœ
˜8Jš
˜Jšœ œA˜dš
œœ
œ
œ6œœ
˜fJ˜(J˜&Jšœœ
˜$š
œœ
œ
œ9œœ
˜pšœ3œ5œ˜sJ˜0J˜4J˜:Jšœ
˜J˜
—Jšœ
˜—Jš
œ<˜<Jš
œ>˜>J˜*J˜%Jšœ
˜—Jšœ
˜—J˜š‘œœ"˜BJš
˜Jšœœœ$˜7J˜ J˜$š	œœAœœ
˜ošœ(œ-œ
˜_J˜
—Jšœ˜	—Jšœ
˜—J˜š‘
œœœœœœ˜CJš
˜Jšœœ
œ
œ˜4Jšœ
˜J˜—š
‘œœœ
œœ˜GJš
˜Jšœ œ˜9šœœ
˜ Jš
œX˜X—š
˜šœ˜!J˜Y——Jšœ
˜J˜—š‘œœ"˜>Jš
˜š	œœAœœ
˜nšœ'œ5œ7˜Ÿ
Jš
œo˜o—Jšœ˜	—Jšœ
˜—J˜š‘œœœ*œ
œœ˜sJš
˜Jšœœ(˜0Jšœœg˜„
JšœœN˜pšœœ
œŸ$˜PJš
œr˜r—J˜3Jš
œœ
œ
œ
œ˜$Jšœœœœœœ
œŸ˜|šœœ
œ˜Jšœ
œ6˜BJšœœŒ
˜–
šœ	œ˜*Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ#˜#J˜Jš
œ˜J˜Jš
œ
˜
—J˜5Jšœœ
˜J˜J˜Jšœ
˜—Jšœ
˜J˜—š
‘
œœ"œœœ˜tJ™~Jš
˜Jšœœ
˜
Jšœœ˜Jšœœ˜Jšœ	œœ
˜Jšœœ@˜Nšœœ
˜J˜ZJ˜Jšœ
˜—šœ1œ˜9Jšœ	œ
˜J˜J˜J˜
—šœ˜Jšœ	œ
˜J˜J˜J˜—šœœŸ˜1šœ
˜Jšœ
œ
˜Jšœœ>˜Ršœœ
˜šœœ>œ˜QJšœ
œ
˜J˜
J˜—šœ	œ>œ˜RJšœ
œ
˜J˜
J˜—J˜Jšœ
˜—Jšœ
˜——Jšœœ?˜ZJšœ
˜J˜—š
‘œœ6œ+œ	œ˜―
J™…
Jš
˜J˜šœœ
˜J˜|J˜Jšœ
˜—šœ
œœ
˜šœN˜TJšœœ#˜5——˜&Jšœ
˜—Jšœ
˜J˜—š‘œœœœ+œ	œœœ˜ƒ
Jš
˜š	œœƒ
œœ
˜Β
šœœ
œ
˜'Jšœ
œ˜—Jšœ
˜—Jšœ
˜J˜—š œœ
œœ)œœ˜Jš
˜Jšœœ
œ_˜{Jšœ
˜—J˜Jš
œT˜TJš
œT˜TJš
œW˜WJš
œW˜WJ˜Jšœ
˜—…—$τ0+