
<<CDCellCommands.mesa   (part of ChipNDale)>>
<<Copyright © 1983, 1984 by Xerox Corporation.  All rights reserved.>>
<<by Christian Jacobi   July 11, 1983 3:42 pm >>
<<last edited Christian Jacobi   November 19, 1984 2:36:06 pm PST>>

DIRECTORY
CD,
CDBasics,
CDCells,
CDCommandOps,
CDDirectory,
CDDirectoryExtras,
CDInterestRects,
CDMarks,
CDOps,
CDSequencer,
CDX,
TerminalIO,
Rope;

CDCellCommands: CEDAR PROGRAM
IMPORTS CDBasics, CDInterestRects, CDX, CDOps, CDCells, CDCommandOps, CDDirectory, CDDirectoryExtras, CDMarks, CDSequencer, 
TerminalIO = 
BEGIN

orientForTest: CD.Orientation _  0;

DrawCellComm: PROC [comm: CDSequencer.Command] =
BEGIN
name: Rope.ROPE;
cellOb: CD.ObPtr;
found: BOOLEAN;
TerminalIO.WriteRope["Include cell; "];
DO
name _ TerminalIO.RequestRope["type name\n"! TerminalIO.UserAbort => {GOTO aborted}];
[found, cellOb] _ CDDirectory.Fetch[comm.design, name];
IF found THEN {
<<CDOps.AddAnObject[>>
<<design: comm.design, >>
<<ob: cellOb, >>
<<location: comm.pos, >>
<<orientation: 0];>>
app: CD.ApplicationPtr = CDX.IncludeRelative[design: comm.design, 
ob: cellOb, 
cellPosition: comm.pos, 
obPosition: CDBasics.BaseOfRect[CDInterestRects.GetInterestRect[cellOb].r],
orientation: orientForTest,
coordSystem: outerCoordinates
];
CDCommandOps.RedrawApplication[comm.design, app, FALSE];
TerminalIO.WriteRope[name];
TerminalIO.WriteRope[" inserted\n"];
RETURN
};
TerminalIO.WriteRope[name]; TerminalIO.WriteRope[" not found\n"];
IF NOT TerminalIO.UserSaysYes[label: "another try ?"
! TerminalIO.UserAbort => {GOTO aborted}] THEN RETURN;
ENDLOOP
EXITS
aborted => NULL;
END;

DeleteCell: PROC [comm: CDSequencer.Command] =
BEGIN

EachEntryCheck: CDDirectory.EachEntryAction 
-- PROC [name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL_FALSE]-- =
BEGIN
IF ob.marked#mark AND ob#toDeleteOb THEN { 
-- an occurence of cellOb should not be marked
CDMarks.MarkUnMarkedInclusiveChildren[comm.design, ob, mark];
IF  toDeleteOb.marked=mark THEN {
usedBy _ name;
quit _ TRUE
}
};
END;

<<-- DeleteCell>>
name: Rope.ROPE_NIL;
usedBy: Rope.ROPE_NIL;
toDeleteOb: CD.ObPtr;
found: BOOLEAN;
mark: CDMarks.MarkRange;
TerminalIO.WriteRope["delete cell; "];
name _ TerminalIO.RequestRope["type name\n"! TerminalIO.UserAbort => {GOTO aborted}];
[found, toDeleteOb] _ CDDirectory.Fetch[comm.design, name];
IF ~found THEN
BEGIN
TerminalIO.WriteRope[name]; TerminalIO.WriteRope[" not found\n"];
RETURN
END;
<<-- mark all entries (excluding toDeleteOb), and all their children>>
<<-- test then if toDeleteOb is marked; if it is, it is a child and used >>
mark _ CDMarks.GetNewMark[comm.design];
found _ CDDirectory.Enumerate[comm.design, EachEntryCheck].quit;
<<CDMarks.ReturnMark[comm.design];>>
IF found THEN {
TerminalIO.WriteRope[name]; TerminalIO.WriteRope[" is used by "];
TerminalIO.WriteRope[usedBy]; 
TerminalIO.WriteRope[" (and maybe others); not deleted\n"];
RETURN
};
IF CDDirectory.Remove[comm.design, name, toDeleteOb] THEN {
TerminalIO.WriteRope[" deleted\n"];
}
ELSE {
TerminalIO.WriteRope[" not deleted; error in delete routine\n"];
}
EXITS
aborted => NULL;
END;

EachEntryDisplay: CDDirectory.EachEntryAction 
--[name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL] -- =
BEGIN
WITH ob.specificRef SELECT FROM
cp: CD.CellPtr => {
TerminalIO.WriteRope["   "]; 
TerminalIO.WriteRope[cp.name]; 
};
ENDCASE => {
TerminalIO.WriteRope["   ("]; TerminalIO.WriteRope[name]; 
TerminalIO.WriteRope[") "];
TerminalIO.WriteRope[CDOps.Info[ob]];
};
TerminalIO.WriteLn[];
quit _ FALSE
END;

