DIRECTORY
CD,
CDBasics,
CDDirectory,
CDErrors,
CDMarks,
CDOps,
CDOrient,
CDProperties,
CDRects,
CDX,
Rope,
TerminalIO;

CDErrorsImpl: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDDirectory, CDMarks, CDOrient, CDProperties, CDOps, CDRects, CDX, Rope, TerminalIO
EXPORTS CDErrors =
BEGIN

AppPredicate: TYPE = CDErrors.AppPredicate;

WhereFound: TYPE = {itself, cell, design, none};

foundAndStop: SIGNAL = CODE;
foundInFirstPlace: SIGNAL = CODE;

MyDevice: TYPE = RECORD [
mark: CDMarks.MarkRange,
searchOb: CD.ObPtr,
found: BOOL_FALSE, 
pos: CD.DesignPosition_[0, 0], 
orient: CD.Orientation_0, 
cell: CD.ObPtr_NIL,
cellFound: BOOL_FALSE,
cellPos: CD.DesignPosition_[0, 0],
cellOrient: CD.Orientation_0
];

MyDrawChild: CD.DrawProc =
BEGIN
device: REF MyDevice = NARROW[pr.devicePrivate];
IF aptr.ob.marked = device.mark THEN RETURN;
aptr.ob.marked _ device.mark;
IF aptr.ob=device.searchOb THEN {
device.pos _ pos;
device.orient _ orient;
device.found _ TRUE;
SIGNAL foundInFirstPlace;
RETURN
};
aptr.ob.p.drawMe[aptr: aptr, pos: pos, orient: orient, pr: pr ! 
foundInFirstPlace => {
IF IsCell[aptr.ob] THEN {
device.cell _ aptr.ob;
device.cellPos _ pos;
device.cellOrient _ orient;
device.cellFound _ TRUE;
SIGNAL foundAndStop;
ERROR
};
REJECT
}
]; 
END;

IsPushedInto: PROC [design: CD.Design, ob: CD.ObPtr] RETURNS [yes: BOOL_FALSE] =
BEGIN
FOR list: LIST OF CD.PushRec _ design.actual, list.rest WHILE list#NIL DO
IF list.first.dummyCell.ob=ob THEN RETURN [TRUE];
ENDLOOP
END;

FindAnInstance: PROC [design: CD.Design, ob: CD.ObPtr] RETURNS [where: WhereFound _ none, cell: CD.ObPtr_NIL, pos: CD.DesignPosition_[0, 0], orientation: CD.Orientation_0] =
BEGIN

ProtectedDrawDesign: PROC [] =
BEGIN
ENABLE UNWIND => CDMarks.ReleaseMark[design, myMark];
CDOps.DrawDesign[design, myDrawRef ! 
foundAndStop, foundInFirstPlace => CONTINUE;
];
CDMarks.ReleaseMark[design, myMark ! CD.Error => GOTO exit];
EXITS 
exit => TerminalIO.WriteRope["** release problem in CDErrorsImpl\n"];
END;

myDrawRef: REF CD.DrawInformation;
myDevice: REF MyDevice;
myMark: CDMarks.MarkRange;
IF IsCell[ob] THEN RETURN [where _ itself, cell _ ob];
myDrawRef _ CD.CreateDrawRef[design];
myDrawRef.interestClip _ CDBasics.universe;
myDrawRef.drawChild _ MyDrawChild;
myMark _ CDMarks.GetNewMark[design];
myDrawRef.devicePrivate _ myDevice _ NEW[MyDevice _ [searchOb: ob, mark: myMark]];
ProtectedDrawDesign[];
IF myDevice.found THEN {
IF myDevice.cellFound AND ~IsPushedInto[design, cell] THEN {
r: CD.DesignRect;
cell _ myDevice.cell;
where _ WhereFound[cell];
r _ CDOrient.DeMapRect[
itemInWorld: CDOrient.RectAt[myDevice.pos, myDevice.searchOb.size, myDevice.orient],
cellSize: myDevice.cell.size,
cellInstOrient: myDevice.cellOrient,
cellInstPos: myDevice.cellPos
].itemInCell;
pos _ CDBasics.BaseOfRect[r];
orientation _ CDOrient.DecomposeOrient[
itemOrientInWorld: myDevice.orient, 
cellOrientInWorld: myDevice.cellOrient
].itemOrientInCell;
}
ELSE {
where _ WhereFound[design];
pos _ myDevice.pos;
orientation _ myDevice.orient;
}
}  
END;

