DIRECTORY
Ascii,
CD,
CDCells,
CDCommandOps,
CDDirectory,
CDDirectoryOps,
CDOps,
CDSequencer,
TerminalIO,
Rope;

CDCellCommands: CEDAR PROGRAM
IMPORTS Ascii, CDOps, CDCells, CDCommandOps, CDDirectory, CDDirectoryOps, CDSequencer, Rope, TerminalIO = 
BEGIN

orientForTest: CD.Orientation _ 0;
obCSystemForTest: CDCells.CoordSystem _ interrestCoords;

DrawCellComm: PROC [comm: CDSequencer.Command] =
BEGIN
name: Rope.ROPE;
cellOb: CD.Object;
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 {
inst: CD.Instance = CDCells.IncludeOb[design: comm.design, 
ob: cellOb, 
position: comm.pos, 
obCSystem: obCSystemForTest, 
orientation: orientForTest
].newInst;
CDCommandOps.RedrawInstance[comm.design, inst, 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;

DeleteCellComm: PROC [comm: CDSequencer.Command] =
BEGIN
name, msg: Rope.ROPE_NIL;
done: BOOL;
ob: CD.Object;
TerminalIO.WriteRope["remove object from directory; "];
name _ TerminalIO.RequestRope["type name\n"];
[done, ob] _ CDDirectory.Fetch[comm.design, name];
IF ~done OR ob=NIL THEN {
TerminalIO.WriteRope[name]; TerminalIO.WriteRope[" not found\n"];
RETURN
};
[done, msg] _ CDDirectoryOps.RemoveObjectFromDirectory[comm.design, ob];
TerminalIO.WriteRope[msg];
IF ~done THEN TerminalIO.WriteRope[" not "]; 
TerminalIO.WriteRope["done\n"];
END;


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

EachEntryDisplay: CDDirectory.EachEntryAction 
--[name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL] -- =
BEGIN
quit _ FALSE;
count _ count+1;
IF comm.a=$RestricedDisplayCellNames THEN {
IF Rope.Length[name]<=0 THEN RETURN
ELSE {
ch: CHAR = Rope.Fetch[name];
IF ~Ascii.Letter[ch] AND ~Ascii.Digit[ch] THEN RETURN
}
};
displayed _ displayed+1;
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[];
END;

count: INT _ 0;
displayed: INT _ 0;
TerminalIO.WriteRope["Display object names\n"];
IF CDDirectory.Enumerate[comm.design, EachEntryDisplay] THEN TerminalIO.WriteRope["stopped\n"];
TerminalIO.WriteInt[count];
TerminalIO.WriteRope[" objects counted  "];
IF count#displayed THEN {
TerminalIO.WriteInt[displayed];
TerminalIO.WriteRope[" displayed"];
};
TerminalIO.WriteLn[]
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
Expand: PROC [inst: CD.Instance] RETURNS [ob: CD.Object] =
BEGIN
ob _ CDDirectory.Expand[inst.ob, comm.design, comm.design];
IF ob=NIL THEN TerminalIO.WriteRope["expand failed\n"]
ELSE TerminalIO.WriteRope["object expanded\n"];
END;
inst: CD.Instance _ CDCommandOps.TheInstance[comm: comm, text: "Push into cell "]; 
IF inst#NIL THEN {
WHILE ~CDCells.IsCell[inst.ob] DO
TerminalIO.WriteRope[CDOps.Info[inst.ob]]; 
TerminalIO.WriteRope[" is not cell;"]; 
IF ~ inst.ob.class.inDirectory THEN CDSequencer.QuitCommand[" not done"];
SELECT TerminalIO.RequestSelection[label: "convert to cell?", 
choice: LIST["all instances", "this instance"],
text: " convert to cell?\n",
default: 1] FROM
1 => {--all instances
ob: CD.Object _ Expand[inst];
IF ob=NIL THEN RETURN;
CDSequencer.MarkChanged[comm.design];
CDDirectory.ReplaceObject[design: comm.design, old: inst.ob, new: ob]
};
2 => {--this instance
ob: CD.Object _ Expand[inst];
IF ob=NIL THEN RETURN;
CDSequencer.MarkChanged[comm.design];
inst.ob _ ob;
};
ENDCASE => CDSequencer.QuitCommand["no expansion; not done"];
ENDLOOP;
IF CDCells.PushInCellInstance[comm.design, inst] THEN TerminalIO.WriteRope["done\n"] 
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;



CleanUpDirectoryComm: PROC [comm: CDSequencer.Command] =
BEGIN
autoOnly: BOOL;
TerminalIO.WriteRope["Clean up directory\n"]; 
autoOnly _ comm.a#$DeleteUnUsedObjects;
CDDirectoryOps.CleanUpDirectory[design: comm.design, autoOnly: autoOnly, askFirst: TRUE];
END;


SetSimplification: PROC [comm: CDSequencer.Command] =
BEGIN
ap: CD.Instance;
multiple: BOOL;
TerminalIO.WriteRope["Set cell simplification\n"]; 
[ap, multiple] _ CDOps.SelectedInstance[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.class.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;

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

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

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

ReplaceComm: PROC [comm: CDSequencer.Command] =
BEGIN
name: Rope.ROPE;
old, new: CD.Object;
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.Position_ [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;
};
CDDirectory.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[$CreateCellSAndName, CreateCellAndName];
CDSequencer.ImplementCommand[$CreateCellSUnNamed, CreateCellDefaultName];
CDSequencer.ImplementCommand[$DisplayCellNames, DisplayCellNames,, doQueue];
CDSequencer.ImplementCommand[$RestricedDisplayCellNames, DisplayCellNames,, doQueue];
CDSequencer.ImplementCommand[$DrawCell, DrawCellComm];
CDSequencer.ImplementCommand[$RemoveCell, DeleteCellComm,, doQueue];
CDSequencer.ImplementCommand[$DeleteUnUsedObjects, CleanUpDirectoryComm,, doQueue];
CDSequencer.ImplementCommand[$DeleteUnUsedAutoObs, CleanUpDirectoryComm,, doQueue];
CDSequencer.ImplementCommand[$CellSimplification, SetSimplification,, doQueue];
CDSequencer.ImplementCommand[$RenameS, RenameComm,, doQueue];
CDSequencer.ImplementCommand[$Replace, ReplaceComm];
END.


ÞCDCellCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi,  July 11, 1983 3:42 pm
last edited by Christian Jacobi,  July 1, 1985 12:08:09 pm PDT
�Ê	û˜š
œ)™)Jšœ
Ïm
œ7™BJš
œ+™+Jš
œ>™>—J˜š
Ïk	˜	Jšœž
˜Jšžœ
˜J˜J˜
J˜Jš
œ˜J˜J˜J˜J˜J˜—šÏnœžœ
ž˜Jšžœc˜j—Jš
ž˜J˜Jšœžœ˜"Jšœž
œ˜8J˜šŸœžœ˜0Jš
ž˜Jšœžœ
˜Jšœžœ˜Jšœžœ
˜J˜'š
ž˜JšœFžœ˜UJ˜7šžœžœ˜šœžœ3˜;Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
—Jšœ/žœ˜6J˜J˜$Jš
ž˜Jš
œ˜—J˜Ašžœ
žœ.˜4Jšœžœžœ
žœ
˜6—Jš
ž˜—š
ž˜Jšœžœ
˜—Jšžœ
˜J˜—šŸœžœ˜2Jš
ž˜Jšœžœ
žœ
˜Jšœžœ
˜J˜J˜7Jš
œ-˜-Jš
œ2˜2šžœžœžœ
žœ˜J˜AJš
ž˜Jš
œ˜—Jš
œH˜HJš
œ˜Jšžœžœ ˜-Jš
œ˜Jšžœ
˜—J˜J˜šŸœžœ˜4Jš
ž˜J˜šÏbœ˜.JšÏc:œ˜<Jš
ž˜Jšœžœ
˜
Jš
œ˜šžœ#žœ˜+Jšžœžœ
ž˜#šžœ˜Jšœžœ˜Jšžœžœžœ
ž˜5Jš
œ
˜
—J˜—Jš
œ˜šžœžœ
ž˜šœžœ
˜Jš
œ˜Jš
œ˜J˜—šžœ˜J˜:J˜Jš
œ%˜%J˜——J˜Jšžœ
˜J˜—Jšœžœ˜Jšœžœ˜J˜/Jšžœ6žœ#˜_Jš
œ˜Jš
œ+˜+šžœžœ˜Jš
œ˜Jš
œ#˜#J˜—Jš
œ˜Jšžœ
˜J˜—šŸœžœ˜5Jš
ž˜Jšœžœ
˜J˜'J˜7Jšžœžœ%˜2Jšžœ
˜J˜—šŸœžœ˜9Jš
ž˜Jšœžœ
˜J˜4J˜DJšžœžœ&˜3Jšžœ
˜J˜—šŸ
œžœ˜1Jš
ž˜š
Ÿœžœžœžœžœ
˜:Jš
ž˜Jš
œ;˜;Jšžœžœ
žœ(˜6Jšžœ+˜/Jšžœ
˜—JšœžœK˜Sšžœžœ
žœ˜šžœž˜!Jš
œ+˜+Jš
œ'˜'Jšžœžœ&˜Išžœ8˜>Jšœžœ#˜/Jš
œ˜Jšœž˜šœ¡˜Jšœžœ˜Jšžœžœ
žœ
žœ
˜Jš
œ%˜%Jš
œE˜EJ˜—šœ¡˜Jšœžœ˜Jšžœžœ
žœ
žœ
˜Jš
œ%˜%Jš
œ
˜
Jš
œ˜—Jšžœ6˜=—Jšžœ
˜—Jšžœ/žœ ˜UJšžœ$˜(Jš
œ˜—Jšžœ
˜J˜—šŸœžœ˜3Jš
ž˜Jš
œ˜šžœ0žœ
˜7J˜%—Jšžœ
˜J˜—šŸœžœ˜4Jš
ž˜Jš
œ(˜(šžœ*žœ
˜1J˜%—Jšžœ
˜J˜—šŸœžœ˜6Jš
ž˜Jš
œ*˜*šžœ,žœ
˜3J˜%—Jšžœ
˜J˜—šŸœžœ˜2Jš
ž˜Jš
œ&˜&šžœ,žœ
˜3J˜%—Jšžœ
˜J˜—J˜J˜šŸœžœ˜8Jš
ž˜Jšœ
žœ
˜J˜.Jš
œ'˜'JšœSžœ˜YJšžœ
˜J˜—J˜šŸœžœ˜5Jš
ž˜Jšœžœ
˜Jšœ
žœ
˜J˜3Jš
œ5˜5Jšžœ
žœ;˜KJšžœžœ
žœ5˜Hšžœ
ž
˜Jš
œ2˜2šžœ
žœžœ
ž˜/Jšœžœžœ˜-Jš
œC˜CJš
œ%˜%šœžœ
˜šžœ
˜Jš
œ+˜+Jš
œ˜—Jšžœ
žœ
˜	Jš
œ˜—Jš
œ!˜!J˜
—Jšžœ4˜8—Jšžœ
˜J˜—šŸ
œžœ˜.Jš
ž˜J˜šŸœžœ	žœ
žœ˜7Jš
ž˜Jšœžœžœ
˜Jšžœžœ
žœ)˜7šžœ˜Jš
œ2˜2Jšžœ
žœžœ5˜Xšžœ˜Jšœžœ*˜<Jšžœžœ˜,Jš
œ2˜2J˜—J˜—Jšžœžœ žœ$˜TJšžœ
˜—J˜Jšœžœ+˜1Jšžœžœ
žœ˜+Jšžœ
˜—J˜šŸœžœ˜/Jš
ž˜Jšœžœ
˜Jšœ
žœ˜Jšœžœ
˜J˜AJš
œ5˜5Jš
œ4˜4šžœžœ˜Jš
œ0˜0Jš
œ4˜4J˜—šžœžœ˜J˜J˜J˜%J˜
—šžœ˜Jšœžœ˜Jš
œ>˜>šžœ2žœžœ˜AJš
œ>˜>Jš
œ>˜>J˜—Jš
œP˜PJ˜(Jš
œ
˜
—Jšžœ
˜—J˜Jš
œB˜BJš
œ@˜@Jš
œD˜DJš
œH˜HJš
œ>˜>Jš
œE˜EJš
œI˜IJš
œL˜LJš
œU˜UJš
œ6˜6Jš
œD˜DJš
œS˜SJš
œS˜SJš
œO˜OJš
œ=˜=Jš
œ4˜4Jšžœ
˜J˜J˜—…—#².‹