DisplayCellNames: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Display cell names\n"];
IF CDDirectory.Enumerate[comm.design, EachEntryDisplay] THEN TerminalIO.WriteRope["stopped\n"]
ELSE TerminalIO.WriteRope["---\n"]
END;

CreateCellAndName: PROC [comm: CDSequencer.Command] =
BEGIN
done: BOOL;
TerminalIO.WriteRope["Create cell  "]; 
[done: done] _ CDCells.CreateCellSelected[comm.design];
IF ~done THEN TerminalIO.WriteRope[" not done\n"];
END;

CreateCellDefaultName: PROC [comm: CDSequencer.Command] =
BEGIN
done: BOOL;
TerminalIO.WriteRope["Create cell without name\n"]; 
[done: done] _ CDCells.CreateCellSelected[comm.design, "-no name-"];
IF ~done THEN TerminalIO.WriteRope["  not done\n"];
END;

PushIntoCellS: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Push into cell "]; 
IF CDCells.PushInCellSelected[comm.design] THEN 
{TerminalIO.WriteRope[comm.design.actual.first.specific.name]; TerminalIO.WriteLn[]}
ELSE TerminalIO.WriteRope["not done\n"];
END;

PushIntoCellP: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Push into cell "]; 
IF CDCells.PushInCellPointed[comm.design, comm.pos] THEN 
{TerminalIO.WriteRope[comm.design.actual.first.specific.name]; TerminalIO.WriteLn[]}
ELSE TerminalIO.WriteRope["not done\n"];
END;

PopFromCellMenu: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["pop\n"];
IF ~CDCells.PopFromCell[comm.design, interactive] THEN 
TerminalIO.WriteRope["  not done\n"];
END;

PopFromCellFlush: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["pop and flush\n"];
IF ~CDCells.PopFromCell[comm.design, flush] THEN 
TerminalIO.WriteRope["  not done\n"];
END;

PopFromCellReplace: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["pop and replace\n"];
IF ~CDCells.PopFromCell[comm.design, replace] THEN 
TerminalIO.WriteRope["  not done\n"];
END;

PopFromCellNew: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["pop and new\n"];
IF ~CDCells.PopFromCell[comm.design, newcell] THEN 
TerminalIO.WriteRope["  not done\n"];
END;

CleanUpDirectory: PROC [comm: CDSequencer.Command] ~
BEGIN
<<ENABLE UNWIND => CDMarks.ReturnMark[comm.design];>>

RemoveIfNotMarked: PROC [name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL_FALSE] ~
BEGIN
IF ob.marked#m THEN { 
[] _ CDDirectory.Remove[design: comm.design, name: name, expectObject: ob];
}
END;

ListNotMarked: PROC [name: Rope.ROPE, ob: CD.ObPtr] RETURNS [quit: BOOL_FALSE] ~
BEGIN
IF ob.marked#m THEN { 
TerminalIO.WriteRope["  - "]; TerminalIO.WriteRope[name]; TerminalIO.WriteLn[];
cnt _ cnt + 1
}
END;

cnt: NAT _ 0;
m: CDMarks.MarkRange;
TerminalIO.WriteRope["Clean up library\n"]; 
m _ CDMarks.GetNewMark[comm.design];
FOR l: LIST OF CD.PushRec _ comm.design.actual, l.rest WHILE l#NIL DO
IF l.first.mightReplace#NIL THEN {
CDMarks.MarkUnMarkedInclusiveChildren[comm.design, l.first.mightReplace.ob, m];
};
CDMarks.MarkUnMarkedInclusiveChildren[comm.design, l.first.dummyCell.ob, m];
ENDLOOP;
TerminalIO.WriteRope["  List of objects not used:\n"]; 
[] _ CDDirectory.Enumerate[design: comm.design, action: ListNotMarked];
TerminalIO.WriteRope[" "];
TerminalIO.WriteInt[cnt]; 
TerminalIO.WriteRope[" objects not used in design\n"];
IF cnt>0 THEN {
IF TerminalIO.UserSaysYes[
label: "delete them?",
text: "  you may delete all the listed objects\n  (deletion must be performed atomic)\n"
] THEN {
TerminalIO.WriteRope["  **** start atomic\n"]; 
TerminalIO.WriteRope["     if for any reason it crashes while deleting,\n"];
TerminalIO.WriteRope["     the deleting process must be repeated before\n"];
TerminalIO.WriteRope["     the design is otherwise used\n"];
[] _ CDDirectory.Enumerate[design: comm.design, action: RemoveIfNotMarked];
TerminalIO.WriteRope["  **** end atomic\n  finished successfully\n"]; 
}
ELSE TerminalIO.WriteRope["  not done\n"];
};
<<CDMarks.ReturnMark[comm.design]>>
END;

