DIRECTORY
AMBridge,
Atom,
CD,
CDAtomicObjects,
CDDebug,
CDDirectory,
CDEnvironment,
CDEvents,
CDOps,
CDProperties,
CDSequencer,
CDValue,
CDViewer,
Commander,
IO,
PopUpSelection USING [Request],
PrintTV,
Process,
Rope,
RuntimeError USING [UNCAUGHT],
TerminalIO,
UserProfile,
ViewerClasses USING [Viewer];

CDDebugCommands: CEDAR PROGRAM
IMPORTS AMBridge, Atom, CD, CDEnvironment, CDEvents, CDOps, CDProperties, CDSequencer, CDValue, CDViewer, IO, PopUpSelection, PrintTV, Process, Rope, RuntimeError, TerminalIO, UserProfile
EXPORTS CDDebug = 
BEGIN

rememberDesigns: PUBLIC BOOL _ FALSE;
someDesign: PUBLIC CD.Design;  -- last created or debugged design; accessable from debugger

debug: SIGNAL = CODE;

BreakProc: PROC [comm: CDSequencer.Command] = {
ENABLE ABORTED => TerminalIO.PutRope["debugger aborted\n"];
Include: PROC [x: REF_NIL] RETURNS [Rope.ROPE] = {--called from debugger
RETURN [DoInclude[x, comm]]
};
design: CD.Design _ comm.design;
ob: CD.Object _ NIL;
inst: CD.Instance _ CDOps.SelectedInstance[design].first;
specific: REF _ NIL;
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF inst#NIL THEN {ob _ inst.ob; specific _ ob.specific};
IF rememberDesigns THEN someDesign _ design ELSE someDesign _ NIL;
TerminalIO.PutRopes[
"  Look:	ob, inst, design, comm, specific, viewer\n",
"  Call: 	Include[x]\n"];
SIGNAL debug;
TerminalIO.PutRope["debugger disabled\n"];
};

DoInclude: PROC [x: REF, comm: CDSequencer.Command] RETURNS [r: Rope.ROPE_NIL] = {
WITH x SELECT FROM
ob: CD.Object => {
TerminalIO.PutRope[r _ CD.Describe[ob, NIL, comm.design, 2]];
TerminalIO.PutRope[" put down from interpreter\n"];
[] _ CDOps.IncludeObjectI[comm.design, ob, comm.pos];
};
inst: CD.Instance => {
TerminalIO.PutRope[r _ CD.Describe[inst.ob, inst.properties, comm.design, 2]];
TerminalIO.PutRope[" put down from interpreter\n"];
CDOps.IncludeInstance[comm.design, inst];
};
rob: REF CD.Object => 		RETURN[DoInclude[rob^, comm]];
rrob: REF REF CD.Object => 	RETURN[DoInclude[rrob^^, comm]];
rinst: REF CD.Instance => 	RETURN[DoInclude[rinst^, comm]];
rrinst: REF REF CD.Instance => RETURN[DoInclude[rrinst^^, comm]];
ENDCASE => {
r _ Rope.Cat[
IF x=NIL THEN "NIL" ELSE CDOps.ToRope[x, "unknown"], 
"; not included"
];
};
CDOps.DoTheDelayedRedraws[comm.design]
};

TestCommand: PROC [comm: CDSequencer.Command] = {
p: CDSequencer.CommandProc _ CDSequencer.FetchCommand[$test].proc;
IF p=DebugComm OR p=NIL THEN TerminalIO.PutRope["no test procedure loaded\n"]
ELSE {
stream: IO.STREAM _ IO.ROS[];
TRUSTED {PrintTV.Print[AMBridge.TVForProc[p], stream]};
IF TerminalIO.Confirm[Rope.Cat["call procedure ", IO.RopeFromROS[stream]]] THEN
CDSequencer.ExecuteCommand[key: $test, comm: comm];
};
};