IncludeMessage: PUBLIC PROC [
	design: CD.Design,
	ob: CD.ObPtr,
	rect: CD.DesignRect,
	message: Rope.ROPE_NIL, 
	owner: ATOM_NIL] 
RETURNS [done: BOOL_TRUE, into: CD.ObPtr_NIL, app: CD.ApplicationPtr_NIL] =
BEGIN
mappedRect: CD.DesignRect;
where: WhereFound;
cell: CD.ObPtr;
pos: CD.DesignPosition;
orientation: CD.Orientation;
from: Rope.ROPE _ NIL;
IF design=NIL OR ob=NIL OR ~CDBasics.NonEmpty[rect] THEN RETURN [done_FALSE];
[where: where, cell: cell, pos: pos, orientation: orientation] _ FindAnInstance[design, ob];
IF where=none THEN RETURN [done_FALSE]
ELSE IF where=itself THEN {mappedRect _ rect; into _ ob} 
ELSE {
cellRep: REF;  
from _ CDDirectory.Name[ob];
IF from=NIL THEN from _ CDOps.Info[ob];
IF where=design THEN {mappedRect _ rect; cellRep _ $design} 
ELSE IF cell#NIL THEN {
mappedRect _ CDOrient.MapRect[
itemInCell: rect, 
cellSize: ob.size,
cellInstOrient: orientation, 
cellInstPos: pos
];
cellRep _ CDDirectory.Name[cell];
into _ cell;
IF cellRep=NIL THEN {cellRep _ $design; into _ NIL};
}
ELSE ERROR;
IF ob.p.inDirectory THEN { 
x: REF = CDProperties.GetPropFromObject[ob, hasErrorsInOtherCellsKey];
IF x=NIL THEN CDProperties.PutPropOnObject[ob, hasErrorsInOtherCellsKey, cellRep]
ELSE IF x#$many AND x#cellRep THEN {
IF ~ISTYPE[x, Rope.ROPE] OR ~Rope.Equal[NARROW[x, Rope.ROPE], CDDirectory.Name[ob]] THEN 
CDProperties.PutPropOnObject[ob, hasErrorsInOtherCellsKey, $many] 
}
};
message _ Rope.Cat[message, " [local to ", from, "]"];
};
IF where#design THEN {
ir: CD.DesignRect _ CD.InterestRect[cell];
clipped: CD.Rect _ CDBasics.Intersection[ir, mappedRect];
IF ~CDBasics.NonEmpty[clipped] AND ISTYPE[cell.specificRef, CD.CellPtr] THEN {
cellPtr: CD.CellPtr _ NARROW[cell.specificRef];
IF ~cellPtr.useDIr THEN  {
clipped _ CDBasics.Intersection[CDBasics.RectAt[[0, 0], cell.size], mappedRect]
}
};
IF CDBasics.NonEmpty[clipped] THEN mappedRect _ clipped ELSE mappedRect _ ir;
};
app _ CDX.IncludeOb[design: design, 
cell: cell, 
ob: CDRects.CreateRect[CDBasics.SizeOfRect[mappedRect], CD.highLightError], 
position: CDBasics.BaseOfRect[mappedRect], 
cellCSystem: cdCoords, 
obCSystem: cdCoords, 
mode: dontPropagate
].newApp;
CDOps.DelayedRedraw[design, (IF cell=NIL THEN mappedRect ELSE CDBasics.universe)];
IF owner#NIL THEN CDProperties.PutPropOnApplication[app, ownerKey, owner];
IF message#NIL THEN CDProperties.PutPropOnApplication[app, messageKey, message];
IF from#NIL THEN CDProperties.PutPropOnApplication[app, showErrorsForOtherKey, from];
END;