SetSimplification: PROC [comm: CDSequencer.Command] =
BEGIN
ap: CD.ApplicationPtr;
multiple: BOOL;
TerminalIO.WriteRope["Set cell simplification\n"]; 
[ap, multiple] _ CDOps.SelectedApplication[comm.design];
IF multiple THEN TerminalIO.WriteRope["   multiple selection; not done\n"] 
ELSE IF ap=NIL THEN TerminalIO.WriteRope["   no selection; not done\n"] 
ELSE {
TerminalIO.WriteRope[ap.ob.p.describe[ap.ob]];
IF ISTYPE[ap.ob.specificRef, CD.CellPtr] THEN {
cptr: CD.CellPtr ~ NARROW[ap.ob.specificRef];
TerminalIO.WriteRope["   [currently: simplification if height < "];
TerminalIO.WriteInt[cptr.simplifyOn];
cptr.simplifyOn _ MIN[
MAX[
TerminalIO.RequestInt[" pixels] type > "], 
0], 
LAST[NAT]
];
TerminalIO.WriteRope["   done\n"]
}
ELSE TerminalIO.WriteRope[" not a cell; not done\n"]; 
}
END;

RenameSP: PROC [comm: CDSequencer.Command] =
BEGIN

RenameAppOb: PROC[design: CD.Design, ap: CD.ApplicationPtr] =
BEGIN
done: BOOL _ FALSE;
IF ap=NIL THEN TerminalIO.WriteRope["   no object;\n"] 
ELSE {
TerminalIO.WriteRope[ap.ob.p.describe[ap.ob]];
IF NOT ap.ob.p.inDirectory THEN TerminalIO.WriteRope[" object can not have name;\n"]
ELSE {
newName: Rope.ROPE = TerminalIO.RequestRope[" new name > "];
done _ CDDirectory.Rename[design, ap.ob, newName];
};
};
IF done THEN TerminalIO.WriteRope["done\n"] ELSE TerminalIO.WriteRope[" not done\n"]
END;

ap: CD.ApplicationPtr = CDCommandOps.TheApplication[comm];
IF ap#NIL THEN RenameAppOb[comm.design, ap]
END;

ReplaceComm: PROC [comm: CDSequencer.Command] =
BEGIN
name: Rope.ROPE;
old, new: CD.ObPtr;
found: BOOLEAN;
TerminalIO.WriteRope["replace an entry allover in the design\n"];
name _ TerminalIO.RequestRope["  replace (name) > "];
[found, old] _ CDDirectory.Fetch[comm.design, name];
IF found THEN {
name _ TerminalIO.RequestRope["  by (name) > "];
[found, new] _ CDDirectory.Fetch[comm.design, name];
};
IF ~found THEN {
TerminalIO.WriteRope["  "];
TerminalIO.WriteRope[name]; 
TerminalIO.WriteRope[" not found\n"];
}
ELSE {
offset: CD.DesignPosition_ [0, 0];
TerminalIO.WriteRope["  do you want to specify an offset?\n"];
IF TerminalIO.UserSaysYes[label: "offset", default: FALSE] THEN {
offset.x _ TerminalIO.RequestInt["  x in lambda >"]*CD.lambda;
offset.y _ TerminalIO.RequestInt["  y in lambda >"]*CD.lambda;
};
CDDirectoryExtras.ReplaceObject[design: comm.design, old: old, new: new, off: offset];
TerminalIO.WriteRope["  end replace\n"];
}
END;

CDSequencer.ImplementCommand[$PopMenu, PopFromCellMenu,, doQueue];
CDSequencer.ImplementCommand[$PopNew, PopFromCellNew,, doQueue];
CDSequencer.ImplementCommand[$PopFlush, PopFromCellFlush,, doQueue];
CDSequencer.ImplementCommand[$PopReplace, PopFromCellReplace,, doQueue];
CDSequencer.ImplementCommand[$PushS, PushIntoCellS,, doQueue];
CDSequencer.ImplementCommand[$PushP, PushIntoCellP,, doQueue];
CDSequencer.ImplementCommand[$CreateCellSAndName, CreateCellAndName];
CDSequencer.ImplementCommand[$CreateCellSUnNamed, CreateCellDefaultName];
CDSequencer.ImplementCommand[$DisplayCellNames, DisplayCellNames,, doQueue];
CDSequencer.ImplementCommand[$DrawCell, DrawCellComm];
CDSequencer.ImplementCommand[$RemoveCell, DeleteCell,, doQueue];
CDSequencer.ImplementCommand[$DeleteUnUsedObjects, CleanUpDirectory,, doQueue];
CDSequencer.ImplementCommand[$CellSimplification, SetSimplification,, doQueue];
CDSequencer.ImplementCommand[$RenameS, RenameSP,, doQueue];
CDSequencer.ImplementCommand[$RenameP, RenameSP,, doQueue];
CDSequencer.ImplementCommand[$Replace, ReplaceComm];
END.