DebugComm: PROC [comm: CDSequencer.Command] = {
ForkedBreak: PROC = {
TerminalIO.PutRope["**open detached debugger view\n"];
BreakProc[comm];
};
InLineBreak: PROC = TRUSTED {
TerminalIO.PutRope["Try open debugger view with designs lock\n"];
CDSequencer.ExecuteCommand[key: $BreakProc, comm: comm];
};
IF comm.design.mutability#editable THEN {
TerminalIO.PutF["%l**Warning: design %g NOT editable but debug may break locks%l\n",
IO.rope["b"],
IO.rope[CD.DesignName[comm.design]],
IO.rope[" "]
];
Process.PauseMsec[300]; -- better than flush
};
SELECT PopUpSelection.Request[
header: "Debug options",
choice: LIST["detached debug", "queued debug", "run test", "garbage menu"],
headerDoc: "discard menu for not debugging", 
choiceDoc: LIST["enter debugger; not monitored; can still issue commands", "enter debugger; safe, but can't issue commands", "executes a prepared test procedure", "contains entries included in undefined menus"],
timeOut: 20
] FROM
1 => ForkedBreak[];
2 => InLineBreak[];
3 => TestCommand[comm];
4 => CDSequencer.ExecuteCommand[key: $GarbageMenu, comm: comm];
ENDCASE => TerminalIO.PutRope["skipped\n"];
};

NewDesign: CDEvents.EventProc = {
IF rememberDesigns THEN someDesign _ design ELSE someDesign _ NIL;
};

ClassRope: PROC [c: REF READONLY CD.ObjectClassRec] RETURNS [Rope.ROPE] = TRUSTED {
RETURN [SELECT TRUE FROM
c=NIL => "NIL class",
Rope.IsEmpty[c.description] AND c.objectType#NIL => Atom.GetPName[c.objectType],
ENDCASE => c.description]
};