EqualXR: PROC [x: REF, r: Rope.ROPE] RETURNS [BOOL] =
INLINE BEGIN
WITH x SELECT FROM
xr: Rope.ROPE => RETURN [Rope.Equal[xr, r]];
ENDCASE  => RETURN [x=r] --both NIL
END;

RemoveMessFromCell: PROC [design: CD.Design, owner: ATOM, cell: CD.ObPtr, removeIt: AppPredicate, restricted: Rope.ROPE_NIL, all: BOOL_FALSE] RETURNS [others: BOOL] =
BEGIN
redraw: BOOL_FALSE;
removeList: CD.ApplicationList _ NIL;
countAll: INT _ 0;
countRemove: INT _ 0;
cp: CD.CellPtr _ NARROW[cell.specificRef];
FOR list: CD.ApplicationList _ cp.contents, list.rest WHILE list#NIL DO
IF IsError[list.first.ob] THEN { 
countAll _ countAll+1;
IF owner=NIL OR owner=CDProperties.GetPropFromApplication[list.first, ownerKey] THEN { 
IF all OR EqualXR[
CDProperties.GetPropFromApplication[list.first, showErrorsForOtherKey], 
restricted] THEN
IF removeIt=NIL OR removeIt[list.first] THEN { 
countRemove _ countRemove+1;
removeList _ CONS[list.first, removeList] 
} 
}
}
ENDLOOP;
FOR list: CD.ApplicationList _ removeList, list.rest WHILE list#NIL DO
[] _ CDX.RemoveApp[design, cell, list.first, doit]
ENDLOOP;
IF countRemove>0 THEN CDOps.DelayedRedraw[design];
others _ countAll#countRemove; 
END;

RemoveMessFromWorld: PROC [design: CD.Design, owner: ATOM, removeIt: AppPredicate, restricted: Rope.ROPE, all: BOOL_FALSE] RETURNS [others: BOOL] =
BEGIN
countAll: INT _ 0;
countRemove: INT _ 0;
removeList: CD.ApplicationList _ NIL;
FOR list: CD.ApplicationList _ CDOps.AppList[design], list.rest WHILE list#NIL DO
IF IsError[list.first.ob] THEN { 
countAll _ countAll+1;
IF owner=NIL OR owner=CDProperties.GetPropFromApplication[list.first, ownerKey] THEN { 
IF all OR EqualXR[
CDProperties.GetPropFromApplication[list.first, showErrorsForOtherKey], 
restricted] THEN 
IF removeIt=NIL OR removeIt[list.first] THEN { 
countRemove _ countRemove+1;
removeList _ CONS[list.first, removeList] 
}
}
}
ENDLOOP;
FOR list: CD.ApplicationList _ removeList, list.rest WHILE list#NIL DO
CDOps.RemoveApplication[design, list.first]
ENDLOOP;
others _ countAll#countRemove
END;

RemoveMessages: PUBLIC PROC [design: CD.Design, ob: CD.ObPtr, owner: ATOM, alsoOthers: BOOL, removeIt: AppPredicate] =
BEGIN

RemoveMessFromEveryWhere: PROC [restricted: Rope.ROPE_NIL] RETURNS [others: BOOL_ FALSE] =
BEGIN
EachEntry: PROC [name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL_FALSE] =
BEGIN
IF IsCell[ob] THEN 
others _ others OR RemoveMessFromCell[design, owner, ob, removeIt, restricted];
END;
[] _ CDDirectory.Enumerate[design, EachEntry];
others _ others OR RemoveMessFromWorld[design, owner, removeIt, restricted];
END;