PrintInstance: PrintTV.TVPrintProc = TRUSTED {
ENABLE RuntimeError.UNCAUGHT => GOTO someErr;
x: REF;
i: REF READONLY CD.InstanceRep _ NARROW[AMBridge.TVToRef[tv]];
IF i=NIL THEN RETURN [useOld_TRUE];
stream.PutRope["{ob: "];
PrintTV.Print[AMBridge.TVForReferent[i.ob], stream, depth-1];
IF depth>0 THEN {
stream.PutF[", at: [%g, %g]", IO.int[i.trans.off.x], IO.int[i.trans.off.y]];
IF i.trans.orient#original THEN stream.PutF[", orient: %g", IO.int[ORD[i.trans.orient]]];
IF i.selected THEN stream.PutRope[", S"];
IF depth>1 THEN {
x _ CDProperties.GetListProp[i.properties, $SignalName];
IF x#NIL THEN stream.PutF[", SignalName: %g", IO.refAny[x]];
x _ CDProperties.GetListProp[i.properties, $InstanceName];
IF x#NIL THEN stream.PutF[", InstanceName: %g", IO.refAny[x]];
};
};
stream.PutChar['}];
EXITS someErr => useOld_TRUE
};

PrintObject: PrintTV.TVPrintProc = TRUSTED {
ENABLE RuntimeError.UNCAUGHT => GOTO someErr;
o: REF READONLY CD.ObjectRep _ NARROW[AMBridge.TVToRef[tv]];
IF o=NIL OR o.class=NIL THEN RETURN [useOld_TRUE];
stream.PutChar['{];
stream.PutRope[ClassRope[o.class]];
IF depth>=1 THEN { 
stream.PutF[",  bbox: [%g, %g, %g, %g]", IO.int[o.bbox.x1], IO.int[o.bbox.y1], IO.int[o.bbox.x2], IO.int[o.bbox.y2]];
IF CD.LayerTechnology[o.layer]#NIL OR o.class.wireTyped THEN
stream.PutF[", layer: %g", IO.rope[CDOps.LayerRope[o.layer]]];
IF ~o.class.wireTyped AND ~ISTYPE[o.specific, CDAtomicObjects.AtomicObsSpecific] AND o.specific#NIL THEN {
stream.PutRope[", "];
PrintTV.Print[AMBridge.TVForReferent[o.specific], stream, depth-1];
}
};
stream.PutChar['}];
EXITS someErr => useOld_TRUE
};

TechName: PROC [t: REF READONLY CD.TechnologyRep] RETURNS [Rope.ROPE] = {
IF t=NIL THEN RETURN ["NIL"] 
ELSE IF t.name#NIL THEN RETURN [t.name]
ELSE RETURN [Atom.GetPName[t.key]]
};

PrintDesign: PrintTV.TVPrintProc = TRUSTED {
d: REF READONLY CD.DesignRec _ NARROW[AMBridge.TVToRef[tv]];
IF d=NIL THEN RETURN [useOld_TRUE];
stream.PutF["{name: %g, technology: %g}", 
IO.rope[IF Rope.Length[d.name]>0 THEN d.name ELSE "(no name)"],
IO.rope[TechName[d.technology]]
];
};

PrintTechnology: PrintTV.TVPrintProc = TRUSTED {
t: REF READONLY CD.TechnologyRep = NARROW[AMBridge.TVToRef[tv]];
stream.PutRope[TechName[t]] ;
};

Draw: PUBLIC PROC [ob: CD.Object, technologyHint: REF_NIL, name: Rope.ROPE_NIL] RETURNS [dummyDesign: CD.Design, viewer: ViewerClasses.Viewer] = {
tech: CD.Technology;
IF ob=NIL THEN ERROR;
IF tech=NIL THEN WITH technologyHint SELECT FROM
a: ATOM => tech _ CD.FetchTechnology[a];
t: CD.Technology => tech _ t;
ENDCASE => NULL;
IF tech=NIL THEN tech _ ob.class.technology;
IF tech=NIL THEN tech _ CD.FetchTechnology[$cmosB];
IF tech=NIL THEN ERROR;
IF ob.class.technology#NIL AND ob.class.technology#tech THEN ERROR;
dummyDesign _ CDOps.CreateDesign[tech];
dummyDesign.name  _ name;
CDValue.Store[dummyDesign, $DontGC, $DontGC]; -- avoid finalization !
[] _ CDOps.IncludeObjectI[dummyDesign, ob, [0, 0]];
CDOps.SetMutability[dummyDesign, inaccessible];
viewer _ CDViewer.CreateViewer[dummyDesign, FALSE];
TerminalIO.PutRope["inaccessible debugging design created\n"]
};

RegisterPrintProcs: PUBLIC PROC [on: BOOL_TRUE] = {
IF on THEN {
PrintTV.RegisterTVPrintProc[type: CODE[CD.Instance], proc: PrintInstance];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Object], proc: PrintObject];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Design], proc: PrintDesign];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Technology], proc: PrintTechnology];
}
ELSE {
PrintTV.RegisterTVPrintProc[type: CODE[CD.Instance], proc: NIL];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Object], proc: NIL];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Design], proc: NIL];
PrintTV.RegisterTVPrintProc[type: CODE[CD.Technology], proc: NIL];
}
};

PrintProcsCommand: Commander.CommandProc = {
off: BOOL _ Rope.Match["*off*", cmd.commandLine, FALSE]; 
IF off THEN IO.PutRope[cmd.out, "--off"] ELSE cmd.out.PutRope["--on"];
RegisterPrintProcs[~off];
};

RemDCommand: Commander.CommandProc = {
off: BOOL _ Rope.Match["*off*", cmd.commandLine, FALSE]; 
IF off THEN IO.PutRope[cmd.out, "--off"] ELSE cmd.out.PutRope["--on"];
rememberDesigns _ off;
};