IF IsCell[ob] THEN [] _ RemoveMessFromCell[design, owner, ob, removeIt, NIL, alsoOthers]
ELSE IF ob.p.inDirectory THEN { 
others: BOOL _ TRUE; -- found error messages of other owners
x: REF = CDProperties.GetPropFromObject[ob, hasErrorsInOtherCellsKey];
IF x#NIL THEN {
obName: Rope.ROPE = CDDirectory.Name[ob];
IF x=$design THEN 
others _ RemoveMessFromWorld[design, owner, removeIt, obName]
ELSE
WITH x SELECT FROM
r: Rope.ROPE => {
other: CD.ObPtr _ CDDirectory.Fetch[design, r].object;
IF other#NIL AND IsCell[other] THEN 
others _ RemoveMessFromCell[design, owner, other, removeIt, obName]
};
ENDCASE => others _ RemoveMessFromEveryWhere[obName];
IF owner=NIL OR ~others THEN
CDProperties.PutPropOnObject[ob, hasErrorsInOtherCellsKey, NIL];
};
}
ELSE [] _ RemoveMessFromEveryWhere[CDOps.Info[ob]];
END;

RemoveAllMessages: PUBLIC PROC [design: CD.Design, owner: ATOM, removeIt: AppPredicate] =
BEGIN
EachEntry: PROC [name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL_FALSE] =
BEGIN
IF IsCell[ob] THEN [] _ RemoveMessFromCell[design, owner, ob, removeIt, NIL, TRUE]
END;
[] _ CDDirectory.Enumerate[design, EachEntry];
[] _ RemoveMessFromWorld[design, owner, removeIt, NIL, TRUE];
END;

IsError: PROC [ob: CD.ObPtr] RETURNS [BOOL] =
INLINE BEGIN
RETURN [ob.layer=CD.highLightError AND ob.p.objectType=$Rect]
END;

IsCell: PROC [ob: CD.ObPtr] RETURNS [BOOL] =
INLINE BEGIN
RETURN [ob.p.objectType=$Cell]
END;

messageKey: PUBLIC ATOM _ $SignalName; 
ownerKey: ATOM = $ErrorOwner; 
hasErrorsInOtherCellsKey: ATOM = $showErrorsElseWhere; 
showErrorsForOtherKey: ATOM = $showErrorsForOthers; 
[] _ CDProperties.RegisterProperty[hasErrorsInOtherCellsKey, $many];
[] _ CDProperties.RegisterProperty[showErrorsForOtherKey, $Rope];
[] _ CDProperties.RegisterProperty[ownerKey, $ATOM];
END. 



.CDErrorsImpl.mesa        (part of Chipndale)
Copyright c 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi,  March 1, 1985 9:40:12 am PST 
last edited by Christian Jacobi,  April 11, 1985 9:16:48 am PST
Last Edited by: Beretta, July 1, 1985 4:12:31 pm PDT
--PROC [aptr: CD.ApplicationPtr] RETURNS [yes: BOOL_TRUE];
--PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation, pr: REF CD.DrawInformation] 
--not needed in this application of procedure
--IF list.first.mightReplace#NIL AND list.first.mightReplace.ob=ob THEN RETURN [TRUE]
--get an instance
--mapp the error rectangle
--make ob pointing to errormessage places if of any value and possible
--include the error rectangle
--properties
--all: whether we want restricted to be applied
--restricted: whether only messages with Name(origin)=restricted will be removed
--to improve, handle innerrect crap, removing and repositioning inside
--all: whether we want restricted to be applied
--restricted: whether only messages with Name(origin)=restricted will be removed
�Êv˜š
œ,™,Jšœ
Ïm
œ1™<Jš
œ3™3Jš
œ?™?—J™4J˜š
Ïk	˜	Jšžœ
˜Jš
œ	˜	Jš
œ˜Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ	˜	Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—šÏbœžœ
ž˜Jšžœb˜iJšžœ˜—Jš
ž˜J˜šœžœ˜+Jš
œ:™:—J˜Jšœžœ ˜0J˜Jšœžœžœ
˜Jšœžœžœ
˜!J˜šœ
žœžœ˜Jš
œ˜Jšœ
žœ˜Jšœžœ
žœ˜Jšœžœ˜Jšœžœ˜Jšœžœžœ
˜Jšœžœ
žœ
˜Jšœ	žœ˜"Jšœžœ˜Jš
œ˜—J˜šŸœžœ˜Jš
œm™mJš
ž˜Jšœžœžœ˜0Jšžœžœ
žœ
˜,Jš
œ˜šžœžœ˜!Jš
œ˜Jš
œ˜Jšœž˜Jšžœ˜Jš
ž˜J˜—š
œ@˜@š
œ˜šžœžœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ
˜Jšžœ˜Jš
ž˜Jš
œ˜—Jš
ž˜Jš
œ
˜
—Jš
œ˜—Jšžœ
˜—J˜šÏnœžœ
žœ
žœžœžœ
žœ˜PJš
ž˜šžœžœ
žœ'žœžœ
ž˜IJšžœžœ
žœžœ˜1Jš
œ-™-Jš
œU™UJš
ž˜—Jšžœ
˜—J˜š œžœ
žœ
žœžœ"žœžœžœ%žœ˜­
Jš
ž˜J˜š œžœ˜š
ž˜Jšžœ
žœ(˜5—š
œ%˜%Jšœ#žœ
˜,Jš
œ˜—Jšœ%žœ
žœ˜<šžœ
˜Jš
œE˜E—Jšžœ
˜—J˜Jšœžœ
žœ˜"Jšœ
žœ
˜Jš
œ˜Jšžœžœ
žœ˜6Jšœžœ˜%Jš
œ+˜+Jš
œ"˜"Jš
œ$˜$Jšœ%žœ*˜RJš
œ˜šžœžœ˜šžœžœžœ˜<Jšœžœ˜Jš
œ˜Jš
œ˜˜Jš
œT˜TJš
œ˜Jš
œ$˜$Jš
œ˜Jš
œ
˜
—Jš
œ˜š
œ'˜'Jš
œ$˜$Jš
œ&˜&Jš
œ˜—J˜
—šžœ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜
—Jš
œ˜—Jšžœ
˜—J˜šÐbnœžœ
žœ˜Jšœ	žœ˜Jšœžœ˜Jšœžœ˜Jšœžœ
žœ˜šœžœ
žœ˜Jšžœžœ
žœžœžœžœžœ˜K—Jš
ž˜Jšœžœ˜Jš
œ˜Jšœžœ˜Jšœžœ˜Jšœ
žœ
˜Jšœžœžœ
˜Jšžœžœ
žœžœ
žœžœ
žœžœ˜MJš
œ™Jš
œ\˜\Jš
œ™Jšžœžœ
žœžœ
˜&Jšžœ
žœžœ ˜9šžœ˜Jšœ	žœ˜Jš
œ˜Jšžœžœ
žœ˜'Jšžœžœ(˜<šžœ
žœžœ
žœ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ!˜!Jš
œ˜Jšžœ	žœ
žœžœ˜4J˜
—Jšžœ
žœ
˜Jš
œF™Fšžœžœ˜Jšœžœ@˜FJšžœžœ
žœD˜Qšžœ
žœ	žœžœ˜$šžœžœ	žœžœ
žœ	žœžœ
˜YJš
œB˜B—J˜
—J˜—Jš
œ6˜6J˜—šžœžœ˜Jšœžœ$˜*Jš
œ9˜9š
žœžœ
žœžœ
žœ˜NJšœ	žœžœ˜/šžœžœ˜Jš
œO˜OJ˜
—J˜—Jšžœžœžœ˜MJ˜—Jš
œ™šœžœ˜$Jš
œ˜Jšœ8žœ˜LJš
œ+˜+Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ	˜	—Jš	œžœžœ
žœžœ˜RJš
œ™Jšžœžœ
žœ9˜JJšžœ	žœ
žœ=˜PJšžœžœ
žœE˜UJšžœ
˜—J˜š œžœžœ
žœžœžœ˜5Jšžœ
ž˜šžœžœ
ž˜Jšœ	žœžœ˜,JšžœžœÏc
˜#—Jšžœ
˜—J˜š œžœ
žœžœžœ1žœ
žœžœ
žœžœ
žœ˜¦
Jš
œ/™/Jš
œP™PJš
ž˜Jšœžœ
žœ
˜Jšœžœžœ
˜%Jšœ
žœ˜Jšœ
žœ˜Jšœžœžœ˜*Jš
œF™Fš	žœžœ*žœžœ
ž˜Gšžœžœ˜!Jš
œ˜šžœžœ
žœAžœ˜Wšžœžœ	˜Jš
œH˜Hšœž˜šžœ
žœ
žœžœ˜/Jš
œ˜Jšœ
žœ˜*Jš
œ˜———J˜
—J˜
—Jšžœ
˜—š	žœžœ)žœžœ
ž˜FJšœžœ*˜2Jšžœ
˜—Jšžœžœ˜2Jš
œ˜Jšžœ
˜J˜—š œžœ
žœžœ+žœžœ
žœžœ
žœ˜“
Jš
œ/™/Jš
œP™PJš
ž˜Jšœ
žœ˜Jšœ
žœ˜Jšœžœžœ
˜%š	žœžœ4žœžœ
ž˜Qšžœžœ˜!Jš
œ˜šžœžœ
žœAžœ˜Wšžœžœ	˜Jš
œH˜Hšœž˜šžœ
žœ
žœžœ˜/Jš
œ˜Jšœ
žœ˜*J˜
———J˜
—J˜
—Jšžœ
˜—š	žœžœ)žœžœ
ž˜FJš
œ+˜+Jšžœ
˜—Jš
œ˜Jšžœ
˜J˜—š œžœ
žœ
žœ
žœžœžœ˜vJš
ž˜J˜š œžœžœ
žœžœ
žœžœ˜ZJš
ž˜š 	œžœ
žœžœžœžœ
žœ˜LJš
ž˜šžœžœ
˜Jšœžœ=˜O—Jšžœ
˜—Jš
œ.˜.Jšœžœ:˜LJšžœ
˜J˜—Jšžœžœ4žœ
˜Xšžœ
žœžœ˜ Jšœžœžœ
¢(˜<Jšœžœ@˜Fšžœžœ
žœ˜Jšœ
žœ˜)šžœžœ
˜Jš
œ=˜=—š
ž˜šžœžœ
ž˜šœžœ˜Jšœžœ-˜6šžœžœ
žœžœ
˜$Jš
œC˜C—Jš
œ˜—Jšžœ.˜5——šžœžœ
žœ	ž˜Jšœ;žœ˜@—Jš
œ˜—Jš
œ
˜
—Jšžœ/˜3Jšžœ
˜—J˜š
 œžœ
žœ
žœžœ˜YJš
ž˜š 	œžœ
žœžœžœžœ
žœ˜LJš
ž˜Jšžœžœ4žœžœ
˜RJšžœ
˜—Jš
œ.˜.Jšœ0žœžœ˜=Jšžœ
˜J˜—š
 œžœžœžœžœ˜-Jšžœ
ž˜Jšžœžœžœ˜=Jšžœ
˜—J˜š
 œžœžœžœžœ˜,Jšžœ
ž˜Jšžœ˜Jšžœ
˜—J˜Jšœžœ
žœ˜'Jšœ
žœ˜Jšœžœ˜7Jšœžœ˜4Jš
œD˜DJš
œA˜AJš
œ4˜4Jšžœ˜J˜J˜J˜—…—&”98