CDProperties.PutAtomProp[$CDDebugPrivate, $CDDebugPrivate, NEW[SIGNAL ANY RETURNS ANY_debug]];
CDEvents.RegisterEventProc[$CreateNewDesign, NewDesign];
CDEnvironment.RegisterCommander["CDRememberDesigns", RemDCommand, "Set whether ChipNDales remembers last design (CDRememberDesigns {on|off})"];
CDEnvironment.RegisterCommander["CDPrintProcs", PrintProcsCommand, "Set whether ChipNDales uses tv print procs (CDPrintProcs {on|off})"];
CDSequencer.ImplementCommand[$Debug, DebugComm,, dontQueue];
CDSequencer.ImplementCommand[$BreakProc, BreakProc,, doQueue];
CDSequencer.ImplementCommand[$test, DebugComm];
IF UserProfile.Boolean["ChipNDale.RegisterTVPrintProcs", TRUE] THEN RegisterPrintProcs[]
END.


ςCDDebugCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 29, 1983 4:44 pm 
Last edited by: Christian Jacobi, April 7, 1987 2:36:39 pm PDT
--Implements Include, which is called interactively through the debugger
--Creates a viewer which allows looking at an object
--Procedure to be called for debugging purposes only
--Invalidates directory invariants
-- don't clean up: to get the original objects
Κs˜
codeš
œ*™*Kšœ
Οm
œ=™HKš
œ3™3K™>K˜—š
Οk	˜	Kšœž
˜	Kšœž
˜Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜K˜
K˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kšœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ
žœžœ˜K˜Kš
œ˜Kšœžœ
˜—K˜šΟnœžœ
ž˜KšžœžœPžœO˜»
Kšžœ˜—Kš
ž˜K˜Kšœžœ
žœžœ
˜%Kšœž	œ
Οc<˜[K˜Kšœžœžœ
˜K˜šŸ	œžœ ˜/Kšžœ
žœ-˜;š
Ÿœžœžœ
žœžœžœ ˜HKšžœ˜Kš
œ˜—Kšœžœ˜ Kšœžœ
žœ
˜Kšœžœ1˜9Kšœ
žœžœ
˜Kš
œ8˜8Kšžœžœ
žœ(˜8Kšžœžœžœžœ
˜Bš
œ˜Kš
œ5˜5Kš
œ˜—Kšžœ˜
Kš
œ*˜*Kš
œ˜K˜—šŸ	œžœžœžœ
žœ
žœ˜RKš
œH™Hšžœžœ
ž˜šœžœ˜Kšœžœžœ˜=Kš
œ3˜3Kš
œ5˜5K˜—šœžœ˜Kšœžœ5˜NKš
œ3˜3Kš
œ)˜)K˜—Kšœžœ
žœžœ˜6Kš	œžœ
žœ
žœžœ˜<Kšœžœ
žœ
žœ˜;Kš	œžœ
žœ
žœ
žœ˜Ašžœ˜š
œ
˜
Kšžœžœ
žœžœ˜5Kš
œ˜Kš
œ˜—K˜——Kš
œ&˜&Kš
œ˜—K˜šŸœžœ ˜1Kš
œB˜BKšžœ
žœžœ
žœ1˜Mšžœ˜Kš	œžœ
žœžœ
žœ˜Kšžœ0˜7šžœ0žœž˜OKš
œ3˜3—K˜—Kš
œ˜—K˜šŸ	œžœ ˜/šŸœžœ˜Kš
œ6˜6Kš
œ˜Kš
œ˜—šŸœžœžœ
˜Kš
œA˜AKš
œ8˜8Kš
œ˜—šžœ!žœ˜)š
œT˜TKšžœ˜
Kšžœžœ˜$Kšžœ
˜Kš
œ˜—Kšœ ˜,K˜—šžœ˜Kš
œ˜Kšœžœ?˜KKš
œ-˜-KšœžœΔ
˜Σ
Kš
œ˜Kšœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ?˜?Kšžœ$˜+—Kš
œ˜K˜—šŸ	œ˜!Kšžœžœžœžœ
˜BKš
œ˜K˜—šΠbn	œžœžœ
žœ
žœžœžœžœ˜Sšžœžœ
žœ
ž˜Kšœžœ˜Kšœžœžœ ˜PKšžœ˜—Kš
œ˜—K˜šΟb
œžœ˜.Kšžœžœžœ	˜-Kšœžœ
˜Kš	œžœ
žœ
žœžœ˜>Kš
žœžœ
žœ
žœ	žœ˜#Kš
œ˜Kš
œ=˜=šžœ	žœ˜Kšœžœžœ˜LKšžœžœžœžœ˜YKšžœžœ˜)šžœ	žœ˜Kš
œ8˜8Kšžœžœ
žœ!žœ˜<Kš
œ:˜:Kšžœžœ
žœ#žœ˜>Kš
œ˜—K˜—Kš
œ˜Kšžœž˜Kš
œ˜—K˜š’œžœ˜,Kšžœžœžœ	˜-Kš	œžœ
žœ
žœ
žœ˜<Kšžœžœ
žœ	žœ
žœ
žœ	žœ˜2Kš
œ˜Kš
œ#˜#šžœ
žœ
˜Kš	œ)žœžœžœžœ˜uš	žœ
žœžœ
žœž˜<Kšœžœ!˜>—šžœžœžœ0žœžœ
žœ˜jKš
œ˜Kš
œC˜CK˜
—K˜—Kš
œ˜Kšžœž˜Kš
œ˜—K˜šŸœžœžœ
žœ
žœžœžœ˜IKšžœžœ
žœ
žœ	˜Kš
žœ
žœžœ
žœ
žœ	˜'Kšžœ
žœ˜"K˜—K˜š’œžœ˜,Kš	œžœ
žœ
žœ
žœ˜<Kš
žœžœ
žœ
žœ	žœ˜#š
œ*˜*Kšžœžœžœžœ˜?Kšžœ˜Kš
œ˜—Kš
œ˜—K˜š’œžœ˜0Kš	œžœ
žœ
žœžœ˜@Kš
œ˜Kš
œ˜—K˜šŸœžœ
žœžœžœ
žœžœ
žœžœžœ*˜’
K™4K™4K™"Kšœžœ˜Kšžœžœ
žœ
žœ
˜šžœžœ
žœ
žœžœ
ž˜0Kšœžœžœ˜(Kšœžœ˜Kšžœžœ
˜—Kšžœžœ
žœ˜,Kšžœžœ
žœžœ˜3Kšžœžœ
žœ
žœ
˜Kš
žœžœ
žœžœ
žœ
˜CKš
œ'˜'Kš
œ˜Kšœ. ˜EKš
œ3˜3Kš
œ/˜/Kš
œ.™.Kšœ,žœ˜3Kš
œ=˜=Kš
œ˜—K˜šŸœžœžœ
žœ˜3šžœžœ˜Kšœ"žœ
žœ!˜JKšœ"žœ
žœ˜FKšœ"žœ
žœ˜FKšœ"žœ
žœ%˜NK˜
—šžœ˜Kšœ"žœ
žœžœ˜@Kšœ"žœ
žœžœ˜>Kšœ"žœ
žœžœ˜>Kšœ"žœ
žœžœ˜BK˜
—K˜—K˜šŸœ˜,Kšœžœ(žœ˜9Kšžœžœ
žœžœ˜FKš
œ˜Kš
œ˜—K˜šŸœ˜&Kšœžœ(žœ˜9Kšžœžœ
žœžœ˜FKš
œ˜Kš
œ˜—K˜Kšœ;žœ
žœ
žœ
žœ
žœ	˜^Kš
œ8˜8Kš
œ
˜
Kš
œ‰
˜‰
Kš
œ<˜<Kš
œ>˜>K˜/Kšžœ7žœžœ˜XKšžœ
˜K˜—…—#.0“